session-saver

1// Session Saver: pairs with unpause.
2//   - Names an untitled session after its second turn (Haiku picks 2-4 words), so `unpause`
3//     lists "ship-mods" instead of a bare id.
4//   - /park [note] saves where you left off and the next step.
5//   - A resumed session shows that note above the prompt until you type, and toasts it.
6import { atom, read, update } from 'claude-code'
7import type { EngineInterface, PromptOrigin, Register } from 'claude-code'
8
9import type { Parked } from '../types'
10
11const MODEL = 'haiku'
12const NAME_AFTER_TURNS = 2
13
14// Held by the host, so the resume note survives a hot reload of this file.
15const resumed = atom({ plugin: 'session-saver', key: 'resumed' } as const, null as Parked | null)
16// Whether this process showed the note yet: the session's state, so a reload does not show it twice.
17const isShown = atom({ plugin: 'session-saver', key: 'isShown' } as const, false)
18
19export const register: Register = on => {
20  let prompt = ''
21
22  on('session.start', async ($, e, next) => {
23    const r = await next(e)
24    if ((await $.session.messages()).length > 0) void showResume($).catch(() => {})
25    await $.command.register({ name: 'park', description: 'Save where you left off and the next step, for when you resume', argumentHint: '[note]' }).catch(() => {}) // a name Claude Code already has is refused: start anyway
26    return r
27  })
28
29  // A resumed session: bring back where it was left. The engine's resume signal can fire
30  // before this mod loads, so loading into a session that already has messages counts too.
31  on('classic.SessionStart', async ($, e, next) => {
32    const r = await next(e)
33    if (e.source === 'resume') await showResume($)
34    return r
35  })
36
37  // Only what the person typed counts: task notifications, other sessions' messages and
38  // schedules arrive as prompts too, and must not become "you asked" or hide the note.
39  on('prompt.submit', async ($, e, next) => {
40    if (!isTyped(e.origin, e.text)) return next(e)
41    prompt = e.text.slice(0, 600)
42    if (await read($, resumed)) await update($, resumed, () => null) // the note has done its job
43    return next(e)
44  })
45
46  on('turn.complete', async ($, e, next) => {
47    const r = await next(e)
48    if (!e.agentId) {
49      const id = await $.session.id()
50      // Without a /park, a resume still shows the last thing asked.
51      if (prompt) {
52        const last: Parked = { leftOff: `you asked: ${oneLine(prompt, 80)}`, next: '', note: '', at: Date.now() }
53        await $.store.set(`last:${id}`, last)
54      }
55      if ((await $.session.turns()) >= NAME_AFTER_TURNS && !(await $.store.get(`named:${id}`))) {
56        await $.store.set(`named:${id}`, true) // one try per session, whatever happens
57        void autoname($, id).catch(() => {})
58      }
59    }
60    return r
61  })
62
63  on('command.run', { command: 'park' }, async ($, e) => {
64    const id = await $.session.id()
65    const { why, ...parked } = await summarize($, e.args.trim(), prompt)
66    await $.store.set(`park:${id}`, parked)
67    const lines = [`Parked. Left off: ${parked.leftOff}`, parked.next && `Next: ${parked.next}`, parked.note && `Note: ${parked.note}`, why && `(no AI summary: ${why})`, 'Resume any time with unpause.']
68    return { text: lines.filter(Boolean).join('\n') }
69  })
70
71  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
72    const rest = await next(e) // what other mods and Claude Code draw here stays
73    const p = await read($, resumed)
74    if (e.props.hasSurvey || !p) return rest
75    const { Box, Text } = $.ui.resolve(e)
76    return (
77      <Box flexDirection="column">
78        <Text wrap="truncate-end">
79          <Text color="green" bold>{` ↩ Last time (${ago(p.at)}): `}</Text>
80          <Text>{p.leftOff}</Text>
81          {p.next !== '' && <Text dimColor>{'  ·  next: '}</Text>}
82          {p.next !== '' && <Text>{p.next}</Text>}
83        </Text>
84        {p.note !== '' && <Text dimColor wrap="truncate-end">{`   note: ${p.note}`}</Text>}
85        {rest}
86      </Box>
87    )
88  })
89}
90
91async function showResume($: EngineInterface) {
92  if (await read($, isShown)) return
93  const id = await $.session.id()
94  const parked = ((await $.store.get(`park:${id}`)) ?? (await $.store.get(`last:${id}`))) as Parked | undefined
95  if (!parked) return
96  await update($, isShown, () => true)
97  await update($, resumed, () => parked)
98  $.ui.toast(`Last time (${ago(parked.at)}): ${parked.leftOff}${parked.next ? ` · next: ${parked.next}` : ''}`, { timeoutMs: 8000 })
99}
100
101// Names the session through unpause, only when nobody named it yet.
102async function autoname($: EngineInterface, id: string) {
103  const list = await $.process.run(['unpause', 'list', '--json'], { timeoutMs: 20_000 })
104  const row = (JSON.parse(list.stdout || '[]') as { id: string; custom_title?: string }[]).find(s => s.id === id)
105  if (!row || row.custom_title) return
106
107  const messages = (await $.session.messages()).filter(m => m.role === 'user').slice(0, 3)
108  const r = await $.model.complete({
109    model: MODEL,
110    maxTokens: 30,
111    system: 'Name a coding session in 2 to 4 lowercase words joined by hyphens (like "ship-mods" or "fix-login-ci"). Reply with the name only.',
112    prompt: messages.map(m => m.text.slice(0, 500)).join('\n---\n'),
113  })
114  if (!r.isAnswered) return
115  const name = kebab(r.text)
116  if (!name) return
117  const done = await $.process.run(['unpause', 'rename', id, name], { timeoutMs: 20_000 })
118  if (done.exitCode === 0) $.ui.toast(`Session named "${name}" (rename any time with /rename)`)
119}
120
121async function summarize($: EngineInterface, note: string, prompt: string): Promise<Parked & { why?: string }> {
122  // Only messages with words in them: tool-only turns and tool results carry no text.
123  const messages = (await $.session.messages()).filter(m => m.text.trim() !== '').slice(-12)
124  const asked = prompt || messages.filter(m => m.role === 'user' && !isWrapped(m.text)).at(-1)?.text || ''
125  const fallback = { leftOff: asked ? `you asked: ${oneLine(asked, 70)}` : 'parked', next: '', note, at: Date.now() }
126  const r = await $.model.complete({
127    model: MODEL,
128    maxTokens: 300,
129    system:
130      'Someone is pausing a coding session and will resume it later. Plain words, no em dashes. ' +
131      'Reply with JSON only, no code fence: {"leftOff": "where things stand, at most 80 characters", "next": "the next step, at most 60 characters"}.',
132    // The transcript is material to summarize, not a chat to continue: tagged, instruction last.
133    prompt: [
134      '<transcript>',
135      ...messages.map(m => `[${m.role === 'user' ? 'person' : 'assistant'}] ${m.text.slice(0, 600)}`),
136      '</transcript>',
137      '',
138      'Summarize the transcript above for when they resume. Reply with the JSON object only.',
139    ].join('\n'),
140  })
141  if (!r.isAnswered) return { ...fallback, why: r.reason }
142  try {
143    const o = JSON.parse(r.text.slice(r.text.indexOf('{'), r.text.lastIndexOf('}') + 1)) as { leftOff?: string; next?: string }
144    const leftOff = oneLine(o.leftOff ?? '', 80)
145    if (!leftOff) return { ...fallback, why: 'empty summary' }
146    return { leftOff, next: oneLine(o.next ?? '', 60), note, at: Date.now() }
147  } catch {
148    return { ...fallback, why: `reply was not JSON: ${oneLine(r.text, 60)}` }
149  }
150}
151
152// The person's own words: typed at the prompt, from the phone bridge or the SDK host, a Slack
153// ping from the owner, or a mod sending them as the person's (`asUser`). No origin counts as
154// typed (the engine leaves it out for the person's own prompt).
155const TYPED = new Set(['composer', 'bridge', 'sdk', 'slack-ping'])
156
157export function isTyped(origin: PromptOrigin | undefined, text: string) {
158  if (isWrapped(text)) return false
159  if (!origin) return true
160  return TYPED.has(origin.kind) || (origin.kind === 'plugin' && origin.asUser === true)
161}
162
163// Text the engine wraps in tags or frames, not words anyone typed: `<task-notification>`,
164// `<local-command-caveat>`, `<command-name>`, `<system-reminder>`, a peer session's message.
165export function isWrapped(text: string) {
166  const t = text.trimStart()
167  // Only the engine's own wrappers: a prompt the person starts with `<div>` is still theirs.
168  return /^<(task-notification|local-command-caveat|local-command-stdout|command-name|command-message|command-args|system-reminder)\b/.test(t) || t.startsWith('Another Claude session sent a message')
169}
170
171export function kebab(text: string) {
172  return text
173    .toLowerCase()
174    .replace(/["'`.]/g, '')
175    .replace(/[^a-z0-9]+/g, '-')
176    .replace(/^-+|-+$/g, '')
177    .split('-')
178    .slice(0, 4)
179    .join('-')
180}
181
182export function ago(at: number, now = Date.now()) {
183  const m = Math.round((now - at) / 60_000)
184  if (m < 1) return 'just now'
185  if (m < 60) return `${m}m ago`
186  const hours = Math.round(m / 60)
187  return hours < 48 ? `${hours}h ago` : `${Math.round(hours / 24)}d ago`
188}
189
190function oneLine(text: string, max: number) {
191  const t = text.replace(/\s+/g, ' ').replace(/\s*—\s*/g, ', ').trim()
192  return t.length <= max ? t : `${t.slice(0, max - 1)}…`
193}
194

1export type Parked = { leftOff: string; next: string; note: string; at: number }
2
3declare module 'claude-code' {
4  interface PluginState {
5    'session-saver': { resumed: Parked | null; isShown: boolean }
6  }
7}
8