create-pmos 0.168.0 → 0.169.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.168.0",
+  "version": "0.169.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@21b6322
+kernel-source: pmos@d87e438
 assembled: 2026-10-12
 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-12T14:26:40Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T14:51:11Z"}
 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-12T14:26:40Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T14:51:11Z"}
 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-12T14:26:40Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T14:51:11Z"}
 status: stable
 ---
 

package/workspace/c3-driver-fixture.js

@@ -0,0 +1,61 @@
+'use strict';
+/* c3-driver-fixture.js — a real server, a scratch repository and a seeded driver ledger for the console3 Initiative Driver suite
+ * (c3-driver-test.js). Not a suite: it asserts nothing. The server runs with PMOS_DRIVER=off, so no headless run starts: every
+ * proposal, run and blocker the page shows is a line this file wrote with lib/driver.js, the single writer.
+ *
+ *   const F = await start({ name })  -> { BASE, ws, board, team, ledger, ids, item, itemDue, post, get, stop }
+ *   ids: { problem, evidence, sizing, move, follow, step } proposal ids; item: the Work task with a follow-up; itemDue: the one with a due date
+ */
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const T = require('./test-run').configure({ name: 'c3-driver' });
+const { makeRepos, codeRepo, write, git } = require('./plan-test-repos');
+const D = require('./lib/driver.js');
+
+const HOUR = 3600000;
+async function call(base, method, p, body, headers) {
+  const r = await fetch(base + p, { method, headers: headers || {}, body: body === undefined ? undefined : JSON.stringify(body) });
+  const raw = await r.text(); let j = null; try { j = JSON.parse(raw); } catch { /* not JSON */ }
+  return { status: r.status, body: j, raw };
+}
+
+async function start({ name = 'c3-driver' } = {}) {
+  const R = makeRepos(name);
+  const team = codeRepo(path.join(R.base, 'team'));
+  fs.mkdirSync(path.join(team, 'pmos', 'state'), { recursive: true });
+  write(team, 'pmos/state/.keep', '');
+  git(team, ['add', '-A']); git(team, ['commit', '-q', '-m', 'state']);
+  const ledger = path.join(team, 'pmos', 'state', 'driver.jsonl');
+  const BASE = T.BASE;
+  const srv = spawn(process.execPath, [path.join(__dirname, 'server.js')], { cwd: __dirname, stdio: 'ignore',
+    env: T.env({ PMOS_WS_PORT: String(T.PORT), PMOS_SELF_ROOT: team, PMOS_NO_OPEN: '1', PMOS_DRIVER: 'off' }) });
+  await T.waitForServer(BASE);
+  const press = await T.pressHeaders(BASE);
+  const post = (p, body) => call(BASE, 'POST', p, body, press);
+  const get = (p) => call(BASE, 'GET', p);
+  const reg = await post('/api/workspaces', { root: team, focus: true });
+  const ws = reg.body.workspace.id;
+  const made = await post('/api/initiatives', { ws, title: 'Partner API onboarding', lane: 'feature', anchor: 'health:tech', id: 'drv-ui' });
+  if (made.status !== 200) throw new Error('could not create the initiative: ' + made.raw);
+  const a = (await post('/api/pm-items/add', { line: 'Get the sandbox access date from Dana waiting on Dana Hartono' })).body.item;
+  const b = (await post('/api/pm-items/add', { line: 'Send the partner onboarding list to Lina' })).body.item;
+  const tI = { kind: 'initiative', ws, id: 'drv-ui' };
+  const now = Date.now();
+  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; };
+  const ids = { problem: 'p-aaaaaaaa01', evidence: 'p-aaaaaaaa02', sizing: 'p-aaaaaaaa03', move: 'p-aaaaaaaa04', follow: 'p-aaaaaaaa05', step: 'p-aaaaaaaa06' };
+  w({ ev: 'epoch' }, now - 3 * 24 * HOUR);
+  w({ ev: 'run-start', run: 'run-aaaaaaaa01', target: tI, board: ws, wakes: [], session: 'sess-4.0a1b2c3d' }, now - 5 * HOUR);
+  prop(ids.problem, tI, 'problem', { text: 'New partners wait 9 days on average from signed contract to first live API call. Support handles 23 onboarding tickets a month.' }, 'first draft from the Jira and Slack threads', [{ label: 'Jira', ref: 'IDPF-1204' }, { label: 'Slack', ref: '#partner-support, 6 Oct' }], now - 4 * HOUR, 'run-aaaaaaaa01');
+  prop(ids.evidence, tI, 'evidence', { text: 'Six sources back the problem statement. Four name sandbox access as the main delay.', items: [{ text: 'Partner X waited 9 days for sandbox access', ref: 'IDPF-1204' }, { text: 'Two partners paused go-live this quarter', ref: 'https://example.invalid/partner-council/1-oct' }] }, 'evidence for the problem', [{ label: 'Meeting note', ref: 'IDPF DSU, 8 Oct' }], now - 4 * HOUR + 600000, 'run-aaaaaaaa01');
+  prop(ids.sizing, tI, 'sizing', { text: '14 partners are in the pipeline this half. Cutting the wait from 9 days to 3 moves about 5 go-lives into Q4.' }, 'low confidence: two data points', [{ label: 'Slack', ref: '#sales-asks, 7 Oct' }], now - 3 * HOUR, 'run-aaaaaaaa01');
+  prop(ids.move, tI, 'move', { to: 'Plan' }, 'the problem, evidence and sizing are in', [], now - 50 * HOUR, 'run-aaaaaaaa01');
+  w({ ev: 'run-end', run: 'run-aaaaaaaa01', ok: true, agent_run: null }, now - 3 * HOUR + 60000);
+  w({ ev: 'blocker', key: `initiative:${ws}:drv-ui:pm-open`, day: D.localDay(now), target: tI, board: ws, code: 'pm-open', owner: 'pm', text: "The agent's drafts have waited on you since " + new Date(now - 50 * HOUR).toISOString().slice(0, 10) }, now - HOUR);
+  prop(ids.follow, { kind: 'work', ws, id: a.id }, 'follow-up', { text: 'Hi Dana,\n\nQuick follow-up on the sandbox access for Nusa Pay. Can you tell me which day your engineers can use the sandbox?\n\nThanks,\nWawan', to: 'Dana' }, 'waiting 4 days, no reply', [{ label: 'Slack', ref: '#partner-support' }], now - 2 * HOUR, null);
+  prop(ids.step, { kind: 'work', ws, id: b.id }, 'next-step', { text: 'Send the list to Lina', due: '2026-10-15' }, 'overdue with no next step', [], now - HOUR, null);
+  const stop = () => { try { srv.kill('SIGKILL'); } catch { /* gone */ } T.killTmux(); R.cleanup(); };
+  return { BASE, ws, board: ws, team, ledger, ids, item: a, itemDue: b, post, get, stop, T, D, tI };
+}
+module.exports = { start };

