create-pmos 0.190.0 → 0.192.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.190.0",
+  "version": "0.192.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@69822e9
+kernel-source: pmos@6849bbf
 assembled: 2026-10-13
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-13T06:33:21Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T07:20:02Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-13T06:33:21Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T07:20:02Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-13T06:33:21Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T07:20:02Z"}
 status: stable
 ---
 

package/workspace/c3-driver-fixture.js

@@ -43,7 +43,7 @@ async function start({ name = 'c3-driver' } = {}) {
   const tI = { kind: 'initiative', ws, id: 'drv-ui' };
   const now = Date.now();
   // Today's run must fall on today: a run 5 hours back is yesterday's between midnight and 05:00, and the strip then reads
-  // "0 of 3 runs used today". So the same-day timeline is squeezed into the time since midnight when that is shorter.
+  // "0 runs today". So the same-day timeline is squeezed into the time since midnight when that is shorter.
   const H = Math.min(HOUR, Math.floor((now - new Date(now).setHours(0, 0, 0, 0)) / 6));
   const w = (line, at) => D.append(ledger, line, { now: at });
   const prop = (id, target, what, data, why, sources, at, run) => { w({ ev: 'proposal', id, target, what, data, why, sources: sources || [], run, by: 'agent:sess-4.0a1b2c3d' }, at); return id; };

package/workspace/c3-driver-test.js

@@ -4,7 +4,7 @@
  * LIVE mode: a real server and a scratch repository whose driver.jsonl this suite seeds (c3-driver-fixture.js; PMOS_DRIVER=off, so no
  * run starts and every line the page shows is one the fixture wrote). A real Chromium drives /c3.html.
  *
- *   strip      Initiative · Overview shows the Agent strip: the count, Pause, "1 of 3 runs used today", the status, the last action, the
+ *   strip      Initiative · Overview shows the Agent strip: the count, Pause, "1 run today", the status, the last action, the
  *              blocker line, one row per open proposal; a row opens to its text and sources (a URL source is a link)
  *   runs       the runs chip opens a sheet that lists today's run
  *   decide     Keep on a problem proposal posts /api/driver/keep and the row turns "Kept by you"; Send back asks for a note and posts it;
@@ -58,7 +58,7 @@ process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
   const rows = await st(() => [...document.querySelectorAll('[data-drv-row]')].map((r) => r.dataset.drvRow));
   ok('S1 the Agent strip draws one row per open proposal, in the order the agent filed them', rows.join() === [ids.problem, ids.evidence, ids.sizing, ids.move].join(), rows.join());
   const head = await st(() => document.querySelector('[data-drv="strip"] .sh2').textContent);
-  ok('S2 the header says AGENT 4, has Pause and "1 of 3 runs used today"', /Agent\s*4/i.test(head) && /Pause/.test(head) && /1 of 3 runs used today/.test(head), head);
+  ok('S2 the header says AGENT 4, has Pause and "1 run today", with no limit', /Agent\s*4/i.test(head) && /Pause/.test(head) && /1 run today/.test(head) && !/ of \d+ runs/.test(head), head);
   const body = await st(() => document.querySelector('[data-drv="strip"]').textContent);
   ok('S3 the status line says the agent is idle and waiting on you, with the last action', /Agent is idle · waiting on you/.test(body) && /The oldest proposal is 2 days old/.test(body) && /Last: filed 4 proposals/.test(body), body.slice(0, 300));
   ok('S4 the blocker line names who stopped the agent', /Stopped by: you\./.test(await st(() => document.querySelector('[data-drv="blocker"]').textContent)));
@@ -70,7 +70,7 @@ process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
   await page.click('[data-drv="runs"]');
   await sel('[data-drv="runs-sheet"]');
   const runs = await st(() => document.querySelector('[data-shell="sheet"]').textContent);
-  ok('S7 the runs chip opens a sheet with today\'s run', /Agent runs today/.test(runs) && /1 of 3 runs used today/.test(runs) && /Filed 4 proposals/.test(runs), runs.slice(0, 300));
+  ok('S7 the runs chip opens a sheet with today\'s run', /Agent runs today/.test(runs) && /1 run today/.test(runs) && /no daily limit/.test(runs) && /Filed 4 proposals/.test(runs), runs.slice(0, 300));
   await page.keyboard.press('Escape');
 
   /* ── decide ── */

package/workspace/c3-phone-test.js

@@ -16,6 +16,8 @@
  *   nodesk    there is no Full console; a phone that chose it before 2026-10-13 shows the companion again
  *   focus     Record on a meeting opens focus in one column: the clock, the now line, Topics, Captured, Note and Your slides as sheets,
  *             a context chip in a sheet, Ask and Stop at the foot, nothing wider than the screen; Back to your day closes it and recording goes on
+ *   two sides focus is two fixed halves that never scroll (v6): the room's latest line large over the one before it, and PMOS's newest
+ *             note alone below; ‹ › steps back through earlier notes, "N newer" returns; held notes open in a sheet and pull one in
  *   narrow    a long title and a long list of people never widen the companion past the screen
  *   desktop   at 1280 wide no companion is drawn
  *   620       the companion shows up to 640 wide, where the phone styling starts
@@ -141,7 +143,8 @@ const writes = (p) => (window.__c3demoWrites || []).filter((w) => w.path === p |
   await waitFor(page, () => !document.querySelector('[data-shell="sheet"] [data-fc="note-sheet"]'), null, 3000);
   await page.fill('[data-c3focus] [data-fc="ask-input"]', 'What did Budi ask?');
   await page.press('[data-c3focus] [data-fc="ask-input"]', 'Enter');
-  ok('record: Ask PMOS quietly adds the question to the conversation', await waitFor(page, () => /What did Budi ask/.test(document.querySelector('[data-c3focus] [data-fc="stream"]')?.textContent || ''), null, 5000));
+  ok('record: Ask PMOS quietly shows the answer with your question, as the newest note', await waitFor(page, () => { const s = document.querySelector('[data-c3focus] [data-fc="stream"]'); const at = s?.querySelector('[data-fc="pg-at"]')?.textContent || ''; const k = at.match(/^(\d+) of (\d+)$/);
+    return /You asked: What did Budi ask/.test(s?.textContent || '') && !!k && k[1] === k[2]; }, null, 5000));
   await page.click('[data-c3focus] [data-fc="leave"]');
   ok('record: Back to your day closes focus and keeps recording', await waitFor(page, () => !document.querySelector('[data-c3focus]') && !!document.querySelector('[data-c3ph-recbar] [data-c3ph-stop]'), null, 5000));
   ok('record: the bar has Focus', !!(await page.$('[data-c3ph-recbar] [data-c3ph-focus-bar]')));
@@ -172,6 +175,24 @@ const writes = (p) => (window.__c3demoWrites || []).filter((w) => w.path === p |
   ok('focus: no stage on the page itself, no desktop Leave focus or End meeting', await page.evaluate(() => !document.querySelector('[data-c3focus] [data-fc="stage"]') && !/Leave focus|End meeting/.test(document.querySelector('[data-c3focus]').textContent)));
   ok('focus: nothing is wider than the phone', await page.evaluate(() => { const f = document.querySelector('[data-c3focus]'); return f.scrollWidth <= innerWidth + 1 && [...f.querySelectorAll('*')].every((n) => n.getBoundingClientRect().right <= innerWidth + 1 || n.closest('.fc-cxs')); }),
     await page.evaluate(() => [...document.querySelectorAll('[data-c3focus] *')].filter((n) => n.getBoundingClientRect().right > innerWidth + 1 && !n.closest('.fc-cxs')).slice(0, 3).map((n) => n.className + ':' + Math.round(n.getBoundingClientRect().right)).join(' ')));
+  ok('two sides: the room shows its latest line large, the one before it faint', await page.evaluate(() => { const r = document.querySelector('[data-c3focus] [data-fc="room"]'); const now = r && r.querySelector('[data-fc="said-now"]'); const prev = r && r.querySelector('[data-fc="said-prev"]');
+    return !!now && !!prev && parseFloat(getComputedStyle(now).fontSize) > parseFloat(getComputedStyle(prev).fontSize) && !!r.querySelector('[data-fc="gist"]'); }));
+  ok('two sides: PMOS shows one note, the newest, with a pager', await page.evaluate(() => { const m = document.querySelector('[data-c3focus] [data-fc="pmos"]'); const at = m.querySelector('[data-fc="pg-at"]')?.textContent || ''; const k = at.match(/^(\d+) of (\d+)$/);
+    return m.querySelectorAll('[data-fc="note-card"]').length === 1 && !!k && k[1] === k[2] && +k[2] > 1; }));
+  ok('two sides: neither half scrolls and the page fits the screen', await page.evaluate(() => { const f = document.querySelector('[data-c3focus]'); const ft = f.querySelector('[data-fc="phone-foot"]').getBoundingClientRect();
+    return ['room', 'pmos'].every((k) => { const n = f.querySelector('[data-fc="' + k + '"]'); return n.scrollHeight <= n.clientHeight + 1 && getComputedStyle(n).overflowY !== 'auto'; }) && ft.bottom <= innerHeight + 1; }));
+  const firstNote = await page.textContent('[data-c3focus] [data-fc="note-card"] .fc-b');
+  await page.click('[data-c3focus] [data-fc="pg-prev"]');
+  ok('two sides: ‹ steps back to an earlier note and offers the newer one', await waitFor(page, (t) => { const c = document.querySelector('[data-c3focus] [data-fc="note-card"] .fc-b'); return !!c && c.textContent !== t && !!document.querySelector('[data-c3focus] [data-fc="pg-newest"]'); }, firstNote, 3000));
+  await page.click('[data-c3focus] [data-fc="pg-newest"]');
+  ok('two sides: "newer" goes back to the newest note', await waitFor(page, (t) => document.querySelector('[data-c3focus] [data-fc="note-card"] .fc-b')?.textContent === t && !document.querySelector('[data-c3focus] [data-fc="pg-newest"]'), firstNote, 3000));
+  if (await page.$('[data-c3focus] [data-fc="held"]')) {
+    const before = await page.textContent('[data-c3focus] [data-fc="pg-at"]');
+    await page.click('[data-c3focus] [data-fc="held"]');
+    ok('two sides: the held chip opens what PMOS is holding', await waitFor(page, () => !!document.querySelector('[data-shell="sheet"] [data-fc="held-sheet"] [data-fc="pull"]'), null, 3000));
+    await page.click('[data-shell="sheet"] [data-fc="pull"]');
+    ok('two sides: pulling one in shows it as the newest note', await waitFor(page, (b) => { const at = document.querySelector('[data-c3focus] [data-fc="pg-at"]')?.textContent || ''; const k = at.match(/^(\d+) of (\d+)$/); return !document.querySelector('[data-shell="sheet"] [data-fc="held-sheet"]') && at !== b && !!k && k[1] === k[2] && /early/.test(document.querySelector('[data-c3focus] [data-fc="note-card"]')?.textContent || ''); }, before, 3000));
+  } else ok('two sides: the demo meeting holds a note', false);
   ok('focus: the address does not change', await page.evaluate(() => !new URL(location.href).searchParams.has('focus')));
   await page.click('[data-c3focus] [data-fc="topics"]');
   ok('focus: Topics opens as a sheet over focus', await waitFor(page, () => !!document.querySelector('[data-shell="sheet"] [data-fc="topics-sheet"]') && !!document.querySelector('[data-c3focus]'), null, 5000));

package/workspace/c3-work-test.js

@@ -87,7 +87,10 @@ const W = '[data-pm-work]';
   if (!ready) return finish(1);
 
   /* the six views and their counts (R1) */
-  const bar = await st((w) => [...document.querySelectorAll(w + ' [data-pm-lenses] [data-lens]')].map((b) => [b.getAttribute('data-lens'), b.textContent.replace(/\d+$/, '').trim()]), W);
+  const readBar = () => st((w) => [...document.querySelectorAll(w + ' [data-pm-lenses] [data-lens]')].map((b) => [b.getAttribute('data-lens'), b.textContent.replace(/\d+$/, '').trim()]), W);
+  // A redraw puts a new bar in the header and the quiet layout moves it beside Add work 50 ms later; read it once it has settled.
+  await until(async () => (await readBar()).length === VIEWS.length, 3000, 100);
+  const bar = await readBar();
   ok('the bar has the six views in order: Inbox, Today, Upcoming, Waiting, Someday, Review', JSON.stringify(bar.map((b) => b[0])) === JSON.stringify(VIEWS) && JSON.stringify(bar.map((b) => b[1])) === JSON.stringify(LABELS), JSON.stringify(bar));
   const c0 = await counts();
   ok('each view shows its count (3, 5, 6, 2, 2, 3)', JSON.stringify(VIEWS.map((v) => c0[v])) === '[3,5,6,2,2,3]', JSON.stringify(c0));

package/workspace/guide/console3-sessions.md

@@ -91,6 +91,17 @@ If the connection to the workspace server is down, the message is not sent. The
 
 **Try again** on a session that has not started is not available. The session can wait for a question, for example whether to trust the folder. Open the session and read the question first.
 
+## Background runs
+
+Some jobs run in the background, with no terminal: the Initiative Driver, a refresh of Jira status or My work, and the other jobs PMOS starts by itself. They are listed under **Automatic**.
+
+- While a background run works, open it to see each step: the tool it uses and what it does (for example `› Bash pmos driver propose …`), the words of the agent, and a step that failed.
+- When a background run ends well, its row and its card show the first line of the agent's last message, for example "Filed 3 proposals".
+- When a background run does not end well, its row and its card give the reason: you stopped it, it ran past the time limit, the process was ended, it exited with an error code, it reported an error, or it used a tool that is not allowed in a background run.
+- If PMOS restarts while a background run works, its result cannot be read. The row and the card say "Interrupted: PMOS restarted while this run was working". Run the job again.
+
+A background run does not send replies to its card as a terminal session does. It files its work with its own commands, for example the Driver's proposals on the initiative.
+
 ## End a session
 
 1. Press the row to open it.

package/workspace/guide/initiative-driver.md

@@ -38,8 +38,8 @@ The sweep starts a run for a blocker the agent can work on, at most once per blo
 
 ## The limits
 
-- At most 3 runs per initiative per day, and 1 per Work task per day.
-- At most 3 runs at the same time. The others wait.
+- There is no daily limit on runs.
+- At most 3 runs at the same time, and 1 per initiative or Work task. The others wait.
 - A run that fails or times out counts against the day. Its reason is in the ledger.
 - A paused initiative or Work task starts no run.
 - `PMOS_DRIVER=off` in the environment of the server starts none.
@@ -52,7 +52,7 @@ In Discover, the agent writes the problem statement, the evidence, the opportuni
 
 ## Where you see the agent
 
-- **The Agent strip.** Open an initiative and stay on Overview. The Agent section is at the top. It shows the state of the agent (working, idle, waiting on you, paused or off), the last thing it did, and what stops it ("Stopped by: ..."). Each open proposal is one row with Keep, Send back and Drop. Press a row to read its text and its sources. A source that is a link opens in a new tab. Pause and Resume are in the header. The text "1 of 3 runs used today" opens the list of today's runs.
+- **The Agent strip.** Open an initiative and stay on Overview. The Agent section is at the top. It shows the state of the agent (working, idle, waiting on you, paused or off), the last thing it did, and what stops it ("Stopped by: ..."). Each open proposal is one row with Keep, Send back and Drop. Press a row to read its text and its sources. A source that is a link opens in a new tab. Pause and Resume are in the header. The text "1 run today" opens the list of today's runs.
 - **Keep, Send back and Drop on a row.** A kept row stays in the strip, marked "Kept by you", until you leave the page. Send back asks for a one-line note. A kept stage move changes the stage on the page at once. These three acts cannot be undone: each adds one line to the ledger.
 - **One line in Work.** A Work task with an open proposal shows one line under its title, for example "Agent drafted a follow-up to Dana. Nothing is sent." Press Review to read the draft. Keep copies the text so you can send it yourself, and records your decision. If the browser does not allow copying, the text is selected and you press Ctrl+C. A suggested next step shows Keep and Drop in the line. Shadow and Off show no line.
 - **Needs you.** In Briefing, the agent has two kinds of row: "Agent has 3 drafts on ..." and "... is waiting on you". Press a row to open the initiative. A long title wraps inside the card.

package/workspace/guide/phone-companion.md

@@ -46,14 +46,14 @@ The red button records a conversation or a meeting with the same recorder as **R
 
 ## Focus
 
-Focus is the desktop Meeting focus in one column. From the top:
+Focus shows the meeting on one screen. You do not scroll it. From the top:
 
 - **Back to your day**, the title, and the clock: the time since the start and the time left. Under them, the bar of what the room talked about.
 - The topic that the room is on now, and how long it has been on it.
 - **Topics**, **Captured**, **Note** and **Your slides** (or **Material**). Each one opens a sheet over focus. **Note** shows what the live note has found so far, or the last lines of the transcript.
-- **What's being said**, with context. Tap a context to see its detail.
-- The room's last lines, and the notes PMOS writes for you. The newest note is open. Tap an older note to open it. PMOS holds some notes for the right moment; tap one to see it now.
-- At the bottom, **Ask PMOS quietly** and **Stop**. Only you see your question and the answer. **Stop** asks before it stops the recording.
+- **The room**: the last line that was said, in large text, with the line before it in faint text. It changes when someone speaks. Under it, **What's being said**, with context. Tap a context to see its detail.
+- **PMOS, to you**: only the newest note that PMOS wrote for you, in large text, with the line that it answers. Tap **‹** to see earlier notes. If a new note comes while you look at an earlier one, tap **1 newer** to go to it. PMOS holds some notes for the right moment. Tap **Holding** to see them, and tap **Now** to see one now.
+- At the bottom, **Ask PMOS quietly** and **Stop**. Only you see your question and the answer. The answer shows as the newest note, under your question. **Stop** asks before it stops the recording.
 
 A recording that is not on the calendar, for example a talk in the corridor, opens the same focus without topics and slides.
 

package/workspace/lib/driver-cli.js

@@ -149,11 +149,10 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
     const mine = [...state.proposals.values()].filter((p) => D.targetKey(p.target) === D.targetKey(t.target));
     const day = D.localDay(now == null ? Date.now() : now);
     const used = D.runsOnDay(state, t.target, day);
-    const limit = t.target.kind === 'work' ? D.BUDGET.workPerDay : D.BUDGET.initiativePerDay;
-    const out = { target: t.target, paused: D.isPaused(state, t.target), mode: D.modeOf(state, t.target.kind === 'work' ? 'work' : null), runs_today: used, runs_limit: limit,
+    const out = { target: t.target, paused: D.isPaused(state, t.target), mode: D.modeOf(state, t.target.kind === 'work' ? 'work' : null), runs_today: used, runs_limit: null,
       proposals: mine.map((p) => ({ id: p.id, what: p.what, state: p.state, why: p.why, note: p.note, at: p.at })) };
     if (json) { say(JSON.stringify({ ok: true, ...out })); return 0; }
-    say(`${t.target.kind} ${t.target.id} · mode ${out.mode}${out.paused ? ' · paused' : ''} · ${used} of ${limit} runs today`);
+    say(`${t.target.kind} ${t.target.id} · mode ${out.mode}${out.paused ? ' · paused' : ''} · ${used} ${used === 1 ? 'run' : 'runs'} today`);
     for (const p of out.proposals) say(`  ${p.id} · ${p.what} · ${p.state}${p.note ? ` · "${p.note}"` : ''} — ${p.why}`);
     if (!out.proposals.length) say('  no proposals');
     return 0;

package/workspace/lib/driver-run.js

@@ -9,7 +9,7 @@
  *   3. finds the wakes: a `created` placement line (the page, Triage accept and `pmos initiative new` all write one), a board
  *      `move` line, a proposal the PM sent back with a note. Each key wakes once (the ledger's `wake` line makes it idempotent);
  *   4. every 30 minutes inside the day-check window, and outside quiet hours, runs the unblock sweep (no model, lib/driver.js);
- *   5. starts the queued runs the rules allow (mode, pause, budget, 3 at once) through spawnSession with origin `drive:<kind>:<id>`
+ *   5. starts the queued runs the rules allow (mode, pause, 3 at once) through spawnSession with origin `drive:<kind>:<id>`
  *      and the skill prompt, which lib/headless.js turns into a `claude -p` run with a fixed tool list.
  * `PMOS_DRIVER=off` does none of it. A run ends in a `run-end` line with its reason when it fails or times out.
  *

package/workspace/lib/driver.js

@@ -3,7 +3,7 @@
  *
  * The driver is a short headless run for one initiative or one Work task. It reads the record, files what it found as
  * PROPOSALS, and ends. The PM keeps, sends back or drops each proposal. This file is the pure core: the shape of every
- * line in <state folder>/driver.jsonl, the fold, the budget, the modes, the wake queue and the unblock sweep. It reads the
+ * line in <state folder>/driver.jsonl, the fold, the limits, the modes, the wake queue and the unblock sweep. It reads the
  * clock only through the `now` its callers pass. The only I/O is the thin read/append pair at the bottom.
  *
  *   LEDGER · KINDS · WHATS · MODES · DEFAULT_MODE · WAKES · BUDGET
@@ -28,15 +28,15 @@
  *   correction { proposal, run, kind: 'return'|'drop', by }   one per return or drop; the north star counts it
  *   pause|resume { target, by } · mode { board, mode, by }     PM only, as above. `board` '*' is every board.
  *   wake       { key, target, board, reason: created|moved|answered|stuck, blocker? }   queued: a run should start
- *   run-start  { run, target, board, wakes: [key], session }   one per run; counts against the day's budget
+ *   run-start  { run, target, board, wakes: [key], session }   one per run
  *   run-end    { run, ok, reason?, agent_run }                  agent_run is the run record the correction rate reads
  *   refused    { target, wakes: [key], reason }                 a wake the rules turned away, recorded
  *   blocker    { key, day, target, board, code, owner: 'pm'|'agent', text }   the sweep's finding, once per key per day
  *   epoch      { }                                              the first scan of this ledger: older events do not wake
  *
- * BUDGET (PM decision 4): 3 runs per initiative per local day, 1 per Work task per day, 3 at once, no daily total. A run
- * that fails or times out still counts. A wake the budget turns away is recorded as `refused`; a wake that only waits for
- * a free slot stays queued. Several wakes of one target are answered by ONE run.
+ * BUDGET (PM decision 4, as Wawan corrected it on 2026-10-13): no run limit per day, on an initiative, a Work task or in total.
+ * At most 3 runs at once and one per target at a time. A wake the mode or a pause turns away is recorded as `refused`; a
+ * wake that only waits for a free slot stays queued. Several wakes of one target are answered by ONE run.
  *
  * THE FACTORY NEVER WRITES HERE (D65): the CLI and the routes pass the actor from the call path. This ledger is not an
  * initiative record, an acceptance, an anchor or a stage move; Keep writes those through their own writers.
@@ -57,7 +57,7 @@ const MODES = Object.freeze(['off', 'shadow', 'approve']);
 const DEFAULT_MODE = 'approve';
 const WAKES = Object.freeze(['created', 'moved', 'answered', 'stuck']);
 const EVENTS = Object.freeze(['proposal', 'keep', 'return', 'drop', 'correction', 'pause', 'resume', 'mode', 'wake', 'run-start', 'run-end', 'refused', 'blocker', 'epoch']);
-const BUDGET = Object.freeze({ initiativePerDay: 3, workPerDay: 1, concurrent: 3 });
+const BUDGET = Object.freeze({ concurrent: 3 });
 const DAY = 86400000;
 const PM_WAIT_MS = DAY;                 // an open proposal older than this makes the PM the blocker
 const SWEEP_EVERY_MS = 30 * 60 * 1000;  // the sweep's cadence inside the day-check window
@@ -76,7 +76,7 @@ const pm = (by) => typeof by === 'string' && by.startsWith('pm:');
 
 const targetKey = (t) => `${t.kind}:${t.ws}:${t.id}`;
 const wsIdOf = (root) => crypto.createHash('sha1').update(path.resolve(root)).digest('hex').slice(0, 10);
-/** The local calendar day of a time in ms, YYYY-MM-DD. The budget counts per local day. */
+/** The local calendar day of a time in ms, YYYY-MM-DD. The runs of a day are listed per local day. */
 function localDay(ms) {
   const d = new Date(ms);
   const p = (n) => String(n).padStart(2, '0');
@@ -242,14 +242,12 @@ function openProposals(state, target) {
   return state.order.map((id) => state.proposals.get(id)).filter((p) => p.state === 'open' && (!want || targetKey(p.target) === want));
 }
 const runsOnDay = (state, target, day) => [...state.runs.values()].filter((r) => targetKey(r.target) === targetKey(target) && r.start && localDay(Date.parse(r.start)) === day).length;
-const budgetFor = (target) => (target.kind === 'work' ? BUDGET.workPerDay : BUDGET.initiativePerDay);
 
 /** May a run start for this target now? `running` is the number of driver runs alive. A closed rule refuses (and the
  * caller records it); a full house only waits. */
 function admit(state, { target, board }, { now, running = 0 } = {}) {
   if (modeOf(state, board) === 'off') return { ok: false, refuse: 'mode-off' };
   if (isPaused(state, target)) return { ok: false, refuse: 'paused' };
-  if (runsOnDay(state, target, localDay(now)) >= budgetFor(target)) return { ok: false, refuse: 'budget' };
   if (running >= BUDGET.concurrent) return { ok: false, wait: 'concurrency' };
   return { ok: true };
 }
@@ -266,18 +264,12 @@ function plan(state, { now, running = 0, activeTargets = [] } = {}) {
   }
   const start = []; const refused = [];
   const active = new Set(activeTargets);
-  // Plan on a scratch copy of the run counts so four wakes of one target never plan four runs.
-  const planned = new Map();
   let live = running;
   for (const g of groups.values()) {
     if (active.has(targetKey(g.target))) continue;
     const verdict = admit(state, g, { now, running: live });
     if (verdict.refuse) { refused.push({ target: g.target, wakes: g.wakes, reason: verdict.refuse }); continue; }
     if (verdict.wait) continue;
-    const day = localDay(now);
-    const used = runsOnDay(state, g.target, day) + (planned.get(targetKey(g.target)) || 0);
-    if (used >= budgetFor(g.target)) { refused.push({ target: g.target, wakes: g.wakes, reason: 'budget' }); continue; }
-    planned.set(targetKey(g.target), (planned.get(targetKey(g.target)) || 0) + 1);
     live++;
     start.push(g);
   }

package/workspace/lib/headless.js

@@ -6,10 +6,17 @@
  *   kindFor({ agent, origin, skill, env })        → 'notes' | 'skill' | 'ask' | 'drive' | 'scan-web' | 'scan-repo' | 'scan-research-web' | 'scan-research-repo' | 'report-setup' | 'report-find' | null   (null: open a pane, as before)
  *   argsFor(kind, { modelArgs, addDirs })          → the argv after `claude`
  *   parseResult(stdout)                            → { ok, text, isError, turns, durationMs, costUsd, denied[] }
+ *   streamLines(line)                              → { log: [lines], result: object|null }   one stream-json event, for the live log
  *   logLines(result, exitCode)                     → the lines the read-only log pane shows at the end
+ *   outcomeOf(result, { code, signal, timedOut, stopped, timeoutMin }) → { ok, headline, why, turns, durationMs, denied }   what the run card says
  *
  * Pure: no I/O, no process. server.js spawnSession starts the child and keeps the session row.
  *
+ * initiative background-run-outcome: the run prints `--output-format stream-json`, one JSON event per line, so the log shows
+ * each step while the run works (streamLines) and not only when it ends. The last event is the same result object that
+ * `--output-format json` prints, so parseResult reads either. outcomeOf is what the Sessions card says about a finished run:
+ * its first line of text when it ended well, or the real reason when it did not.
+ *
  * A headless run uses the PM's own login, model choice (D75), profile and connectors, exactly as a pane does.
  * It cannot ask for permission, so each kind gets a FIXED tool list here; a connector tool runs only where the
  * PM's own Claude Code settings already allow it, and anything else is denied and reported. No bypass flag is
@@ -114,7 +121,8 @@ function kindFor({ agent, origin, skill, env } = {}) {
 function argsFor(kind, { modelArgs = [], addDirs = [] } = {}) {
   const tools = TOOLS[kind];
   if (!tools) throw new Error('unknown headless kind: ' + kind);
-  const argv = ['-p', '--output-format', 'json', '--no-session-persistence', ...modelArgs, '--allowedTools', tools.join(',')];
+  // stream-json needs --verbose in print mode; it adds the step events, and the last line is the same result object as `json`.
+  const argv = ['-p', '--output-format', 'stream-json', '--verbose', '--no-session-persistence', ...modelArgs, '--allowedTools', tools.join(',')];
   // A web run gets no directory at all, whatever the caller passes: it must not be able to read the repository.
   if (!WEB_KINDS.includes(kind)) for (const d of addDirs) if (d) argv.push('--add-dir', String(d));
   return argv;
@@ -125,13 +133,23 @@ function timeoutMs(env) {
   return Number.isFinite(n) && n > 0 ? n : DEFAULT_TIMEOUT_MS;
 }
 
-/** The last JSON object on stdout (`--output-format json` prints one). Anything unreadable is not a result. */
+/** One JSON object per line, or null. */
+function jsonOf(line) {
+  const t = String(line || '').trim();
+  if (!t.startsWith('{')) return null;
+  try { const o = JSON.parse(t); return o && typeof o === 'object' ? o : null; } catch { return null; }
+}
+
+/** The result object on stdout: the whole of it (`--output-format json`), else the last line whose type is `result`
+ * (`stream-json`), else the last line that parses. Anything unreadable is not a result. */
 function parseResult(stdout) {
   const text = String(stdout || '').trim();
-  let o = null;
-  try { o = JSON.parse(text); } catch {
-    const at = text.lastIndexOf('\n{');
-    try { o = JSON.parse(at >= 0 ? text.slice(at + 1) : ''); } catch { o = null; }
+  let o = jsonOf(text);
+  if (!o || (o.type && o.type !== 'result')) {
+    const lines = text.split('\n');
+    o = null;
+    for (let i = lines.length - 1; i >= 0 && !o; i--) { const x = jsonOf(lines[i]); if (x && x.type === 'result') o = x; }
+    if (!o) { const at = text.lastIndexOf('\n{'); const x = jsonOf(at >= 0 ? text.slice(at + 1) : ''); if (x && (!x.type || x.type === 'result')) o = x; }
   }
   if (!o || typeof o !== 'object') return { ok: false, text: text.slice(-2000), isError: true, turns: null, durationMs: null, costUsd: null, denied: [] };
   const denied = Array.isArray(o.permission_denials)
@@ -147,6 +165,62 @@ function parseResult(stdout) {
   };
 }
 
+const oneLine = (v, max) => { const t = String(v == null ? '' : v).replace(/\s+/g, ' ').trim(); return t.length > max ? t.slice(0, max - 1) + '…' : t; };
+// The one argument that says what a tool call does: the command, the file, the pattern, the address.
+function toolWhat(input) {
+  const i = input && typeof input === 'object' ? input : {};
+  for (const k of ['command', 'file_path', 'path', 'pattern', 'url', 'query', 'description', 'prompt']) if (typeof i[k] === 'string' && i[k].trim()) return oneLine(i[k], 160);
+  return '';
+}
+
+/** The live log lines for one stream-json event, and the result when the event is the result. A line that is not an event
+ * (a warning the CLI printed) is shown as it is. Text the agent wrote is shown, cut to one short line per block. */
+function streamLines(line) {
+  const raw = String(line || '').replace(/\r$/, '');
+  if (!raw.trim()) return { log: [], result: null };
+  const o = jsonOf(raw);
+  if (!o) return { log: [oneLine(raw, 300)], result: null };
+  if (o.type === 'result') return { log: [], result: o };
+  if (o.type === 'system' && o.subtype === 'init') return { log: [`Started${o.model ? ' · ' + oneLine(o.model, 60) : ''}`], result: null };
+  const content = o.message && Array.isArray(o.message.content) ? o.message.content : [];
+  const log = [];
+  if (o.type === 'assistant') {
+    for (const c of content) {
+      if (!c || typeof c !== 'object') continue;
+      if (c.type === 'tool_use') { const w = toolWhat(c.input); log.push(`› ${oneLine(c.name, 60)}${w ? ' ' + w : ''}`); }
+      else if (c.type === 'text' && String(c.text || '').trim()) log.push(oneLine(c.text, 300));
+    }
+  } else if (o.type === 'user') {
+    for (const c of content) {
+      if (!c || c.type !== 'tool_result' || !c.is_error) continue;
+      const body = Array.isArray(c.content) ? c.content.map((x) => (x && x.text) || '').join(' ') : c.content;
+      log.push(`  ✗ ${oneLine(body, 200) || 'the tool call failed'}`);
+    }
+  }
+  return { log, result: null };
+}
+
+/** What the run card says about a finished background run. `ok` only when the process ended by itself with code 0 and its
+ * result is not an error. The headline is the first line of the agent's last message; the reason, when it failed, is the
+ * real one: stopped by the PM, the timeout, a signal, the exit code, an error result, or output that was not a result. */
+function outcomeOf(r, { code = null, signal = null, timedOut = false, stopped = false, timeoutMin = null } = {}) {
+  const res = r || { ok: false, text: '', isError: true, denied: [] };
+  const first = String(res.text || '').split('\n').map((x) => x.replace(/^[#>*\-\s]+/, '').trim()).find(Boolean) || '';
+  const denied = Array.isArray(res.denied) ? res.denied : [];
+  const base = { turns: res.turns == null ? null : res.turns, durationMs: res.durationMs == null ? null : res.durationMs, denied };
+  const ok = !timedOut && !stopped && !signal && code === 0 && res.ok && !res.isError;
+  if (ok) return { ok: true, headline: oneLine(first || 'Finished. It wrote no summary.', 160), why: null, ...base };
+  let why;
+  if (stopped) why = 'Stopped by you.';
+  else if (timedOut) why = `Stopped: still running after ${timeoutMin || Math.round(DEFAULT_TIMEOUT_MS / 60000)} minutes.`;
+  else if (signal) why = `The process was ended (${signal}).`;
+  else if (!res.ok) why = `It exited with code ${code} and printed no result${res.text ? ': ' + oneLine(res.text.split('\n').filter(Boolean).pop(), 200) : '.'}`;
+  else if (res.isError) why = `The run reported an error${first ? ': ' + oneLine(first, 200) : '.'}`;
+  else why = `It exited with code ${code}.`;
+  if (denied.length) why += ` Not allowed in a background run: ${denied.join(', ')}.`;
+  return { ok: false, headline: null, why, ...base };
+}
+
 function logLines(r, exitCode) {
   const out = [];
   if (r.text) out.push(...String(r.text).split('\n'));
@@ -158,4 +232,4 @@ function logLines(r, exitCode) {
   return out;
 }
 
-module.exports = { HEADLESS_SKILLS, HEADLESS_ORIGINS, ASK_ORIGINS, DRIVE_ORIGINS, SCAN_WEB_ORIGINS, SCAN_REPO_ORIGINS, SCAN_RESEARCH_WEB_ORIGINS, SCAN_RESEARCH_REPO_ORIGINS, WEB_KINDS, REPORT_SETUP_ORIGINS, REPORT_FIND_ORIGINS, TOOLS, DEFAULT_TIMEOUT_MS, kindFor, argsFor, timeoutMs, parseResult, logLines, switchedOff };
+module.exports = { HEADLESS_SKILLS, HEADLESS_ORIGINS, ASK_ORIGINS, DRIVE_ORIGINS, SCAN_WEB_ORIGINS, SCAN_REPO_ORIGINS, SCAN_RESEARCH_WEB_ORIGINS, SCAN_RESEARCH_REPO_ORIGINS, WEB_KINDS, REPORT_SETUP_ORIGINS, REPORT_FIND_ORIGINS, TOOLS, DEFAULT_TIMEOUT_MS, kindFor, argsFor, timeoutMs, parseResult, streamLines, outcomeOf, logLines, switchedOff };

package/workspace/lib/routes-driver.js

@@ -62,7 +62,7 @@ function stripOf(state, target, { now = Date.now(), board: asked = null } = {})
   const open = D.openProposals(state, target);
   return {
     target, board, mode: D.modeOf(state, board), paused: D.isPaused(state, target),
-    budget: { used: D.runsOnDay(state, target, day), limit: target.kind === 'work' ? D.BUDGET.workPerDay : D.BUDGET.initiativePerDay, concurrent: D.BUDGET.concurrent },
+    budget: { used: D.runsOnDay(state, target, day), limit: null, concurrent: D.BUDGET.concurrent },
     today: runs.filter((r) => r.start && D.localDay(Date.parse(r.start)) === day).map((r) => ({ run: r.run, start: r.start, end: r.end, ok: r.ok, reason: r.reason, proposals: [...state.proposals.values()].filter((p) => p.run === r.run).length })),
     running: running ? { run: running.run, since: running.start } : null,
     last: ended ? { run: ended.run, at: ended.end, ok: ended.ok, reason: ended.reason, proposals: [...state.proposals.values()].filter((p) => p.run === ended.run).length } : null,

package/workspace/lib/routes-report-setups.js

@@ -181,6 +181,9 @@ function startRun(ctx, w, file, ask, extra) {
   const s = ctx.spawnSession({ name: 'Report setup', agent: 'claude', ws: w.id, origin, initialInput: askPrompt(skill, ask, extra),
     extraEnv: { PMOS_REPORT_FILE: file, PMOS_REPORT_RUN: `setup:${ask.id}` },
     onDone: (r) => {
+      // A run that a Change has replaced ends after the new run started: its end must not settle the ask (the new run's proposal is
+      // still to come), and it must not drop the new run from `runs`.
+      if (s && runs.get(ask.id) !== s.id) return;
       runs.delete(ask.id);
       const res = (r && r.result) || {};
       const ok = !!(r && !r.timedOut && !r.stopped && r.code === 0 && res.ok && !res.isError);

package/workspace/lib/routes-runs.js

@@ -39,7 +39,8 @@ function sessionsOf(sessDir, live) {
     const exitedAt = Date.parse(meta.exitedAt);
     out.push({ id: meta.id, plan_item: meta.plan_item || null, name: meta.name || meta.id, origin: meta.origin || 'manual', cardId: meta.plan_item || null,
       startedAt: meta.created || null, endedAt: exited ? (Number.isFinite(exitedAt) ? exitedAt : st.mtimeMs) : null,
-      shown: row ? row.shown || null : null, label: row ? row.label || null : null });
+      shown: row ? row.shown || null : null, label: row ? row.label || null : null,
+      headless: meta.headless || null, outcome: meta.outcome || (row && row.outcome) || null, note: (row && row.note) || meta.note || '' });
   }
   return out;
 }
@@ -61,6 +62,31 @@ function pendingFor(run, hookLines, answers) {
   return out;
 }
 
+/* initiative background-run-outcome. A background run (`claude -p`, lib/headless.js) never writes `pmos reply` lines: it files
+ * its work through its own verbs (`pmos driver propose`, a skill's filing). Folding its empty reply file always gave "ended
+ * without a usable result", even for a run that did its work. Its card comes from how the process ended instead: the agent's
+ * own first line when it ended well, or the real reason when it did not. A run recorded before the outcome was kept is read
+ * from its note. */
+function outcomeFromNote(note) {
+  const n = String(note || '');
+  if (n === 'exited (code 0)') return { ok: true, headline: 'Finished. Open the session to read what it did.', why: null };
+  if (/^restored after server restart|^interrupted/.test(n)) return { ok: false, why: 'Interrupted: PMOS restarted while this run was working, so its result was not read. Run it again.' };
+  if (/^stopped: still running after/.test(n)) return { ok: false, why: n.charAt(0).toUpperCase() + n.slice(1) + '.' };
+  if (n === 'ended by the PM') return { ok: false, why: 'Stopped by you.' };
+  if (n === 'exited (the run reported an error)') return { ok: false, why: 'The run reported an error. Open the session to read it.' };
+  if (n) return { ok: false, why: 'It ' + n.replace(/^exited/, 'exited with') .replace(/\(code (\S+)\)/, 'code $1').replace(/\((signal [^)]+)\)/, '$1').replace(/\s+/g, ' ') + '.' };
+  return { ok: false, why: 'It ended without saying why. Open the session to read its log.' };
+}
+function headlessCard(card, s) {
+  const o = s.outcome || outcomeFromNote(s.note);
+  const facts = [o.turns != null ? o.turns + ' turns' : '', o.durationMs != null ? Math.round(o.durationMs / 1000) + ' s' : ''].filter(Boolean).join(' · ');
+  if (o.ok) {
+    return { ...card, state: 'done', title: 'Result', failure: null, recover: [], problems: [], fallback: null, nextMoves: [], claims: [],
+      result: { type: 'note', headline: o.headline, note: [o.headline, facts, (o.denied || []).length ? 'Not allowed in a background run: ' + o.denied.join(', ') + '.' : ''].filter(Boolean).join(' · '), flags: [], suggest: [] } };
+  }
+  return { ...card, state: 'failed', title: 'Failed', result: null, claims: [], failure: { code: 'background', why: o.why }, recover: ['open_session'], nextMoves: [] };
+}
+
 function lastAtOf(lines) {
   const t = lines.map((l) => l && l.at && Date.parse(l.at)).filter(Number.isFinite);
   return t.length ? Math.max(...t) : 0;
@@ -79,7 +105,8 @@ function view(ctx, now = Date.now()) {
     if (!live && !recent) continue;
     const lines = readLines(path.join(ctx.runtimeDir, 'replies', s.id + '.jsonl'));
     const run = runFor({ session: s.id, plan_item: s.plan_item });
-    const card = cardFor(lines, { run, extra: runAnswers.asEvents(run, answers), ended: !live, ctx: { now, lastAt: lastAtOf(lines) } });
+    let card = cardFor(lines, { run, extra: runAnswers.asEvents(run, answers), ended: !live, ctx: { now, lastAt: lastAtOf(lines) } });
+    if (s.headless && !live && !card.result) card = headlessCard(card, s);
     card.asked = card.ask ? card.ask.id : null;
     card.permissions = pendingFor(s.id, readLines(path.join(ctx.runtimeDir, 'hooks', s.id + '.jsonl')), answers);
     cards[s.id] = card;
@@ -125,4 +152,4 @@ async function handle(req, res, url, ctx) {
   return true;
 }
 
-module.exports = { prefixes, handle, view, sessionsOf };
+module.exports = { prefixes, handle, view, sessionsOf, headlessCard, outcomeFromNote };

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.190.0",
+  "version": "0.192.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.190.0",
+      "version": "0.192.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.190.0",
+  "version": "0.192.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/pm/c3-driver.js

@@ -122,7 +122,6 @@ export function openSendBack(ctx, p, onSent) {
 /** Plain words for the state of the agent on this initiative, from GET /api/driver/strip. */
 export function statusOf(d, now = Date.now()) {
   const open = d.proposals || [];
-  const used = (d.budget && d.budget.used) || 0; const limit = (d.budget && d.budget.limit) || 3;
   const oldest = open.map((p) => daysOld(p.at, now)).reduce((a, b) => Math.max(a, b), 0);
   let last = 'No run yet.';
   if (d.last) last = d.last.ok ? 'Last: ' + (d.last.proposals ? 'filed ' + plural(d.last.proposals, 'proposal') : 'looked and found nothing new') + ' · ' + whenLabel(d.last.at, new Date(now))
@@ -130,7 +129,6 @@ export function statusOf(d, now = Date.now()) {
   if (d.paused) return { ic: 'pause', b: 'Agent is paused', sub: 'It files nothing until you resume.', last };
   if (d.running) return { ic: 'spark', b: 'Agent is working · started ' + whenLabel(d.running.since, new Date(now)), sub: 'It works inside the limits you set and files each result as a proposal.', last };
   if (open.length) return { ic: 'wait', b: 'Agent is idle · waiting on you', sub: oldest >= 1 ? 'The oldest proposal is ' + plural(oldest, 'day') + ' old.' : plural(open.length, 'proposal') + ' wait for your decision.', last };
-  if (used >= limit) return { ic: 'clock', b: 'Agent is idle · used its runs for today', sub: 'It runs up to ' + limit + ' times a day on each initiative. It starts again tomorrow.', last };
   return { ic: 'spark', b: 'Agent is idle', sub: 'It starts again when something changes: a stage move, a new initiative, or a note from you.', last };
 }
 /** The line that says what stops the agent, or ''. A blocker the PM owns names the PM. */
@@ -186,14 +184,14 @@ export function driverStrip(ctx, row) {
   }
   function openRuns() {
     const d = S.data; const runs = (d && d.today) || [];
-    const used = d && d.budget ? d.budget.used : runs.length; const limit = d && d.budget ? d.budget.limit : 3;
+    const used = d && d.budget ? d.budget.used : runs.length;
     ctx.openSheet({ title: 'Agent runs today', icon: 'clock', body: el('div', { class: 'drv-sheet', 'data-drv': 'runs-sheet' },
-      note(row.title + ' · ' + used + ' of ' + limit + ' runs used today'),
+      note(row.title + ' · ' + plural(used, 'run') + ' today'),
       runs.length ? chgl(runs.map((r) => el('li', { 'data-drv-run': r.run }, icon('clock', 'sm'),
         el('span', null, el('b', null, whenLabel(r.start)), ' ', r.end ? (r.ok ? 'Run ended' : 'Run did not finish') : 'Running now'),
         tag(r.end ? (r.ok ? (r.proposals ? 'Filed ' + plural(r.proposals, 'proposal') : 'Nothing new') : (r.reason || 'Failed')) : 'Running now'))))
         : el('div', { class: 'fold' }, icon('info', 'sm'), 'The agent has not run on this initiative today.'),
-      el('div', { class: 'fold' }, icon('info', 'sm'), 'The agent runs up to ' + limit + ' times a day on each initiative. It stops at the limit and starts again tomorrow. A run that fails still counts.'),
+      el('div', { class: 'fold' }, icon('info', 'sm'), 'There is no daily limit. The agent runs when something changes, at most 3 at once across all initiatives.'),
       el('div', { class: 'iacts chips2' }, pbtn('outline', 'Board settings', 'settings', { onclick: () => { closeAnd(() => ctx.openBoardSettings()); } }))) });
   }
   const closeAnd = (fn) => { import('./c3-sheet.js').then((m) => { m.closeSheet(); fn(); }); };
@@ -227,7 +225,7 @@ export function driverStrip(ctx, row) {
     if (S.err || !d) { put(wrap, sect({ ic: 'spark', title: 'Agent', attrs: { 'aria-label': 'Agent' } },
       S.err ? el('div', { class: 'fold w', role: 'alert', 'data-drv': 'error' }, icon('alert', 'sm'), S.err, ' ', pbtn('outline', 'Try again', null, { onclick: load })) : note('Reading the agent'))); return; }
     if (!d.ledger) { put(wrap, sect({ ic: 'spark', title: 'Agent', attrs: { 'aria-label': 'Agent' } }, el('div', { class: 'fold', 'data-drv': 'no-ledger' }, icon('info', 'sm'), 'This repository has no state folder (pmos/state, state or .pmos), so the agent has nowhere to keep its drafts.'))); return; }
-    const used = d.budget.used + ' of ' + d.budget.limit + ' runs used today';
+    const used = plural(d.budget.used, 'run') + ' today';
     const right = el('div', { class: 'chips2' },
       d.mode === 'approve' ? (d.paused ? pbtn('outline', 'Resume', 'next', { 'data-drv-act': 'resume', onclick: () => pause(false) }) : pbtn('outline', 'Pause', 'pause', { 'data-drv-act': 'pause', onclick: () => pause(true) })) : null,
       lk({ 'data-drv': 'runs', onclick: openRuns }, icon('clock', 'sm'), used));

package/workspace/public/pm/c3-focus.css

@@ -251,3 +251,54 @@
 [data-shell="sheet"] [data-fc="stage"] .fc-card { display: flex; gap: var(--sp-2); align-items: center; margin-top: var(--sp-2); padding: var(--sp-2); border: 1px solid var(--border); border-radius: 8px; background: var(--card); flex-wrap: wrap; }
 [data-shell="sheet"] [data-fc="stage"] .fc-card .nb { display: grid; gap: 2px; flex: 1 1 160px; min-width: 0; overflow-wrap: anywhere; }
 [data-shell="sheet"] [data-fc="stage"] .seg { flex-wrap: wrap; }
+/* phone mode, two sides (v6): the room on top, PMOS to you below, each showing only its latest. Nothing scrolls. */
+.c3focus.fc-phone .fc-page { gap: 6px; }
+.c3focus.fc-phone .fc-side { display: flex; align-items: center; gap: 6px; font-size: 11px; letter-spacing: .6px; text-transform: uppercase; color: var(--muted-foreground); flex: none; }
+.c3focus.fc-phone .fc-side .fc-dot { width: 6px; height: 6px; }
+.c3focus.fc-phone .fc-room, .c3focus.fc-phone .fc-me { min-height: 0; display: flex; flex-direction: column; gap: 6px; padding: 10px 12px; border-radius: 8px; overflow: hidden; }
+.c3focus.fc-phone .fc-room { flex: 1.15 1 0; border: 1px solid var(--border); background: var(--card); }
+.c3focus.fc-phone .fc-said { flex: 1 1 0; min-height: 0; display: flex; flex-direction: column; justify-content: flex-end; gap: 4px; overflow: hidden; container-type: size; }
+.c3focus.fc-phone .fc-said p { margin: 0; flex: none; }
+.c3focus.fc-phone .fc-sp { font-size: var(--fs-1); color: var(--muted-foreground); }
+.c3focus.fc-phone .fc-said-prev { display: flex; gap: 6px; align-items: baseline; opacity: .55; font-size: var(--fs-2); min-width: 0; }
+.c3focus.fc-phone .fc-said-prev.you { justify-content: flex-end; }
+.c3focus.fc-phone .fc-said-prev .fc-st { min-width: 0; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.c3focus.fc-phone .fc-said-now { display: grid; gap: 1px; font-size: 20px; line-height: 1.3; font-weight: 500; animation: fcsaidin .35s ease-out; }
+.c3focus.fc-phone .fc-said-now .fc-sp { font-size: var(--fs-2); font-weight: 600; color: var(--foreground); }
+.c3focus.fc-phone .fc-said-now .fc-st { display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; }
+.c3focus.fc-phone .fc-said-now.you { text-align: right; }
+.c3focus.fc-phone .fc-said-now.you .fc-sp { color: var(--acc); }
+.c3focus.fc-phone .fc-said-now.dim { font-size: var(--fs-2); font-weight: 400; }
+@container (max-height: 96px) { .c3focus.fc-phone .fc-said-prev { display: none; } }
+@keyframes fcsaidin { from { opacity: 0; transform: translateY(6px); } }
+.c3focus.fc-phone .fc-room .fc-bandwrap { flex: none; border-top: 1px solid var(--border); padding-top: 6px; }
+.c3focus.fc-phone .fc-room .fc-gist { padding: 0; border: 0; background: none; }
+.c3focus.fc-phone .fc-room .fc-gist p > span { display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; }
+.c3focus.fc-phone .fc-room .fc-gist p > .ic { display: none; }
+.c3focus.fc-phone .fc-room .fc-gl { display: inline; font-size: 11px; letter-spacing: .6px; text-transform: uppercase; }
+.c3focus.fc-phone .fc-me { flex: 1.5 1 0; background: color-mix(in oklab, var(--acc) 9%, var(--card)); border: 1px solid color-mix(in oklab, var(--acc) 30%, var(--border)); }
+.c3focus.fc-phone .fc-me.fc-arr { animation: fcarr .9s ease-out; }
+@keyframes fcarr { 0% { box-shadow: 0 0 0 0 color-mix(in oklab, var(--acc) 45%, transparent); } 100% { box-shadow: 0 0 0 10px transparent; } }
+@media (prefers-reduced-motion: reduce) { .c3focus.fc-phone .fc-me.fc-arr, .c3focus.fc-phone .fc-said-now { animation: none; } }
+.c3focus.fc-phone .fc-one { flex: 1; min-height: 0; display: flex; flex-direction: column; gap: 6px; overflow: hidden; }
+.c3focus.fc-phone .fc-one > * { flex: none; }
+.c3focus.fc-phone .fc-mh { display: flex; align-items: center; justify-content: space-between; gap: 8px; }
+.c3focus.fc-phone .fc-mh .fc-side { color: var(--acc); }
+.c3focus.fc-phone .fc-pg { display: flex; align-items: center; gap: 2px; font-size: var(--fs-1); color: var(--muted-foreground); font-variant-numeric: tabular-nums; }
+.c3focus.fc-phone .fc-pg .ib { width: 32px; height: 32px; min-width: 0; padding: 0; }
+.c3focus.fc-phone .fc-pg .ib:disabled { opacity: .3; }
+.c3focus.fc-phone .fc-onote { flex: 1 1 auto !important; min-height: 0; display: flex; flex-direction: column; gap: 6px; overflow: hidden; }
+.c3focus.fc-phone .fc-onote > * { flex: none; }
+.c3focus.fc-phone .fc-cath { display: flex; align-items: center; gap: 8px; font-size: var(--fs-2); }
+.c3focus.fc-phone .fc-cath b { color: var(--acc); }
+.c3focus.fc-phone .fc-newer { margin-left: auto; min-height: 28px; padding: 2px 10px; border-radius: 6px; background: var(--acc); color: var(--background); font-size: var(--fs-1); font-weight: 600; }
+.c3focus.fc-phone .fc-onote .fc-re { font-size: var(--fs-1); font-style: italic; color: var(--muted-foreground); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.c3focus.fc-phone .fc-one .fc-b { margin: 0; font-size: 16px; line-height: 1.35; display: -webkit-box; -webkit-line-clamp: 4; -webkit-box-orient: vertical; overflow: hidden; }
+.c3focus.fc-phone .fc-onote .fc-acts2 { display: flex; gap: 6px; flex-wrap: wrap; }
+.c3focus.fc-phone .fc-onote .fc-meta { font-size: var(--fs-1); display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; }
+.c3focus.fc-phone .fc-onote .fc-meta > span + span::before { content: ' · '; }
+.c3focus.fc-phone .fc-dots { display: flex; justify-content: center; gap: 5px; margin-top: auto; }
+.c3focus.fc-phone .fc-pdot { width: 6px; height: 6px; border-radius: 50%; background: color-mix(in oklab, var(--acc) 25%, transparent); }
+.c3focus.fc-phone .fc-on.fc-pdot { background: var(--acc); }
+.c3focus.fc-phone .fc-heldc { align-self: flex-start; min-height: 30px; padding: 2px 10px; border-radius: 6px; border: 1px dashed color-mix(in oklab, var(--acc) 45%, var(--border)); font-size: var(--fs-1); color: var(--muted-foreground); }
+.c3focus.fc-phone:not([data-fc-state="ok"]) .fc-room, .c3focus.fc-phone:not([data-fc-state="ok"]) .fc-me { display: none; }

package/workspace/public/pm/c3-focus.js

@@ -110,7 +110,12 @@ export function openFocus({ event, date, pop, back, phone, note, meet, mtitle }
     ? el('div', { class: 'fc-page' },
       r.top = el('header', { class: 'fc-phd', 'data-fc': 'phone-head' }),
       r.now = el('div', { class: 'fc-phnow', 'data-fc': 'now-line' }),
-      r.band = el('div', { class: 'fc-bandwrap' }), convo,
+      el('section', { class: 'fc-room', 'data-fc': 'room', 'aria-label': 'The room' },
+        el('span', { class: 'fc-side mono' }, el('span', { class: 'fc-dot' }), 'The room'),
+        r.tick = el('div', { class: 'fc-said', 'aria-live': 'polite', 'data-fc': 'ticker' }),
+        r.band = el('div', { class: 'fc-bandwrap' })),
+      r.me = el('section', { class: 'fc-me', 'data-fc': 'pmos', 'aria-label': 'PMOS to you. Only you see it.' },
+        r.stream = el('div', { class: 'fc-one', 'data-fc': 'stream' })),
       el('div', { class: 'fc-phft', 'data-fc': 'phone-foot' }, r.form, r.act = el('span', { class: 'fc-phact' })))
     : pop
     ? el('div', { class: 'fc-page' },
@@ -128,7 +133,7 @@ export function openFocus({ event, date, pop, back, phone, note, meet, mtitle }
         el('div', { class: 'fc-s' }, r.stage = el('div', { class: 'fc-stagewrap' }), r.cap = el('div', { class: 'fc-capwrap' })),
         el('aside', { class: 'fc-w', 'aria-label': 'Conversation' }, convo)));
   root.append(page);
-  F = { id, date: day, ev0: ev, root, r, sig: {}, data: null, offset: 0, ui: { open: new Set(), folded: new Set(), pulled: [], stage: 0, picker: false, newTopic: false, addTopic: false, heldOpen: false, pending: new Map(), failed: new Map(), pill: false },
+  F = { id, date: day, ev0: ev, root, r, sig: {}, data: null, offset: 0, ui: { ni: null, open: new Set(), folded: new Set(), pulled: [], stage: 0, picker: false, newTopic: false, addTopic: false, heldOpen: false, pending: new Map(), failed: new Map(), pill: false },
     pop: !!pop, back: !!back, phone: !!phone, noteId: id ? '' : String(note || ''), meet: String(meet || ''), mtitle: String(mtitle || ''), choices: null,
     timers: {}, askTimers: new Map(), sheet: null, sheetOpen: false, status: 'reading', error: '',
     opener: document.activeElement && document.activeElement !== document.body ? document.activeElement : null, seenNotes: 0 };
@@ -567,6 +572,7 @@ function askBubble(a, err) {
 }
 
 function drawConversation(d) {
+  if (F.phone) { drawPhRoom(d); drawPhMe(d); return; }
   const tail = (d.tail || []).slice(F.pop ? -1 : -2);
   region('tick', tail, () => tail.map((x) => el('p', null, el('span', { class: 'mono' }, x.who), ' ' + x.text)));
   const notes = d.notes || [];
@@ -606,6 +612,76 @@ function drawConversation(d) {
   F.seenNotes = nNotes;
 }
 
+/* ── phone mode: two sides, like a translator app in conversation mode (v6) ─────────────────────────────────────────
+   The scrolling conversation was hard to follow live, so nothing scrolls. The room gets the top: its latest line, large,
+   and the one before it, faint. PMOS gets the bottom: only its newest note, large. ‹ › steps back through earlier notes;
+   a note that arrives while you look back shows as "1 newer". Held notes wait behind one chip. */
+
+function drawPhRoom(d) {
+  const tail = (d.tail || []).slice(-2);
+  region('tick', tail, () => {
+    if (!tail.length) return [el('p', { class: 'fc-said-now dim', 'data-fc': 'said-now' }, recState(d) === 'recording' ? 'Listening to the room.' : 'PMOS hears the room when it records.')];
+    const line = (x, cls, fc) => el('p', { class: cls + (x.who === 'You' ? ' you' : ''), 'data-fc': fc }, el('span', { class: 'fc-sp mono' }, x.who), el('span', { class: 'fc-st' }, x.text));
+    const cur = tail[tail.length - 1]; const prev = tail.length > 1 ? tail[0] : null;
+    return [prev ? line(prev, 'fc-said-prev', 'said-prev') : null, line(cur, 'fc-said-now', 'said-now')];
+  });
+}
+/** What PMOS has shown you, oldest first: notes, notes you pulled in early, and questions not answered yet (an answer carries its question). */
+function phItems(d) {
+  const notes = d.notes || [];
+  const pulled = F.ui.pulled.map((id) => notes.find((n) => n.id === id)).filter(Boolean);
+  const shown = notes.filter((n) => n.show !== 'hold').concat(pulled.map((n) => ({ ...n, at: F.pulledAt && F.pulledAt[n.id] || n.at, pulledWhy: 'You asked for it early. PMOS was holding it ' + (n.when || 'for later') + '.' })));
+  const asks = (d.asks || []).slice();
+  for (const [id, p] of F.ui.pending) if (!asks.some((a) => a.id === id)) asks.push({ id, at: p.at, question: p.question, state: 'working' });
+  const answered = new Set(shown.map((n) => n.ask).filter(Boolean));
+  const qOf = new Map(asks.map((a) => [a.id, a.question]));
+  return [...shown.map((n) => ({ kind: 'note', at: n.at, n, q: n.ask ? qOf.get(n.ask) || '' : '' })), ...asks.filter((a) => !answered.has(a.id) && a.state !== 'answered').map((a) => ({ kind: 'ask', at: a.at, a }))]
+    .map((x, i) => ({ ...x, i })).sort((a, b) => a.at - b.at || a.i - b.i);
+}
+function drawPhMe(d) {
+  const items = phItems(d); const N = items.length; const last = N - 1;
+  const i = F.ui.ni == null ? last : Math.max(0, Math.min(F.ui.ni, last));
+  const newer = F.ui.ni == null ? 0 : last - i;
+  const held = (d.notes || []).filter((n) => n.show === 'hold' && !F.ui.pulled.includes(n.id));
+  const comp = d.companion || {}; const recording = recState(d) === 'recording';
+  const x = items[i];
+  const sig = [items.map((y) => y.kind === 'note' ? [y.n.id, y.n.pulledWhy ? 1 : 0, y.q] : [y.a.id, y.a.state]), i, newer, held.map((n) => n.id), recording, !!comp.on, comp.error || '', [...F.ui.failed]];
+  region('stream', sig, () => {
+    const head = el('div', { class: 'fc-mh' }, el('span', { class: 'fc-side mono' }, icon('spark', 'sm'), 'PMOS, to you'),
+      N > 1 ? el('span', { class: 'fc-pg' }, ib('Earlier note', 'prev', { 'data-fc': 'pg-prev', ...(i === 0 ? { disabled: '' } : {}) }), el('span', { class: 'mono', 'data-fc': 'pg-at' }, (i + 1) + ' of ' + N), ib('Later note', 'next', { 'data-fc': 'pg-next', ...(i === last ? { disabled: '' } : {}) })) : null);
+    let body;
+    if (!x) body = el('p', { class: 'fc-b dim', 'data-fc': 'listening' }, !recording ? 'PMOS listens when the meeting records.' : comp.on === false ? 'PMOS is listening to the transcript only. The companion is off, so it adds no notes.' : 'Listening. A note shows here when it helps.');
+    else if (x.kind === 'ask') {
+      const err = F.ui.failed.get(x.a.id);
+      body = el('div', { class: 'fc-onote', 'data-fc': 'ask-q' }, el('span', { class: 'fc-re' }, 'You asked: ' + x.a.question),
+        el('p', { class: 'fc-b dim', role: 'status' }, err ? 'PMOS could not answer: ' + err : 'PMOS is reading the record.'));
+    } else {
+      const n = x.n; const why = n.pulledWhy || n.why;
+      body = el('div', { class: 'fc-onote', 'data-fc': 'note-card', 'data-cat': n.cat },
+        el('span', { class: 'fc-cath' }, el('b', null, n.cat), el('span', { class: 'dim mono' }, hhmm(n.at)),
+          newer ? button({ variant: 'ghost', label: [newer + ' newer', icon('next', 'sm')], attrs: { class: 'fc-newer', 'data-fc': 'pg-newest', title: 'Show the newest note' } }) : null),
+        x.q ? el('span', { class: 'fc-re' }, 'You asked: ' + x.q) : n.heard ? el('span', { class: 'fc-re' }, n.heard) : null,
+        el('p', { class: 'fc-b' }, n.body),
+        (n.acts || []).length ? el('div', { class: 'fc-acts2' }, ...n.acts.map(actBtn)) : null,
+        el('span', { class: 'fc-meta dim' }, why ? el('span', null, el('b', null, 'Why now'), ' ' + why) : null, n.src ? el('span', null, 'from ' + n.src) : null));
+    }
+    return [head, body,
+      N > 1 ? el('div', { class: 'fc-dots', 'aria-hidden': 'true' }, ...items.map((_, k) => el('i', { class: 'fc-pdot' + (k === i ? ' fc-on' : '') }))) : null,
+      held.length ? button({ variant: 'ghost', label: [icon('clock', 'sm'), 'Holding ' + held.length + ' for later'], attrs: { class: 'fc-heldc', 'data-fc': 'held', title: 'What PMOS is holding for the right moment' } }) : null,
+      comp.error ? el('p', { class: 'dim fc-note', role: 'status' }, comp.error) : null];
+  });
+  if (N > F.seenNotes && F.ui.ni == null && F.seenNotes) { const m = F.r.me; m.classList.remove('fc-arr'); void m.offsetWidth; m.classList.add('fc-arr'); }
+  F.seenNotes = N;
+}
+function heldBuild() {
+  const held = (F.data.notes || []).filter((n) => n.show === 'hold' && !F.ui.pulled.includes(n.id));
+  return [el('div', { class: 'fc-heldsheet', 'data-fc': 'held-sheet' },
+    el('p', { class: 'dim fc-note' }, 'Each one waits for the moment it fits. Pull one in now if you want it early.'),
+    held.length ? el('ul', { class: 'list', role: 'list' }, ...held.map((n) => el('li', { class: 'nrow' }, el('span', { class: 'ki' }, icon('clock')),
+      el('div', { class: 'nb' }, el('span', { class: 'tt' }, n.cat), n.when ? el('div', { class: 'dim fc-note' }, 'Shows ' + n.when) : null),
+      pbtn('outline', 'Now', null, { 'data-fc': 'pull', 'data-id': n.id, title: 'Show it now' })))) : el('p', { class: 'dim fc-note' }, 'Nothing is held.'))];
+}
+
 function askForm() {
   const input = el('input', { type: 'text', 'aria-label': 'Ask PMOS, only you see it', placeholder: 'Ask PMOS quietly', maxlength: '500', autocomplete: 'off', 'data-fc': 'ask-input' });
   const form = el('form', { class: 'fc-in', 'data-fc': 'ask-form' }, input, ib('Ask', 'next', { type: 'submit', 'data-fc': 'ask' }));
@@ -622,7 +698,7 @@ async function ask(question) {
   const r = await pmPost('/api/meeting-focus/ask', body);
   if (F !== f) return;
   if (!r || !r.ok) { toast({ text: (r && r.error) || 'The question was not sent.', tone: 'error' }); return; }
-  f.ui.pending.set(r.id, { question, at });
+  f.ui.pending.set(r.id, { question, at }); f.ui.ni = null;
   draw();
   const t = setInterval(async () => {
     const s = await pmGet('/api/meeting-focus/ask?id=' + encodeURIComponent(r.id));
@@ -800,6 +876,9 @@ function onClick(ev) {
   if (k === 'open-link' || k === 'present') { openUrl(t.dataset.url); return; }
   if (k === 'start') { startRecording(); return; }
   if (k === 'end') { endMeeting(); return; }
+  if (k === 'pg-prev' || k === 'pg-next') { const N = phItems(d).length; const i = F.ui.ni == null ? N - 1 : F.ui.ni; const j = k === 'pg-prev' ? Math.max(0, i - 1) : i + 1; F.ui.ni = j >= N - 1 ? null : j; drawConversation(d); return; }
+  if (k === 'pg-newest') { F.ui.ni = null; drawConversation(d); return; }
+  if (k === 'held' && F.phone) { showSheet('held', 'PMOS is holding', 'clock', heldBuild); return; }
   if (k === 'fold') { F.ui.folded.add(t.dataset.id); drawConversation(d); return; }
   if (k === 'unfold') { const id = t.dataset.id; if (F.ui.open.has(id)) F.ui.open.delete(id); else F.ui.open.add(id); F.ui.folded.delete(id); drawConversation(d); return; }
   if (k === 'pull') {
@@ -830,5 +909,6 @@ document.addEventListener('click', (ev) => {
   if (k === 'material-pick') { F.ui.stage = Number(t.dataset.i) || 0; refreshSheet(true); return; }
   if (k === 'note-tab') { F.ui.noteTab = t.dataset.tab === 'said' ? 'said' : 'note'; refreshSheet(true); return; }
   if (k === 'stop-keep') { closeSheet(); return; }
+  if (k === 'pull') { const id = t.dataset.id; F.ui.pulled.push(id); (F.pulledAt ||= {})[id] = nowMs(); F.ui.ni = null; closeSheet(); drawConversation(F.data); return; }
   if (k === 'stop-ok') { closeSheet(); endMeeting().then(() => { if (F && F.phone) closeFocus(); }); return; }
 });

package/workspace/public/pm/run-card.js

@@ -81,6 +81,7 @@ function failBox(ctx, card, ui) {
     else if (code === 'blocked') { title = 'Blocked'; why = card.failure.why; }
     else if (code === 'api_error') { title = 'The turn failed on an API error'; why = 'Nothing on the card changed. Retrying usually works.'; retry = true; }
     else if (code === 'format') { title = 'Recorded in a newer format'; why = card.failure.why; }
+    else if (code === 'background') { title = 'The background run did not finish its work'; why = card.failure.why; retry = false; }
     else if (code === 'crashed') { title = 'The session ended with an error'; why = 'It exited with a non-zero code. Nothing on the card changed.'; retry = true; }
     else { title = 'The session ended without a usable result'; why = 'Nothing on the card changed.'; retry = true; }
   } else return null;

package/workspace/public/pm/sessions-panel.js

@@ -31,7 +31,7 @@ const liveWord = (s, c) => (plain(s, c) ? s.label : stateWord(c || { state: 'wor
 function outcomeOf(card, meta) {
   if (meta && meta.out) return meta.out;
   if (!card) return 'ended';
-  if (card.state === 'done' && card.result) return 'Result: ' + card.result.type;
+  if (card.state === 'done' && card.result) return card.result.headline || ('Result: ' + card.result.type);
   if (card.state === 'failed') return (card.failure && card.failure.why) || 'Failed';
   return card.title || 'ended';
 }

package/workspace/server.js

@@ -2639,6 +2639,7 @@ function persist(s) {
   if (s.autoDelete) meta.autoDelete = s.autoDelete;
   if (s.autoEnded) meta.autoEnded = true;
   if (s.headless) meta.headless = s.headless;
+  if (s.outcome) meta.outcome = s.outcome;   // a background run's end, for its card (initiative background-run-outcome)
   if (s.exitedAt) meta.exitedAt = s.exitedAt;
   // The breakdown item a Hand to agent session is bound to, so a restart keeps the binding (pm-os-absorb Run 1).
   if (s.plan_item) meta.plan_item = s.plan_item;
@@ -2729,6 +2730,14 @@ function restorePersisted() {
         // seed: this server was DOWN, so output produced in the gap never reached our ring buffer.
         // Control mode replays no history, so take tmux's — it is the superset (R7 + scrollback).
         attachPty(s, { seed: true });       // the process is alive — reconnect to it, live
+      } else if (meta.headless && meta.state !== 'exited') {
+        // A background run that was still working when this server stopped. Its process (detached) may have finished on its own,
+        // but its output went nowhere: say so on the row, in its log and on its card, instead of a blank "Running in the background".
+        s.state = 'exited';
+        s.note = 'interrupted: PMOS restarted while this background run was working';
+        s.outcome = { ok: false, headline: null, why: 'Interrupted: PMOS restarted while this run was working, so its result was not read. Run it again.', turns: null, durationMs: null, denied: [] };
+        s.buf += `\r\n\x1b[38;5;203m[${s.note}]\x1b[0m\r\n`;
+        if (!s.exitedAt) { try { s.exitedAt = new Date(fs.statSync(path.join(SESS_DIR, f)).mtimeMs).toISOString(); } catch {} }
       } else {
         s.state = 'exited';
         s.note = meta.note || 'restored after server restart — scrollback preserved; ↻ respawn to start a new process';
@@ -2949,6 +2958,7 @@ function sessionList() {
       automatic: sessionOrigin.isAutomatic(s.origin),   // the workspace started it, not the PM: the dock hides these by default
       auto_delete: s.autoDelete || null,
       headless: s.headless || null,   // workspace-headless-jobs: a background run with no terminal ('notes' or 'skill')
+      outcome: s.outcome || null,      // background-run-outcome: how a finished background run ended (lib/headless.js outcomeOf)
       plan_item: s.plan_item || null,   // Hand to agent: the breakdown item this session is bound to (pm-os-absorb Run 1)
       // No `token` and no `tokenHash` here, ever: the page never sees a session token (F5; r25-guards.test.js checks it).
       // Derived presentation state, JOINED from both sources: the cadence clock above and the
@@ -3497,9 +3507,23 @@ function startHeadless(base, workdir, kind, launchArgs, env, initialInput, addDi
     say(`\x1b[38;5;203m✗ ${s.note}\x1b[0m\n`); persist(s); pushSessions(); pushWorkspaces(); return s;
   }
   s.child = child;
-  let out = '', err = '', timedOut = false;
-  const CAP = 5 * 1024 * 1024;
-  child.stdout.on('data', (d) => { if (out.length < CAP) out += d; s.lastOutputAt = Date.now(); });
+  // initiative background-run-outcome: stdout is stream-json, one event per line. Each step goes into the log as it happens,
+  // so the session shows what the run is doing. Only the result line and a short tail are kept for the end.
+  let out = '', err = '', timedOut = false, part = '', resultLine = '';
+  const TAIL = 64 * 1024;
+  const dim = (t) => `\x1b[38;5;244m${t}\x1b[0m`;
+  const feed = (line) => {
+    const ev = headlessLib.streamLines(line);
+    if (ev.result) resultLine = line;
+    if (ev.log.length) say(ev.log.map((l) => (/^›/.test(l) ? dim(l) : l)).join('\n') + '\n');
+  };
+  child.stdout.on('data', (d) => {
+    s.lastOutputAt = Date.now();
+    out = (out + d).slice(-TAIL);
+    part += d;
+    const lines = part.split('\n'); part = lines.pop();
+    for (const l of lines) feed(l);
+  });
   child.stderr.on('data', (d) => { if (err.length < 65536) err += d; });
   child.on('error', (e) => { err += String(e && e.message || e); });
   const timer = setTimeout(() => {
@@ -3517,15 +3541,20 @@ function startHeadless(base, workdir, kind, launchArgs, env, initialInput, addDi
     clearTimeout(timer); clearInterval(beat);
     s.child = null; s.state = 'exited';
     if (s.scratchDir) { try { fs.rmSync(s.scratchDir, { recursive: true, force: true }); } catch { /* the temp folder goes with the next clean-up */ } }
-    const r = headlessLib.parseResult(out);
-    if (r.ok) say(headlessLib.logLines(r, code).join('\n') + '\n');
-    else if (out.trim()) say(r.text + '\n');
-    if (err.trim()) say(`\x1b[38;5;244m${err.trim().split('\n').slice(-20).join('\n')}\x1b[0m\n`);
-    s.note = timedOut ? `stopped: still running after ${Math.max(1, Math.round(headlessLib.timeoutMs() / 60000))} minutes`
+    if (part) { feed(part); part = ''; }
+    const r = headlessLib.parseResult(resultLine || out);
+    if (r.ok) say('\n' + headlessLib.logLines(r, code).join('\n') + '\n');
+    else if (out.trim() && !resultLine) say(r.text.split('\n').slice(-20).join('\n') + '\n');
+    if (err.trim()) say(dim(err.trim().split('\n').slice(-20).join('\n')) + '\n');
+    const timeoutMin = Math.max(1, Math.round(headlessLib.timeoutMs() / 60000));
+    s.note = timedOut ? `stopped: still running after ${timeoutMin} minutes`
       : s.stoppedByPm ? 'ended by the PM'
       : signal ? `exited (signal ${signal})`
       : (code === 0 && r.ok && r.isError) ? 'exited (the run reported an error)'
       : `exited (code ${code})`;
+    // What the Sessions card says about this run (lib/routes-runs.js): the agent's own first line, or the real reason it failed.
+    s.outcome = headlessLib.outcomeOf(r, { code, signal, timedOut, stopped: !!s.stoppedByPm, timeoutMin });
+    if (!s.outcome.ok && err.trim() && !r.ok) s.outcome.why += ' ' + err.trim().split('\n').filter(Boolean).pop().slice(0, 200);
     if (s.note !== 'exited (code 0)') say(`\x1b[38;5;203m[${s.note}]\x1b[0m\n`);
     persist(s); pushSessions();
     // page-starts-agent: a caller that started this run from the page reads its result here (a proposal, never a write).