create-pmos 0.191.0 → 0.193.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.191.0",
+  "version": "0.193.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@0c10704
+kernel-source: pmos@1e4f936
 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-13T07:07:45Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T08:02:12Z"}
 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-13T07:07:45Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T08:02:12Z"}
 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-13T07:07:45Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T08:02:12Z"}
 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-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/console-calendar.md

@@ -137,7 +137,7 @@ When PMOS holds nothing for a past meeting, the detail says so. For a coming mee
 
 ### Meeting focus
 
-**Focus** opens one calm page for a meeting that is today. It shows on the detail of a meeting that has not ended, and next to the recording on the header while a meeting is recorded. The page covers the console. **Leave focus** gives the console back. Leaving does not stop the recording. The page stays open when you reload it.
+**Focus** opens one calm page for a meeting that is today. It shows on the detail of a meeting that has not ended, and next to the recording on the header while a meeting is recorded. The page covers the console. **Leave focus** gives the console back. Leaving does not stop the recording. The page stays open when you reload it. From the recording, the page finds the meeting by its start time and title, so it also finds a meeting that has no calendar id, or that moved on the same day after you started to record.
 
 The page has these parts:
 

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/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-meeting-focus.js

@@ -55,14 +55,32 @@ function linesOf(runtimeDir, keys) {
 
 /* ── the meeting, its note and its brief ──────────────────────────────────────────────────────────────────────────── */
 
+const minuteOf = (t) => { const ms = Date.parse(t); return Number.isFinite(ms) ? Math.floor(ms / 60000) : null; };
+const normTitle = (t) => require('./calendar-memory.js').normTitle(t);
+/** A meeting named by its start and title (a recording whose meeting has no stored id). The start is compared as an instant, not as
+ * text: a note keeps its meeting's start in UTC ("…T07:00:00.000Z") while the calendar writes it with the local offset ("…T15:00:00+08:00").
+ * Same minute and same title first, then the only meeting of that title on that local day (a meeting moved after the note linked it). */
+function findByStart(events, by) {
+  const m = minuteOf(by.at); if (m === null) return null;
+  const rows = (events || []).filter((e) => e && e.id && minuteOf(e.at) !== null);
+  const title = by.title ? normTitle(by.title) : '';
+  const atMin = rows.filter((e) => minuteOf(e.at) === m);
+  const both = title ? atMin.filter((e) => normTitle(e.title) === title) : atMin;
+  if (both.length) return both[0];
+  if (!title) return null;
+  const day = localDay(m * 60000);
+  const named = rows.filter((e) => normTitle(e.title) === title && localDay(Date.parse(e.at)) === day);
+  return named.length === 1 ? named[0] : null;
+}
 function findEvent(events, id, date, by) {
-  if (!id && by && by.at) {   // a meeting without a stored id: its start and title name it
-    const hit = (events || []).filter((e) => e && e.id && e.at === String(by.at) && (!by.title || e.title === String(by.title)));
-    return hit[0] || null;
-  }
+  if (!id && by && by.at) return findByStart(events, by);
   const rows = (events || []).filter((e) => e && e.id && (String(e.id) === id || baseId(e.id) === baseId(id)));
   const onDay = rows.filter((e) => !date || String(e.at || '').slice(0, 10) === date);
-  return onDay.find((e) => String(e.id) === id) || onDay[0] || null;
+  const hit = onDay.find((e) => String(e.id) === id) || onDay[0] || null;
+  if (hit) return hit;
+  // a date that is the UTC day of the start, not its local day (an early-morning meeting east of UTC): the start names it
+  if (by && by.at) return findByStart(events, by);
+  return rows.find((e) => String(e.id) === id) || null;   // an occurrence id names one meeting whatever the day says
 }
 /** A recording that is not on the calendar (a talk in the corridor): the note stands in for the meeting. It has no end, no people
  * and no brief, so focus shows what is said, PMOS's notes and Captured, and no topics from an invite. */

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.191.0",
+  "version": "0.193.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.191.0",
+      "version": "0.193.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.191.0",
+  "version": "0.193.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.js

@@ -32,6 +32,8 @@ import { toast } from './c3-toast.js';
 const POLL_MS = 3000;
 const LAST_MINUTES = 5;                 // the last minutes of the meeting: the captured items show under the stage
 const pad = (n) => String(n).padStart(2, '0');
+/** The local day of a start: a note keeps its meeting's start in UTC, and its first ten characters can be the day before. */
+const localDayOf = (t) => { const ms = Date.parse(t); if (!Number.isFinite(ms)) return ''; const d = new Date(ms); return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`; };
 const hhmm = (ms) => { const d = new Date(ms); return pad(d.getHours()) + ':' + pad(d.getMinutes()); };
 export const baseId = (id) => String(id || '').split('@')[0];
 /** 3:07, or 1:03:07 from an hour on; a minus sign before a negative time. Pure. */
@@ -84,7 +86,7 @@ export function closeFocus() {
   const grid = host && host.querySelector('.c3grid'); if (grid) grid.inert = false;
   const comp = host && host.querySelector('[data-c3ph]'); if (comp) comp.inert = false;
   if (f.phone) { const st = f.phone && document.querySelector('[data-c3ph-focus-bar]'); if (st) st.focus({ preventScroll: true }); return; }
-  try { const u = new URL(location.href); if (u.searchParams.has('focus')) { u.searchParams.delete('focus'); u.searchParams.delete('fdate'); history.replaceState(history.state, '', u); } } catch { /* no history */ }
+  try { const u = new URL(location.href); if (u.searchParams.has('focus')) { u.searchParams.delete('focus'); u.searchParams.delete('fdate'); u.searchParams.delete('fat'); u.searchParams.delete('ftitle'); history.replaceState(history.state, '', u); } } catch { /* no history */ }
   if (f.opener && document.contains(f.opener) && typeof f.opener.focus === 'function') { try { f.opener.focus({ preventScroll: true }); } catch { /* not focusable any more */ } }
 }
 
@@ -95,7 +97,7 @@ export function openFocus({ event, date, pop, back, phone, note, meet, mtitle }
   if (phone) pop = false;   // the phone has the whole page, in one column
   const resolve = !!pop && want === 'now';   // the extension names no meeting: which one this call is comes first
   const id = resolve ? '' : want;
-  const day = String(date || String(ev.at || ev.start || '').slice(0, 10) || '');
+  const day = String(date || localDayOf(ev.at || ev.start) || '');
   ensureCss();
   const host = document.getElementById('c3-root') || document.body;
   const root = el('div', { class: 'c3focus' + (pop ? ' fc-pop' : '') + (phone ? ' fc-phone' : ''), role: 'region', 'aria-label': pop ? 'PMOS meeting helper' : 'Meeting focus', 'data-c3focus': '', ...(pop ? { 'data-fc-pop': '' } : {}), ...(phone ? { 'data-fc-phone': '' } : {}) });
@@ -142,7 +144,7 @@ export function openFocus({ event, date, pop, back, phone, note, meet, mtitle }
   host.append(root);
   const grid = host.querySelector && host.querySelector('.c3grid'); if (grid) grid.inert = true;
   const comp = host.querySelector && host.querySelector('[data-c3ph]'); if (comp) comp.inert = true;   // the phone companion under the page
-  if (!pop && !phone) { try { const u = new URL(location.href); u.searchParams.set('focus', id); if (day) u.searchParams.set('fdate', day); history.replaceState(history.state, '', u); } catch { /* no history */ } }   // the compact page keeps its address: a reload asks again which meeting it is
+  if (!pop && !phone) { try { const u = new URL(location.href); u.searchParams.set('focus', id); if (day) u.searchParams.set('fdate', day); if (!id && ev.at) { u.searchParams.set('fat', ev.at); if (ev.title) u.searchParams.set('ftitle', ev.title); } history.replaceState(history.state, '', u); } catch { /* no history */ } }   // the compact page keeps its address: a reload asks again which meeting it is
   draw();
   F.timers.clock = setInterval(tick, 1000);
   if (resolve) resolveNow(); else load();
@@ -185,7 +187,7 @@ async function load() {
   if (f.id) p.set('event', f.id);
   else if (f.noteId) p.set('note', f.noteId);   // a recording with no meeting
   if (f.date && !f.noteId) p.set('date', f.date);
-  if (!f.id && !f.noteId && (e.at || e.start)) { p.set('at', e.at || e.start); if (e.title) p.set('title', e.title); }
+  if (!f.noteId && (e.at || e.start)) { p.set('at', e.at || e.start); if (e.title) p.set('title', e.title); }   // the start and title still find the meeting when the id or the day does not
   const j = await pmGet('/api/meeting-focus?' + p.toString());
   if (F !== f) return;
   if (j && j.ok) {

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

@@ -623,7 +623,7 @@ async function boot() {
   let start = q.get('tab');
   const saved = DEMO ? null : await pmGet('/api/settings' + (S.ws ? '?ws=' + encodeURIComponent(S.ws) : '')).catch(() => null);   // demo mode's workspace is not registered
   if (saved && saved.ok) { applyLook(root, saved.settings); if (!start) { const s = (saved.settings || []).find((x) => x.key === 'look.start'); if (s && BUILD[s.value]) start = s.value; } }
-  if (q.get('focus') || q.get('fdate')) import('./c3-focus.js').then((m) => m.openFocus({ event: { id: q.get('focus') || '' }, date: q.get('fdate') || '', pop: q.get('pop') === '1', meet: q.get('meet') || '', mtitle: q.get('mtitle') || '' })).catch(() => { /* the focus page is not available */ });   // a reload keeps the Meeting focus page open; ?pop=1 is its compact form for the Chrome extension (focus=now asks which meeting the Meet call is)
+  if (q.get('focus') || q.get('fdate')) import('./c3-focus.js').then((m) => m.openFocus({ event: { id: q.get('focus') || '', ...(q.get('fat') ? { at: q.get('fat'), title: q.get('ftitle') || '' } : {}) }, date: q.get('fdate') || '', pop: q.get('pop') === '1', meet: q.get('meet') || '', mtitle: q.get('mtitle') || '' })).catch(() => { /* the focus page is not available */ });   // a reload keeps the Meeting focus page open; ?pop=1 is its compact form for the Chrome extension (focus=now asks which meeting the Meet call is)
   if (!S.userNav) showTab(start || 'brief', false);   // a press during the read above (the gear, a tab) wins over the start page
   new ResizeObserver(moveInd).observe(S.tabNav);
   workCount(); briefCount(); askCount(); S.dock.start();

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/public/pm/shell-recording.js

@@ -173,9 +173,8 @@ function meetingOfNote(id) {
   return m && m.kind === 'event' && m.start ? m : null;
 }
 /** Meeting focus (initiative c3-meeting-focus): the page for the meeting being recorded. The event id is empty for a meeting without a stored id; the page then finds it by start and title. */
-function openFocusFor(m) {
-  const day = String(m.start || '').slice(0, 10);
-  import('./c3-focus.js').then((f) => f.openFocus({ event: { id: m.event_id || '', at: m.start, end: m.end || null, title: m.title }, date: day }))
+function openFocusFor(m) {   // no date: the page takes the local day of the start (the note keeps it in UTC)
+  import('./c3-focus.js').then((f) => f.openFocus({ event: { id: m.event_id || '', at: m.start, end: m.end || null, title: m.title } }))
     .catch(() => toast({ text: 'The focus page could not load.', tone: 'error' }));
 }
 

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).