package/workspace/c3-driver-test.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+'use strict';
+/* c3-driver-test.js — the Initiative Driver on console3 (initiative initiative-driver; PRD section 5 and done-criterion 9).
+ * 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
+ *              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;
+ *              Drop posts and the row leaves
+ *   pause      Pause posts /api/driver/pause and the strip says Paused; Resume brings it back
+ *   work       a Work task with a follow-up shows the agent line; Review opens the sheet with the draft and "the agent sent nothing";
+ *              Keep records the keep; a task with a next-step shows Keep and Drop in the line
+ *   setting    Board settings has the Agent setting; pressing Shadow posts /api/driver/mode and the ledger holds it
+ *   briefing   Needs you shows the agent's two kinds of row and a press opens the initiative
+ *   phone      at 400 wide the strip has no horizontal scroll
+ * Every wait polls the page. The page must raise no script error.
+ */
+const path = require('path');
+const { findBrowser } = require('./lib/find-browser');
+const F = require('./c3-driver-fixture');
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const until = async (fn, ms = 20000, step = 120) => { const t0 = Date.now(); for (;;) { const v = await fn(); if (v) return v; if (Date.now() - t0 > ms) return v; await sleep(step); } };
+const results = [];
+const ok = (n, cond, extra = '') => { results.push({ n, cond: !!cond }); console.log(`${cond ? '✓' : '✗'} ${n}${!cond && extra !== '' ? ' — ' + String(extra).slice(0, 400) : ''}`); };
+let fx = null; let browser = null;
+const finish = async (code) => {
+  if (browser) await browser.close().catch(() => {});
+  if (fx) fx.stop();
+  const bad = results.filter((x) => !x.cond).length;
+  console.log(`\n${results.length - bad}/${results.length} c3-driver assertions passed`);
+  process.exit(code !== undefined ? code : (bad ? 1 : 0));
+};
+process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
+
+(async () => {
+  const exe = findBrowser();
+  if (!exe) { console.log('· no Chrome/Chromium on this machine — c3-driver suite skipped'); process.exit(0); }
+  let chromium;
+  try { ({ chromium } = require('playwright-core')); } catch { console.log('· playwright-core not installed — c3-driver suite skipped'); process.exit(0); }
+  fx = await F.start({ name: 'c3-driver' });
+  const { BASE, ws, ids, D, ledger } = fx;
+  const state = () => D.fold(D.readLines(ledger));
+  browser = await chromium.launch({ executablePath: exe });
+  const ctx = await browser.newContext({ viewport: { width: 1280, height: 900 } });
+  const page = await ctx.newPage();
+  const errors = []; page.on('pageerror', (e) => errors.push(String((e && e.message) || e)));
+  const posts = []; page.on('request', (r) => { if (r.method() === 'POST' && r.url().includes('/api/driver/')) posts.push({ path: new URL(r.url()).pathname, body: JSON.parse(r.postData() || '{}') }); });
+  const st = (f, a) => page.evaluate(f, a);
+  const sel = (s) => until(() => page.$(s));
+  const INI = `/c3.html?tab=init&init=ini:${ws}:drv-ui:overview`;
+
+  /* ── strip ── */
+  await page.goto(BASE + INI, { waitUntil: 'load' });
+  await sel('[data-drv-row]');
+  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);
+  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)));
+  ok('S5 the old proposal says how long it waited', /waiting 2 days/.test(await st(() => document.querySelector(`[data-drv-row="${'p-aaaaaaaa04'}"]`).textContent)));
+  await page.click(`[data-drv-title="${ids.evidence}"]`);
+  await until(() => st((id) => document.querySelector(`[data-drv-row="${id}"] .xp.open`), ids.evidence));
+  const ev = await st((id) => { const r = document.querySelector(`[data-drv-row="${id}"]`); return { text: r.textContent, link: (r.querySelector('a[href^="https://example.invalid"]') || {}).href || '', n: r.querySelectorAll('[data-drv-src]').length }; }, ids.evidence);
+  ok('S6 a row opens to its text and its sources (label and ref); a URL ref is a link', /Six sources back the problem statement/.test(ev.text) && /IDPF DSU, 8 Oct/.test(ev.text) && ev.n === 3 && /partner-council/.test(ev.link), JSON.stringify(ev));
+  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));
+  await page.keyboard.press('Escape');
+
+  /* ── decide ── */
+  await page.click(`[data-drv-row="${ids.problem}"] [data-drv-act=keep]`);
+  await until(() => posts.some((p) => p.path === '/api/driver/keep'));
+  ok('D1 Keep posts /api/driver/keep with the proposal id and no writer field', posts.some((p) => p.path === '/api/driver/keep' && p.body.proposal === ids.problem && !('by' in p.body)), JSON.stringify(posts));
+  await until(() => st((id) => { const r = document.querySelector(`[data-drv-row="${id}"]`); return r && r.dataset.drvState === 'kept'; }, ids.problem));
+  ok('D2 the row turns "Kept by you" and loses its buttons; the ledger holds the keep by the PM', await st((id) => { const r = document.querySelector(`[data-drv-row="${id}"]`); return /Kept by you/.test(r.textContent) && !r.querySelector('[data-drv-act]'); }, ids.problem)
+    && state().proposals.get(ids.problem).state === 'kept' && state().proposals.get(ids.problem).decided_by === 'pm:wawan');
+  await until(() => st(() => /Kept: Problem statement|Kept/.test(document.querySelector('[data-c3-toast]') ? document.querySelector('[data-c3-toast]').textContent : '')));
+  await page.click(`[data-drv-row="${ids.sizing}"] [data-drv-act=back]`);
+  await sel('[data-drv="send-back"]');
+  await page.click('[data-drv="send-back"]');
+  ok('D3 Send back with an empty note is refused in plain words and posts nothing', !!(await until(() => page.$('[data-drv="note-error"]:not([hidden])'))) && !posts.some((p) => p.path === '/api/driver/return'));
+  await page.fill('[data-drv="note"]', 'Use active partners, not signed ones');
+  await page.click('[data-drv="send-back"]');
+  await until(() => posts.some((p) => p.path === '/api/driver/return'));
+  ok('D4 Send back posts the note; the row says it was sent back; the ledger holds it', posts.some((p) => p.path === '/api/driver/return' && p.body.note === 'Use active partners, not signed ones')
+    && !!(await until(() => st((id) => { const r = document.querySelector(`[data-drv-row="${id}"]`); return r && r.dataset.drvState === 'back'; }, ids.sizing))) && state().proposals.get(ids.sizing).state === 'returned');
+  await page.click(`[data-drv-row="${ids.evidence}"] [data-drv-act=drop]`);
+  await until(() => st((id) => !document.querySelector(`[data-drv-row="${id}"]`), ids.evidence));
+  ok('D5 Drop posts /api/driver/drop and the row leaves', posts.some((p) => p.path === '/api/driver/drop' && p.body.proposal === ids.evidence) && state().proposals.get(ids.evidence).state === 'dropped');
+
+  /* ── pause ── */
+  await page.click('[data-drv-act=pause]');
+  await until(() => st(() => /Agent is paused/.test(document.querySelector('[data-drv="status"]').textContent)));
+  ok('P1 Pause posts /api/driver/pause for the initiative and the strip says Paused with a Resume button', posts.some((p) => p.path === '/api/driver/pause' && p.body.target_kind === 'initiative' && p.body.id === 'drv-ui')
+    && !!(await page.$('[data-drv-act=resume]')) && D.isPaused(state(), fx.tI));
+  await page.click('[data-drv-act=resume]');
+  await until(() => st(() => !!document.querySelector('[data-drv-act=pause]')));
+  ok('P2 Resume lifts it', !D.isPaused(state(), fx.tI));
+
+  /* ── setting ── */
+  await page.goto(BASE + `/c3.html?tab=init&init=board:${ws}:summary`, { waitUntil: 'load' });
+  await (await sel('[data-ini=board-settings]')).click();
+  await sel('[data-drv="setting"] [data-drv-mode]');
+  ok('T1 Board settings shows the Agent setting at Approve, with the one-line explanations', await st(() => { const s = document.querySelector('[data-drv="setting"]'); return s.querySelector('[data-drv-mode=approve]').getAttribute('aria-pressed') === 'true' && /The agent drafts and asks you/.test(s.textContent) && /The agent does nothing on this board/.test(s.textContent); }));
+  await page.click('[data-drv-mode=shadow]');
+  await until(() => posts.some((p) => p.path === '/api/driver/mode'));
+  await until(() => st(() => document.querySelector('[data-drv-mode=shadow]').getAttribute('aria-pressed') === 'true'));
+  ok('T2 pressing Shadow posts /api/driver/mode for the board and the ledger holds it', posts.some((p) => p.path === '/api/driver/mode' && p.body.mode === 'shadow' && p.body.board === ws) && D.modeOf(state(), ws) === 'shadow');
+  await page.goto(BASE + INI, { waitUntil: 'load' });
+  await sel('[data-drv="shadow"]');
+  ok('T3 in Shadow the strip says so and offers no Keep', !(await page.$('[data-drv-act=keep]')) && /Shadow mode/.test(await st(() => document.querySelector('[data-drv="shadow"]').textContent)));
+  await page.goto(BASE + `/c3.html?tab=init&init=board:${ws}:summary`, { waitUntil: 'load' });
+  await (await sel('[data-ini=board-settings]')).click();
+  await sel('[data-drv-mode=approve]');
+  await page.click('[data-drv-mode=approve]');
+  await until(() => D.modeOf(state(), ws) === 'approve');
+  ok('T4 pressing Approve puts it back', D.modeOf(state(), ws) === 'approve');
+
+  /* ── work ── */
+  await page.goto(BASE + '/c3.html?tab=work', { waitUntil: 'load' });
+  await sel('[data-pm-lenses]');
+  await page.click('[data-pm-lenses] [data-lens=waiting]');
+  const line = await sel(`[data-drv-line="${fx.item.id}"]`);
+  ok('W1 a Waiting task with a follow-up shows "Agent drafted a follow-up to Dana. Nothing is sent." and Review', /Agent drafted a follow-up to Dana\. Nothing is sent\./.test(await line.textContent()) && !!(await page.$('[data-drv-wnote-act=review]')));
+  await page.click('[data-drv-wnote-act=review]');
+  await sel('[data-drv="work-sheet"]');
+  const sheet = await st(() => document.querySelector('[data-drv="work-sheet"]').textContent);
+  ok('W2 Review opens a sheet with the draft and the line that the agent sent nothing', /Quick follow-up on the sandbox access/.test(sheet) && /The agent sent nothing and cannot send/.test(sheet) && !!(await page.$('[data-drv=sheet-keep]')) && !!(await page.$('[data-drv=sheet-back]')) && !!(await page.$('[data-drv=sheet-drop]')));
+  await ctx.grantPermissions(['clipboard-read', 'clipboard-write'], { origin: BASE }).catch(() => {});
+  await page.click('[data-drv=sheet-keep]');
+  await until(() => state().proposals.get(ids.follow).state === 'kept');
+  ok('W3 Keep records the keep (by the PM) and the sheet closes', state().proposals.get(ids.follow).decided_by === 'pm:wawan' && !!(await until(async () => !(await page.$('[data-drv="work-sheet"]')))));
+  const clip = await page.evaluate(() => navigator.clipboard.readText().catch(() => null));
+  ok('W4 the draft text was copied to the clipboard (or the browser refused, and the text was selected)', (clip && /Quick follow-up on the sandbox access/.test(clip)) || clip === null, String(clip));
+  await page.click('[data-pm-lenses] [data-lens=inbox]');
+  await sel(`[data-drv-line="${fx.itemDue.id}"]`);
+  ok('W5 a task with a next-step shows the suggestion with Keep and Drop in the line', /Agent suggests a next step: Send the list to Lina, due Thu 15 Oct/.test(await st((id) => document.querySelector(`[data-drv-line="${id}"]`).textContent, fx.itemDue.id)) && !!(await page.$('[data-drv-wnote-act=keep]')) && !!(await page.$('[data-drv-wnote-act=drop]')));
+  await page.click('[data-drv-wnote-act=drop]');
+  await until(() => state().proposals.get(ids.step).state === 'dropped');
+  ok('W6 Drop in the line drops the proposal and the line goes', !!(await until(async () => !(await page.$(`[data-drv-line="${fx.itemDue.id}"]`)))));
+
+  /* ── briefing ── */
+  await page.goto(BASE + '/c3.html?tab=brief', { waitUntil: 'load' });
+  await sel('[data-drv-need]');
+  const needs = await st(() => [...document.querySelectorAll('[data-drv-need]')].map((r) => r.dataset.drvNeed + ':' + r.textContent.replace(/\s+/g, ' ')));
+  ok('B1 Needs you shows the agent\'s rows: the drafts left on the initiative, and the initiative waiting on you', needs.some((t) => /^driver-drafts:Agent has 1 draft on Partner API onboarding/.test(t)) && needs.some((t) => /^driver-blocked:.*Partner API onboarding is waiting on you/.test(t)), needs.join(' | '));
+  await page.click('[data-drv-need="driver-drafts"] .tt');
+  await until(() => page.$('[data-drv="strip"]'));
+  ok('B2 a press on the row opens the initiative with its Agent strip', !!(await page.$('[data-drv="strip"]')));
+
+  /* ── phone ── */
+  await page.setViewportSize({ width: 400, height: 900 });
+  await page.goto(BASE + INI, { waitUntil: 'load' });
+  await sel('[data-drv-row]');
+  ok('M1 at 400 wide the page has no horizontal scroll', await st(() => document.documentElement.scrollWidth <= window.innerWidth + 1), await st(() => document.documentElement.scrollWidth));
+  ok('N1 no page error was thrown', errors.length === 0, errors.join(' | '));
+  await finish();
+})().catch((e) => { console.error(e); finish(1); });

