create-pmos 0.133.0 → 0.135.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.133.0",
+  "version": "0.135.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@c3d0fb4
+kernel-source: pmos@62ceee4
 assembled: 2026-10-11
 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-11T04:26:11Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T23:50:45Z"}
 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-11T04:26:11Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T23:50:45Z"}
 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-11T04:26:11Z"}
+generated: {by: process:create-pmos, at: "2026-10-11T23:50:45Z"}
 status: stable
 ---
 

package/workspace/bin/notes-replay.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+/* notes-replay — notes-live-settle Run 1: play a kept meeting through the live transcription again, on a private server, so the PM
+ * can listen to it and read what came out; and measure whether this machine could also correct the transcript during a call.
+ *
+ *   node bin/notes-replay.js list                                   the kept meetings: id, date, length, title
+ *   node bin/notes-replay.js <note-id> [--speed 1] [--minutes <n>] [--from <min>] [--port 7460] [--settle] [--exit]
+ *
+ * WHAT IT DOES.
+ *   1. Reads the note's two kept sources (`<id>.mic.pcm` and `<id>.meeting.pcm`, lib/notes-audio.js). It never writes to that note.
+ *   2. Starts a second PMOS server on its own port (7460 by default) with its own empty state folder in the system temp folder.
+ *      Its engines are the PM's own (the Whisper model and the final pass's engines are linked, not copied). In that server Jev,
+ *      Wispr Flow and the bullets agent are off, so nothing is sent anywhere.
+ *   3. Makes a note "Replay of <title>", presses Listen, and sends both sources in one-second chunks as the page does, at the
+ *      meeting's own pace (`--speed 2` is twice as fast; the measurements need 1).
+ *   4. Presses Stop, waits for the live lines and the final pass, and writes a report: lines said twice (a source repeating
+ *      itself, or the microphone's echo of the meeting), how late the live lines came, and with `--settle` what the settle tier
+ *      would cost. The report goes to `<state>/notes/replays/<note-id>-<time>.json` and is printed.
+ *   5. Keeps the server up so the PM can open http://127.0.0.1:<port>, go to Notes and play the replay; Ctrl-C stops it and
+ *      deletes its temp folder. `--exit` stops at once after the report.
+ *
+ * --settle: while the replay runs, at each settle point (a 1.5 s pause, or the other source starting to talk) the last 30 s of
+ * that source is transcribed again with the final pass's engine (lib/notes-replay.js createSettleMeter). The report says the
+ * share of the meeting's time that engine was busy; the plan builds correction during the call only when it is under 0.5.
+ *
+ * It never uses port 7433 and never stops another server.
+ */
+'use strict';
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const net = require('net');
+const { spawn } = require('child_process');
+const { defaultRoot } = require('../lib/state-root');
+const notes = require('../lib/notes');
+const notesAudio = require('../lib/notes-audio');
+const notesFinal = require('../lib/notes-final');
+const R = require('../lib/notes-replay');
+
+const argv = process.argv.slice(2);
+const opt = (n, d = null) => { const i = argv.indexOf('--' + n); return i !== -1 && argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[i + 1] : d; };
+const flag = (n) => argv.includes('--' + n);
+const die = (m, c = 2) => { console.error('notes-replay: ' + m); process.exit(c); };
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const RATE = notesAudio.RATE;
+const SEC = RATE * 2;
+const mmss = (ms) => { const s = Math.max(0, Math.round(ms / 1000)); return Math.floor(s / 60) + ':' + String(s % 60).padStart(2, '0'); };
+const NEVER_PORT = 7433;
+
+const stateDir = path.resolve(opt('state', defaultRoot()));
+const cmd = argv[0];
+if (!cmd || cmd === '--help' || cmd === '-h') { console.log(fs.readFileSync(__filename, 'utf8').split('\n').slice(1, 22).join('\n')); process.exit(0); }
+
+if (cmd === 'list') {
+  const rows = [];
+  for (const n of (notes.list(stateDir).notes || [])) {
+    const srcs = notesAudio.sources(stateDir, n.id);
+    if (!srcs.length) continue;
+    rows.push({ id: n.id, at: String(n.created_at || '').slice(0, 16).replace('T', ' '), ms: Math.max(...srcs.map((s) => s.ms)), sources: srcs.map((s) => s.source).join('+'), title: n.title || '' });
+  }
+  if (!rows.length) { console.log('No meeting with kept audio in ' + stateDir); process.exit(0); }
+  for (const r of rows) console.log(`${r.id}  ${r.at}  ${mmss(r.ms).padStart(6)}  ${r.sources.padEnd(12)}  ${r.title}`);
+  process.exit(0);
+}
+
+const srcId = cmd;
+const orig = notes.read(stateDir, srcId);
+if (!orig.ok) die(`no note ${srcId} in ${stateDir} (node bin/notes-replay.js list shows the kept meetings)`);
+if (orig.note.private) die('that note is marked private, so it is not replayed');
+const srcs = notesAudio.sources(stateDir, srcId);
+if (!srcs.length) die('that note kept no audio of its own sources, so there is nothing to replay');
+const speed = Number(opt('speed', '1'));
+if (!(speed > 0 && speed <= 50)) die('--speed is a number from 0.1 to 50');
+const port = Number(opt('port', '7460'));
+if (!Number.isInteger(port) || port < 1024 || port > 65535) die('--port is a port number from 1024');
+if (port === NEVER_PORT) die('port 7433 is never used by this command');
+const settle = flag('settle');
+if (settle && speed !== 1) console.log('notes-replay: --settle measures at the meeting\'s own pace; with --speed ' + speed + ' its numbers are not the real ones');
+
+const audio = Object.fromEntries(srcs.map((s) => [s.source, fs.readFileSync(s.file)]));
+const totalSec = Math.ceil(Math.max(...Object.values(audio).map((b) => b.length)) / SEC);
+const fromSec = Math.max(0, Math.round(Number(opt('from', '0')) * 60));
+const minutes = opt('minutes');
+const toSec = Math.min(totalSec, minutes ? fromSec + Math.round(Number(minutes) * 60) : totalSec);
+if (!(toSec > fromSec)) die('nothing to replay in that stretch: the meeting is ' + mmss(totalSec * 1000) + ' long');
+
+function portFree(p) {
+  return new Promise((resolve) => { const s = net.createServer(); s.once('error', () => resolve(false)); s.listen(p, '127.0.0.1', () => s.close(() => resolve(true))); });
+}
+
+/* ── the private server ───────────────────────────────────────────────────────────────────────────── */
+const scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'pmos-replay-'));
+const rt = path.join(scratch, 'state');
+let srv = null;
+function cleanup() {
+  if (srv) { try { srv.kill('SIGTERM'); } catch { /* gone */ } srv = null; }
+  try { fs.rmSync(scratch, { recursive: true, force: true }); } catch { /* best effort */ }
+}
+process.on('SIGINT', () => { console.log('\nnotes-replay: stopped; the replay server and its temp folder are gone.'); cleanup(); process.exit(130); });
+process.on('exit', cleanup);
+
+function linkEngines() {
+  const from = path.join(stateDir, 'notes'); const to = path.join(rt, 'notes');
+  fs.mkdirSync(path.join(to, 'final'), { recursive: true });
+  // the Whisper models and the final pass's engines are the PM's own: linked, never copied or changed
+  const w = path.join(from, 'whisper');
+  if (fs.existsSync(w)) fs.symlinkSync(w, path.join(to, 'whisper'));
+  let es = []; try { es = fs.readdirSync(path.join(from, 'final')); } catch { /* none set up */ }
+  for (const e of es) if (!e.startsWith('tmp-')) fs.symlinkSync(path.join(from, 'final', e), path.join(to, 'final', e));
+  // the PM's language, model and accuracy choices; not settings.json (Jev), so the replay sends nothing
+  for (const f of ['whisper-settings.json', 'audio-settings.json']) { try { fs.copyFileSync(path.join(from, f), path.join(to, f)); } catch { /* not set */ } }
+}
+
+async function boot(base) {
+  const home = path.join(scratch, 'home'); fs.mkdirSync(home, { recursive: true });
+  const hf = process.env.HF_HOME || path.join(os.homedir(), '.cache', 'huggingface');
+  srv = spawn(process.execPath, [path.join(__dirname, '..', 'server.js')], { cwd: path.join(__dirname, '..'), stdio: 'ignore',
+    env: { ...process.env, PMOS_STATE_DIR: rt, PMOS_WS_PORT: String(port), HOME: home, USERPROFILE: home, HF_HOME: hf,
+      PMOS_NOTES_WISPR: 'off', PMOS_NOTES_BULLETS_AGENT: 'off' } });
+  srv.once('exit', (c) => { if (srv) { srv = null; console.error('notes-replay: the replay server stopped (' + c + ')'); } });
+  for (const t0 = Date.now(); ;) {
+    const r = await fetch(base + '/pm/tokens.css').catch(() => null);
+    if (r && r.status === 200) break;
+    if (!srv || Date.now() - t0 > 60000) die('the replay server did not start on ' + base, 1);
+    await sleep(200);
+  }
+  // the replay server is this command's own; it is pressed the way its page presses it (pm-guard: Origin and the launch nonce)
+  const html = await (await fetch(base + '/')).text();
+  const m = /<meta name="pmos-nonce" content="([^"]*)"/.exec(html);
+  return { 'Content-Type': 'application/json', Origin: base, ...(m && m[1] ? { 'x-pmos-nonce': m[1] } : {}) };
+}
+
+async function main() {
+  if (!await portFree(port)) die(`port ${port} is in use; pick another with --port`);
+  linkEngines();
+  const base = `http://127.0.0.1:${port}`;
+  console.log(`notes-replay: starting a replay server on ${base} (its own state, in ${scratch})`);
+  const H = await boot(base);
+  const call = async (m, p, body) => { const r = await fetch(base + p, { method: m, headers: H, body: body === undefined ? undefined : JSON.stringify(body) }); let j = null; try { j = await r.json(); } catch { /* not JSON */ } return { status: r.status, body: j }; };
+  const eng = (await call('GET', '/api/notes/engine')).body || {};
+  if (!eng.whisper || eng.whisper.ready === false) die('local transcription is not set up on this machine (Settings, Notes), so there is nothing to replay through', 1);
+
+  const title = 'Replay of ' + (orig.note.title || srcId) + (fromSec || toSec < totalSec ? ` (${mmss(fromSec * 1000)} to ${mmss(toSec * 1000)})` : '');
+  const made = await call('POST', '/api/notes/new', { title });
+  if (!made.body || !made.body.ok) die('the replay note was not made: ' + JSON.stringify(made.body), 1);
+  const id = made.body.note.id;
+  const rec = await call('POST', '/api/notes/record', { id });
+  if (!rec.body || !rec.body.ok || !rec.body.capture) die('Listen was refused: ' + JSON.stringify(rec.body), 1);
+  const cap = rec.body.capture;
+
+  const meter = settle ? R.createSettleMeter({ transcribe: (pcm) => notesFinal.transcribeClip(rt, pcm) }) : null;
+  const seen = new Map();   // live line index → the wall time it was first seen
+  const began = Date.now();
+  const wallOf = (meetingMs) => began + (meetingMs - fromSec * 1000) / speed;
+  let polling = true;
+  const poll = (async () => {
+    while (polling) {
+      const n = (await call('GET', '/api/notes/one?id=' + id).catch(() => ({ body: null }))).body;
+      const ts = (n && n.note && n.note.transcript) || [];
+      ts.forEach((l, i) => { if (!seen.has(i)) seen.set(i, { at: Date.now(), line: l }); });
+      await sleep(1000);
+    }
+  })();
+  console.log(`notes-replay: replaying ${mmss((toSec - fromSec) * 1000)} of "${orig.note.title || srcId}" (${Object.keys(audio).join(' + ')}) at ${speed}x${settle ? ', measuring the settle tier' : ''}`);
+  const seq = { mic: -1, meeting: -1 };
+  for (let sec = fromSec; sec < toSec; sec++) {
+    const due = began + ((sec - fromSec) * 1000) / speed;
+    if (due > Date.now()) await sleep(due - Date.now());
+    await Promise.all(Object.keys(audio).map(async (source) => {
+      const pcm = audio[source].subarray(sec * SEC, (sec + 1) * SEC);
+      if (!pcm.length) return;
+      seq[source]++;
+      if (meter) meter.feed(source, pcm);
+      const r = await call('POST', '/api/notes/audio', { id, source, pcm: pcm.toString('base64'), final: sec === toSec - 1, cap: cap.token, seq: seq[source], off: (sec - fromSec) * RATE });
+      if (!r.body || !r.body.ok) console.error(`notes-replay: ${source} at ${mmss(sec * 1000)} was refused: ${(r.body && r.body.error) || r.status}`);
+    }));
+    if ((sec - fromSec) % 60 === 59) console.log(`  ${mmss((sec - fromSec + 1) * 1000)} of ${mmss((toSec - fromSec) * 1000)} sent, ${seen.size} live lines so far`);
+  }
+  const elapsed = Date.now() - began;
+  await call('POST', '/api/notes/stop', { id });
+  // the page asks for the notes after Stop, which queues the final pass; the replay asks for the pass itself
+  const fq = await call('POST', '/api/notes/final', { id });
+  if (!fq.body || !fq.body.ok) console.log('notes-replay: the final pass was not queued: ' + ((fq.body && fq.body.error) || fq.status));
+  console.log('notes-replay: Stop pressed; waiting for the last live lines and the final pass');
+  // the live lines are done when the transcript has not changed for 10 s; then the final pass, for as long as it runs
+  let last = ''; let still = 0; let note = null;
+  for (let i = 0; i < 60 * 60 * 2; i++) {
+    note = (await call('GET', '/api/notes/one?id=' + id)).body.note;
+    const k = JSON.stringify(note.transcript || []);
+    still = k === last ? still + 1 : 0; last = k;
+    const fs0 = note.final_state && note.final_state.state;
+    if (still >= 10 && (!fs0 || fs0 === 'done' || fs0 === 'failed')) break;
+    if (i % 60 === 59) console.log('  final pass: ' + (fs0 || 'not started') + (note.final_state && note.final_state.step ? ', ' + note.final_state.step : ''));
+    await sleep(1000);
+  }
+  polling = false; await poll;
+  if (meter) await meter.idle();
+
+  const live = (note.transcript || []).filter((l) => !l.dropped);
+  const dupLive = R.duplicates(live);
+  const finalSegs = ((note.final && note.final.segments) || []).map((g) => ({ t: g.t, t_end: g.end, text: g.text, source: g.source }));
+  const dupFinal = R.duplicates(finalSegs);
+  const lateOf = [...seen.values()].filter((s) => !s.line.dropped && Number.isFinite(s.line.t)).map((s) => ({ late_ms: s.at - wallOf(Number.isFinite(s.line.t_end) ? s.line.t_end : s.line.t) }));
+  const show = (d) => ({ kind: d.kind, at: mmss(d.a.t), a: `${d.a.source}: ${d.a.text}`, b: `${d.b.source} at ${mmss(d.b.t)}: ${d.b.text}`, overlap: d.overlap });
+  const report = {
+    at: new Date().toISOString(), note: srcId, title: orig.note.title || '', replay_note: id, from: mmss(fromSec * 1000), to: mmss(toSec * 1000), speed,
+    live: { lines: live.length, by_source: Object.fromEntries(['mic', 'meeting'].map((s) => [s, live.filter((l) => l.source === s).length])),
+      repeats: dupLive.filter((d) => d.kind === 'repeat').length, echoes: dupLive.filter((d) => d.kind === 'echo').length, lag: R.lag(lateOf), said_twice: dupLive.map(show) },
+    final: note.final ? { engine: note.final.engine, lines: finalSegs.length, took_ms: note.final.took_ms, repeats: dupFinal.filter((d) => d.kind === 'repeat').length,
+      echoes: dupFinal.filter((d) => d.kind === 'echo').length, said_twice: dupFinal.map(show) } : { state: note.final_state || null },
+    settle: meter ? meter.report(elapsed) : null,
+  };
+  const outDir = path.join(stateDir, 'notes', 'replays'); fs.mkdirSync(outDir, { recursive: true });
+  const outFile = path.join(outDir, `${srcId}-${report.at.replace(/[:.]/g, '-')}.json`);
+  fs.writeFileSync(outFile, JSON.stringify(report, null, 2) + '\n', { mode: 0o600 });
+
+  console.log('\n── Replay report ──');
+  console.log(`Live lines: ${report.live.lines} (microphone ${report.live.by_source.mic}, meeting ${report.live.by_source.meeting}).`);
+  console.log(`Said twice in the live transcript: ${report.live.repeats} repeats, ${report.live.echoes} echoes of the meeting on the microphone.`);
+  for (const d of report.live.said_twice.slice(0, 10)) console.log(`  ${d.at} ${d.kind}: "${d.a}" / "${d.b}"`);
+  if (report.live.lag.n) console.log(`Live lines appeared ${Math.round(report.live.lag.median_ms / 100) / 10} s after their audio (median), ${Math.round(report.live.lag.p90_ms / 100) / 10} s at the 90th percentile.`);
+  if (note.final) console.log(`Final pass (${report.final.engine}): ${report.final.lines} lines, ${report.final.repeats} repeats, ${report.final.echoes} echoes.`);
+  else console.log('Final pass: ' + JSON.stringify(report.final.state));
+  if (report.settle) {
+    const s = report.settle;
+    console.log(`Settle tier (${s.engine || 'no engine'}): ${s.runs} of ${s.points} settle points transcribed again, ${s.skipped} skipped because the engine was busy.`);
+    console.log(`  The engine was busy ${s.busy_share === null ? '?' : Math.round(s.busy_share * 100)}% of the meeting's time (the gate is under ${s.gate * 100}%); one 30 s window took ${s.window_rtf_median} of its length (median).`);
+    console.log(s.keeps_up ? '  This machine keeps up: correction at pauses can be built.' : '  This machine does not keep up: correction during the call is not built as planned.');
+    if (s.errors.length) console.log('  Errors: ' + s.errors.join(' | '));
+  }
+  console.log(`\nReport: ${outFile}`);
+  if (flag('exit')) { cleanup(); process.exit(0); }
+  console.log(`To listen: open ${base}, go to Notes, and open "${title}". Press Ctrl-C here when you are done; that deletes the replay.`);
+}
+
+main().catch((e) => { console.error('notes-replay: ' + ((e && e.stack) || e)); cleanup(); process.exit(1); });

