create-pmos 0.167.0 → 0.168.0

package/workspace/lib/headless.js

@@ -3,7 +3,7 @@
  * (initiative workspace-headless-jobs; PM decision 2026-10-11: keep Jev, no direct Claude API, background
  * jobs that need no human run headless).
  *
- *   kindFor({ agent, origin, skill, env })        → 'notes' | 'skill' | 'ask' | null   (null: open a pane, as before)
+ *   kindFor({ agent, origin, skill, env })        → 'notes' | 'skill' | 'ask' | 'drive' | null   (null: open a pane, as before)
  *   argsFor(kind, { modelArgs, addDirs })          → the argv after `claude`
  *   parseResult(stdout)                            → { ok, text, isError, turns, durationMs, costUsd, denied[] }
  *   logLines(result, exitCode)                     → the lines the read-only log pane shows at the end
@@ -14,6 +14,12 @@
  * It cannot ask for permission, so each kind gets a FIXED tool list here; a connector tool runs only where the
  * PM's own Claude Code settings already allow it, and anything else is denied and reported. No bypass flag is
  * ever passed. `PMOS_HEADLESS=off` sends every job back to a pane.
+ *
+ * The `drive` kind is the Initiative Driver (initiative initiative-driver): origin `drive:<kind>:<id>`. It reads, and it files
+ * proposals with `pmos driver propose`. It has no Write, no Edit, no `git push`, no web fetch and no connector write tool: no
+ * connector tool is named in its list, so a connector read runs only where the PM's own Claude Code settings already allow it,
+ * and a connector write is denied and reported like any other tool outside the list. The PM-only `pmos driver` verbs refuse an
+ * agent session by themselves. The driver never runs in a pane (server.js refuses to start it when PMOS_HEADLESS=off).
  */
 
 // The skills whose every start runs headless: they read, file a result for PMOS, and send nothing out.
