@leftoff/cli 0.9.18-beta.1 → 0.9.18-beta.11

package/bin/pty-host-main.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import y from"node:fs";import it from"node:net";import W from"node:path";import C from"node:fs";import P from"node:path";import{spawn as Z,execFile as ut}from"node:child_process";import{createRequire as q}from"node:module";import{StringDecoder as Q}from"node:string_decoder";var wt=2*1024*1024;var gt=192*1024;var yt=64*1024;var tt=String.raw`
+import os, sys, pty, select, struct, fcntl, termios, signal
+cols, rows = int(sys.argv[1]), int(sys.argv[2])
+argv = sys.argv[3:]
+pid, fd = pty.fork()
+if pid == 0:
+    try:
+        os.execvp(argv[0], argv)
+    finally:
+        os._exit(127)
+def size(c, r):
+    try: fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack('HHHH', r, c, 0, 0))
+    except OSError: pass
+size(cols, rows)
+def wall(f, b):
+    while b:
+        try: n = os.write(f, b)
+        except InterruptedError: continue
+        b = b[n:]
+ins = [0, fd, 3]
+ctl = b''
+while True:
+    try: r = select.select(ins, [], [])[0]
+    except InterruptedError: continue
+    if fd in r:
+        try: d = os.read(fd, 65536)
+        except OSError: d = b''
+        if not d: break
+        wall(1, d)
+    if 0 in r:
+        d = os.read(0, 65536)
+        if not d:
+            ins.remove(0)
+            try: os.kill(pid, signal.SIGHUP)
+            except OSError: pass
+        else:
+            try: wall(fd, d)
+            except OSError: pass
+    if 3 in r:
+        d = os.read(3, 4096)
+        if not d: ins.remove(3)
+        ctl += d
+        while b'\n' in ctl:
+            line, ctl = ctl.split(b'\n', 1)
+            p = line.split()
+            try:
+                if p[0] == b'R': size(int(p[1]), int(p[2]))
+                elif p[0] == b'K': os.kill(pid, int(p[1]))
+            except (IndexError, ValueError, OSError): pass
+st = os.waitpid(pid, 0)[1]
+code = os.waitstatus_to_exitcode(st)
+sys.exit(code if code >= 0 else 128 - code)
+`;function et({platform:t=process.platform,exists:n=c=>{try{return C.statSync(c).isFile()}catch{return!1}},isDir:o=c=>{try{return C.statSync(c).isDirectory()}catch{return!1}}}={}){return(t==="darwin"?["/opt/homebrew/bin/python3","/usr/local/bin/python3",...o("/Library/Developer/CommandLineTools")||o("/Applications/Xcode.app")?["/usr/bin/python3"]:[]]:["/usr/bin/python3","/usr/local/bin/python3","/bin/python3"]).find(n)||null}function st(t){return{kind:"node-pty",spawn({file:n,args:o,cwd:c,env:a,cols:d,rows:e}){let r=t.spawn(n,o,{name:"xterm-256color",cols:d,rows:e,cwd:c,env:a});return{pid:r.pid,onData:s=>r.onData(s),onExit:s=>r.onExit(({exitCode:p,signal:u})=>s({code:p,signal:u||null})),write:s=>r.write(s),resize:(s,p)=>{try{r.resize(s,p)}catch{}},kill:(s="SIGHUP")=>{try{r.kill(s)}catch{}}}}}}function U(t,{spawnImpl:n=Z}={}){return{kind:"python",spawn({file:o,args:c,cwd:a,env:d,cols:e,rows:r}){let s=n(t,["-c",tt,String(e),String(r),o,...c],{cwd:a,env:d,stdio:["pipe","pipe","pipe","pipe"]}),p=new Q("utf8"),u=[],H=[],j=!1;s.stdout.on("data",i=>{let h=p.write(i);if(h)for(let b of u)b(h)}),s.stderr.on("data",i=>{let h=String(i);for(let b of u)b(h)});let A=s.stdio[3];for(let i of[s.stdin,A])i&&i.on("error",()=>{});let G=(i,h)=>{if(j)return;j=!0;let b=p.end();if(b)for(let F of u)F(b);for(let F of H)F({code:i??null,signal:h||null})};s.on("exit",(i,h)=>setTimeout(()=>G(i,h),20)),s.on("error",i=>{for(let h of u)h(`\r
+[terminal] `+i.message+`\r
+`);G(127,null)});let V={SIGHUP:1,SIGINT:2,SIGKILL:9,SIGTERM:15};return{pid:s.pid,onData:i=>u.push(i),onExit:i=>H.push(i),write:i=>{try{s.stdin.write(i)}catch{}},resize:(i,h)=>{try{A.write("R "+i+" "+h+`
+`)}catch{}},kill:(i="SIGHUP")=>{try{A.write("K "+(V[i]||1)+`
+`)}catch{}if(i==="SIGKILL")try{s.kill("SIGKILL")}catch{}}}}}}function nt(t,{platform:n=process.platform,arch:o=process.arch,stat:c=d=>C.statSync(d),chmod:a=(d,e)=>C.chmodSync(d,e)}={}){let d=[];for(let e of[P.join(t,"prebuilds",n+"-"+o,"spawn-helper"),P.join(t,"build","Release","spawn-helper")]){let r;try{r=c(e)}catch{continue}if(!(!r.isFile()||(r.mode&73)===73))try{a(e,r.mode&511|493),d.push(e)}catch{}}return d}function rt(t,n){if(!n)return t;let o=t;return{get kind(){return o.kind},spawn(c){try{return o.spawn(c)}catch(a){if(o!==t)throw a;return o=n(),o.spawn(c)}}}}function K({requireImpl:t=q(import.meta.url),python:n=et(),env:o=process.env}={}){let c=null;if(o.LEFTOFF_TERM_BACKEND!=="python")try{let a=t("node-pty");try{nt(P.dirname(t.resolve("node-pty/package.json")))}catch{}return rt(st(a),n?()=>U(n):null)}catch(a){c=a}return n?U(n):{kind:null,why:"No terminal backend: node-pty isn’t installed"+(c&&!/Cannot find module/.test(c.message)?" ("+String(c.message).split(`
+`)[0]+")":"")+" and there’s no python3. Run `leftoff upgrade`, or install python3."}}var X=process.argv[2],l;try{l=JSON.parse(y.readFileSync(X,"utf8"))}catch(t){process.stderr.write("pty-host: no spec: "+t.message+`
+`),process.exit(2)}try{y.rmSync(X,{force:!0})}catch{}var{id:_,dir:B}=l,v=W.join(B,_+".sock"),N=W.join(B,_+".json"),ot=l.bufferMax||2*1024*1024,E=t=>process.stderr.write(new Date().toISOString()+" "+_+" "+t+`
+`);process.on("SIGHUP",()=>{});process.on("SIGPIPE",()=>{});var I=K({env:l.env||process.env});I.kind||(E("no backend: "+I.why),process.exit(3));var f;try{f=I.spawn({file:l.file,args:l.args||[],cwd:l.cwd,env:l.env||process.env,cols:l.cols||80,rows:l.rows||24})}catch(t){E("spawn failed: "+t.message),process.exit(4)}var k=[],M=0,x=0,m=!1,O=null,S=null,J=!1,w=l.cols||80,g=l.rows||24,L={v:1,id:_,hostPid:process.pid,pid:f.pid||null,cwd:l.cwd,createdAt:new Date().toISOString(),cols:w,rows:g,backend:I.kind,...l.meta||{}},D=()=>{try{let t=N+".tmp";y.writeFileSync(t,JSON.stringify({...L,cols:w,rows:g,exited:m,code:O}),{mode:384}),y.renameSync(t,N)}catch(t){E("meta: "+t.message)}},T=new Set,R=t=>{let n=JSON.stringify(t)+`
+`;for(let o of T)if(o.ready)try{o.write(n)}catch{}},$=()=>[...T].filter(t=>t.ready).map(t=>({role:t.role,...t.info||{}}));f.onData(t=>{for(k.push(t),M+=t.length,x+=t.length;M>ot&&k.length>1;)M-=k[0].length,k.shift();R({t:"out",d:t,end:x})});var ct=null;f.onExit(({code:t,signal:n})=>{m=!0,O=t??null,S=n||null,E("program exited ("+O+(S?", "+S:"")+")"),D(),R({t:"exit",code:O,signal:S}),ct=setTimeout(Y,J?300:l.linger==null?3e4:l.linger)});function Y(){for(let t of T)try{t.end()}catch{}try{z.close()}catch{}for(let t of[v,N])try{y.rmSync(t,{force:!0})}catch{}setTimeout(()=>process.exit(0),50)}try{y.rmSync(v,{force:!0})}catch{}var z=it.createServer(t=>{t.setEncoding("utf8");let n="";T.add(t),t.on("data",c=>{n+=c;let a;for(;(a=n.indexOf(`
+`))>=0;){let d=n.slice(0,a);n=n.slice(a+1);let e;try{e=JSON.parse(d)}catch{continue}if(e.t==="hello"){t.role=e.role==="attach"?"attach":"daemon",t.info=e.role==="attach"?{pid:Number(e.pid)||null,tty:e.tty?String(e.tty).slice(0,80):null,term:e.term&&typeof e.term=="object"?e.term:null}:{},t.ready=!0;let r=k.join("");k=r?[r]:[];let s=x-M,p=typeof e.since=="number"&&e.since>=s&&e.since<=x?e.since:s;t.write(JSON.stringify({t:"hello",id:_,pid:f.pid||null,start:s,end:x,exited:m,code:O,signal:S,cols:w,rows:g,meta:L})+`
+`);let u=r.slice(p-s);u&&t.write(JSON.stringify({t:"out",d:u,end:x})+`
+`),m&&t.write(JSON.stringify({t:"exit",code:O,signal:S})+`
+`),R({t:"clients",list:$()})}else if(e.t==="in"){if(!m)try{f.write(String(e.d||""))}catch{}}else if(e.t==="resize"){let r=Math.max(2,Math.min(1e3,Number(e.c)||w)),s=Math.max(1,Math.min(500,Number(e.r)||g));if(r!==w||s!==g){w=r,g=s;try{f.resize(w,g)}catch{}}}else if(e.t==="kill")if(J=!0,m)Y();else{try{f.kill(e.sig||"SIGHUP")}catch{}setTimeout(()=>{if(!m)try{f.kill("SIGKILL")}catch{}},3e3).unref()}else if(e.t==="meta"&&e.patch&&typeof e.patch=="object"){for(let[r,s]of Object.entries(e.patch))/^(title|kind|sessionId|run|startCwd|renamed)$/.test(r)&&(L[r]=s);D()}}});let o=()=>{T.delete(t)&&R({t:"clients",list:$()})};t.on("close",o),t.on("error",o)}),lt=process.umask(127);z.listen(v,()=>{process.umask(lt);try{y.chmodSync(v,384)}catch{}D(),E("listening ("+I.kind+", pid "+f.pid+")")});z.on("error",t=>{E("socket: "+t.message);try{f.kill("SIGHUP")}catch{}process.exit(5)});

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/docs/macos-permissions.md