package/workspace/c3-briefing-test.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+'use strict';
+/* c3-briefing-test.js — the console3 Briefing page (initiative console3-briefing-parity; planning/prd/console3-briefing-parity-prd.md R1 to R6).
+ * Loads /c3.html?demo=1 (demo mode answers every /api call, so nothing reaches the server) and holds:
+ *   R1  two columns: stance + deck + Needs you on the left; Today + Portfolio pulse on the right
+ *   R2  Review, Handled, What I could stop and Data you can lean on are not on the Briefing
+ *   R3  the greeting follows the clock; five day-part buttons (Night included) preview a part and the clock's part comes back on a tap
+ *   R4  Today: a lead line with a ring, "Open calendar", rows with chips (nrow), no old two-column prepared/before layout
+ *   R5  Needs you: "N decisions . M of yours" header, decision tags, a Work home chip on own items
+ *   R6  Portfolio pulse: "N need attention", rows, "All initiatives" goes to Initiatives; 400 wide has no sideways scroll
+ * The page must raise no script error. Every wait polls the page; no fixed sleep stands in for a state.
+ */
+const path = require('path');
+const { spawn } = require('child_process');
+const { findBrowser } = require('./lib/find-browser');
+const T = require('./test-run').configure({ name: 'c3-briefing' });
+
+const BASE = T.BASE;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const until = async (fn, ms = 10000, 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 = (name, cond, extra = '') => { results.push({ name, cond: !!cond }); console.log(`${cond ? '✓' : '✗'} ${name}${!cond && extra !== '' ? ' — ' + extra : ''}`); };
+let srv = null; let browser = null;
+const finish = async (code) => {
+  if (browser) await browser.close().catch(() => {});
+  if (srv) { try { srv.kill('SIGKILL'); } catch { /* gone */ } }
+  T.killTmux();
+  const bad = results.filter((x) => !x.cond).length;
+  console.log(`\n${results.length - bad}/${results.length} c3-briefing 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 — the c3-briefing suite cannot run'); return finish(1); }
+  let chromium;
+  try { ({ chromium } = require('playwright-core')); } catch { console.log('✗ playwright-core is not installed — the c3-briefing suite cannot run'); return finish(1); }
+
+  srv = spawn(process.execPath, [path.join(__dirname, 'server.js')], { cwd: __dirname, stdio: 'ignore', env: T.env({ PMOS_WS_PORT: String(T.PORT) }) });
+  await T.waitForServer(BASE);
+  browser = await chromium.launch({ executablePath: exe });
+
+  const open = async (ctxOpts) => {
+    const ctx = await browser.newContext({ viewport: { width: 1440, height: 1000 }, ...(ctxOpts || {}) });
+    const page = await ctx.newPage();
+    const errors = [];
+    page.on('pageerror', (e) => errors.push(String((e && e.message) || e)));
+    await page.goto(BASE + '/c3.html?demo=1');
+    const up = await until(() => page.evaluate(() => !!document.querySelector('[data-c3-demo="1"]') && document.querySelectorAll('#c3-root .deck .fc').length > 0), 45000, 250);
+    return { ctx, page, errors, up };
+  };
+
+  const A = await open();
+  ok('0 the demo page draws the Briefing deck', A.up);
+  if (!A.up) return finish(1);
+  const p = A.page;
+  await until(() => p.evaluate(() => document.querySelectorAll('[data-c3pg="today"] .nrow').length > 0 && document.querySelectorAll('[data-c3pg="pulse"] [data-pulse-row]').length > 0 && !!document.querySelector('[data-needs-summary]')), 20000);
+
+  /* R1 */
+  const lay = await p.evaluate(() => {
+    const b = document.querySelector('.c3 .brief'); const l = b.querySelector('.bcols > .bcol.l'); const r = b.querySelector('.bcols > .bcol.r');
+    if (!l || !r) return null;
+    return { sideBySide: l.getBoundingClientRect().right <= r.getBoundingClientRect().left + 1, one: b.classList.contains('one'),
+      left: ['deck-host', 'needs'].every((k) => !!l.querySelector(`[data-c3pg="${k}"]`)), right: ['today', 'pulse'].every((k) => !!r.querySelector(`[data-c3pg="${k}"]`)), stance: !!l.querySelector('.stance') };
+  });
+  ok('R1 two columns side by side, no .one', !!lay && lay.sideBySide && !lay.one, JSON.stringify(lay));
+  ok('R1 left holds the stance, the deck and Needs you; right holds Today and Portfolio pulse', !!lay && lay.left && lay.right && lay.stance, JSON.stringify(lay));
+
+  /* R2 */
+  ok('R2 no Review, Handled, Stop or Data trust on the Briefing', await p.evaluate(() => !document.querySelector('[data-c3pg="review-host"], [data-c3pg="handled-host"], [data-c3pg="stop-host"], [data-c3pg="trust-host"]') && !/Data you can lean on|What I could stop|handled for you/i.test(document.querySelector('.c3 .brief').textContent)));
+
+  /* R3 */
+  const dp = () => p.evaluate(() => ({ greet: document.querySelector('.stance b').textContent, line: document.querySelector('.stance .dim').textContent, keys: [...document.querySelectorAll('.stance [data-pg-dp]')].map((b) => b.dataset.pgDp), on: [...document.querySelectorAll('.stance [data-pg-dp]')].filter((b) => b.getAttribute('aria-pressed') === 'true').map((b) => b.dataset.pgDp) }));
+  const d0 = await dp();
+  ok('R3 five day-part buttons, Night last', d0.keys.join() === 'morning,midday,afternoon,evening,night', d0.keys.join());
+  ok('R3 the greeting names the part of the day and the PM', /^Good (morning|afternoon|evening|night), \w+/.test(d0.greet) && d0.on.length === 1, JSON.stringify(d0));
+  const clockPart = d0.on[0];
+  const other = clockPart === 'night' ? 'midday' : 'night';
+  await p.click(`.stance [data-pg-dp="${other}"]`);
+  const d1 = await until(async () => { const d = await dp(); return d.on[0] === other ? d : null; }, 4000);
+  ok('R3 a tap previews that part: pressed, its greeting', !!d1 && d1.greet !== d0.greet && /^Good /.test(d1.greet), JSON.stringify(d1));
+  await p.click(`.stance [data-pg-dp="night"]`);
+  const dn = await until(async () => { const d = await dp(); return d.on[0] === 'night' ? d : null; }, 4000);
+  ok('R3 Night previews: "Good night" and the Reflect line', !!dn && /^Good night/.test(dn.greet) && /^Reflect/.test(dn.line), JSON.stringify(dn));
+  ok('R3 the Night preview names Needs you "Carries over"', await p.evaluate(() => /Carries over/i.test(document.querySelector('[data-c3pg="needs"] .sh2 h2').textContent)));
+  await p.click(`.stance [data-pg-dp="${clockPart}"]`);
+  const d2 = await until(async () => { const d = await dp(); return d.on[0] === clockPart ? d : null; }, 4000);
+  ok('R3 a tap on the clock part brings it back', !!d2 && d2.greet === d0.greet, JSON.stringify(d2));
+
+  /* R4 */
+  const td = await p.evaluate(() => {
+    const t = document.querySelector('[data-c3pg="today"]'); const lh = t.querySelector('.lh');
+    const row = t.querySelector('.nrow[data-today-row]');
+    return { lead: !!lh && /meetings? left today\. \d+ of \d+ prepped/.test(lh.textContent), ring: !!(lh && lh.querySelector('svg circle.rg')), btn: !!t.querySelector('button[data-pg-opencal]'), rows: t.querySelectorAll('.nrow[data-today-row]').length,
+      chips: !!(row && row.querySelector('.chips .chip2')), old: !!t.querySelector('.trow, .tcols'), ref: !!(row && row.hasAttribute('data-ref-row')) };
+  });
+  ok('R4 Today has the lead line with a ring and an Open calendar button', td.lead && td.ring && td.btn, JSON.stringify(td));
+  ok('R4 Today rows are nrow rows with chips and no old tcols layout', td.rows > 0 && td.chips && !td.old && td.ref, JSON.stringify(td));
+  await p.click('[data-c3pg="today"] button[data-pg-opencal]');
+  ok('R4 Open calendar opens the calendar popup', await until(() => p.evaluate(() => !!document.querySelector('[role="dialog"]')), 4000));
+  await p.keyboard.press('Escape');
+
+  /* R5 */
+  const nd = await p.evaluate(() => {
+    const n = document.querySelector('[data-c3pg="needs"]'); const s = n.querySelector('[data-needs-summary]');
+    const own = n.querySelector('.nrow[data-item-id]');
+    return { sum: s ? s.textContent : null, decTag: !!n.querySelector('.nrow:not([data-item-id]) .tag.acc'), home: !!(own && [...own.querySelectorAll('.chip2')].some((c) => c.textContent.trim() === 'Work')), actions: !!n.querySelector('[data-act="done"]') };
+  });
+  ok('R5 Needs you says "N decisions . M of yours"', !!nd.sum && /^\d+ decisions? · \d+ of yours/.test(nd.sum), JSON.stringify(nd));
+  ok('R5 decision rows carry the decision tag; own items carry the Work home chip', nd.decTag && nd.home, JSON.stringify(nd));
+
+  /* R6 */
+  const pu = await p.evaluate(() => { const c = document.querySelector('[data-c3pg="pulse"]'); return { attn: (c.querySelector('[data-pulse-attn]') || {}).textContent, bar: !!c.querySelector('.pbs'), rows: c.querySelectorAll('[data-pulse-row]').length, all: !!c.querySelector('button[data-go="initiatives"]') }; });
+  ok('R6 Portfolio pulse: "N need attention", the bar, rows and All initiatives', /^\d+ need attention$/.test(pu.attn || '') && pu.bar && pu.rows > 0 && pu.all, JSON.stringify(pu));
+  await p.click('[data-c3pg="pulse"] button[data-go="initiatives"]');
+  ok('R6 All initiatives opens the Initiatives tab', await until(() => p.evaluate(() => { const t = document.querySelector('[data-c3-tab="init"]'); return !!t && (t.getAttribute('aria-selected') === 'true' || t.classList.contains('on')); }), 4000));
+  ok('0 no page error', A.errors.length === 0, A.errors.join(' | '));
+  await A.ctx.close();
+
+  const M = await open({ viewport: { width: 400, height: 900 } });
+  ok('R6 at 400 wide the Briefing does not scroll sideways', M.up && await M.page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1 && document.getElementById('c3-root').scrollWidth <= innerWidth + 1), 'scrollWidth');
+  ok('R6 at 400 wide the day-part switch and Needs you are on the page', await M.page.evaluate(() => document.querySelectorAll('.stance [data-pg-dp]').length === 5 && !!document.querySelector('[data-c3pg="needs"]')));
+  ok('0 no page error (400 wide)', M.errors.length === 0, M.errors.join(' | '));
+  await M.ctx.close();
+  return finish();
+})().catch((e) => { console.error(e); finish(1); });

package/workspace/c3-foundation-test.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+'use strict';
+/* c3-foundation-test.js — the console3 shell foundation (initiative console3-foundation; planning/prd/console3-foundation-prd.md R1 to R7).
+ * Loads /c3.html?demo=1 (demo mode answers every /api call, so nothing reaches the server) and holds:
+ *   R1  the page is white: no day-part wash on the page, no radial on the Briefing; data-daypart stays
+ *   R2  one ambient canvas (.c3amb) sits behind the grid; reduced motion draws one still frame; dark theme draws; no canvas, no error
+ *   R3  the build-fix rules: a primary button label is the page background colour; .sect > .sh2 is a flex row outside .brief
+ *   R4  the card front shows number tiles and the kind label; the flipped back holds its options and the confirm control; a decision
+ *       adds .ok and a toast with Undo, and Undo takes it back
+ *   R5  the Briefing and Initiatives tabs carry count badges beside Work's
+ *   R6  the Sessions pill and the dock button draw the bolt, with the mockup's tooltip copy
+ *   R7  the Record control shows when idle in demo mode, starts the simulated recorder and returns to idle on stop
+ * The page must raise no script error. Every wait polls the page; no fixed sleep stands in for a state.
+ */
+const path = require('path');
+const { spawn } = require('child_process');
+const { findBrowser } = require('./lib/find-browser');
+const T = require('./test-run').configure({ name: 'c3-foundation' });
+
+const BASE = T.BASE;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const until = async (fn, ms = 10000, 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 = (name, cond, extra = '') => { results.push({ name, cond: !!cond }); console.log(`${cond ? '✓' : '✗'} ${name}${!cond && extra !== '' ? ' — ' + extra : ''}`); };
+let srv = null; let browser = null;
+const finish = async (code) => {
+  if (browser) await browser.close().catch(() => {});
+  if (srv) { try { srv.kill('SIGKILL'); } catch { /* gone */ } }
+  T.killTmux();
+  const bad = results.filter((x) => !x.cond).length;
+  console.log(`\n${results.length - bad}/${results.length} c3-foundation 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 — the c3-foundation suite cannot run'); return finish(1); }
+  let chromium;
+  try { ({ chromium } = require('playwright-core')); } catch { console.log('✗ playwright-core is not installed — the c3-foundation suite cannot run'); return finish(1); }
+
+  srv = spawn(process.execPath, [path.join(__dirname, 'server.js')], { cwd: __dirname, stdio: 'ignore', env: T.env({ PMOS_WS_PORT: String(T.PORT) }) });
+  await T.waitForServer(BASE);
+  browser = await chromium.launch({ executablePath: exe });
+
+  const open = async (ctxOpts, url, init) => {
+    const ctx = await browser.newContext({ viewport: { width: 1440, height: 1000 }, ...(ctxOpts || {}) });
+    const page = await ctx.newPage();
+    const errors = [];
+    page.on('pageerror', (e) => errors.push(String((e && e.message) || e)));
+    if (init) await page.addInitScript(init);
+    await page.goto(BASE + (url || '/c3.html?demo=1'));
+    const up = await until(() => page.evaluate(() => !!document.querySelector('[data-c3-demo="1"]') && document.querySelectorAll('#c3-root .deck .fc').length > 0), 45000, 250);
+    return { ctx, page, errors, up };
+  };
+  /* the largest alpha on the ambient canvas: 0 means nothing was drawn */
+  const maxAlpha = (page) => page.evaluate(() => { const c = document.querySelector('#c3-root > canvas.c3amb'); if (!c) return -1; const d = c.getContext('2d').getImageData(0, 0, c.width, c.height).data; let m = 0; for (let i = 3; i < d.length; i += 4) if (d[i] > m) m = d[i]; return m; });
+
+  const A = await open();
+  ok('0 the demo page draws the Briefing deck', A.up);
+  if (!A.up) return finish(1);
+  const p = A.page;
+
+  /* R1 */
+  ok('R1 the page has no day-part wash and keeps data-daypart', await p.evaluate(() => { const r = document.getElementById('c3-root'); return !!r.getAttribute('data-daypart') && getComputedStyle(r).backgroundImage === 'none'; }));
+  ok('R1 the Briefing has no blue radial', await p.evaluate(() => { const b = document.querySelector('.c3 .brief'); const s = getComputedStyle(b, '::before'); return !b || s.content === 'none' || s.display === 'none'; }));
+  ok('R1 the daylight strip still has its warm token', await p.evaluate(() => getComputedStyle(document.getElementById('c3-root')).getPropertyValue('--dp-warm').trim() !== ''));
+
+  /* R2 */
+  ok('R2 exactly one ambient canvas, fixed and behind the grid', await p.evaluate(() => { const l = document.querySelectorAll('#c3-root canvas.c3amb'); if (l.length !== 1) return false; const s = getComputedStyle(l[0]); return s.position === 'fixed' && s.pointerEvents === 'none' && s.zIndex === '0' && getComputedStyle(document.querySelector('.c3grid')).zIndex === '1'; }));
+  ok('R2 the canvas gets a frame drawn (light theme)', await until(async () => (await maxAlpha(p)) > 0, 6000));
+  ok('R2 mounted once even after tab changes', await p.evaluate(async () => { document.querySelector('[data-c3-tab="work"]').click(); await new Promise((r) => setTimeout(r, 200)); document.querySelector('[data-c3-tab="brief"]').click(); return document.querySelectorAll('canvas.c3amb').length === 1; }));
+
+  /* R3 */
+  ok('R3 a primary button label takes the page background colour', await p.evaluate(() => {
+    const r = document.getElementById('c3-root'); const b = document.createElement('button'); b.className = 'pmc-btn pmc-btn--primary'; const probe = document.createElement('div'); probe.style.color = 'var(--background)';
+    r.append(b, probe); const same = getComputedStyle(b).color === getComputedStyle(probe).color; b.remove(); probe.remove(); return same;
+  }));
+  ok('R3 .sect > .sh2 is a flex row outside .brief', await p.evaluate(() => {
+    const r = document.getElementById('c3-root'); const s = document.createElement('section'); s.className = 'sect'; s.innerHTML = '<div class="sh2"><h2>Title</h2></div>'; r.append(s);
+    const d = getComputedStyle(s.firstChild).display; const tt = getComputedStyle(s.firstChild.firstChild).textTransform; s.remove(); return d === 'flex' && tt === 'uppercase';
+  }));
+
+  /* R4 */
+  ok('R4 the front shows number tiles and a kind label', await p.evaluate(() => { const c = document.querySelector('#c3-root .deck .fc'); return c.querySelectorAll('.ff .cfh .kp').length >= 1 && !!c.querySelector('.ff .tag.pov') && !c.querySelector('.ff .cfk'); }));
+  ok('R4 the kind label sits beside the tag', await p.evaluate(() => { const c = document.querySelector('#c3-root .deck .fc .ff'); const t = c.querySelector('.tg'); const k = c.querySelector('.tag.pov'); return !!t && !!k && t.parentNode === k.parentNode; }));
+  const key = await p.evaluate(() => document.querySelector('#c3-root .deck .fc').getAttribute('data-bf-card'));
+  const card = `#c3-root .deck .fc[data-bf-card="${key}"]`;
+  const h0 = await p.evaluate((s) => document.querySelector(s).offsetHeight, card);
+  await p.evaluate((s) => document.querySelector(s).click(), card);
+  ok('R4 the card flips', await until(() => p.evaluate((s) => document.querySelector(s).classList.contains('back'), card), 4000));
+  await sleep(500);
+  const fit = await p.evaluate((s) => {
+    const c = document.querySelector(s); const cb = c.getBoundingClientRect(); const fb = c.querySelector('.fb');
+    const inside = (e) => !e || e.getBoundingClientRect().bottom <= cb.bottom + 1;
+    return { grew: c.offsetHeight, noClip: fb.scrollHeight <= fb.clientHeight + 1, opts: inside(c.querySelector('.opts')), conf: inside(c.querySelector('.c3slide, .c3hold')), foot: inside(c.querySelector('.cft')), hasOpts: !!c.querySelector('.opt') };
+  }, card);
+  ok('R4 the flipped back grows to fit its content', fit.grew >= h0 && fit.noClip && fit.opts && fit.conf && fit.foot && fit.hasOpts, JSON.stringify({ h0, fit }));
+  /* decide: a hold button (fine pointer) or a click; the slide where the pointer is coarse */
+  const act = await p.evaluate((s) => { const c = document.querySelector(s); const hb = c.querySelector('.c3hold .hb'); if (hb) { const r = hb.getBoundingClientRect(); return { x: r.left + r.width / 2, y: r.top + r.height / 2, mode: hb.getAttribute('data-hold') }; } return null; }, card);
+  if (act) {
+    await p.mouse.move(act.x, act.y); await p.mouse.down();
+    if (act.mode === 'hold') await sleep(750);
+    await p.mouse.up();
+  }
+  ok('R4 deciding adds .ok to the card', !!act && await until(() => p.evaluate((s) => document.querySelector(s).classList.contains('ok'), card), 5000), JSON.stringify(act));
+  const undo = await until(() => p.evaluate(() => !!document.querySelector('.toast button, [data-c3-toast-action]')), 4000);
+  ok('R4 the decision shows a toast with Undo', undo);
+  if (undo) await p.evaluate(() => (document.querySelector('[data-c3-toast-action]') || document.querySelector('.toast button')).click());
+  ok('R4 Undo takes .ok off', undo && await until(() => p.evaluate((s) => !document.querySelector(s).classList.contains('ok'), card), 4000));
+  await p.keyboard.press('Escape');
+
+  /* R5 */
+  ok('R5 Briefing, Work and Initiatives carry count badges', await until(() => p.evaluate(() => ['brief-count', 'work-count', 'init-count'].every((k) => { const b = document.querySelector(`[data-c3pg="${k}"]`); return !!b && !b.hidden && /^\d+$/.test(b.textContent) && Number(b.textContent) > 0; })), 8000));
+  ok('R5 the badge titles say what they count', await p.evaluate(() => document.querySelector('[data-c3pg="brief-count"]').title === 'Needs you' && document.querySelector('[data-c3pg="init-count"]').title === 'New asks to triage'));
+  ok('R5 the Briefing badge matches the Needs you count', await until(() => p.evaluate(() => { const n = document.querySelector('[data-c3pg="needs"] .sh2 .bdg'); return !!n && n.textContent === document.querySelector('[data-c3pg="brief-count"]').textContent; }), 5000));
+
+  /* R6 */
+  ok('R6 the Sessions pill draws the bolt, with the Agent surfaces tooltip', await p.evaluate(() => { const b = document.querySelector('[data-c3pg="agent-button"]'); const u = b.querySelector('use'); return !!u && /#c3i-bolt$/.test(u.getAttribute('href')) && /^Agent surfaces: /.test(b.title); }));
+  ok('R6 the dock button draws the bolt, with the mockup tooltip', await p.evaluate(() => { const b = document.querySelector('[data-c3pg="dock-agent"]'); const u = b && b.querySelector('use'); return !!u && /#c3i-bolt$/.test(u.getAttribute('href')) && b.title === 'Agent surfaces: the full page of sessions that need you'; }));
+
+  /* R7 */
+  ok('R7 the idle Record control shows in demo mode', await p.evaluate(() => { const g = document.querySelector('.c3rec .recg.idle'); if (!g) return false; const r = g.getBoundingClientRect(); return r.width > 0 && !!g.querySelector('[data-fr-rec-new]') && !!g.querySelector('[data-fr-rec-upcoming]'); }));
+  await p.evaluate(() => document.querySelector('[data-fr-rec-new]').click());
+  ok('R7 Record starts the simulated recorder', await until(() => p.evaluate(() => !!document.querySelector('[data-shell-rec-stop]') && !!document.querySelector('[data-shell-rec-clock]')), 4000));
+  await p.evaluate(() => document.querySelector('[data-shell-rec-stop]').click());
+  ok('R7 Stop returns to the idle control', await until(() => p.evaluate(() => !!document.querySelector('.c3rec .recg.idle [data-fr-rec-new]') && !document.querySelector('[data-shell-rec-stop]')), 4000));
+  ok('0 no page error', A.errors.length === 0, A.errors.join(' | '));
+  await A.ctx.close();
+
+  /* R2: reduced motion draws one still frame, dark theme draws, no canvas means no error */
+  const R = await open({ reducedMotion: 'reduce' });
+  ok('R2 reduced motion: one still frame is drawn', R.up && await until(async () => (await maxAlpha(R.page)) > 0, 6000));
+  /* a still frame redraws only when the layout moves (content arriving); once the page is quiet it holds the same picture */
+  const snap = () => R.page.evaluate(() => document.querySelector('canvas.c3amb').toDataURL());
+  let prev = await snap();
+  ok('R2 reduced motion: the frame does not change once the page is quiet', await until(async () => { await sleep(700); const now = await snap(); const same = now === prev; prev = now; return same; }, 12000, 0));
+  ok('0 no page error (reduced motion)', R.errors.length === 0, R.errors.join(' | '));
+  await R.ctx.close();
+
+  const D = await open({}, '/c3.html?demo=1&theme=dark');
+  ok('R2 dark theme: the canvas draws', D.up && await until(async () => (await maxAlpha(D.page)) > 0, 6000));
+  ok('0 no page error (dark)', D.errors.length === 0, D.errors.join(' | '));
+  await D.ctx.close();
+
+  const N = await open({}, '/c3.html?demo=1', () => { HTMLCanvasElement.prototype.getContext = function () { return null; }; });
+  ok('R2 where canvas is unavailable the page still draws and raises no error', N.up && N.errors.length === 0 && await N.page.evaluate(() => document.querySelectorAll('canvas.c3amb').length === 0), N.errors.join(' | '));
+  await N.ctx.close();
+
+  /* phone width: no horizontal scroll */
+  const M = await open({ viewport: { width: 400, height: 900 } });
+  ok('0 at 400 wide the page does not scroll sideways', M.up && await M.page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1), 'scrollWidth');
+  ok('0 no page error (400 wide)', M.errors.length === 0, M.errors.join(' | '));
+  await M.ctx.close();
+  return finish();
+})().catch((e) => { console.error(e); finish(1); });