@@ -25,12 +31,16 @@ const HEADLESS_SKILLS = Object.freeze([
 const HEADLESS_ORIGINS = Object.freeze(['notes-bullets:', 'notes-summary:']);
 // page-starts-agent: Ask the agent on a document. The run reads and answers with the revised text; it writes nothing.
 const ASK_ORIGINS = Object.freeze(['doc-ask:', 'focus-companion:']);   // focus-companion: the Meeting focus page's quiet companion and its private questions (read-only, nothing sent)
+// initiative-driver: one short run for one initiative or one Work task. Its origin is `drive:<kind>:<id>`.
+const DRIVE_ORIGINS = Object.freeze(['drive:']);
 
 // What each kind may use. Read-only search is always allowed. The notes passes write their JSON (and rename the .tmp
 // file) in their notes folder, which --add-dir opens to them; the skills also run `pmos` verbs and repository scripts.
 const TOOLS = Object.freeze({
   notes: Object.freeze(['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash(mv *)']),
   ask: Object.freeze(['Read', 'Glob', 'Grep']),
+  drive: Object.freeze(['Read', 'Glob', 'Grep', 'Bash(pmos driver *)', 'Bash(pmos initiative list *)', 'Bash(pmos initiative export *)',
+    'Bash(git log *)', 'Bash(ls *)', 'Bash(date *)']),
   skill: Object.freeze(['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash(pmos *)', 'Bash(node *)',
     'Bash(git log *)', 'Bash(git status *)', 'Bash(git diff *)', 'Bash(ls *)', 'Bash(date *)']),
 });
@@ -46,6 +56,7 @@ function kindFor({ agent, origin, skill, env } = {}) {
   const o = String(origin || '');
   if (HEADLESS_ORIGINS.some((p) => o.startsWith(p))) return 'notes';
   if (ASK_ORIGINS.some((p) => o.startsWith(p))) return 'ask';
+  if (DRIVE_ORIGINS.some((p) => o.startsWith(p))) return 'drive';
   if (skill && HEADLESS_SKILLS.includes(String(skill))) return 'skill';
   return null;
 }
@@ -96,4 +107,4 @@ function logLines(r, exitCode) {
   return out;
 }
 
-module.exports = { HEADLESS_SKILLS, HEADLESS_ORIGINS, ASK_ORIGINS, TOOLS, DEFAULT_TIMEOUT_MS, kindFor, argsFor, timeoutMs, parseResult, logLines, switchedOff };
+module.exports = { HEADLESS_SKILLS, HEADLESS_ORIGINS, ASK_ORIGINS, DRIVE_ORIGINS, TOOLS, DEFAULT_TIMEOUT_MS, kindFor, argsFor, timeoutMs, parseResult, logLines, switchedOff };

package/workspace/lib/meeting-focus.js

@@ -9,6 +9,7 @@
  *   foldState(lines, { topics, startMs, nowMs }) → the page's state    the append-only focus/<id>.jsonl folded
  *   outLine(parsed, at) · moveLine(...)   → the lines the state file takes
  *   shouldRun(now, state, note, opts)     → { run, reason }            the rules of when the companion may run
+ *   pickNow(events, { now, meet, title }) → { ok, event, date, by } | { ok:false, status:404, error, choices }   which meeting a Google Meet call is (the Chrome extension, c3-meet-extension)
  *
  * Nothing here reads a file or starts a process; lib/routes-meeting-focus.js does both.
  *
@@ -289,4 +290,50 @@ function shouldRun(now, state, note, opts = {}) {
   return { run: true, reason: 'new lines' };
 }
 
-module.exports = { CATS, REF_TYPES, MIN_GAP_MS, TAIL_MINUTES, TAIL_MAX, topicsFrom, tailOf, capturedFrom, companionPrompt, parseCompanion, foldState, outLine, moveLine, shouldRun, norm, str, off };
+/* ── which meeting is this Google Meet call (c3-meet-extension) ───────────────────────────────────────────────────── */
+
+const MEET_CODE = /\b[a-z]{3}-[a-z]{4}-[a-z]{3}\b/i;
+const NOW_SLACK_MS = 10 * 60000;   // a call may start 10 minutes early and run 10 minutes over
+const DEFAULT_LEN_MS = 60 * 60000;
+const CHOICES_MAX = 6;
+const localDayOf = (ms) => { const d = new Date(ms); return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0'); };
+const startOf = (e) => Date.parse(e && (e.at || e.start));
+const endOf = (e) => { const s = startOf(e); const t = Date.parse(e && e.end); return Number.isFinite(t) && t > s ? t : s + DEFAULT_LEN_MS; };
+/** Every text of an event that may carry the Meet address: its links, and the fields a calendar reader may fill. */
+const meetTextsOf = (e) => [].concat((Array.isArray(e.links) ? e.links : []).map((l) => (l && typeof l === 'object' ? l.url : l)), e.hangoutLink, e.hangout_link, e.meet_url, e.conference, e.location)
+  .filter((x) => typeof x === 'string').map((x) => x.toLowerCase());
+/** The tab title of a Meet call without its "Meet - " lead, in a form two titles can be compared in. A bare Meet code is no title. */
+function meetTitle(title) {
+  const raw = String(title == null ? '' : title).replace(/^\s*meet\s*[-\u2013\u2014]\s*/i, '').trim();
+  return /^[a-z]{3}-[a-z]{4}-[a-z]{3}$/i.test(raw) ? '' : norm(raw);
+}
+const titleFits = (a, b) => !!a && !!b && (a === b || (Math.min(a.length, b.length) >= 4 && (a.includes(b) || b.includes(a))));
+
+/**
+ * Which meeting on the calendar is the Google Meet call the browser shows. In order: the meeting whose links carry the Meet code, the meeting whose
+ * title is the tab's title, the meeting under way now (from 10 minutes before the start to 10 minutes after the end; of several, the one that
+ * started last). Only today's meetings, and any meeting under way now, are looked at. Several that fit one rule: the one under way, else the nearest start.
+ * When none fits: { ok:false, status:404, error, choices } with today's meetings nearest now (at most 6, in time order). Pure.
+ */
+function pickNow(events, { now = Date.now(), meet = '', title = '' } = {}) {
+  const day = localDayOf(now);
+  const pool = (events || []).filter((e) => e && e.id && Number.isFinite(startOf(e)) && (localDayOf(startOf(e)) === day || (startOf(e) <= now && now <= endOf(e))));
+  const near = (e) => (now < startOf(e) ? startOf(e) - now : now > endOf(e) ? now - endOf(e) : 0);
+  const best = (list) => list.slice().sort((a, b) => near(a) - near(b) || startOf(b) - startOf(a))[0] || null;
+  const hit = (e, by) => ({ ok: true, by, date: String(e.at || e.start || '').slice(0, 10), event: { id: e.id, title: e.title || '', at: e.at || e.start, end: e.end || null } });
+  const code = (String(meet || '').match(MEET_CODE) || [''])[0].toLowerCase();
+  if (code) { const e = best(pool.filter((x) => meetTextsOf(x).some((t) => t.includes(code)))); if (e) return hit(e, 'meet'); }
+  const want = meetTitle(title);
+  if (want) {
+    const exact = pool.filter((x) => norm(x.title) === want);
+    const e = best(exact.length ? exact : pool.filter((x) => titleFits(norm(x.title), want)));
+    if (e) return hit(e, 'title');
+  }
+  const under = pool.filter((e) => startOf(e) - NOW_SLACK_MS <= now && now <= endOf(e) + NOW_SLACK_MS);
+  if (under.length) return hit(under.slice().sort((a, b) => startOf(b) - startOf(a))[0], 'time');
+  const choices = pool.slice().sort((a, b) => near(a) - near(b) || startOf(a) - startOf(b)).slice(0, CHOICES_MAX).sort((a, b) => startOf(a) - startOf(b))
+    .map((e) => ({ id: e.id, title: e.title || '', at: e.at || e.start, end: e.end || null }));
+  return { ok: false, status: 404, error: 'No meeting on the calendar fits this call.', choices };
+}
+
+module.exports = { CATS, REF_TYPES, MIN_GAP_MS, TAIL_MINUTES, TAIL_MAX, topicsFrom, tailOf, capturedFrom, companionPrompt, parseCompanion, foldState, outLine, moveLine, shouldRun, pickNow, meetTitle, norm, str, off };

package/workspace/lib/needs-providers.js

@@ -33,6 +33,7 @@ const PROVIDERS = Object.freeze([
   'initiative-needs',   // Run 2 (2C): day one, agent proposals, passed check-by (kind 7); a record with no anchor (kind 8)
   'work-check-needs',   // Run 4 (4D): a person's item in Review, a batched Release (kind 4)
   'report-needs',       // Run 5 (5C): a report to issue (kind 1), cycle rows (kind 7), a schedule left no output (kind 8)
+  'driver-needs',       // initiative-driver: drafts the agent filed (kind 7), a target the PM is blocking (kind 7)
 ]);
 /** Kinds that already mean something in the needs queue. A provider may not reuse one. */
 const RESERVED_KINDS = Object.freeze(['question', 'accept', 'outcome', 'keep', 'evidence', 'plan-flag', 'provider-error']);

package/workspace/lib/pmos-verbs.js

@@ -53,6 +53,12 @@ const VERBS = Object.freeze({
   // Not a pm-os-absorb verb (run: null): tracker-read-freshness added it through the same table.
   tracker: Object.freeze({ module: 'tracker-cli.js', run: null, guide: 'data-freshness.md',
     help: 'pmos tracker done|status — record when the tracker-refresh skill finished a read of this repository (pmos tracker help)' }),
+  // Not a pm-os-absorb verb (run: null): c3-meet-extension added it through the same table.
+  extension: Object.freeze({ module: 'extension-cli.js', run: null, guide: 'console-calendar.md',
+    help: 'pmos extension — the folder of the Chrome extension for Google Meet, and the three steps to load it' }),
+  // Not a pm-os-absorb verb (run: null): initiative initiative-driver added it through the same table.
+  driver: Object.freeze({ module: 'driver-cli.js', run: null, guide: 'initiative-driver.md',
+    help: 'pmos driver propose|status|keep|return|drop|pause|resume|mode … — the Initiative Driver: drafts for you to keep, send back or drop (pmos driver help)' }),
   launcher: Object.freeze({ module: 'launcher-cli.js', run: null, guide: 'launcher.md',
     help: 'pmos launcher on|off|status — a PMOS app and a login item, so the workspace starts without a terminal' }),
 });

package/workspace/lib/route-modules.js

@@ -68,6 +68,7 @@ const MODULES = Object.freeze([
   'routes-sources',       // workspace-data-freshness: how old each source is, Refresh now, the change detector switch
   'routes-meeting-focus', // console3 Meeting focus: the meeting, its note's talk, the companion's notes (GET); topic corrections and Ask PMOS quietly (page press)
   'routes-stage-tools',   // stage-tools-records: the records the PM edits per stage, what PMOS holds per stage, the sprint burndown
+  'routes-driver',        // initiative-driver: the Agent strip's data, Keep, Send back, Drop, Pause and the board mode (driver.jsonl)
 ]);
 const PM_DIR = path.join(__dirname, '..', 'public', 'pm');
 const MODULE_NAME = /^[a-z0-9][a-z0-9-]*\.js$/;

package/workspace/lib/routes-boards.js

@@ -776,6 +776,16 @@ async function handle(req, res, url, ctx) {
   return true;
 }
 
+/** The PM's move of one initiative, by the same function POST /api/boards/move runs (initiative initiative-driver: Keep on a
+ * driver proposal). `g` is the guard's answer ({ ok, actor }); nothing is chosen by the caller. Answers { status, body } with the
+ * body the route would send ({ ok, row, warnings } or { ok: false, error }); the route's validation and warnings apply. */
+function move(ctx, body, g) {
+  let out = { status: 500, body: { ok: false, error: 'the move was not answered' } };
+  const cap = { ...ctx, json: (_res, obj, code) => { out = { status: code || 200, body: obj }; } };
+  WRITES['/api/boards/move'](cap, null, body, g);
+  return out;
+}
+
 /** The board of each initiative of a workspace, for other routes (Reports): { boards: [{ id, title }], of(id) → board id }.
  * Rows still being read fall back to the ledger's assignment, else the default board. */
 function boardIndex(ctx, w) {
@@ -836,4 +846,4 @@ function meetingBoards(ctx) {
   return { list, detail };
 }
 
-module.exports = { prefixes: ['/api/boards'], handle, boardIndex, meetingBoards, boardsOf, baseRows, boardRow, portfolio, SELF_REFUSAL, NO_STATE };
+module.exports = { prefixes: ['/api/boards'], handle, move, boardIndex, frameFor, boardIdOf, meetingBoards, boardsOf, baseRows, boardRow, portfolio, SELF_REFUSAL, NO_STATE };

package/workspace/lib/routes-driver.js

@@ -0,0 +1,135 @@
+'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 }
+ *   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
+ *
+ * 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'];
+
+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() } = {}) {
+  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 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 },
+    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 })),
+  };
+}
+
+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 (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) } });
+  }
+
+  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.168.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.167.0",
+      "version": "0.168.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.168.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-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-focus.css