@@ -0,0 +1,52 @@
+# macOS permission prompts
+
+## What the prompt means
+
+> **"node" would like to access data from other apps.**
+> Keeping app data separate makes it easier to manage your privacy and security.
+
+macOS 14 and later ask this when a program reads inside another app's data: `~/Library/Containers/<app>`, `~/Library/Group Containers/<group>`, and on macOS 15 and later an app's own folder in `~/Library/Application Support`. The privacy service is called App Data (`kTCCServiceSystemPolicyAppData`).
+
+macOS asks on behalf of the *responsible* program. A program started by the login service is responsible for everything it starts, and so is a terminal app for its shells. Before Leftoff 1.0 the login service started `node` itself. So anything Leftoff ran showed up as "node": a headless Claude Code or Codex session, a board terminal, git. Claude Code's command sandbox asks for App Data on its own when it sets up.
+
+Two things made it repeat:
+- A bare `node` binary is remembered by its path, and a Homebrew or nvm upgrade puts node at a new path.
+- macOS keeps no "Don't Allow" for this service, so after Don't Allow it simply asks again.
+
+## What Leftoff does about it (1.0)
+
+- **Leftoff's own code stays out of other apps' data.** No walk, listing, git call or file read goes into `~/Library` except the two places Leftoff uses: its own `Application Support/Leftoff` and `LaunchAgents`. In particular:
+  - the board terminal's "Match my Ghostty" reads Ghostty's folder only once you pick that theme, not every time the menu opens;
+  - Syncthing's `config.xml` is read every 10 minutes instead of every minute;
+  - a git repo rooted at your home folder (dotfiles) never lets git walk `~/Library`.
+- **The rest asks as "Leftoff", once.** On a Mac the login service now starts a small launcher inside `~/Library/Application Support/Leftoff/Agent/Leftoff.app` (bundle id `dev.leftoff.Leftoff`). That launcher runs node as its child, so macOS names Leftoff, and an Allow is kept for the app across Leftoff and node upgrades.
+  - The app is built on your Mac once, with the Command Line Tools' compiler, and signed ad hoc. It is never rebuilt by an upgrade.
+  - Without the Command Line Tools the service runs node directly, as before, and `leftoff doctor` says so (`xcode-select --install`, then `leftoff update`).
+
+After `leftoff update`, expect at most one prompt that says "Leftoff". Click **Allow**.
+
+## If you clicked Don't Allow
+
+macOS doesn't keep a Don't Allow for App Data, so the next request asks again; click Allow then.
+
+To take back an Allow and be asked again (no sudo, only your own user's answers):
+
+    tccutil reset SystemPolicyAppData dev.leftoff.Leftoff
+
+`tccutil reset SystemPolicyAppData` without the id resets the answer for every app.
+
+## See who is asking
+
+    leftoff doctor --tcc
+
+This reads macOS's privacy log for the last 2 hours, then watches for a minute while you use Leftoff. It prints each request: who it was asked for (Leftoff, node, a terminal), which program touched the data, and whether a prompt showed. Options: `--seconds=120`, `--since=6h`, `--all` for every privacy service. It needs an admin account, never sudo; some fields may read `<private>`.
+
+To watch it by hand:
+
+    log stream --style compact --predicate 'subsystem == "com.apple.TCC" AND eventMessage CONTAINS "AUTHREQ"'
+
+`leftoff doctor` (without `--tcc`) says whether the login service runs as Leftoff.app.
+
+## Rebuilding
+
+`leftoff update --force` rebuilds Leftoff.app. A new build is a new code signature, so macOS asks once more.

package/docs/test-plan.md

@@ -0,0 +1,43 @@
+# Test plans from merged PRs
+
+Merging 50 PRs shouldn't need 50 reviews to feel safe. A test plan turns what Leftoff already knows about a batch of merged work into one short manual script: what to click, what you should see, and why it's on the list, ordered by risk and fitted to the time you have.
+
+## Where to start one
+
+- A project's page: **Test plan**, next to Decisions and Ask.
+- A repo's or a project's decision log: **Test plan**.
+- The PRs page: pick merged PRs, then **Test plan for these**.
+- The terminal: `leftoff testplan --project acme` (or `--repo web`), with `--since 14d` and `--minutes 15`, `30` or `60`. It prints Markdown.
+
+The window is the last 7 days unless you say otherwise. The budget is 30 minutes; 15 and 60 are the other choices, picked for each plan (it isn't a setting).
+
+## What it reads
+
+Only Leftoff's own notes, plus what the PRs page already reads with `gh` where it's signed in:
+
+- the PRs merged in the window that belong to the project or repo (or the ones you picked), each with its sessions;
+- each PR's sessions' newest checkpoint (Goal, Progress, Decided);
+- the walkthrough kept for its session: steps, Look / Assumption / Untested callouts, weak-test flags, spots, and the decisions a step follows or departs from. A PR with no kept walkthrough is not walked through on its own; it's read from its files, checkpoints and decisions and marked **no walkthrough**. **Walk through the N without one first** runs the usual walkthrough for each, one at a time;
+- the decisions these PRs accepted, superseded or departed from.
+
+## What it makes
+
+Up to about 12 checks that fit the budget. Each has a title, where to go (a screen, command or endpoint), at most 5 steps, what you should see, why it's on the list (with chips for the PRs, steps, checkpoints and decisions it comes from), minutes, and its risk as a shape and a word (▲ High, ◆ Medium, ▽ Low). Checks are ordered by risk, then by how many PRs each covers; checks on the same flow sit together.
+
+These always become checks, or are listed under **Not covered** with the reason: every Look and Untested callout on a Core step, every weak test (the test isn't trusted, so the behaviour gets a manual check), every decision a PR departs from or that was superseded in the window ("D-b replaced D-a on Nov 2: confirm the new behaviour, and that the old one is gone"), and every migration, config or auth change. A last line says how many of the PRs have at least one check.
+
+Every citation is checked against what Leftoff gave the model. A tag it made up is dropped, and a check left with none is dropped too, with a note under **What was checked in the answer**.
+
+## How it runs
+
+The same way Ask does: Claude Code headless and read-only (Read, Grep and Glob, nothing that changes a file, the same budget and timeout), never a session on the board. Without Claude Code it uses your summary model with a smaller pack; with neither, it makes the plan from the rules above. Starting one from the board follows Ask's rule for a model run: this Mac's own browser, or a paired device with **Trust my paired devices** on.
+
+## While you test
+
+Tick a check **Checked** or **Failed**; "3 of 9 checked" shows at the top. A failed check takes a one-line note, which goes into the export, and offers **Propose a decision**: what you learned goes into the repo's decision log as a proposed correction, linked to the plan, for you to accept or not later. It is never accepted on its own.
+
+**Copy as Markdown** gives a checklist with checkboxes; **Download .html** gives one self-contained file in the walkthrough export's look.
+
+## Where it's kept
+
+On the Mac that wrote it, in `~/.config/checkpoints/testplans/`, the newest 100 for 90 days, each deletable. Never in the synced folder. The list shows your other Macs' plans too, read over the peer link. Nothing is posted to GitHub or sent to anyone.

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

@@ -1,6 +1,6 @@
 {
   "name": "leftoff",
-  "version": "0.9.18-beta.1",
+  "version": "0.9.18-beta.11",
   "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

@@ -506,6 +506,10 @@ export function renderCheckpointMd(cp) {
   // Informative / long checkpoints (v0.4.6): sections below the three lines.
   // Older readers only pick up the **Label:** lines, so they still work.
   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.
+  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) {
     const v = cp[k]
     if (k === 'recap') { if (v) lines.push('', '### ' + SECTION_TITLES[k], oneLine(v).replace(/^\*+/, '')); continue }
@@ -683,7 +687,7 @@ const SESSION_ORDER = ['id', 'title', 'title_source', 'machine', 'cwd', 'repo',
 export const SESSION_EXTRA = ['inTurn', 'needsInput', 'backgroundTasks', 'turnsSinceCheckpoint', 'dormantStretch',
   'finalCheckpointDone', 'firstPrompt', 'lastPreview', 'lastNotification', 'lastEventAt', 'statusChanges', 'folder',
   'pid', 'tty', 'pidStartedAt', 'pidSource', 'term', 'closedAt', 'answers', 'lastNotificationMessage', 'needsInputAt', 'question', 'questionAt',
-  'startSource', 'historyTurns', 'healedAt', 'healedVia', 'archivedReason', 'backend', 'prLinks', 'prUnlinked', 'todos', 'files', 'startRepo', 'editedRepos', 'parked', 'nonInteractive', 'transcriptCwd', 'doubtedCheckpoints', 'liveLink', 'transcriptTurns', 'wasLive', 'headless', 'startedFrom', 'startProject', 'backgroundList', 'doneAt', 'recap', 'reviewed', 'wtLook', 'prShort']
+  'startSource', 'historyTurns', 'healedAt', 'healedVia', 'archivedReason', 'backend', 'prLinks', 'prUnlinked', 'todos', 'files', 'startRepo', 'editedRepos', 'parked', 'nonInteractive', 'transcriptCwd', 'doubtedCheckpoints', 'liveLink', 'transcriptTurns', 'wasLive', 'headless', 'startedFrom', 'startProject', 'backgroundList', 'doneAt', 'recap', 'reviewed', 'wtLook', 'prShort', 'decisionsGiven']
 
 export const SESSION_FIELDS = ['id', 'title', 'titleSource', 'machine', 'cwd', 'repo', 'transcriptPath', 'model', 'surface', 'capture',
   'status', 'startedAt', 'lastActivityAt', 'lastHeartbeatAt', 'endedAt', 'endReason', 'turns', 'lastCheckpointId',
@@ -1389,10 +1393,16 @@ const CHECKPOINT_BASE = [
   'If the session is blocked on the human (a question, a permission, a decision), start Next with "YOU:".',
   '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, 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):',
-  'Decisions:',
-  '- <a decision made in the session and the reason, one line each, at most 4>',
+  'Approach notes:',
+  '- <how the work is being done: the approach taken, a pattern or constraint it follows; one line each, at most 4. Not a choice between alternatives: those go only under Decided>',
   'Open questions:',
   '- <an unresolved question or uncertainty, at most 3>',
   'Files:',
@@ -1409,9 +1419,9 @@ const LONG_SECTIONS = [
   '3. <the step after that>',
 ]
 export const CHECKPOINT_SYSTEMS = {
-  short: [...CHECKPOINT_BASE, 'Write only those five lines.', 'Optionally a 6th line "Title: <max 6 words>" if asked for a title.', 'No preamble. No markdown. Under 90 words total.'].join('\n'),
-  informative: [...CHECKPOINT_BASE, ...INFORMATIVE_SECTIONS, 'Optionally a final line "Title: <max 6 words>" if asked for a title.', 'No preamble. No other markdown. Under 280 words total.'].join('\n'),
-  long: [...CHECKPOINT_BASE, ...INFORMATIVE_SECTIONS, ...LONG_SECTIONS, 'Optionally a final line "Title: <max 6 words>" if asked for a title.', 'No preamble. No other markdown. Under 630 words total.'].join('\n'),
+  short: [...CHECKPOINT_BASE, ...DECIDED_SECTION, 'Write only those five lines (and Decided, when there is one).', 'Optionally a 6th line "Title: <max 6 words>" if asked for a title.', 'No preamble. No markdown. Under 90 words total.'].join('\n'),
+  informative: [...CHECKPOINT_BASE, ...DECIDED_SECTION, ...INFORMATIVE_SECTIONS, 'Optionally a final line "Title: <max 6 words>" if asked for a title.', 'No preamble. No other markdown. Under 280 words total.'].join('\n'),
+  long: [...CHECKPOINT_BASE, ...DECIDED_SECTION, ...INFORMATIVE_SECTIONS, ...LONG_SECTIONS, 'Optionally a final line "Title: <max 6 words>" if asked for a title.', 'No preamble. No other markdown. Under 630 words total.'].join('\n'),
 }
 // The short prompt, as before v0.4.6 (kept under its old name for anything importing it).
 export const CHECKPOINT_SYSTEM = CHECKPOINT_SYSTEMS.short
@@ -1463,28 +1473,210 @@ export function buildCheckpointPrompt({ session, previous, messages, cfg = DEFAU
   head.push('Previous checkpoint: ' + prev, 'Files touched since then: ' + (files.length ? files.join(', ') : 'none'))
   if (Array.isArray(uncommitted)) head.push('Uncommitted files now: ' + (uncommitted.length ? uncommitted.slice(0, 12).join(', ') + (uncommitted.length > 12 ? ' and ' + (uncommitted.length - 12) + ' more' : '') : 'none (everything is committed)'))
   if (userNote) head.push('Note from the developer: ' + userNote)
+  // 2026-11-03: already read from its questions and plans, no model needed; redacted like the prompt, since they're saved
+  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('; '))
   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 }
+  return { system: CHECKPOINT_SYSTEMS[len], prompt, filesTouched: files, inputChars: prompt.length, length: len, maxTokens: SUMMARY_LENGTHS[len].maxTokens, found }
+}
+
+// ---------------------------------------------------------------- decisions (2026-11-03)
+//
+// A decision is a choice between real alternatives that someone made or
+// approved in a session: a question you answered from its options, a plan you
+// approved, a correction you gave, or a trade-off the agent chose and said so.
+// Not a task done or a file edited. A checkpoint with none is normal.
+// In a checkpoint each is one line under "### Decided":
+//   - <what was decided> · why: <one line> · over: <alt>; <alt> · from: asked
+// Both "·" and "|" separate the labelled parts (a model may write either).
+export const DECIDED_TITLE = 'Decided'
+export const DECIDED_MAX = 8
+export const DECISION_SOURCES = ['asked', 'plan', 'correction', 'agent']
+const DEC_PART = /\s+[·|]\s+(why|over|instead of|alternatives|from|source)\s*:\s*/i
+
+export function parseDecidedLine(line) {
+  let t = String(line == null ? '' : line).replace(/^\s*(?:[-*•]|\d+[.)])\s+/, '').replace(/\*\*/g, '').trim()
+  if (!t || NONE_RE.test(t)) return null
+  const d = { text: '', why: '', alternatives: [], source: 'agent' }
+  const m0 = t.match(/^\[(asked|plan|correction|agent)\]\s*/i) // "[asked] …" also reads
+  if (m0) { d.source = m0[1].toLowerCase(); t = t.slice(m0[0].length) }
+  const parts = t.split(DEC_PART)
+  d.text = parts[0].trim()
+  for (let i = 1; i + 1 < parts.length; i += 2) {
+    const k = parts[i].toLowerCase(), v = parts[i + 1].trim()
+    if (k === 'why') d.why = v
+    else if (k === 'from' || k === 'source') { const src = v.toLowerCase().replace(/[^a-z]/g, ''); if (DECISION_SOURCES.includes(src)) d.source = src }
+    else d.alternatives = v.split(/\s*;\s*/).map((x) => x.trim()).filter((x) => x && !NONE_RE.test(x))
+  }
+  return cleanDecided([d])[0] || null
+}
+
+export function renderDecidedLine(d) {
+  const safe = (x) => oneLine(x).replace(/\s+[·|]\s+/g, ' - ')
+  return '- ' + safe(d.text) + (d.why ? ' · why: ' + safe(d.why) : '') + (d.alternatives && d.alternatives.length ? ' · over: ' + d.alternatives.map((a) => safe(a).replace(/;/g, ',')).join('; ') : '') + ' · from: ' + (d.source || 'agent')
+}
+
+// Any list -> [{ text, why, alternatives, source }], one line each, deduplicated by text.
+export function cleanDecided(list) {
+  const out = [], seen = new Set()
+  for (const x of Array.isArray(list) ? list : []) {
+    if (!x || typeof x !== 'object') continue
+    const text = clip(oneLine(x.text).replace(/^["“]|["”]$/g, ''), 240)
+    if (!text || NONE_RE.test(text)) continue
+    const k = decisionNorm(text)
+    if (seen.has(k)) continue
+    seen.add(k)
+    const alternatives = (Array.isArray(x.alternatives) ? x.alternatives : []).map((a) => clip(oneLine(a), 120)).filter(Boolean).slice(0, 6)
+    out.push({ text, why: clip(oneLine(x.why), 240), alternatives, source: DECISION_SOURCES.includes(x.source) ? x.source : 'agent' })
+    if (out.length >= DECIDED_MAX) break
+  }
+  return out
+}
+export const decisionNorm = (t) => String(t || '').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').trim()
+
+// A decision's key in a repo's log: the same decision from the same session is
+// the same entry wherever it was read (the mod or the daemon). 12 hex characters.
+export function decisionKey(sessionId, text) {
+  const str = String(sessionId || '') + '\n' + decisionNorm(text)
+  let h1 = 0x811c9dc5, h2 = 0x01000193 ^ 0x5bd1e995
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i)
+    h1 = Math.imul(h1 ^ c, 0x01000193) >>> 0
+    h2 = Math.imul(h2 ^ c, 0x5bd1e995) >>> 0
+    h2 = (h2 ^ (h2 >>> 15)) >>> 0
+  }
+  return (h1.toString(16).padStart(8, '0') + h2.toString(16).padStart(8, '0')).slice(0, 12)
+}
+
+// "User has answered your questions: "Q"="A", "Q2"="B". You can now continue…" -> { Q: A }
+function questionAnswers(text, questions) {
+  const out = {}
+  const t = String(text || '')
+  for (let i = 0; i < questions.length; i++) {
+    const q = questions[i]
+    const at = t.indexOf('"' + q + '"="')
+    if (at < 0) continue
+    const from = at + q.length + 4
+    let end = -1
+    for (let j = i + 1; j < questions.length && end < 0; j++) { const n = t.indexOf('", "' + questions[j] + '"="', from); if (n >= 0) end = n }
+    if (end < 0) { const m = t.slice(from).search(/"(?:\.\s|\.?$|,\s*"[^"]*"=")/); end = m >= 0 ? from + m : t.length }
+    out[q] = t.slice(from, end).trim()
+  }
+  return out
+}
+
+const PLAN_OK = /(?:approved your plan|user has approved|plan (?:was )?approved)/i
+function planHeadline(plan) {
+  const lines = String(plan || '').replace(/\r\n?/g, '\n').split('\n').map((l) => l.trim()).filter(Boolean)
+  const h = lines.find((l) => /^#{1,3}\s+\S/.test(l)) || lines[0] || ''
+  return h.replace(/^#{1,6}\s+/, '').replace(/^(?:plan|implementation plan)\s*[:\-–—]\s*/i, '').replace(/\*\*/g, '').trim()
+}
+
+// 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 || []) {
+      const name = u && (u.tool || u.name)
+      if (!u || u.isError || !u.input) continue
+      if (name === 'AskUserQuestion' && Array.isArray(u.input.questions) && u.text) {
+        const qs = u.input.questions.filter((q) => q && q.question && Array.isArray(q.options) && q.options.length >= 2)
+        const ans = questionAnswers(u.text, qs.map((q) => String(q.question)))
+        for (const q of qs) {
+          const a = ans[q.question]
+          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])
+          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)) {
+        const head = planHeadline(u.input.plan)
+        if (head) out.push({ text: clip('Plan approved: ' + head, 240), why: '', alternatives: [], source: 'plan' })
+      }
+    }
+  }
+  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.
+// earlier: decisions already in this session's previous checkpoints (by text), left out.
+export function mergeDecided(found, fromModel, { earlier = [] } = {}) {
+  const seen = new Set((earlier || []).map((d) => decisionNorm(d && d.text)))
+  return cleanDecided([...(found || []), ...(fromModel || [])]).filter((d) => !seen.has(decisionNorm(d.text)))
 }
 
 // The extra sections of an informative / long checkpoint, by the heading a
 // model (or a checkpoint file) uses for them.
 const SECTION_KEYS = {
-  'decisions': 'decisions', 'key decisions': 'decisions',
+  // 1i (testplan): the section is "Approach notes" now (real choices go only under Decided); a checkpoint
+  // written before, or a model still saying "Decisions:" / "Key decisions", reads into the same field.
+  'approach notes': 'decisions', 'approach': 'decisions', 'decisions': 'decisions', 'key decisions': 'decisions',
   'open questions': 'questions', 'questions': 'questions',
   'files': 'files', 'files touched': 'files',
   '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',
+  'decided': 'decided', // 2026-11-03 decision memory
 }
-export const SECTION_TITLES = { decisions: 'Key decisions', questions: 'Open questions', files: 'Files touched', didntWork: 'What didn\'t work', recap: 'Recap', nextSteps: 'Next steps' }
+export const SECTION_TITLES = { decisions: 'Approach notes', questions: 'Open questions', files: 'Files touched', didntWork: 'What didn\'t work', recap: 'Recap', nextSteps: 'Next steps' }
 const SECTION_ORDER = ['decisions', 'questions', 'files', 'didntWork', 'recap', 'nextSteps']
 const NONE_RE = /^(none|n\/a|nothing|-|—|none yet|no(ne)? (open )?questions?)\.?$/i
-const LIMITS = { decisions: 6, questions: 5, files: 10, didntWork: 5, nextSteps: 5 }
+const LIMITS = { decided: DECIDED_MAX, decisions: 6, questions: 5, files: 10, didntWork: 5, nextSteps: 5 }
 
 // "src/a.js — retry loop" / "`src/a.js`: why" -> { path, why }
 export function parseFileNote(text) {
@@ -1495,7 +1687,7 @@ export function parseFileNote(text) {
   return p ? { path: p[1], why: '' } : { path: '', why: t }
 }
 
-function emptyExtras() { return { decisions: [], questions: [], files: [], didntWork: [], recap: '', nextSteps: [] } }
+function emptyExtras() { return { decided: [], decisions: [], questions: [], files: [], didntWork: [], recap: '', nextSteps: [] } }
 export function hasExtras(cp) {
   return !!cp && (['decisions', 'questions', 'files', 'didntWork', 'nextSteps'].some((k) => Array.isArray(cp[k]) && cp[k].length) || !!cp.recap)
 }
@@ -1510,6 +1702,7 @@ function parseSections(lines) {
     if (!v || NONE_RE.test(v)) 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 }
     ex[k].push(v)
   }
   for (const raw of lines) {
@@ -1528,8 +1721,11 @@ function parseSections(lines) {
     if (item) push(cur, item[1])
     else if (cur === 'recap') push(cur, line)
     else if (/^(doing|stopped at|next|title|open question|note|resume)\s*:/i.test(h)) cur = null
+    else if (cur === 'decided') continue // a decision is one bullet line; loose prose under the heading is not one
     else push(cur, line)
   }
+  // 1i: a line a model put under both Decided and the approach notes is a decision: it stays under Decided only
+  if (ex.decided.length && ex.decisions.length) { const dn = new Set(ex.decided.map((d) => decisionNorm(d.text))); ex.decisions = ex.decisions.filter((t) => !dn.has(decisionNorm(String(t).split(/\s+·\s+|\s+[-—–]\s+because\b/)[0]))) }
   for (const k of Object.keys(LIMITS)) ex[k] = ex[k].slice(0, LIMITS[k])
   ex.recap = clip(ex.recap, 1600)
   return ex
@@ -1707,6 +1903,8 @@ export function heuristicCheckpoint(messages, session = {}, { length = 'short',
   else if (lastError) next = 'Look at the last error and decide whether to retry or change approach.'
   else if (lastEdit >= 0 && lastCommit < lastEdit) next = 'Commit, or keep going.'
   const base = { doing, stoppedAt, next, title: null, openQuestion: null, parseOk: true }
+  const found = decisionsFromMessages(ms_) // 2026-11-03: only what the transcript states outright; the heuristic guesses none
+  if (found.length) base.decided = found
   const len = normalizeLength(length)
   if (len === 'short') return base
   const ex = emptyExtras()
@@ -1733,7 +1931,7 @@ export function heuristicCheckpoint(messages, session = {}, { length = 'short',
     ].filter(Boolean).join(' ')
     ex.nextSteps = next ? [next] : []
   }
-  return { ...base, ...ex }
+  return { ...base, ...ex, decided: base.decided || [] }
 }
 
 // Fallback title: {repo}@{branch} · {first 6 words of the first prompt}
@@ -1750,7 +1948,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)
 }