package/workspace/guide/initiative-driver.md

@@ -50,6 +50,14 @@ The agent reads, and it files proposals with `pmos driver propose`. It has no Wr
 
 In Discover, the agent writes the problem statement, the evidence, the opportunity sizing, the riskiest assumption and the stakeholders. When you have kept the first three, it proposes the move to Plan. In the other stages, it names the blocker and proposes what would clear it.
 
+## 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.
+- **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.
+- **The Agent setting.** Open the board, press Board settings, and find Agent. Choose Off, Shadow or Approve. The setting is saved when you press it.
+
 ## Keep, send back, drop
 
 Open proposals appear in Needs you as one row for each initiative or task: "Agent has 3 drafts on the initiative".

package/workspace/lib/routes-driver.js

@@ -1,13 +1,16 @@
 'use strict';
 /* routes-driver.js — the Initiative Driver's routes (initiative initiative-driver, PRD sections 4 and 5).
  *
- *   GET  /api/driver/strip?ws&target_kind&id       → { ok, ws, target, mode, board, paused, budget, running, last, blocker, proposals }
+ *   GET  /api/driver/strip?ws&target_kind&id[&board] → { ok, ws, target, mode, board, paused, budget, today: [runs of today], running, last, blocker, proposals }
  *   POST /api/driver/keep    { ws, proposal }                     → { ok, proposal, wrote, warnings }
  *   POST /api/driver/return  { ws, proposal, note }               → { ok, proposal }       the note is required; it wakes a run
  *   POST /api/driver/drop    { ws, proposal, note? }              → { ok, proposal }
  *   POST /api/driver/pause   { ws, target_kind, id }              → { ok, paused: true, target }
  *   POST /api/driver/resume  { ws, target_kind, id }              → { ok, paused: false, target }
  *   POST /api/driver/mode    { ws, board?, mode }                 → { ok, board, mode }    board omitted: every board
+ *   GET  /api/driver/mode?ws&board                                → { ok, ws, board, mode }  the mode a board runs in (Approve when none is set)
+ *   GET  /api/driver/open?ws&target_kind                          → { ok, ws, kind, mode, targets: { <id>: [proposal] } }  every open proposal of
+ *                                                                    one kind, by target: the Work list draws one agent line per task from this
  *
  * The strip is the data of the Agent strip on an initiative's Overview and of the one-line version on a Work task. Its
  * `proposals` are the open ones; `by` is the page name (`agent:sess-<n>`), never the session token. `running` is a run that has
@@ -28,6 +31,8 @@ const stageTools = require('./stage-tools.js');
 const text = (v) => (typeof v === 'string' ? v : '');
 const bad = (status, error) => ({ status, body: { ok: false, error } });
 const POSTS = ['keep', 'return', 'drop', 'pause', 'resume', 'mode'];
+const GETS = ['strip', 'mode', 'open'];
+const proposalOut = (p) => ({ id: p.id, what: p.what, data: p.data, why: p.why, sources: p.sources, run: p.run, by: actorLib.pageName(p.by), at: p.at });
 
 function wsOf(ctx, id) {
   const w = ctx.getWs(id || '');
@@ -46,22 +51,23 @@ function boardOfTarget(state, target) {
   return runs.length ? runs[runs.length - 1].board : null;
 }
 
-function stripOf(state, target, { now = Date.now() } = {}) {
+function stripOf(state, target, { now = Date.now(), board: asked = null } = {}) {
   const key = D.targetKey(target);
   const runs = [...state.runs.values()].filter((r) => D.targetKey(r.target) === key);
   const running = runs.filter((r) => !r.end).pop() || null;
   const ended = runs.filter((r) => r.end).pop() || null;
-  const board = boardOfTarget(state, target);
+  const board = boardOfTarget(state, target) || asked || null;
   const day = D.localDay(now);
   const blocker = state.blockers.filter((b) => b.target && D.targetKey(b.target) === key && b.day === day).pop() || 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 },
+    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,
     blocker: blocker ? { code: blocker.code, text: blocker.text, owner: blocker.owner, day: blocker.day } : null,
-    proposals: open.map((p) => ({ id: p.id, what: p.what, data: p.data, why: p.why, sources: p.sources, run: p.run, by: actorLib.pageName(p.by), at: p.at })),
+    proposals: open.map(proposalOut),
   };
 }
 
@@ -69,7 +75,33 @@ async function handle(req, res, url, ctx) {
   const p = url.pathname;
   const send = (r) => { ctx.json(res, r.body, r.status); return true; };
   const sub = p.replace(/^\/api\/driver\/?/, '');
-  if (sub !== 'strip' && !POSTS.includes(sub)) return send(bad(404, 'no such driver route'));
+  if (!GETS.includes(sub) && !POSTS.includes(sub)) return send(bad(404, 'no such driver route'));
+
+  if (sub === 'mode' && req.method === 'GET') {
+    const w = wsOf(ctx, url.searchParams.get('ws'));
+    if (!w) return send(bad(404, 'no such workspace'));
+    const board = text(url.searchParams.get('board'));
+    if (!board || !D.ID_RE.test(board)) return send(bad(400, 'board must be a board id'));
+    const file = ledgerOf(ctx, w);
+    const state = D.fold(file ? D.readLines(file) : []);
+    return send({ status: 200, body: { ok: true, ws: w.id, ledger: !!file, board, mode: D.modeOf(state, board) } });
+  }
+
+  if (sub === 'open') {
+    if (req.method !== 'GET') return send(bad(405, 'GET only'));
+    const w = wsOf(ctx, url.searchParams.get('ws'));
+    if (!w) return send(bad(404, 'no such workspace'));
+    const kind = text(url.searchParams.get('target_kind'));
+    if (!D.KINDS.includes(kind)) return send(bad(400, `target_kind must be one of ${D.KINDS.join(', ')}`));
+    const file = ledgerOf(ctx, w);
+    const state = D.fold(file ? D.readLines(file) : []);
+    const targets = {};
+    for (const pr of D.openProposals(state)) {
+      if (pr.target.kind !== kind || pr.target.ws !== w.id) continue;
+      (targets[pr.target.id] = targets[pr.target.id] || []).push(proposalOut(pr));
+    }
+    return send({ status: 200, body: { ok: true, ws: w.id, ledger: !!file, kind, mode: D.modeOf(state, kind === 'work' ? 'work' : null), targets } });
+  }
 
   if (sub === 'strip') {
     if (req.method !== 'GET') return send(bad(405, 'GET only'));
@@ -79,7 +111,7 @@ async function handle(req, res, url, ctx) {
     if (!t.ok) return send(bad(400, t.error));
     const file = ledgerOf(ctx, w);
     const state = D.fold(file ? D.readLines(file) : []);
-    return send({ status: 200, body: { ok: true, ws: w.id, ledger: !!file, ...stripOf(state, t.target) } });
+    return send({ status: 200, body: { ok: true, ws: w.id, ledger: !!file, ...stripOf(state, t.target, { board: text(url.searchParams.get('board')) || null }) } });
   }
 
   if (req.method !== 'POST') return send(bad(405, 'POST only'));

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.168.0",
+  "version": "0.169.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-brief-needs.js

@@ -15,11 +15,12 @@ import { el } from './dom.js';
 import { c3ic } from './pm-work-view.js';
 import { pmPost } from './http.js';
 import { makeXp, attachExpand } from './c3-expand.js';
-import { needRow, belowLine, BX, toast } from './c3-brief.js';
+import { needRow, belowLine, BX, toast, hooks } from './c3-brief.js';
 import { onBriefing, loadBriefing } from './shell-ticker.js';
 import { cardView, TAG_STYLE } from './briefing-model.js';
 import { onBriefPage } from './c3-brief-data.js';
 import { button, ensureComponentsCss } from './primitives.js';
+import { loadDriverNeeds, needsRow as driverRow } from './c3-driver.js';
 
 const reduced = () => typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches;
 const post = (path, body) => pmPost(path, body).catch(() => ({ ok: false }));
@@ -104,11 +105,12 @@ export function needsSection(S) {
   const sumState = { dec: 0, own: 0, late: 0, quick: 0 };
   const own = el('ul', { class: 'list', role: 'list', 'data-needs-own': '' });
   const ownNote = el('div');
+  const agent = el('ul', { class: 'list', role: 'list', 'data-needs-agent': '' });   // the Initiative Driver's rows (c3-driver.js)
   const list = el('ul', { class: 'list', role: 'list' });
   const extra = el('div');
   const alertHost = el('div');
   const box = el('section', { class: 'card sect', 'data-c3pg': 'needs', 'aria-label': 'Needs you' },
-    el('div', { class: 'sh2' }, el('h2', null, c3ic('inbox', 'sm'), 'Needs you ', count)), alertHost, ownNote, own, list, extra);
+    el('div', { class: 'sh2' }, el('h2', null, c3ic('inbox', 'sm'), 'Needs you ', count)), alertHost, ownNote, own, agent, list, extra);
   let sig = ''; let last = null; let ownSig = ''; let page = null;
   const nothing = () => el('li', { class: 'fold' }, c3ic('check', 'sm'), 'Nothing needs you right now.');
   /* the header line: "3 decisions · 4 of yours · 2 overdue", then how many take under 2 minutes */