@@ -167,3 +167,34 @@
 .c3focus .fc-cx > span { display: grid; gap: 1px; overflow: visible; text-align: left; }
 .c3focus .fc-cx > span > b { font-weight: 600; }
 .c3.fc-open { container-type: normal; }
+
+/* compact mode (?pop=1, initiative c3-meet-extension): the panel the Chrome extension frames over a Google Meet call. A head, What is being said,
+ * the conversation and a foot. Folded to a pill, only the head shows. The look is the mockup's "Over Google Meet" panel. Tokens only. */
+.c3focus.fc-pop { overflow: hidden; }
+.c3focus.fc-pop .fc-page { display: flex; flex-direction: column; gap: 8px; height: 100%; max-width: none; margin: 0; padding: 10px; }
+.c3focus.fc-pop .fc-ph { display: flex; align-items: center; gap: 8px; min-height: 24px; font-size: var(--fs-2); flex: 0 0 auto; }
+.c3focus.fc-pop .fc-ph b { font-size: var(--fs-1); color: var(--acc); }
+.c3focus.fc-pop .fc-ph-topic { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-weight: 600; }
+.c3focus.fc-pop .fc-ph .mono.dim { font-variant-numeric: tabular-nums; }
+.c3focus.fc-pop .fc-popbody { display: flex; flex-direction: column; gap: 8px; flex: 1 1 auto; min-height: 0; overflow: auto; }
+.c3focus.fc-pop .fc-ph .ib { flex: 0 0 auto; width: 28px; height: 28px; min-width: 0; min-height: 0; padding: 0; }
+.c3focus.fc-pop .fc-bandwrap { flex: 0 0 auto; }
+.c3focus.fc-pop .fc-gist { padding: 8px; border-radius: 8px; }
+.c3focus.fc-pop .fc-gist p { font-size: var(--fs-2); }
+.c3focus.fc-pop .fc-gl { display: block; margin: 0 0 2px; }
+.c3focus.fc-pop .fc-cx { padding: 2px 8px; }
+.c3focus.fc-pop .fc-cx > span { display: block; }
+.c3focus.fc-pop .fc-cx > span > span { display: none; }
+.c3focus.fc-pop .fc-cv { display: flex; flex-direction: column; flex: 1 0 auto; min-height: 200px; max-height: none; border: 0; background: none; border-radius: 0; }
+.c3focus.fc-pop .fc-tk { padding: 4px 2px 6px; }
+.c3focus.fc-pop .fc-s2 { flex: 1 1 auto; padding: 4px 2px; }
+.c3focus.fc-pop .fc-in { padding: 6px 2px 0; }
+.c3focus.fc-pop .fc-foot { display: flex; justify-content: space-between; align-items: center; gap: 8px; flex: 0 0 auto; position: sticky; bottom: 0; padding-top: 4px; background: var(--background); font-size: var(--fs-1); }
+.c3focus.fc-pop .fc-popmsg { display: grid; gap: 6px; margin: 0; padding: 8px; border: 1px solid var(--border); border-radius: 8px; background: var(--card); font-size: var(--fs-2); }
+.c3focus.fc-pop .fc-popmsg p { margin: 0; line-height: 1.5; }
+.c3focus.fc-pop .fc-choices { display: grid; gap: 6px; }
+.c3focus.fc-pop .fc-choices button { justify-content: flex-start; text-align: left; white-space: normal; height: auto; }
+.c3focus.fc-pop .fc-choices .mono { margin-right: 4px; }
+.c3focus.fc-pop:not([data-fc-state="ok"]) .fc-cv, .c3focus.fc-pop:not([data-fc-state="ok"]) .fc-foot { display: none; }
+.c3focus.fc-pop.fc-pill .fc-popbody { display: none; }
+.c3focus.fc-pop.fc-pill .fc-page { padding: 6px 10px; justify-content: center; }