create-pmos 0.167.0 → 0.169.0

package/workspace/lib/routes-driver.js

@@ -0,0 +1,167 @@
+'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[&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
+ * started and not ended; `last` is the most recent run that ended; `blocker` is the sweep's latest finding of today.
+ *
+ * WHO WRITES. Every POST passes pm-guard requirePagePress, and a request that carries an agent session header is refused
+ * first. `by` of every line is the guard's actor. Keep writes through the existing writers (lib/driver-decide.js): a problem
+ * into the stage tools, a move through the board move route (lib/routes-boards.js move), a Work next step into the Work items.
+ * State: <state folder>/driver.jsonl, one per repository (lib/driver.js). Nothing here sends anything outward.
+ */
+const path = require('path');
+const guard = require('./pm-guard.js');
+const actorLib = require('./actor.js');
+const D = require('./driver.js');
+const decideLib = require('./driver-decide.js');
+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 || '');
+  return w && (!id || w.id === id) ? w : null;
+}
+function ledgerOf(ctx, w) {
+  const d = ctx.stateDirFor ? ctx.stateDirFor(w) : null;
+  return D.ledgerFile(d);
+}
+const runtimeOf = (ctx) => ctx.runtimeDir || require('./state-root.js').defaultRoot();
+
+/** The board a target's mode is read from: the board of its latest run, else Work's own, else every board. */
+function boardOfTarget(state, target) {
+  if (target.kind === 'work') return 'work';
+  const runs = [...state.runs.values()].filter((r) => D.targetKey(r.target) === D.targetKey(target) && r.board);
+  return runs.length ? runs[runs.length - 1].board : null;
+}
+
+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) || 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(proposalOut),
+  };
+}
+
+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 (!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'));
+    const w = wsOf(ctx, url.searchParams.get('ws'));
+    if (!w) return send(bad(404, 'no such workspace'));
+    const t = D.checkTarget({ kind: text(url.searchParams.get('target_kind')), ws: w.id, id: text(url.searchParams.get('id')) });
+    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, { board: text(url.searchParams.get('board')) || null }) } });
+  }
+
+  if (req.method !== 'POST') return send(bad(405, 'POST only'));
+  const read = await ctx.readJson(req);
+  if (!read.ok) return send(bad(400, 'the body is not JSON'));
+  const body = read.body;
+  if (req.headers && req.headers['x-pmos-session']) return send(bad(403, 'an agent session cannot keep, send back, drop, pause or change the mode of the driver'));
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) return send(bad(g.status, g.error));
+  const w = wsOf(ctx, text(body.ws));
+  if (!w) return send(bad(404, 'no such workspace'));
+  const file = ledgerOf(ctx, w);
+  if (!file) return send(bad(409, 'this repository has no state folder (pmos/state, state or .pmos), so the driver has nowhere to keep its ledger'));
+  const refresh = () => { try { if (ctx.invalidateNeedsAgg) ctx.invalidateNeedsAgg(w.id); } catch { /* the next poll recounts */ } };
+
+  if (sub === 'keep' || sub === 'return' || sub === 'drop') {
+    const proposal = text(body.proposal);
+    if (!D.PROPOSAL_RE.test(proposal)) return send(bad(400, 'proposal must be a driver proposal id'));
+    const stateDir = ctx.stateDirFor(w);
+    const dctx = {
+      stageFile: path.join(stateDir, stageTools.LEDGER),
+      itemsDir: path.join(runtimeOf(ctx), 'pm-items'),
+      correctionsFile: path.join(runtimeOf(ctx), 'corrections.jsonl'),
+      // The board move route's own function: its validation and its warnings apply, and `by` is the PM.
+      move: async (pr) => {
+        const routesBoards = require('./routes-boards.js');
+        let board = pr.data && pr.data.board;
+        if (!board) { try { board = routesBoards.boardIndex(ctx, w).of(pr.target.id); } catch { board = null; } }
+        return routesBoards.move(ctx, { ws: w.id, board: board || w.id, id: pr.target.id, to: pr.data.to, why: (pr.why || '').slice(0, 500) }, g);
+      },
+    };
+    const r = await decideLib.decide(sub, { file, proposal, note: body.note == null ? undefined : text(body.note), actor: g.actor, ctx: dctx });
+    if (!r.ok) return send(bad(r.status, r.error));
+    refresh();
+    return send({ status: 200, body: { ok: true, proposal: { ...r.proposal, by: actorLib.pageName(r.proposal.by) }, wrote: r.wrote, warnings: r.warnings } });
+  }
+
+  if (sub === 'pause' || sub === 'resume') {
+    const t = D.checkTarget({ kind: text(body.target_kind), ws: w.id, id: text(body.id) });
+    if (!t.ok) return send(bad(400, t.error));
+    const r = decideLib.setPause(file, sub, t.target, g.actor);
+    if (!r.ok) return send(bad(r.status, r.error));
+    refresh();
+    return send({ status: 200, body: { ok: true, paused: r.paused, target: r.target } });
+  }
+
+  const r = decideLib.setMode(file, body.board == null || body.board === '' ? '*' : text(body.board), text(body.mode), g.actor);
+  if (!r.ok) return send(bad(r.status, r.error));
+  refresh();
+  return send({ status: 200, body: { ok: true, board: r.board, mode: r.mode } });
+}
+
+module.exports = { prefixes: ['/api/driver'], handle, stripOf, boardOfTarget };