@@ -118,6 +120,8 @@ export function needsSection(S) {
     if (!quick.isConnected) box.querySelector('.sh2').append(quick);
     quick.replaceChildren(document.createTextNode(dec + (dec === 1 ? ' decision' : ' decisions') + ' · ' + ownRows.length + ' of yours'));
     if (late) quick.append(' · ', el('span', { class: 'tag bad' }, late + ' overdue'));
+    const ag = agent.children.length;
+    if (ag) quick.append(' · ' + ag + ' from the agent');
     if (sumState.quick) quick.append(' · ', c3ic('bolt', 'sm'), sumState.quick + ' under 2 min');
   };
   const recount = () => {
@@ -168,9 +172,21 @@ export function needsSection(S) {
     extra.replaceChildren();
     recount();
   };
+  /* the agent's rows: drafts waiting on the PM, a target the PM is blocking. A press opens the initiative (its Overview holds the strip) or Work. */
+  let agentSig = '';
+  const goAgent = (n) => {
+    if (n.initiative_id) { try { const u = new URL(location.href); u.searchParams.set('init', 'ini:' + encodeURIComponent(n.ws) + ':' + encodeURIComponent(n.initiative_id) + ':overview'); history.replaceState(history.state, '', u); } catch { /* no history */ } }
+    if (hooks.go) hooks.go({ action: n.initiative_id ? 'goinit' : 'gowork' });
+  };
+  const fillAgent = () => loadDriverNeeds().then((rows) => {
+    const g = JSON.stringify(rows.map((r) => [r.run_id, r.question]));
+    if (g === agentSig) return; agentSig = g;
+    agent.replaceChildren(...rows.map((r) => driverRow(r, goAgent)));
+    recount();
+  }, () => {});
   S.refreshNeeds = () => { sig = ''; if (last) fill(last); };
   S.needsFill = fill;
-  onBriefing((b) => { S.brief = b; fill(b); });
+  onBriefing((b) => { S.brief = b; fill(b); fillAgent(); });
   onBriefPage(fillOwn);
   loadBriefing();
   return box;

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

@@ -0,0 +1,110 @@
+/* pm/c3-driver-work.js — the Initiative Driver on a Work task (PRD section 5; mockup 39-driver.js workNote and openDraft).
+ * One agent line under the title of a task that has an open driver proposal, and the sheet behind its Review.
+ *
+ *   loadDriverOpen(ws)        GET /api/driver/open?target_kind=work → { ok, ws, mode, targets: { <task id>: [proposal] } }, or null
+ *   workNote(o)               the line: o = { item, props, ws, mode, done } → a node, or null (Shadow and Off draw no line, PRD section 5)
+ *   openDraftSheet(o)         the sheet: the draft text, the line that the agent sent nothing, Keep (copies the text), Send back, Drop
+ *
+ * A kept follow-up is copied to the clipboard and recorded. When the browser refuses the clipboard, the text is selected and the
+ * sheet stays open so Ctrl+C works. Presses: POST /api/driver/keep, return, drop (the server takes the PM from the call path).
+ * `done()` runs after a press so the Work list reads again. Nothing here sends anything to a person.
+ */
+import { el } from './dom.js';
+import { SEL } from './primitives.js';
+import { pmGet, pmPost } from './http.js';
+import { c3ic } from './pm-work-view.js';
+import { openSheet } from './c3-sheet.js';
+import { toast } from './c3-toast.js';
+import { pbtn, chip, tag, put } from './c3-ini-ui.js';
+import { whenLabel, dueLabel, titleOf, ensureDriverCss } from './c3-driver.js';
+
+export async function loadDriverOpen(ws) {
+  const r = await pmGet('/api/driver/open?target_kind=work' + (ws ? '&ws=' + encodeURIComponent(ws) : ''));
+  return r && r.ok ? r : null;
+}
+
+const press = async (ws, route, body, what) => {
+  const r = await pmPost('/api/driver/' + route, { ws, ...body });
+  if (!r || !r.ok) { toast({ text: what + ' did not work: ' + ((r && r.error) || 'the workspace did not answer') + '.', tone: 'error', timeout: 6000 }); return null; }
+  return r;
+};
+const short = (s, n) => { s = String(s || ''); return s.length > n ? s.slice(0, n - 1) + '…' : s; };
+const lead = (props) => props.find((p) => p.what === 'follow-up') || props[0];
+const who = (item, p) => (p.data && typeof p.data.to === 'string' && p.data.to) || item.waiting_on || '';
+
+/** The words of the line, by what the agent filed. Pure. */
+export function lineOf(item, props) {
+  const p = lead(props || []);
+  if (!p) return null;
+  const more = props.length > 1 ? ' (+' + (props.length - 1) + ' more)' : '';
+  const t = p.data && typeof p.data.text === 'string' ? p.data.text : '';
+  if (p.what === 'follow-up') return { p, text: 'Agent drafted a follow-up' + (who(item, p) ? ' to ' + who(item, p) : '') + '. Nothing is sent.' + more, act: 'review' };
+  if (p.what === 'next-step') return { p, text: 'Agent suggests ' + (p.data && p.data.due && !t ? 'a new due date: ' + dueLabel(p.data.due) : 'a next step: ' + short(t, 70) + (p.data && p.data.due ? ', due ' + dueLabel(p.data.due) : '')) + '.' + more, act: 'keepdrop' };
+  return { p, text: 'Agent left a note: ' + short(t, 70) + more, act: 'review' };
+}
+
+export function workNote({ item, props, ws, mode, done }) {
+  if (mode !== 'approve') return null;
+  ensureDriverCss();
+  const l = lineOf(item, props);
+  if (!l) return null;
+  const lk = (label, attrs, fn) => pbtn('ghost', label, null, { ...attrs, class: 'lk', onclick: (e) => { e.stopPropagation(); fn(); } });
+  const decide = async (route) => {
+    const r = await press(ws, route, { proposal: l.p.id }, route === 'keep' ? 'Keep' : 'Drop');
+    if (!r) return;
+    toast(route === 'keep' ? 'Kept: ' + titleOf(l.p) + '.' : 'Dropped the suggestion.');
+    done();
+  };
+  return el('span', { class: 'drv-note', 'data-drv-wnote': item.id, 'data-drv-what': l.p.what }, c3ic('spark', 'sm'), l.text, ' ',
+    l.act === 'review' ? lk('Review', { 'data-drv-wnote-act': 'review' }, () => openDraftSheet({ item, props, ws, done }))
+      : [lk('Keep', { 'data-drv-wnote-act': 'keep' }, () => decide('keep')), lk('Drop', { 'data-drv-wnote-act': 'drop' }, () => decide('drop'))]);
+}
+
+/** Copy `text`. The clipboard first; when the browser refuses, select the node's text so Ctrl+C works. Returns 'copied' or 'selected'. */
+export async function copyText(text, node) {
+  try { if (navigator.clipboard && navigator.clipboard.writeText) { await navigator.clipboard.writeText(text); return 'copied'; } } catch { /* fall back to the selection */ }
+  try { const r = document.createRange(); r.selectNodeContents(node); const s = window.getSelection(); s.removeAllRanges(); s.addRange(r); } catch { /* the PM selects by hand */ }
+  return 'selected';
+}
+
+export function openDraftSheet({ item, props, ws, done }) {
+  ensureDriverCss();
+  const p = lead(props);
+  const text = (p.data && typeof p.data.text === 'string' && p.data.text) || '';
+  const isDraft = p.what === 'follow-up';
+  const to = who(item, p);
+  const draft = el('p', { class: 'sit drv-pre', 'data-drv': 'draft' }, text || 'The agent filed no text.');
+  const backBox = el('div', { class: 'form', hidden: true, 'data-drv': 'back-box' }, el('input', { type: 'text', placeholder: 'Tell the agent what to change', 'aria-label': 'Note to the agent', 'data-drv': 'note', maxlength: '500', autocomplete: 'off' }));
+  const status = el('div', { class: 'fold', 'data-drv': 'sheet-note' }, c3ic('info', 'sm'), isDraft ? 'The agent sent nothing and cannot send. Keep copies this text so you can send it yourself.' : 'The agent sent nothing. Keep records that you rely on this note.');
+  const sayStatus = (t, warn) => { status.className = 'fold' + (warn ? ' w' : ''); put(status, c3ic(warn ? 'alert' : 'info', 'sm'), t); };
+  let sh = null; let backOpen = false;
+  const keepBtn = pbtn('primary', isDraft ? 'Keep (copy to send yourself)' : 'Keep', 'check', { 'data-drv': 'sheet-keep', onclick: async () => {
+    const r = await press(ws, 'keep', { proposal: p.id }, 'Keep');
+    if (!r) return;
+    const how = isDraft && text ? await copyText(text, draft) : 'none';
+    done();
+    if (how === 'selected') { sayStatus('Kept. The browser did not allow copying, so the text is selected: press Ctrl+C. Nothing was sent.', true); keepBtn.disabled = true; return; }
+    sh.close();
+    toast(how === 'copied' ? 'Draft copied. Nothing was sent: send it yourself.' : 'Kept.');
+  } });
+  const backBtn = pbtn('outline', 'Send back', 'reply', { 'data-drv': 'sheet-back', onclick: async () => {
+    const inp = backBox.querySelector('input');
+    if (!backOpen) { backOpen = true; backBox.hidden = false; inp.focus(); backBtn.querySelector(SEL.btnLabel).textContent = 'Send back with note'; return; }
+    const n = inp.value.trim();
+    if (!n) { sayStatus('Write one line for the agent. A note starts its next run.', true); inp.focus(); return; }
+    const r = await press(ws, 'return', { proposal: p.id, note: n }, 'Send back');
+    if (!r) return;
+    sh.close(); toast('Sent back with your note. The agent redrafts it.'); done();
+  } });
+  const dropBtn = pbtn('ghost', 'Drop', null, { 'data-drv': 'sheet-drop', onclick: async () => {
+    const r = await press(ws, 'drop', { proposal: p.id }, 'Drop');
+    if (!r) return;
+    sh.close(); toast('Dropped the draft.'); done();
+  } });
+  sh = openSheet({ title: isDraft ? 'Draft follow-up' + (to ? ' to ' + to : '') : titleOf(p), icon: 'mail', body: el('div', { class: 'drv-sheet', 'data-drv': 'work-sheet' },
+    el('div', { class: 'chips' }, tag(isDraft ? 'draft' : p.what), to ? chip(c3ic('user', 'sm'), to) : null, p.at ? chip(c3ic('clock', 'sm'), whenLabel(p.at)) : null, chip(c3ic('check', 'sm'), short(item.title, 48))),
+    el('div', { class: 'case' }, draft),
+    p.why ? el('div', { class: 'dim drv-small' }, 'Why: ' + p.why) : null, status, backBox,
+    el('div', { class: 'iacts chips2' }, keepBtn, backBtn, dropBtn)) });
+  return sh;
+}

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

@@ -0,0 +1,18 @@
+/* pm/c3-driver.css — the few rules the Initiative Driver needs beyond console3.css (c3-driver.js, c3-driver-work.js). The mockup's
+ * 39-driver.css under the `drv-` prefix: the Agent strip on an initiative's Overview, the Agent board setting, the agent line on a Work
+ * row and the sheets. Held to the R28 rules: tokens only, no inline style, corners 0, 6px or 8px, font sizes from the --fs tokens. */
+.c3 .drv .nrow .acts{flex-wrap:wrap;justify-content:flex-end}
+.c3 .drv-src{display:flex;gap:8px;align-items:baseline;flex-wrap:wrap}
+.c3 .drv-src .drv-ref{font-size:var(--fs-1);color:var(--muted-foreground);overflow-wrap:anywhere}
+.c3 .drv-src a.drv-ref{color:var(--acc)}
+.c3 .drv-pre{margin:0;white-space:pre-line;overflow-wrap:anywhere}
+.c3 .drv-small{font-size:var(--fs-2);line-height:1.45}
+.c3 .drv-sub{margin-top:2px}
+.c3 .drv-set{display:grid;gap:var(--sp-2)}
+.c3 .drv-set .seg{max-width:100%;overflow-x:auto}
+.c3 .drv-note{display:block}
+.c3 .drv-note .ic{vertical-align:-2px;margin-right:6px}
+.c3 .drv-note .lk{margin-left:4px}
+.c3 .drv-sheet{display:grid;gap:var(--sp-3)}
+.c3 .drv-sheet .sit{white-space:pre-line;overflow-wrap:anywhere}
+.c3 .drv-sheet input[type=text]{width:100%}

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

@@ -0,0 +1,298 @@
+/* pm/c3-driver.js — the Initiative Driver on console3 (initiative initiative-driver, PRD section 5; mockup mockup-c3-driver, 39-driver.js).
+ * The agent works on every initiative and Work task on its own and files each result as a PROPOSAL. Nothing it writes changes a record
+ * or leaves PMOS: the PM keeps, sends back with a note, or drops. This file draws the three places the PM sees it:
+ *
+ *   driverStrip(ctx, row)            the Agent strip on an initiative's Overview: status, last action, blocker, one row per open proposal
+ *   agentSetting(state, { onPick })  the Agent setting (Off, Shadow, Approve) in the Board settings sheet; loadAgentMode(api, board) reads it
+ *   workNote(o) · openDraftSheet(o)  the one agent line under a Work task and the sheet behind its Review (c3-driver-work.js draws them)
+ *
+ * Reads: GET /api/driver/strip, /api/driver/mode, /api/driver/open. Presses: POST /api/driver/keep, return, drop, pause, resume, mode,
+ * through http.js (the nonce and the page Origin). The page sends no `by`: the server takes the PM from the call path. After each press
+ * the strip is read again. Keep, send back and drop have no Undo: each adds a line to the ledger, and nothing is removed.
+ * A proposal that was just decided stays in its strip, marked, until the page is left. Plain words for every empty and error state.
+ */
+import { el } from './dom.js';
+import { icon, pbtn, lk, chip, tag, st, note, lbl, chgl, list, nrow, sect, put, btn, plural } from './c3-ini-ui.js';
+import { toast } from './c3-toast.js';
+import { pmGet } from './http.js';
+
+/** Link c3-driver.css once, from this module's own folder (the way c3-initiatives.js links its stylesheet). */
+export function ensureDriverCss() {
+  if (typeof document === 'undefined' || document.querySelector('link[data-c3-drv]')) return;
+  const l = document.createElement('link');
+  l.rel = 'stylesheet'; l.href = new URL('./c3-driver.css', import.meta.url).href; l.setAttribute('data-c3-drv', '');
+  document.head.appendChild(l);
+}
+
+/* ── words ── */
+export const WHAT = {
+  problem: ['Problem statement', 'doc'], evidence: ['Evidence', 'doc'], sizing: ['Opportunity sizing', 'target'], assumption: ['Riskiest assumption and spike brief', 'bolt'],
+  stakeholders: ['Stakeholders', 'user'], move: ['Move', 'next'], note: ['Note', 'notes'], 'next-step': ['Next step', 'check'], 'follow-up': ['Follow-up', 'mail'],
+};
+export const MODES = [
+  ['off', 'Off', 'The agent does nothing on this board.'],
+  ['shadow', 'Shadow', 'The agent drafts but raises nothing. You see its drafts only on the initiative page.'],
+  ['approve', 'Approve', 'The agent drafts and asks you. Each draft waits for Keep, Send back or Drop.'],
+];
+const errText = (r, what) => what + ': ' + ((r && r.error) || 'the workspace did not answer') + '.';
+const isUrl = (s) => /^https?:\/\/\S+$/i.test(String(s || ''));
+const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const WD = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const p2 = (n) => String(n).padStart(2, '0');
+const clock = (d) => p2(d.getHours()) + ':' + p2(d.getMinutes());
+/** '11:05' for today, 'Fri 9 Oct, 16:05' for any other day. */
+export function whenLabel(iso, now = new Date()) {
+  const d = new Date(iso);
+  if (!Number.isFinite(d.getTime())) return '';
+  return d.toDateString() === now.toDateString() ? clock(d) : WD[d.getDay()] + ' ' + d.getDate() + ' ' + MON[d.getMonth()] + ', ' + clock(d);
+}
+/** Whole days a time is old. */
+export const daysOld = (iso, now = Date.now()) => { const t = Date.parse(iso); return Number.isFinite(t) ? Math.floor((now - t) / 864e5) : 0; };
+/** 'Thu 15 Oct' for a YYYY-MM-DD. */
+export function dueLabel(ymd) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(String(ymd || ''));
+  if (!m) return '';
+  const d = new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+  return WD[d.getDay()] + ' ' + d.getDate() + ' ' + MON[d.getMonth()];
+}
+const textOf = (p) => (p && p.data && typeof p.data.text === 'string' ? p.data.text : '');
+export const titleOf = (p) => (p.what === 'move' && p.data && p.data.to ? 'Move to ' + p.data.to : (WHAT[p.what] || [p.what])[0]);
+
+/** The text a proposal shows when it opens: the draft, then the agent's one-line reason. */
+export function bodyOf(p) {
+  const out = [];
+  const t = textOf(p);
+  if (p.what === 'move') out.push('Move this initiative to ' + ((p.data && p.data.to) || 'the next stage') + '.');
+  else if (t) out.push(t);
+  else if (p.data && Array.isArray(p.data.items)) out.push(plural(p.data.items.length, 'item') + ' with a pointer each.');
+  else if (p.data && typeof p.data === 'object' && Object.keys(p.data).length) out.push(Object.entries(p.data).map(([k, v]) => k + ': ' + (typeof v === 'string' ? v : JSON.stringify(v))).join('\n'));
+  if (p.what === 'next-step' && p.data && p.data.due) out.push('Due: ' + dueLabel(p.data.due) + '.');
+  if (p.why) out.push('Why: ' + p.why);
+  if (p.what === 'move') out.push('Keep moves the stage. The agent only proposes.');
+  return out.join('\n');
+}
+/** The sources of a proposal: its own list, then the items of an evidence draft that carry a pointer. */
+export function sourcesOf(p) {
+  const out = (p.sources || []).map((s) => ({ label: s.label, ref: s.ref, text: '' }));
+  if (p.data && Array.isArray(p.data.items)) for (const i of p.data.items) if (i && i.ref) out.push({ label: 'Evidence', ref: String(i.ref), text: String(i.text || '') });
+  return out;
+}
+const srcIcon = (label) => (/jira/i.test(label) ? 'jira' : /slack|mail|email|thread/i.test(label) ? 'mail' : 'doc');
+function srcRow(s) {
+  const ref = isUrl(s.ref) ? el('a', { class: 'mono drv-ref', href: s.ref, target: '_blank', rel: 'noopener noreferrer' }, s.ref) : el('span', { class: 'mono drv-ref' }, s.ref);
+  return el('li', { 'data-drv-src': '' }, icon(srcIcon(s.label), 'sm'), el('span', { class: 'drv-src' }, el('b', null, s.label), ref, s.text ? el('span', null, s.text) : null));
+}
+
+/* ── what the PM decided this visit: kept and sent-back rows stay in the strip, marked ── */
+const DECIDED = new Map();   // target key -> Map(proposal id -> { st: 'kept' | 'back', note, p })
+const decidedOf = (key) => { if (!DECIDED.has(key)) DECIDED.set(key, new Map()); return DECIDED.get(key); };
+
+/** One press on the driver. Returns the server's answer; an error is a toast and null. */
+async function press(ctx, route, body, what) {
+  const r = await ctx.api.post('/api/driver/' + route, body);
+  if (!r || !r.ok) { toast({ text: errText(r, what + ' did not work'), tone: 'error', timeout: 6000 }); return null; }
+  return r;
+}
+
+/** The sheet that asks for a one-line note and sends a proposal back with it. */
+export function openSendBack(ctx, p, onSent) {
+  const input = el('input', { type: 'text', 'data-drv': 'note', placeholder: 'Tell the agent what is wrong or missing', 'aria-label': 'Note to the agent', maxlength: '500', autocomplete: 'off' });
+  const err = el('div', { class: 'fold w', role: 'alert', hidden: true, 'data-drv': 'note-error' });
+  let busy = false;
+  const send = async () => {
+    const n = input.value.trim();
+    if (!n) { err.hidden = false; put(err, icon('alert', 'sm'), 'Write one line for the agent. A note starts its next run.'); input.focus(); return; }
+    if (busy) return; busy = true;
+    const r = await press(ctx, 'return', { proposal: p.id, note: n }, 'Send back');
+    busy = false;
+    if (!r) return;
+    sh.close();
+    toast('Sent back with your note. The agent redrafts it.');
+    onSent(n);
+  };
+  input.addEventListener('keydown', (e) => { if (e.key === 'Enter' && !e.isComposing) { e.preventDefault(); send(); } });
+  const sh = ctx.openSheet({ title: 'Send back: ' + titleOf(p), icon: 'reply', body: el('div', { class: 'drv-sheet' },
+    el('p', { class: 'drv-pre' }, bodyOf(p)), el('div', { class: 'form' }, input), err,
+    el('div', { class: 'iacts chips2' }, pbtn('primary', 'Send back with note', 'reply', { 'data-drv': 'send-back', onclick: send }), pbtn('ghost', 'Cancel', null, { onclick: () => sh.close() }))) });
+  setTimeout(() => input.focus(), 30);
+  return sh;
+}
+
+/* ── the Agent strip ── */
+/** 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))
+    : 'Last run did not finish' + (d.last.reason ? ': ' + d.last.reason : '') + ' · ' + whenLabel(d.last.at, new 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. */
+export function blockerLine(d) {
+  if (!d.blocker || !d.blocker.text) return '';
+  if (d.blocker.owner === 'pm') return 'Stopped by: you. ' + d.blocker.text + '. The agent starts no run until you decide.';
+  return 'Stopped by: ' + String(d.blocker.text).replace(/\.$/, '') + '.';
+}
+
+/**
+ * The Agent section of an initiative's Overview. Draws at once with "Reading the agent" and fills itself from the server.
+ * ctx: api, row (the initiative), board, refresh, openSheet, openBoardSettings.
+ */
+export function driverStrip(ctx, row) {
+  ensureDriverCss();
+  const wrap = el('div', { class: 'drv', 'data-drv': 'strip' });
+  const key = (ctx.ws || '') + ':initiative:' + row.id;
+  const S = { data: null, err: '', open: new Set(), busy: false };
+
+  async function load() {
+    const r = await ctx.api.get('/api/driver/strip', { target_kind: 'initiative', id: row.id, board: ctx.board && ctx.board.id });
+    if (!r || !r.ok) { S.data = null; S.err = errText(r, 'The agent strip could not be read'); } else { S.data = r; S.err = ''; }
+    draw();
+  }
+  const reread = load;
+
+  async function decide(route, p, extra) {
+    const r = await press(ctx, route, { proposal: p.id, ...(extra || {}) }, route === 'keep' ? 'Keep' : 'Drop');
+    return r;
+  }
+  async function keep(p) {
+    const r = await decide('keep', p);
+    if (!r) return;
+    decidedOf(key).set(p.id, { st: 'kept', p });
+    const w = (r.warnings || []).filter(Boolean);
+    toast(p.what === 'move' ? 'Kept. The stage moved to ' + ((p.data && p.data.to) || 'the next stage') + '.' + (w.length ? ' ' + w.join(' ') : '') : 'Kept: ' + titleOf(p));
+    if (['move', 'problem', 'next-step'].includes(r.wrote)) ctx.refresh();   // the stage chips and the record cards read the new record
+    else await reread();
+  }
+  async function drop(p) {
+    const r = await decide('drop', p);
+    if (!r) return;
+    S.open.delete(p.id);
+    toast('Dropped: ' + titleOf(p));
+    await reread();
+  }
+  const sendBack = (p) => openSendBack(ctx, p, (n) => { decidedOf(key).set(p.id, { st: 'back', note: n, p }); reread(); });
+  async function pause(on) {
+    const r = await press(ctx, on ? 'pause' : 'resume', { target_kind: 'initiative', id: row.id }, on ? 'Pause' : 'Resume');
+    if (!r) return;
+    toast(on ? 'Agent paused. It files nothing until you resume.' : 'Agent resumed.');
+    await reread();
+  }
+  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;
+    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'),
+      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: 'iacts chips2' }, pbtn('outline', 'Board settings', 'settings', { onclick: () => { closeAnd(() => ctx.openBoardSettings()); } }))) });
+  }
+  const closeAnd = (fn) => { import('./c3-sheet.js').then((m) => { m.closeSheet(); fn(); }); };
+
+  function propRow(p, state) {
+    const kept = state && state.st === 'kept'; const back = state && state.st === 'back';
+    const old = !state && daysOld(p.at) >= 1;
+    const srcs = sourcesOf(p);
+    const chips = [
+      tag(p.what === 'move' ? 'stage move' : 'draft'),
+      p.at ? chip(icon('clock', 'sm'), whenLabel(p.at)) : null,
+      srcs.length ? chip(icon('out', 'sm'), plural(srcs.length, 'source')) : null,
+      old ? el('span', { class: 'tag warn' }, 'waiting ' + plural(daysOld(p.at), 'day')) : null,
+      kept ? st('ok', 'check', 'Kept by you') : null,
+      back ? tag('Sent back · agent is redrafting') : null,
+    ];
+    const xp = el('div', { class: 'ip' },
+      el('p', { class: 'drv-pre' }, bodyOf(p)),
+      back && state.note ? el('div', { class: 'fold' }, icon('reply', 'sm'), ' Your note: ' + state.note) : null,
+      srcs.length ? [el('span', { class: 'dim ini-note' }, 'Sources'), chgl(srcs.map(srcRow))] : el('span', { class: 'dim ini-note' }, 'No sources. ' + (p.what === 'move' ? 'This is a stage proposal.' : 'The agent named none.')));
+    const acts = state ? [] : S.data.mode === 'shadow' ? [el('span', { class: 'tag', title: 'Shadow mode: the agent drafts and raises nothing.' }, 'Shadow draft')] : [
+      pbtn('outline', 'Keep', 'check', { 'data-drv-act': 'keep', onclick: () => keep(p) }),
+      pbtn('ghost', 'Send back', null, { 'data-drv-act': 'back', onclick: () => sendBack(p) }),
+      pbtn('ghost', 'Drop', null, { 'data-drv-act': 'drop', onclick: () => drop(p) })];
+    const r = nrow({ ic: (WHAT[p.what] || ['', 'doc'])[1], hot: !state, title: titleOf(p), titleAttrs: { 'data-drv-title': p.id }, chips, xp, right: acts, attrs: { 'data-drv-row': p.id, 'data-drv-state': state ? state.st : 'open' }, key: 'drv:' + p.id, open: S.open.has(p.id), onToggle: (on) => { if (on) S.open.add(p.id); else S.open.delete(p.id); } });
+    return r;
+  }
+
+  function draw() {
+    const d = S.data;
+    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 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));
+    let body;
+    if (d.mode === 'off') {
+      body = [el('div', { class: 'lh', 'data-drv': 'off' }, el('span', { class: 'ki' }, icon('pause')),
+        el('div', { class: 'ini-lhm' }, el('b', null, 'Agent is off for ' + ((ctx.board && ctx.board.name) || 'this board')), el('div', { class: 'dim' }, 'Nothing is drafted on this board. Turn it on in the board settings.')),
+        el('div', { class: 'chips2' }, pbtn('outline', 'Board settings', 'settings', { onclick: () => ctx.openBoardSettings() })))];
+    } else {
+      const s = statusOf(d); const blk = blockerLine(d);
+      const decided = decidedOf(key);
+      const ids = new Set((d.proposals || []).map((p) => p.id));
+      const rows = (d.proposals || []).map((p) => propRow(p, decided.get(p.id) || null));
+      for (const [id, x] of decided) if (!ids.has(id) && x.st !== 'dropped') rows.push(propRow(x.p, x));
+      const oldest = [...(d.proposals || [])].sort((a, b) => Date.parse(a.at) - Date.parse(b.at))[0];
+      body = [
+        el('div', { class: 'lh', 'data-drv': 'status' }, el('span', { class: 'ki' }, icon(s.ic)), el('div', { class: 'ini-lhm' }, el('b', null, s.b), el('div', { class: 'dim' }, s.sub), el('div', { class: 'dim', 'data-drv': 'last' }, s.last))),
+        d.mode === 'shadow' ? el('div', { class: 'fold', 'data-drv': 'shadow' }, icon('info', 'sm'), ' Shadow mode. The agent drafts but raises nothing: no Needs you rows, no notes in Work. Switch to Approve in the board settings to act on these.') : null,
+        blk ? el('div', { class: 'fold w', role: 'alert', 'data-drv': 'blocker' }, icon('alert', 'sm'), el('span', null, blk, d.blocker.owner === 'pm' && oldest && d.mode === 'approve' ? [' ', pbtn('outline', 'Review ' + titleOf(oldest), null, { 'data-drv-act': 'focus', onclick: () => { S.open.add(oldest.id); draw(); const t = wrap.querySelector('[data-drv-row="' + oldest.id + '"]'); if (t && t.scrollIntoView) t.scrollIntoView({ block: 'center' }); } })] : null)) : null,
+        rows.length ? list(rows) : el('div', { class: 'fold', 'data-drv': 'empty' }, icon('check', 'sm'), 'No open proposals. The agent files the next one when it has something.')];
+    }
+    put(wrap, sect({ ic: 'spark', title: 'Agent', count: d.mode === 'off' ? 0 : (d.proposals || []).length, right, attrs: { 'aria-label': 'Agent' } }, ...body));
+  }
+
+  draw();
+  load();
+  return wrap;
+}
+
+/* ── the Agent setting in Board settings ── */
+/** Read a board's mode. { ok, mode } or { ok: false, error }. */
+export async function loadAgentMode(api, board) {
+  const r = await api.get('/api/driver/mode', { board });
+  return r && r.ok ? { ok: true, mode: r.mode } : { ok: false, error: errText(r, 'The agent setting could not be read') };
+}
+/** state: { mode, err, busy }. onPick(mode) saves at once (POST /api/driver/mode); the caller redraws. */
+export function agentSetting(state, { onPick } = {}) {
+  ensureDriverCss();
+  const cur = MODES.find((m) => m[0] === state.mode);
+  return el('div', { class: 'drv-set ini-field', 'data-drv': 'setting' }, lbl('AGENT'),
+    state.mode == null && !state.err ? note('Reading the agent setting') : null,
+    state.err ? el('div', { class: 'fold w', role: 'alert', 'data-drv': 'setting-error' }, icon('alert', 'sm'), state.err) : null,
+    state.mode != null ? [
+      el('div', { class: 'seg ini-seg', role: 'group', 'aria-label': 'Agent mode' }, ...MODES.map((m) => btn({ 'aria-pressed': String(state.mode === m[0]), 'data-drv-mode': m[0], disabled: !!state.busy, onclick: () => onPick(m[0]) }, m[1]))),
+      el('div', { class: 'dim ini-note', 'data-drv': 'mode-line' }, el('b', null, cur[1] + '.'), ' ' + cur[2]),
+      chgl(MODES.filter((m) => m !== cur).map((m) => el('li', null, icon('next', 'sm'), el('span', null, el('b', null, m[1] + ':'), ' ' + m[2]), el('span')))),
+      el('div', { class: 'dim ini-note' }, 'The agent files every result as a proposal. It cannot send, merge or change a record by itself. A mode is saved when you press it.')] : null);
+}
+
+/* ── Needs you: the agent's rows (Briefing) ── */
+/** The driver rows of GET /api/needs: "Agent has 3 drafts on <title>" and "<title> is waiting on you". [] when the read fails. */
+export async function loadDriverNeeds() {
+  const r = await pmGet('/api/needs');
+  return r && Array.isArray(r.needs) ? r.needs.filter((n) => n && (n.kind === 'driver-drafts' || n.kind === 'driver-blocked')) : [];
+}
+/** One li.nrow for a driver row (the mockup's two rows). `go(row)` opens the initiative or the Work page. */
+export function needsRow(n, go) {
+  ensureDriverCss();
+  const blocked = n.kind === 'driver-blocked';
+  const work = !n.initiative_id;
+  const chips = blocked ? [el('span', { class: 'tag warn' }, 'waiting on you'), chip(icon(work ? 'check' : 'init', 'sm'), work ? 'Work' : n.initiative_id)]
+    : [tag('agent'), chip(icon(work ? 'check' : 'init', 'sm'), work ? 'Work' : n.initiative_id)];
+  chips[0].className = blocked ? 'tag warn' : 'tag acc';
+  chips.push(el('span', { class: 'dim' }, blocked ? 'The agent will not go on until you decide' : 'Keep, send back or drop each one'));
+  const li = nrow({ ic: blocked ? 'next' : 'spark', hot: true, title: n.question, onOpen: () => go(n), openLabel: n.question, chips,
+    attrs: { 'data-needs-row': n.run_id, 'data-kind': n.kind, 'data-drv-need': n.kind, 'data-ref-row': n.initiative_id || n.run_id } });
+  return li;
+}

