@leftoff/cli 0.9.18-beta.9 → 0.9.18

package/docs/SECURITY.md

@@ -94,7 +94,7 @@ A relayed request is replayed against the Mac's own board from inside the daemon
 
 When your hosted board is open on a Mac that runs Leftoff, the page sends the same sealed requests straight to that Mac's daemon at `http://127.0.0.1:7429/v1/relay/direct` instead of to the relay. Nothing new is trusted: the daemon opens them with the same per-device key (and the same replay and time checks), runs them the same way (a remote device, the rules above), and seals the answer. The page only switches after the daemon says it's on your account and a sealed round trip through it works, so another Leftoff on that port (someone else's account) can't serve your board: it can't open the request or forge the answer. The door is loopback only, never through a proxy, off when Use from anywhere is off, and answers CORS for exactly one origin, `https://<your name>.leftoff.dev` (with Chrome's Private Network Access header); any other page gets a 403 it can't read. If the direct path fails, the request goes through the relay once more and the board stays on the relay until a later check finds the direct path again.
 
-Since 0.9.7 the page also tries `https://leftoff.localhost/v1/relay/direct` (Leftoff's own Caddy from `leftoff setup`, bound to loopback; it rewrites Host, drops X-Forwarded-*, and passes the page's Origin through), since Safari won't let an https page call plain `http://127.0.0.1`. A request that came in through this door came from a browser on this Mac, from your own board's origin, sealed with a paired key, so it may also do the one thing only this Mac's own browser may do: **Restore** (`POST /v1/restore`, which opens Ghostty tabs here). The daemon marks such requests with a second in-memory secret that only the door sets; a sealed request can't carry it, and every other endpoint treats a direct request exactly like the relay (a paired remote device). Through the relay, from a phone or another Mac, Restore stays off.
+Since 0.9.7 the page also tries `https://leftoff.localhost/v1/relay/direct` (Leftoff's own Caddy from `leftoff setup`, bound to loopback, or since 0.9.18 another app's Caddy on port 443 that imports Leftoff's site file, which turns away any client not on loopback by its address; it rewrites Host, drops X-Forwarded-*, and passes the page's Origin through), since Safari won't let an https page call plain `http://127.0.0.1`. A request that came in through this door came from a browser on this Mac, from your own board's origin, sealed with a paired key, so it may also do the one thing only this Mac's own browser may do: **Restore** (`POST /v1/restore`, which opens Ghostty tabs here). The daemon marks such requests with a second in-memory secret that only the door sets; a sealed request can't carry it, and every other endpoint treats a direct request exactly like the relay (a paired remote device). Through the relay, from a phone or another Mac, Restore stays off.
 
 ### Live link (0.9.8 beta)
 