package/workspace/lib/routes-meeting-focus.js

@@ -7,6 +7,10 @@
  *        minutes of that note's transcript with who said them, the decisions, actions and questions so far, and the companion's state.
  *        An unknown meeting is a 404. The read also starts the companion when lib/meeting-focus.js shouldRun says it may: the note
  *        records, new lines arrived, 40 s passed, no run is under way, PMOS_FOCUS_AGENT is not off. The run is fire and forget.
+ *   GET  /api/meeting-focus/now?meet=<abc-defg-hij>&title=<Meet tab title>   (c3-meet-extension)
+ *        → { ok, event: { id, title, at, end }, date, by: 'meet'|'title'|'time' }, or a 404 { ok:false, error, choices:[{ id, title, at, end }] }
+ *        Which meeting a Google Meet call is: the one whose links carry the Meet code, else the one titled like the tab, else the one under way now
+ *        (lib/meeting-focus.js pickNow). It reads the same calendar as the read above and writes nothing.
  *   POST /api/meeting-focus/topic { event | note, date?, action: 'set'|'add'|'park', topic }   page press; the PM's correction, appended to the state
  *   POST /api/meeting-focus/ask   { event, note?, date?, question }                            page press; one headless read-only run with the PM's question
  *   GET  /api/meeting-focus/ask?id=  → { ok, id, state: working | answered | failed, error? }   the answer itself comes back as a note in GET /api/meeting-focus
@@ -175,6 +179,17 @@ async function read(q, ctx) {
   } };
 }
 