package/workspace/public/pm/c3-ii-tabs.js

@@ -1,7 +1,7 @@
 /* pm/c3-ii-tabs.js — the six tabs of an initiative page (mockup v5, 34-initiatives.js iniOverview, iniBreakdown, iniDocs, iniTickets,
  * iniTimeline, iniHistory). registerInitiativeTab(id, mount(host, ctx)); ctx.row, ctx.history (newest first), ctx.tools, ctx.toolsByCat
  * and ctx.tool come from the page (c3-initiatives.js).
- *   Overview   Left: a Summary, then one card per tool of the current stage: the stage records (c3-ini-records.js: problem, RICE, launch
+ *   Overview   On top, the Agent strip (c3-driver.js: GET /api/driver/strip; not in demo mode). Left: a Summary, then one card per tool of the current stage: the stage records (c3-ini-records.js: problem, RICE, launch
  *              checklist, burndown, kill conditions, learnings) and the server's stage tools (ideas, PRD, breakdown, tickets, releases,
  *              measurements, …) drawn from what PMOS holds. ctx.tool (a tool pressed in the strip or picked in More tools) is drawn
  *              first and scrolled to. Right: Details (portfolio, board, workflow with Edit, stage, owner, anchor, horizon, lane), Progress,
@@ -19,6 +19,7 @@ import { wfOf, catOf, kindOf, tplName, toolLabel, toolIcon, loadItems, dropItems
 import { recordCards, recordToolsFor, RECORD_META } from './c3-ini-records.js';
 import { loadDocs, renderDocs } from './c3-ib-docs.js';
 import { timeline, tlInit, tlRange, tlStill } from './c3-ini-timeline.js';
+import { driverStrip } from './c3-driver.js';
 
 const errLine = (text) => el('div', { class: 'fold w', role: 'alert', 'data-ini': 'error' }, icon('alert', 'sm'), text);
 const toneOf = (s) => (s === 'late' ? 'bad' : s === 'at risk' ? 'warn' : 'ok');
@@ -138,7 +139,7 @@ tab('overview', async (ctx, isDead, host) => {
     rels.length ? card({ ic: 'out', title: 'Releases', sub: 'live in the Calendar' }, chgl(rels.map((x) => el('li', null, icon('out', 'sm'), el('span', null, (x.name || x.id) + ' · ' + day(String(x.release_at || x.deploy_at || '').slice(0, 10))), tag('Calendar'))))) : null,
   ];
   if (picked) requestAnimationFrame(() => { const n = host.querySelector('[data-ini-tool-card="' + CSS.escape(picked) + '"]'); if (n && !isDead()) { if (n.scrollIntoView) n.scrollIntoView({ block: 'nearest' }); n.classList.add('ini-flash'); setTimeout(() => n.classList.remove('ini-flash'), 1400); } });
-  return cols(left, right);
+  return [ctx.demo ? null : driverStrip(ctx, r), cols(left, right)];
 });
 
 /* ── Breakdown ── */