package/mod/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "leftoff",
-  "version": "0.9.18-beta.9",
+  "version": "0.9.18",
   "description": "Leftoff (formerly Checkpoints): WTF was I working on? Tracks every Claude Code session on this machine, writes a 3-line checkpoint when one goes quiet, and adds /cp (checkpoint now), /cp-name and a /leftoff pane. Talks to the local Leftoff daemon on 127.0.0.1:7429 and falls back to writing markdown in ~/checkpoints.",
   "author": {
     "name": "One Silly App"

package/mod/hooks/core.js

@@ -508,6 +508,10 @@ export function renderCheckpointMd(cp) {
   const bullet = (x) => '- ' + oneLine(x).replace(/^\*+/, '')
   // 2026-11-03 decision memory: the decisions this checkpoint saw, first of the
   // sections, so an older reader (no section open yet) skips the heading and its lines.
+  // 2026-11-06: what the session's commands show got done (workFacts), first of all, so the
+  // digest can say what shipped in past tense; an older reader skips the heading and its lines
+  const work = (Array.isArray(cp.work) ? cp.work : []).map(renderWorkLine).filter(Boolean)
+  if (work.length) { lines.push('', '### ' + WORK_TITLE); for (const w of work) lines.push('- ' + w) }
   const decided = cleanDecided(cp.decided)
   if (decided.length) { lines.push('', '### ' + DECIDED_TITLE); for (const d of decided) lines.push(renderDecidedLine(d)) }
   for (const k of SECTION_ORDER) {
@@ -566,7 +570,15 @@ export function parseCheckpointMd(text) {
   if (cp.format === 'markdown') for (const f of ['doing', 'stoppedAt', 'next']) cp[f] = cp[f].replace(/\n{3,}/g, '\n\n').trim()
   const sec = []
   for (; k < lines.length; k++) { if (/^Resume: `/.test(lines[k])) break; sec.push(lines[k]) }
+  // 2026-11-06: "### Got done" lines are facts in a fixed shape (renderWorkLine); read them here, not as model prose
+  const work = []
+  let inWork = false
+  for (const l of sec) {
+    if (/^###\s/.test(l)) { inWork = l.replace(/^###\s+/, '').trim() === WORK_TITLE; continue }
+    if (inWork) { const f = parseWorkLine(l); if (f) work.push(f) }
+  }
   Object.assign(cp, parseSections(sec))
+  if (work.length) cp.work = work
   return cp
 }
 
@@ -904,10 +916,11 @@ export function computeStatus(s, now, cfg = DEFAULT_CONFIG) {
     // fire), so a turn that has been silent for twice the dormancy window is
     // treated as over. The mod sees turn.complete for aborted turns too.
     // 0.8.0: a Codex rollout shows no end for a turn Codex was killed in, either.
-    if ((s.capture === 'hooks' || s.capture === 'codex') && idle >= 2 * dormantAfter) return 'dormant'
+    // 2026-11-06: a subagent working is the turn going on, however quiet the session's own hooks are
+    if ((s.capture === 'hooks' || s.capture === 'codex') && idle >= 2 * dormantAfter && !(s.subagents && s.subagents.n > 0)) return 'dormant'
     return 'active'
   }
-  if (s.backgroundTasks > 0) return 'background'
+  if (s.backgroundTasks > 0 || (s.subagents && s.subagents.n > 0)) return 'background' // 2026-11-06: subagents working (the daemon reads them, src/subagents.js), a turn's end missed or not
   return idle >= dormantAfter ? 'dormant' : 'waiting'
 }
 
@@ -1335,6 +1348,189 @@ export function transcriptSlice(messages, { maxInputChars = 24000, cwd } = {}) {
   return blocks.reverse().join('\n')
 }
 
+// ---------------------------------------------------------------- work facts (2026-11-06)
+//
+// What a session got done, read from the commands it ran and what they printed,
+// never from a model: commits ("[branch abc1234] subject"), PRs opened (gh pr
+// create's URL) and merged (gh pr merge, or GitHub's MCP merge tool), branches
+// pushed, and the last test run with its counts. A checkpoint keeps them under
+// "### Got done", one line each, so the digest can say "Merged PR #53: …" in
+// past tense instead of the last status line ("PR 53 was ready to merge").
+export const WORK_TITLE = 'Got done'
+export const WORK_MAX = { prs: 6, commits: 10, pushes: 3 }
+
+const quoted = (s) => s == null ? '' : String(s)
+function argOf(cmd, names) {
+  for (const n of names) {
+    const re = new RegExp('(?:^|\\s)' + n.replace(/-/g, '\\-') + '(?:=|\\s+)(?:"((?:[^"\\\\]|\\\\.)*)"|\'([^\']*)\'|(\\S+))')
+    const m = String(cmd).match(re)
+    if (m) return quoted(m[1] != null ? m[1].replace(/\\(.)/g, '$1') : m[2] != null ? m[2] : m[3])
+  }
+  return ''
+}
+const firstLineOf = (t) => String(t || '').split('\n').map((x) => x.trim()).find(Boolean) || ''
+const TEST_CMD = /(?:^|[\s;&|(])((?:(?:env\s+(?:-u\s+\S+\s+)*)?(?:timeout\s+(?:-k\s+\S+\s+)?\S+\s+)?)?(?:(?:pnpm|npm|yarn|bun)\s+(?:run\s+)?test(?::[\w:.-]+)?|node\s+(?:--?[\w-]+(?:[= ]\S+)?\s+)*--test\b|npx\s+(?:vitest|jest|mocha)|vitest|jest|pytest|python3?\s+-m\s+pytest|go\s+test|cargo\s+test|mocha|rspec|swift\s+test|make\s+test|deno\s+test))/
+function testCounts(text) {
+  const t = String(text || '')
+  let m, passed = null, failed = null
+  if ((m = t.match(/test result: (?:ok|FAILED)\. (\d+) passed; (\d+) failed/))) return { passed: +m[1], failed: +m[2] }
+  const np = [...t.matchAll(/^\s*(?:#|ℹ)\s*pass\s+(\d+)\s*$/gm)].pop(), nf = [...t.matchAll(/^\s*(?:#|ℹ)\s*fail\s+(\d+)\s*$/gm)].pop()
+  if (np || nf) return { passed: np ? +np[1] : 0, failed: nf ? +nf[1] : 0 }
+  if ((m = t.match(/^\s*Tests:?\s+(.*)$/m)) && /\d+ (?:passed|failed)/.test(m[1])) {
+    const p = m[1].match(/(\d+) passed/), f = m[1].match(/(\d+) failed/)
+    return { passed: p ? +p[1] : 0, failed: f ? +f[1] : 0 }
+  }
+  const lines = t.split('\n').filter((l) => /\d+ (?:passed|failed)\b/.test(l))
+  if (lines.length) {
+    const l = lines[lines.length - 1], p = l.match(/(\d+) passed/), f = l.match(/(\d+) failed/)
+    passed = p ? +p[1] : 0; failed = f ? +f[1] : 0
+    return { passed, failed }
+  }
+  return null
+}
+const PR_URL = /https:\/\/github\.com\/([\w.-]+\/[\w.-]+)\/pull\/(\d+)/
+
+export function workFacts(messages) {
+  const prs = new Map() // number -> { kind: 'pr', number, title, state, repo }
+  const commits = [], pushes = []
+  let tests = null
+  const results = new Map()
+  for (const m of messages || []) for (const r of m.toolResults || []) if (r && r.tool_use_id) results.set(r.tool_use_id, r)
+  const pr = (number, patch) => {
+    const n = Number(number)
+    if (!n) return
+    const cur = prs.get(n) || { kind: 'pr', number: n, title: '', state: 'opened', repo: null }
+    // merged is final: a later "opened" (a re-run of create) doesn't take it back
+    const state = cur.state === 'merged' ? 'merged' : (patch.state || cur.state)
+    prs.delete(n) // newest last
+    prs.set(n, { ...cur, ...Object.fromEntries(Object.entries(patch).filter(([, v]) => v)), state })
+  }
+  for (const m of messages || []) {
+    if (m.role !== 'assistant') continue
+    for (const t of m.toolUses || []) {
+      const name = String(t.tool || t.name || '')
+      const res = (t.tool_use_id && results.get(t.tool_use_id)) || null
+      const text = String(t.text != null ? t.text : (res && res.text) || '')
+      const isError = !!(t.isError || (res && res.isError))
+      const input = t.input || {}
+      // GitHub's MCP tools (mcp__github__create_pull_request / merge_pull_request)
+      if (/(?:^|__)create_pull_request$/.test(name)) {
+        if (isError) continue
+        const u = text.match(PR_URL), n = (u && u[2]) || ((text.match(/"number"\s*:\s*(\d+)/) || [])[1])
+        pr(n, { title: clip(String(input.title || ''), 120), state: 'opened', repo: u ? u[1] : (input.owner && input.repo ? input.owner + '/' + input.repo : null) })
+        continue
+      }
+      if (/(?:^|__)merge_pull_request$/.test(name)) {
+        if (isError || /not mergeable|failed|error/i.test(firstLineOf(text))) continue
+        pr(input.pull_number || input.pullNumber || input.number, { state: 'merged', title: clip(String(input.commit_title || ''), 120).replace(/\s*\(#\d+\)$/, ''), repo: input.owner && input.repo ? input.owner + '/' + input.repo : null })
+        continue
+      }
+      if (name !== 'Bash' || !input.command) continue
+      const cmd = String(input.command)
+      if (/\bgit\b[^\n|;&]*\bcommit\b/.test(cmd) && !/--dry-run/.test(cmd)) {
+        for (const c of text.matchAll(/^\[([^\]\s]+)(?: \([^)]*\))? ([0-9a-f]{7,40})\] (.+)$/gm)) {
+          const subject = clip(c[3].trim(), 120)
+          const i = commits.findIndex((x) => x.subject === subject) // an --amend: the new sha, one line
+          if (i >= 0) commits.splice(i, 1)
+          commits.push({ kind: 'commit', sha: c[2].slice(0, 7), subject, branch: c[1] })
+        }
+      }
+      if (/\bgh\s+pr\s+create\b/.test(cmd) && !isError) {
+        const u = text.match(PR_URL)
+        if (u) pr(u[2], { title: clip(argOf(cmd, ['--title', '-t']), 120), state: 'opened', repo: u[1], branch: argOf(cmd, ['--head', '-H']).replace(/^[\w.-]+:/, '') || pushes[pushes.length - 1] || (commits.length ? commits[commits.length - 1].branch : '') })
+      }
+      if (/\bgh\s+pr\s+merge\b/.test(cmd) && !isError) {
+        const n = (cmd.match(/\bgh\s+pr\s+merge\s+(?:[^\s-]\S*\/pull\/)?#?(\d+)\b/) || [])[1] || (text.match(/pull request (?:[\w.-]+\/[\w.-]+)?#(\d+)/i) || [])[1] || ((text.match(PR_URL) || [])[2])
+        const title = (text.match(/pull request (?:[\w.-]+\/[\w.-]+)?#\d+ \((.+)\)\s*$/im) || [])[1] || ''
+        if (/automatically merged|auto-?merge|merge queue|will be merged/i.test(text) || /--auto\b/.test(cmd)) pr(n, { state: 'auto', title: clip(title, 120) })
+        else if (!/not mergeable|failed|error:/i.test(text)) pr(n, { state: 'merged', title: clip(title, 120) })
+      }
+      if (/\bgit\s+push\b/.test(cmd) && !isError) {
+        const b = [...text.matchAll(/(?:\[new branch\]|\.\.|\+)\s*\S*\s+(\S+)\s+->\s+(\S+)/g)].map((x) => x[2]).pop() || [...text.matchAll(/\s(\S+)\s+->\s+(\S+)/g)].map((x) => x[2]).pop()
+        if (b) { const i = pushes.indexOf(b); if (i >= 0) pushes.splice(i, 1); pushes.push(b) }
+      }
+      const tc = cmd.match(TEST_CMD)
+      if (tc) {
+        const counts = testCounts(text)
+        if (counts || isError) tests = { kind: 'tests', ok: !isError && (!counts || counts.failed === 0), passed: counts ? counts.passed : null, failed: counts ? counts.failed : null, cmd: clip(tc[1].replace(/^env\s+(?:-u\s+\S+\s+)*/, '').replace(/^timeout\s+(?:-k\s+\S+\s+)?\S+\s+/, '').replace(/\s--?(?:import|require|loader|r)[= ]\S+/g, '').trim(), 60) }
+      }
+    }
+  }
+  const out = []
+  const prList = [...prs.values()].slice(-WORK_MAX.prs)
+  out.push(...prList.filter((p) => p.state === 'merged'), ...prList.filter((p) => p.state !== 'merged'))
+  out.push(...commits.slice(-WORK_MAX.commits))
+  out.push(...pushes.slice(-WORK_MAX.pushes).map((branch) => ({ kind: 'push', branch })))
+  if (tests) out.push(tests)
+  return out
+}
+
+const oneL = (s) => String(s == null ? '' : s).replace(/\s*\n\s*/g, ' ').trim()
+// One fact, one line; parseWorkLine reads it back.
+export function renderWorkLine(f) {
+  if (!f) return ''
+  if (f.kind === 'pr') {
+    const head = (f.state === 'merged' ? 'Merged' : f.state === 'auto' ? 'Set to merge' : 'Opened') + ' PR #' + f.number + (f.repo ? ' (' + f.repo + ')' : '') + (f.branch ? ' from ' + f.branch : '')
+    return head + (f.title ? ': ' + oneL(f.title) : '')
+  }
+  if (f.kind === 'commit') return 'Committed ' + f.sha + (f.branch ? ' on ' + f.branch : '') + ': ' + oneL(f.subject)
+  if (f.kind === 'push') return 'Pushed ' + f.branch
+  if (f.kind === 'tests') {
+    const n = f.passed != null ? f.passed + ' passed' + (f.failed ? ', ' + f.failed + ' failed' : '') : ''
+    return 'Tests ' + (f.ok ? 'passed' : 'failed') + (n ? ': ' + n : '') + (f.cmd ? ' (' + oneL(f.cmd).replace(/[()]/g, '') + ')' : '')
+  }
+  return ''
+}
+export function parseWorkLine(line) {
+  const t = String(line || '').replace(/^\s*[-*•]\s*/, '').trim()
+  let m
+  if ((m = t.match(/^(Merged|Opened|Set to merge) PR #(\d+)(?: \(([\w.-]+\/[\w.-]+)\))?(?: from (\S+?))?(?::\s*(.*))?$/))) return { kind: 'pr', number: +m[2], state: m[1] === 'Merged' ? 'merged' : m[1] === 'Opened' ? 'opened' : 'auto', repo: m[3] || null, ...(m[4] ? { branch: m[4] } : {}), title: (m[5] || '').trim() }
+  if ((m = t.match(/^Committed ([0-9a-f]{7,40})(?: on (\S+))?:\s*(.*)$/))) return { kind: 'commit', sha: m[1], branch: m[2] || null, subject: m[3].trim() }
+  if ((m = t.match(/^Pushed (\S+)$/))) return { kind: 'push', branch: m[1] }
+  if ((m = t.match(/^Tests (passed|failed)(?::\s*(\d+) passed(?:, (\d+) failed)?)?(?: \((.*)\))?$/))) return { kind: 'tests', ok: m[1] === 'passed', passed: m[2] != null ? +m[2] : null, failed: m[2] != null ? +(m[3] || 0) : null, cmd: m[4] || '' }
+  return null
+}
+// "PR 53 is ready to merge" / "Merge PR 53" about a PR that has merged: a status line gone stale.
+export const STATUSY_PR = /\bPR\s*#?(\d+)\b[^.;]{0,60}?\b(?:ready to merge|ready for review|ready to land|awaiting (?:review|merge|approval)|waiting (?:on|for) (?:review|merge|approval|checks|CI)|open(?:ed)?(?: and)? (?:for|awaiting)|in review|pending (?:review|merge))/i
+export const STALE_NEXT_PR = /\b(?:merge|land|ship|review|approve|squash)\b[^.;]{0,40}?\bPR\s*#?(\d+)/i
+// A checkpoint whose Stopped at / Next calls a PR its own facts show merged ready or next to merge:
+// Stopped at becomes what the facts say, Next is dropped (the digest's next step comes from elsewhere).
+// -> { stoppedAt, next, corrected: [fields] }; nothing changed when nothing is contradicted.
+export function reconcileWithWork(cp, work) {
+  const merged = new Map((work || []).filter((f) => f && f.kind === 'pr' && f.state === 'merged').map((f) => [f.number, f]))
+  const out = { stoppedAt: cp.stoppedAt, next: cp.next, corrected: [] }
+  if (!merged.size) return out
+  const one = (t) => String(t || '').replace(/\s+/g, ' ')
+  const m = one(cp.stoppedAt).match(STATUSY_PR)
+  if (m && merged.has(Number(m[1]))) {
+    const pr = merged.get(Number(m[1]))
+    const tests = (work || []).filter((f) => f.kind === 'tests').pop()
+    out.stoppedAt = 'PR #' + pr.number + (pr.title ? ' (' + clip(pr.title, 80) + ')' : '') + ' is merged' + (tests ? '; tests ' + (tests.ok ? 'pass' : 'fail') + (tests.passed != null ? ' (' + (tests.ok ? tests.passed + ' passed' : tests.failed + ' failed') + ')' : '') : '') + '.'
+    out.corrected.push('stoppedAt')
+  }
+  const n = one(cp.next).match(STALE_NEXT_PR)
+  if (n && merged.has(Number(n[1]))) { out.next = ''; out.corrected.push('next') }
+  return out
+}
+// A work list from anywhere (the mod's POST, a file) made safe: only what renders and reads back.
+export function cleanWork(list) {
+  const out = []
+  for (const f of Array.isArray(list) ? list : []) {
+    const w = typeof f === 'string' ? parseWorkLine(f) : parseWorkLine(renderWorkLine(f))
+    if (w) out.push(w)
+  }
+  return out.slice(0, WORK_MAX.prs + WORK_MAX.commits + WORK_MAX.pushes + 1)
+}
+// The same fact in two checkpoints is one fact (a commit by its subject, since an amend changes the sha).
+export function workKey(f) {
+  if (!f) return ''
+  if (f.kind === 'pr') return 'pr:#' + f.number
+  if (f.kind === 'commit') return 'commit:' + String(f.subject || '').toLowerCase()
+  if (f.kind === 'push') return 'push:' + f.branch
+  if (f.kind === 'tests') return 'tests'
+  return ''
+}
+
 // ---------------------------------------------------------------- checkpoint length (v0.4.6)
 //
 // config summary.length picks how much a checkpoint says. Every length keeps the
@@ -1387,17 +1583,18 @@ const CHECKPOINT_BASE = [
   'You write checkpoints for a developer juggling many coding-agent sessions, read when they come back after half an hour, a day or a weekend. Given the recent transcript of ONE session, start with exactly these five lines:',
   'Goal: <the outcome the developer is after, from what they asked for, in a few plain words; not the latest step. Keep the previous goal unless they changed course or it is done and they moved on>',
   'Progress: <one of Just started, Underway, Mostly done, Done, Stuck> - <what is left between here and the goal, a few words>',
-  'Doing: <what the session was working on, one sentence, concrete nouns: files, features, errors>',
-  'Stopped at: <the exact state when it went quiet: what passed, what failed, what is half-done; say what was actually run or checked, and what is only assumed>',
+  'Doing: <what the session got done or was working on, one sentence, concrete nouns: files, features, errors; past tense for what is finished, e.g. "Merged PR #53, which keeps the reply box above the keyboard">',
+  'Stopped at: <the exact state when it went quiet, as outcomes: what passed, what failed, what is half-done, what is merged and what is not; say what was actually run or checked, and what is only assumed>',
   'Next: <the single next action a human or the agent should take>',
   'If the session is blocked on the human (a question, a permission, a decision), start Next with "YOU:".',
+  'Say outcomes, not statuses: "Merged PR #53" or "Opened PR #53, not merged yet", never "PR 53 was ready to merge". The "Verified from the commands\' output" line is the record of commits, PRs, pushes and tests: never contradict it, and never claim a merge, commit or passing test it does not show.',
   'Describe only what the transcript shows; the lines above it (repo, branch, title, what was asked, previous checkpoint) are background and may be out of date.',
 ]
 // 2026-11-03 decision memory: only when the transcript shows one, quoted, never invented.
 const DECIDED_SECTION = [
   'Only if the transcript shows a decision (a choice between real alternatives that the developer made or approved, a plan they approved, a correction they gave such as "no, do X instead", or a trade-off the agent chose and said so), add after those lines a "Decided:" heading and one "- " line per decision, at most 4:',
   '- <what was decided, in the words the transcript uses> · why: <the reason given, one line> · over: <alternative>; <alternative> · from: <asked | plan | correction | agent>',
-  'A task done, a file edited or a routine step is not a decision. Never invent a choice or a reason the transcript does not show. When unsure, or when there is none, leave the Decided heading out entirely. Skip decisions listed as already recorded.',
+  'A task done, a file edited or a routine step is not a decision, and neither is a one-off choice about this task right now (who does a step, whether to commit, push or deploy now). Never invent a choice or a reason the transcript does not show. When unsure, or when there is none, leave the Decided heading out entirely. Skip decisions listed as already recorded.',
 ]
 const INFORMATIVE_SECTIONS = [
   'Then these sections, each a heading line followed by "- " bullets (write "- none" when there is nothing; never invent):',
@@ -1477,12 +1674,15 @@ export function buildCheckpointPrompt({ session, previous, messages, cfg = DEFAU
   const red = (t) => redact(String(t || ''), (cfg.redact && cfg.redact.patterns) || [])
   const found = decisionsFromMessages(messages).map((d) => ({ ...d, text: red(d.text), why: red(d.why), alternatives: d.alternatives.map(red) }))
   if (found.length) head.push('Decisions already recorded from the session\'s questions and plans (don\'t repeat them): ' + found.map((d) => '“' + clip(d.text, 120) + '”').join('; '))
+  // 2026-11-06: what the commands' own output shows got done, so the model says "Merged PR #53" and not "PR 53 was ready to merge"
+  const work = workFacts(messages).map((f) => (f.kind === 'pr' || f.kind === 'commit' ? { ...f, title: f.title && red(f.title), subject: f.subject && red(f.subject) } : f)).map((f) => Object.fromEntries(Object.entries(f).filter(([, v]) => v !== undefined)))
+  head.push('Verified from the commands\' output (git, gh, the test runner) this session: ' + (work.length ? work.map(renderWorkLine).join('; ') : 'no commit, PR, push or test run'))
   if (session.needsInput) head.push('State: the session is waiting on the developer (' + (session.lastNotification || 'a prompt') + ').')
   if (wantTitle) head.push('Also write the line: Title: <max 6 words>.')
   const slice = transcriptSlice(messages, { maxInputChars, cwd })
   const patterns = (cfg.redact && cfg.redact.patterns) || []
   const prompt = redact(head.join('\n') + '\nTranscript (oldest→newest, trimmed):\n' + (slice || '(empty)'), patterns)
-  return { system: CHECKPOINT_SYSTEMS[len], prompt, filesTouched: files, inputChars: prompt.length, length: len, maxTokens: SUMMARY_LENGTHS[len].maxTokens, found }
+  return { system: CHECKPOINT_SYSTEMS[len], prompt, filesTouched: files, inputChars: prompt.length, length: len, maxTokens: SUMMARY_LENGTHS[len].maxTokens, found, work }
 }
 
 // ---------------------------------------------------------------- decisions (2026-11-03)
@@ -1577,12 +1777,23 @@ function planHeadline(plan) {
   return h.replace(/^#{1,6}\s+/, '').replace(/^(?:plan|implementation plan)\s*[:\-–—]\s*/i, '').replace(/\*\*/g, '').trim()
 }
 
-// The decisions a transcript states outright, with no model: a question you
-// answered from its options (AskUserQuestion, the board's Needs you), its other
-// options as the alternatives; a plan you approved (ExitPlanMode). Messages are
-// src/transcript.js's shape, which is also $.session.messages()'s.
-export function decisionsFromMessages(messages) {
-  const out = []
+// 2026-11-05: a question about one task right now isn't a decision for the repo: who does it ("You update
+// it" / "I'll handle it"), or whether to go ahead with a commit, push, deploy and the like. Never recorded.
+const ACTOR_OPT = /^(?:you|i|i'll|i will|i'd|me|let me|we|we'll|leave it|someone)\b/i
+const NOW_Q = /\b(?:go ahead|proceed|right now|commit|push|merge|deploy|ship|publish|release|restart|open (?:a|the) pr|create (?:a|the) pr|who (?:should|will|does))\b/i
+const YESNO_OPT = /^(?:yes|no|y|n|ok|okay|sure|go ahead|do it|proceed|not now|later|skip|wait|stop|hold off|cancel|continue)\b/i
+export function isOneOffQuestion(q) {
+  const labels = (Array.isArray(q && q.options) ? q.options : []).map((o) => String((o && o.label) || o || '').replace(/\s*\(Recommended\)\s*/i, '').trim()).filter(Boolean)
+  if (labels.length < 2) return false
+  if (labels.every((l) => ACTOR_OPT.test(l))) return true
+  return NOW_Q.test(String((q && q.question) || '')) && labels.every((l) => YESNO_OPT.test(l))
+}
+
+// The transcript's own decisions, oldest first, and the answers it later changed:
+// a question asked again (same header, else the same question) and answered
+// differently keeps only the last answer; the earlier ones are `reversed` (texts).
+function readStated(messages) {
+  const out = [], at = new Map(), replaced = new Set()
   for (const m of messages || []) {
     if (!m || m.role !== 'assistant') continue
     for (const u of m.toolUses || []) {
@@ -1593,17 +1804,22 @@ export function decisionsFromMessages(messages) {
         const ans = questionAnswers(u.text, qs.map((q) => String(q.question)))
         for (const q of qs) {
           const a = ans[q.question]
-          if (!a) continue
+          if (!a || isOneOffQuestion(q)) continue
           const labels = q.options.map((o) => String((o && o.label) || o || '').trim()).filter(Boolean)
           const picked = labels.filter((l) => a === l || a.split(/\s*,\s*/).includes(l))
           const chosen = picked.length ? picked.join(', ') : a
           const opt = q.options.find((o) => o && o.label === picked[0])
-          out.push({
+          const d = {
             text: clip(String(q.header ? q.header + ': ' : '') + chosen.replace(/\s*\(Recommended\)\s*/i, ''), 240),
             why: opt && opt.description ? opt.description : '',
             alternatives: labels.filter((l) => !picked.includes(l)).map((l) => l.replace(/\s*\(Recommended\)\s*/i, '')),
             source: 'asked',
-          })
+          }
+          const topic = 'q:' + decisionNorm(q.header || q.question)
+          const was = at.get(topic)
+          if (was != null && decisionNorm(out[was].text) !== decisionNorm(d.text)) { replaced.add(out[was].text); out[was] = null }
+          if (was != null && out[was]) continue // the same answer again
+          at.set(topic, out.length); out.push(d)
         }
       }
       if (name === 'ExitPlanMode' && u.text && PLAN_OK.test(u.text)) {
@@ -1612,7 +1828,29 @@ export function decisionsFromMessages(messages) {
       }
     }
   }
-  return cleanDecided(out)
+  const found = out.filter(Boolean)
+  const kept = new Set(found.map((d) => decisionNorm(d.text)))
+  return { found, reversed: [...replaced].filter((t) => !kept.has(decisionNorm(t))) }
+}
+
+// The decisions a transcript states outright, with no model: a question you
+// answered from its options (AskUserQuestion, the board's Needs you), its other
+// options as the alternatives, only its last answer; a plan you approved
+// (ExitPlanMode). Messages are src/transcript.js's shape, which is also
+// $.session.messages()'s.
+export function decisionsFromMessages(messages) {
+  return cleanDecided(readStated(messages).found)
+}
+
+// 2026-11-05: what the log settles on its own (src/decisions.js settleStated): the stated decisions,
+// redacted as checkpoints save them, and the texts of answers changed later in the session.
+export function statedDecisions(messages, patterns = []) {
+  const red = (t) => redact(String(t || ''), patterns || [])
+  const { found, reversed } = readStated(messages)
+  return {
+    found: cleanDecided(found).map((d) => ({ ...d, text: red(d.text), why: red(d.why), alternatives: d.alternatives.map(red) })),
+    reversed: reversed.map((t) => red(clip(oneLine(t), 240))),
+  }
 }
 
 // The checkpoint's decisions: what the transcript states outright first, then the model's.
@@ -1633,6 +1871,9 @@ const SECTION_KEYS = {
   'didn\'t work': 'didntWork', 'didnt work': 'didntWork', 'did not work': 'didntWork', 'what didn\'t work': 'didntWork', 'what didnt work': 'didntWork', 'tried': 'didntWork',
   'recap': 'recap',
   'next steps': 'nextSteps', 'next 3 steps': 'nextSteps',
+  // 2026-11-06: "Got done" is written in code from the commands' output (workFacts); a model
+  // that writes the heading itself is not a source for it, so its lines are dropped
+  'got done': 'gotDone',
   'decided': 'decided', // 2026-11-03 decision memory
 }
 export const SECTION_TITLES = { decisions: 'Approach notes', questions: 'Open questions', files: 'Files touched', didntWork: 'What didn\'t work', recap: 'Recap', nextSteps: 'Next steps' }
@@ -1662,6 +1903,7 @@ function parseSections(lines) {
   const push = (k, v) => {
     v = String(v || '').replace(/\*\*/g, '').trim()
     if (!v || NONE_RE.test(v)) return
+    if (k === 'gotDone') return
     if (k === 'recap') { ex.recap = ex.recap ? ex.recap + ' ' + v : v; return }
     if (k === 'files') { const f = parseFileNote(v); if (f.path || f.why) ex.files.push(f); return }
     if (k === 'decided') { const d = parseDecidedLine(v); if (d) ex.decided.push(d); return }
@@ -1910,7 +2152,7 @@ export const TITLE_LANGUAGE = 'Write it in the same language as the user\'s own
 export const TITLE_SYSTEM = 'Write a title of at most 6 words for a coding session, based on its first prompt. ' + TITLE_LANGUAGE + ' Reply with the title only, no quotes, no punctuation at the end.'
 
 export function cleanTitle(text) {
-  const t = String(text || '').replace(/<think>[\s\S]*?<\/think>/gi, '').split('\n').map((l) => l.trim()).find(Boolean) || ''
+  const t = stripChannel(String(text || '').replace(/<think>[\s\S]*?<\/think>/gi, '')).split('\n').map((l) => l.trim()).find(Boolean) || '' // 0.9.18: a model that echoes the Live wrapper
   return clip(t.replace(/^title\s*:\s*/i, '').replace(/^["'`*]+|["'`*.]+$/g, ''), 60)
 }
 

package/mod/hooks/register.js

@@ -19,7 +19,7 @@ import {
   shortId, formatTabTitle, parseTabTitle, tabRenameWaits, detectTerminal, parseProcLine, trailingQuestion,
   parseCheckpointArgs, SUMMARY_LENGTHS, parseBulletList, parseCatchupArgs,
   listHintFrom, backgroundListFrom, extractChecklists, parseTodoArgs, parseDoneArgs, detectBackend, parseParkArgs,
-  boardLinkLines, isNonInteractive, isLeftoffHeadless, lockForPark, parkLockHeld, unlockParkLocks, parkWorktreeText,
+  boardLinkLines, isNonInteractive, isLeftoffHeadless, lockForPark, parkLockHeld, unlockParkLocks, parkWorktreeText, reconcileWithWork,
 } from './core.js'
 
 const PANE_ID = 'checkpoints'
@@ -32,7 +32,7 @@ const START_SKIP_GRACE_MS = 15000 // the same for SessionStart (a cold start can
 const PERM_GRACE_MS = 1500 // how long a permission prompt tool.check saw waits for classic.PermissionRequest before the mod reports it
 
 // Module state. $.state is not used: the pane redraws with $.ui.invalidate.
-const MOD_VERSION = '0.9.18-beta.9' // keep in step with .claude-plugin/plugin.json
+const MOD_VERSION = '0.9.18' // keep in step with .claude-plugin/plugin.json
 
 const st = {
   internal: false,
@@ -866,6 +866,11 @@ async function makeCheckpoint($, trigger, userNote, length, opts = {}) {
     }
     // 0.9.2: nothing to go on (no prompt, no reply): don't save a placeholder over the last real one
     if (isEmptyCheckpoint(parsed)) { if (trigger === 'manual') $.ui.toast(NOTHING_TO_CHECKPOINT, { timeoutMs: 6000 }); return null }
+    // 2026-11-06: a Stopped at / Next that calls a PR this session merged "ready to merge": the facts win
+    if (parsed.format !== 'markdown') {
+      const fix = reconcileWithWork(parsed, ctx.work)
+      if (fix.corrected.length) { parsed = { ...parsed, stoppedAt: fix.stoppedAt, next: fix.next }; generator = { ...(generator || {}), corrected: fix.corrected.join(' ') } }
+    }
     if (opts.next) parsed = { ...parsed, next: opts.next }
     const cp = {
       sessionId: st.sessionId, createdAt: nowIso(), trigger, machine: st.machine,
@@ -874,6 +879,7 @@ async function makeCheckpoint($, trigger, userNote, length, opts = {}) {
       doing: parsed.doing, stoppedAt: parsed.stoppedAt, next: parsed.next, openQuestion: parsed.openQuestion || null,
       userNote: userNote || null, filesTouched: ctx.filesTouched, turnsSinceLast: record.turnsSinceCheckpoint || 0,
       parseOk: parsed.parseOk, ...(parsed.format === 'markdown' ? { format: 'markdown' } : {}), generator, length: ctx.length,
+      work: ctx.work || [], // 2026-11-06: what the commands' output shows got done
       decided: mergeDecided(ctx.found, generator && generator.by === 'heuristic' ? [] : parsed.decided, { earlier: st.lastCheckpoint && st.lastCheckpoint.decided }), // 2026-11-03 decision memory
       decisions: parsed.decisions || [], questions: parsed.questions || [], files: parsed.files || [],
       didntWork: parsed.didntWork || [], recap: parsed.recap || '', nextSteps: parsed.nextSteps || [],
@@ -1107,14 +1113,22 @@ function startReplyLoop($) {
     let backoff = 0
     while (st.replyLoop && st.sessionId) {
       const sid = st.sessionId
-      const r = await api($, 'GET', '/v1/sessions/' + encodeURIComponent(sid) + '/replies/next?ms=' + ASK_POLL_MS, undefined, ASK_POLL_MS + 5000)
+      const r = await api($, 'GET', '/v1/sessions/' + encodeURIComponent(sid) + '/replies/next?cmds=1&ms=' + ASK_POLL_MS, undefined, ASK_POLL_MS + 5000)
       if (!r || !r.ok) {
         // Daemon down: try again on the heartbeat rather than spinning.
         st.replyLoop = false
         return
       }
       const reply = r.json && r.json.reply
-      if (reply && reply.text && !String(reply.text).startsWith('/') && sid === st.sessionId) {
+      // a slash command from the board (the daemon checked it against its list):
+      // Claude Code runs it as if typed, queued behind a running turn (as /rename)
+      if (reply && reply.command && typeof reply.command.name === 'string' && /^[a-z][\w-]{0,30}$/.test(reply.command.name) && sid === st.sessionId) {
+        try {
+          await $.command.run({ command: reply.command.name, args: String(reply.command.args || '').replace(/[\r\n]+/g, ' ').slice(0, 500) })
+        } catch (err) {
+          try { $.ui.toast('Leftoff: couldn’t run the board’s /' + reply.command.name + ': ' + String((err && err.message) || err).slice(0, 120)) } catch {}
+        }
+      } else if (reply && reply.text && !String(reply.text).startsWith('/') && sid === st.sessionId) {
         try {
           await $.prompt.submit({ text: String(reply.text) })
         } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leftoff/cli",
-  "version": "0.9.18-beta.9",
+  "version": "0.9.18",
   "description": "Leftoff: WTF was I working on? Tracks every Claude Code session, writes a 3-line checkpoint when one goes quiet, and gives you a daily digest and a board, on your Mac and (optionally) your phone.",
   "keywords": [
     "claude",