+/* ── GET /api/meeting-focus/now ───────────────────────────────────────────────────────────────────────────────────── */
+
+function nowRoute(q, ctx) {
+  const nowMs = typeof ctx.now === 'function' ? ctx.now() : Date.now();
+  let events = [];
+  try { events = typeof ctx.readEvents === 'function' ? ctx.readEvents() : require('./calendar-events.js').readAll(ctx.runtimeDir, { now: nowMs }); } catch { events = []; }
+  const r = F.pickNow(events, { now: nowMs, meet: F.str(q && q.meet, 40), title: F.str(q && q.title, 300) });
+  if (!r.ok) return fail(404, r.error, { choices: r.choices });
+  return { status: 200, body: { ok: true, event: r.event, date: r.date, by: r.by } };
+}
+
 /* ── POST /api/meeting-focus/topic ────────────────────────────────────────────────────────────────────────────────── */
 
 async function topic(req, body, ctx) {
@@ -272,13 +287,14 @@ const respond = (ctx, res, r) => { ctx.json(res, r.body, r.status); return true;
 
 module.exports = {
   prefixes: ['/api/meeting-focus'],
-  read, topic, ask, askState, settleAsk, settleRun, findEvent, keyOf,
+  read, now: nowRoute, topic, ask, askState, settleAsk, settleRun, findEvent, keyOf,
   handle: async (req, res, url, ctx) => {
     const p = url.pathname;
     const wsId = url.searchParams.get('ws');
     const w = ctx.getWs ? ctx.getWs(wsId) : null;
     const base = { runtimeDir: ctx.runtimeDir, spawnSession: ctx.spawnSession, w, getWs: ctx.getWs, json: ctx.json };
     if (req.method === 'GET' && p === '/api/meeting-focus') return respond(ctx, res, await read(Object.fromEntries(url.searchParams), base));
+    if (req.method === 'GET' && p === '/api/meeting-focus/now') return respond(ctx, res, nowRoute(Object.fromEntries(url.searchParams), base));
     if (req.method === 'GET' && p === '/api/meeting-focus/ask') return respond(ctx, res, askState(Object.fromEntries(url.searchParams), base));
     const fn = req.method === 'POST' && { '/api/meeting-focus/topic': topic, '/api/meeting-focus/ask': ask }[p];
     if (!fn) return false;

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.167.0",
+  "version": "0.169.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.167.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.167.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-demo-focus.js

@@ -2,7 +2,8 @@
  * c3-demo.js passes GET /api/meeting-focus, GET /api/meeting-focus/ask and the two POSTs (topic, ask) here. The content is the approved
  * mockup's (version 7): the Partner API rate-limit review at 18:24 in, with its six topics (one added from the talk), the gist and its four
  * context chips, the room's last lines, three PMOS notes and two it is holding, the captured items and a Google Slides deck.
- * Whatever meeting the page asks for, the demo answers with this one. A correction (set, add, park) and a question change the answer
+ * Whatever meeting the page asks for, the demo answers with this one. GET /api/meeting-focus/now (the compact page of the Chrome extension) names it too;
+ * the Meet code NONE_CODE answers "no meeting fits" with three of the day's meetings as choices, so that path can be walked. A correction (set, add, park) and a question change the answer
  * for the rest of the page's life; nothing is saved and nothing reaches the server. Real mode never loads this file. */
 
 const DAY = '2026-10-08';
@@ -91,8 +92,17 @@ function view() {
   };
 }
 
-/** GET /api/meeting-focus and GET /api/meeting-focus/ask?id= */
+export const NONE_CODE = 'zzz-zzzz-zzz';
+const CHOICES = [['e1', 'Partner standup', '09:30', '10:00'], ['e2', EVENT.title, '11:00', '12:00'], ['e3', 'Onboarding v2 scope check', '14:00', '14:45']]
+  .map(([id, title, from, to]) => ({ id: id + '@' + DAY, title, at: DAY + 'T' + from + ':00', end: DAY + 'T' + to + ':00' }));
+
+/** GET /api/meeting-focus, GET /api/meeting-focus/ask?id= and GET /api/meeting-focus/now?meet=&title= */
 export function focusGet(path, url) {
+  if (path === '/api/meeting-focus/now') {
+    const q = new URL(url, location.origin).searchParams;
+    if (q.get('meet') === NONE_CODE) return { ok: false, status: 404, error: 'No meeting on the calendar fits this call.', choices: CHOICES };
+    return { ok: true, event: { id: EVENT.id, title: EVENT.title, at: EVENT.at, end: EVENT.end }, date: DAY, by: q.get('meet') ? 'meet' : 'time' };
+  }
   if (path === '/api/meeting-focus/ask') {
     const q = new URL(url, location.origin).searchParams;
     const a = S.asks.find((x) => x.id === q.get('id'));

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

@@ -52,7 +52,7 @@ function getRoute(path, url) {
   switch (path) {
     case '/api/briefing': return D.briefing(url);
     case '/api/calendar-views': return withCalendarPage(D.calendarViews(url));
-    case '/api/meeting-focus': case '/api/meeting-focus/ask': return focusGet(path, url);
+    case '/api/meeting-focus': case '/api/meeting-focus/ask': case '/api/meeting-focus/now': return focusGet(path, url);
     case '/api/pm-items': return D.pmItems();
     case '/api/runs': return D.runs();
     case '/api/releases': return D.releases();

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%}