package/workspace/public/pm/c3-ini-ui.js

@@ -7,7 +7,7 @@
  * Rules the builders keep (the conformance gate, R28): every control is a <button> from primitives.js button() (btn() below adds the
  * console3 class it is drawn as, and `ini-b`, the reset that takes the primitive's own height and nowrap off); a colour, a width or a
  * position is a class or a `--in-…` custom property set with geo(), never an inline style; icons come from the console3 sprite
- * (c3ic) or, for the three it lacks (gear, grip, the Jira mark), from svgIcon(). Nothing here reads or writes the server.
+ * (c3ic) or, for the four it lacks (gear, grip, pause, the Jira mark), from svgIcon(). Nothing here reads or writes the server.
  *
  *   btn(attrs, ...kids)            a button; attrs.class is the console3 class (pill, chip2 lk, ib sm, tt, ...), attrs.onclick its press
  *   pbtn(variant, label, icon, attrs)  a primitive button drawn as the primitive (primary, outline, ghost), small
@@ -41,12 +41,14 @@ export function svgIcon(paths, cls) {
 }
 export const GEAR = ['M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22-.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z', 'M15 12a3 3 0 1 1-6 0 3 3 0 0 1 6 0z'];
 export const GRIP = ['M9 5h.01M9 12h.01M9 19h.01M15 5h.01M15 12h.01M15 19h.01'];
+export const PAUSE = ['M8 5v14M16 5v14'];
 export const JIRA = ['M12 3l9 9-9 9-9-9z', 'M12 8l4 4-4 4-4-4z'];
 /** An icon by name: the sprite's, or one of the three drawn here. */
 export function icon(name, cls) {
   if (name === 'settings') return svgIcon(GEAR, cls);
   if (name === 'grip') return svgIcon(GRIP, cls);
   if (name === 'jira') return svgIcon(JIRA, cls);
+  if (name === 'pause') return svgIcon(PAUSE, cls);
   return c3ic(name, cls);
 }
 
@@ -170,7 +172,7 @@ export function nrow(o) {
     el('span', { class: 'ki' + (o.hot ? ' hot' : '') + (o.tone ? ' ini-k-' + o.tone : '') }, icon(o.ic || 'doc')),
     el('div', { class: 'nb' }, t, o.sub ? note(o.sub) : null, o.chips && o.chips.length ? el('div', { class: 'chips' }, ...o.chips.filter(Boolean)) : null, o.after || null, xp),
     o.right && o.right.filter(Boolean).length ? el('div', { class: 'acts' }, ...o.right.filter(Boolean)) : el('span'));
-  if (xp) attachExpand(li, xp, { key: o.key });
+  if (xp) attachExpand(li, xp, { key: o.key, initial: !!o.open, onToggle: o.onToggle });
   return li;
 }
 export function crumbs(parts, right) {

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

@@ -48,6 +48,7 @@ import {
 import { TEMPLATES, BOARD_TEMPLATES, isBuildStage, templateBuilds, offered, wfOf, catOf, kindOf, tplName, TOOL_META, toolLabel, toolIcon, loadItems, dropItems, workTlRows, iniTlRow, rescheduleTask, lockedToast } from './c3-ini-work.js';
 import { timeline, tlInit, tlRange } from './c3-ini-timeline.js';
 import { RECORD_META, recordToolsFor } from './c3-ini-records.js';
+import { agentSetting, loadAgentMode, MODES as AGENT_MODES } from './c3-driver.js';
 
 export { btn, geo };
 export { TEMPLATES, CATS };
@@ -386,6 +387,18 @@ export function mountInitiatives(pane, opts) {
     const sh = openSheet({ title: 'Board settings · ' + b.name, icon: 'cols', body: host, wide: true });
     let usage = null;
     loadItems(makeCtx(b, {})).then((r) => { usage = r; render(); });
+    // The Agent setting (c3-driver.js): read once, and saved at once when a mode is pressed (POST /api/driver/mode). Not in demo mode.
+    const A = { mode: null, err: '', busy: false };
+    if (!opts.demo) loadAgentMode(apiFor(b.ws), b.id).then((r) => { if (r.ok) A.mode = r.mode; else A.err = r.error; render(); });
+    async function pickAgent(mode) {
+      if (A.busy || mode === A.mode) return;
+      A.busy = true; A.err = ''; render();
+      const r = await apiFor(b.ws).post('/api/driver/mode', { board: b.id, mode });
+      A.busy = false;
+      if (!r || !r.ok) A.err = 'The agent setting was not saved: ' + ((r && r.error) || 'no answer') + '.';
+      else { A.mode = r.mode; toast(b.name + ': Agent ' + (AGENT_MODES.find((m) => m[0] === r.mode) || [0, r.mode])[1] + '.'); }
+      render('[data-drv-mode="' + A.mode + '"]');
+    }
     function render(focusSel) {
       const allowed = (k) => B.build || !templateBuilds(k);
       for (const k of [...B.offer]) if (!allowed(k)) B.offer.delete(k);
@@ -409,6 +422,7 @@ export function mountInitiatives(pane, opts) {
         lbl('DEFAULT FOR NEW INITIATIVES AND ACCEPTED ASKS'),
         tplSeg([...B.offer], B.def, (k) => { B.def = k; render('[data-ini-tpl="' + k + '"]'); }, 'Default workflow'),
         tplCase(B.def),
+        opts.demo ? null : agentSetting(A, { onPick: pickAgent }),
         el('div', { class: 'chips2' }, el('span', { class: 'dim ini-note' }, 'Initiatives that do not run their own workflow run the board\'s: ' + workflowLabel(b) + '.'), lk({ 'data-ini': 'edit-board-workflow', onclick: () => openBoardWorkflow(b) }, 'Edit the board\'s workflow')),
         B.err ? errLine(B.err) : null,
         el('div', { class: 'chips2' }, pbtn('primary', B.busy ? 'Saving' : 'Save board settings', null, { 'data-ini': 'settings-save', disabled: B.busy, onclick: save }), pbtn('ghost', 'Cancel', null, { onclick: () => sh.close() })));

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

@@ -524,7 +524,7 @@ function draftsTab(pane) {
   });
 }
 
-const BUILD = { brief: briefTab, cal: (p) => mountCalendarViews(p, { view: 'week', page: true, scope: sc('cal'), deck: planNode('cal', { bare: true }) }), work: (p) => { mountPmWork(p, { go: (t) => showTab(t, true) }); }, init: (p) => mountInitiatives(p, { ws: S.ws, workspaces: S.workspaces, demo: DEMO, showTab }), rep: repTab };
+const BUILD = { brief: briefTab, cal: (p) => mountCalendarViews(p, { view: 'week', page: true, scope: sc('cal'), deck: planNode('cal', { bare: true }) }), work: (p) => { mountPmWork(p, { go: (t) => showTab(t, true), ws: S.ws }); }, init: (p) => mountInitiatives(p, { ws: S.ws, workspaces: S.workspaces, demo: DEMO, showTab }), rep: repTab };
 
 function showTab(id, push) {
   if (!BUILD[id] && id !== 'settings') id = 'brief';

package/workspace/public/pm/pm-work-view.js

@@ -315,8 +315,15 @@ const later = (inst, fn, ms) => { const t = setTimeout(() => { inst.timers.delet
 
 /* ── reads and presses ───────────────────────────────────────────────────────────────────────────────────────────── */
 
+/* The Initiative Driver's open Work proposals (c3-driver-work.js), read with the list. Null when there are none to draw: demo mode, an old server, no answer. */
+async function driverRead(inst) {
+  if (DEMO() || inst.ctx.FIXTURE) return null;
+  try { const m = await import('./c3-driver-work.js'); const o = await m.loadDriverOpen(inst.ctx.ws); return o ? { m, ws: o.ws, mode: o.mode, targets: o.targets || {} } : null; } catch { return null; }
+}
+
 async function load(inst) {
-  const r = await pmGet(API);
+  const [r, drv] = await Promise.all([pmGet(API), driverRead(inst)]);
+  inst.drv = drv;
   inst.base = r && r.ok ? r : null;
   inst.data = inst.base && DEMO() ? applyOv(inst.base, inst.ov) : inst.base;
   if (!inst.data) say({ text: (r && r.error) || COPY.readError, tone: 'error' });
@@ -851,9 +858,12 @@ function itemRow(inst, item, lens, o = {}) {
   if (lens === 'inbox') right = button({ label: COPY.decide, variant: 'ghost', size: 'sm', icon: 'next', attrs: { 'data-pm-decide': item.id }, onClick: (e) => { e.stopPropagation(); if (row.__exp) row.__exp.toggle(); } });
   else if (lens === 'waiting') right = c3ib(COPY.nudge, 'out', { 'data-pm-nudge': item.id, onClick: (e) => { e.stopPropagation(); say({ text: COPY.nudged(item.waiting_on || 'them'), timeout: 4000 }); } }, 'sm');
   else if (lens !== 'someday') right = c3ib(COPY.doneBtn, 'check', { 'data-pm-done': item.id, onClick: (e) => { e.stopPropagation(); doneAct(inst, item, row, 'Done.'); } }, 'sm');
+  /* the agent line (Initiative Driver): one line under the title when the agent filed a proposal for this task */
+  const dn = inst.drv && !item.done ? inst.drv.m.workNote({ item, props: inst.drv.targets[item.id] || [], ws: inst.drv.ws, mode: inst.drv.mode, done: () => load(inst) }) : null;
+  const agentLine = dn ? el('div', { class: 'dim drv-small drv-sub', 'data-drv-line': item.id }, dn) : null;
   const row = el('li', { class: 'nrow wrow', 'data-row': '', 'data-id': item.id, 'data-w': '1', 'data-pm-item': item.id, 'data-lens': lens },
     el('span', { class: 'ki' + (hot ? ' hot' : ''), title: item.kind === 'offline' ? 'Happens outside PMOS' : item.priority || '' }, c3ic(icon)),
-    el('div', { class: 'nb' }, title, mock && item.left ? fuseBar(item.left) : null, chips.filter(Boolean).length ? el('div', { class: 'chips' }, chips.filter(Boolean)) : null),
+    el('div', { class: 'nb' }, title, agentLine, mock && item.left ? fuseBar(item.left) : null, chips.filter(Boolean).length ? el('div', { class: 'chips' }, chips.filter(Boolean)) : null),
     right ? el('div', { class: 'acts' }, right) : el('span'),
     el('span', { class: 'sg', title: agent ? 'Drag right: the agent acts. Drag left: reply.' : 'Drag right: ' + spec.right.label + '. Drag left: ' + spec.left.label + '.' },
       el('span', { class: 'g l' + (recSide === 'l' ? ' y' : '') }, c3ic(spec.left.icon)), el('span', { class: 'g r' + (recSide === 'r' ? ' y' : '') }, c3ic(spec.right.icon))));

package/workspace/test-files.json

@@ -139,6 +139,7 @@
     "pm-portfolio-inline-test.js",
     "pm-brief-page-test.js",
     "c3-settings-test.js",
+    "c3-driver-test.js",
     "c3-sessions-panel-test.js",
     "c3-updates-test.js"
   ],
@@ -190,6 +191,7 @@
     "guide.test.js": 1,
     "driver.test.js": 3,
     "driver-server.test.js": 25,
+    "c3-driver-test.js": 40,
     "next-step-actions.test.js": 5,
     "kg.test.js": 1,
     "doc-category.test.js": 1,