create-pmos 0.175.0 → 0.177.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.175.0",
+  "version": "0.177.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@128e902
+kernel-source: pmos@9ea3e51
 assembled: 2026-10-13
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-13T01:08:07Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T01:28:03Z"}
 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-13T01:08:07Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T01:28:03Z"}
 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-13T01:08:07Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T01:28:03Z"}
 status: stable
 ---
 

package/workspace/c3-briefing-test.js

@@ -43,6 +43,7 @@ process.on('unhandledRejection', (e) => { console.error(e); 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 });
+  require('./lib/c3-full-console').fullConsole(browser);   // the desktop layout at phone width (c3-phone-companion)
 
   const open = async (ctxOpts) => {
     const ctx = await browser.newContext({ viewport: { width: 1440, height: 1000 }, ...(ctxOpts || {}) });

package/workspace/c3-phone-test.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+'use strict';
+/* c3-phone-test.js — the phone companion (initiative c3-phone-companion; PRD done-criteria 1 to 6 and 8).
+ * A real server and a real Chromium drive /c3.html in demo mode (clock frozen at Thu 8 Oct 2026 08:12; ?at=HH:MM moves the companion's clock).
+ *
+ *   phone     at 400 wide the companion shows and the desktop grid does not
+ *   moments   08:12 morning; 10:10 before Checkout sync; 10:45 in the meeting with the Record offer
+ *   done      Done on the waiting item records a write to /api/pm-items/done
+ *   tell      text sent from the ask bar records a capture and clears the bar
+ *   record    the red button shows the recording line; Stop brings the bar back
+ *   debrief   11:25 shows the decisions and actions of the recorded Checkout sync; a meeting with no recording asks you to tell PMOS
+ *   desk      Full console shows the desktop grid and survives a reload; More > Phone companion brings it back
+ *   desktop   at 1280 wide no companion is drawn
+ * No script error may be raised.
+ */
+const path = require('path');
+const { spawn } = require('child_process');
+const { findBrowser } = require('./lib/find-browser');
+const T = require('./test-run').configure({ name: 'c3-phone' });
+
+const BASE = T.BASE;
+const results = [];
+const ok = (name, cond, extra = '') => { results.push({ name, cond: !!cond }); console.log(`${cond ? '✓' : '✗'} ${name}${!cond && extra !== '' ? ' — ' + String(extra).slice(0, 400) : ''}`); };
+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-phone assertions passed`);
+  process.exit(code !== undefined ? code : (bad ? 1 : 0));
+};
+process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
+
+async function waitFor(page, fn, arg, ms = 30000) {
+  try { await page.waitForFunction(fn, arg, { timeout: ms }); return true; } catch { return false; }
+}
+const shown = (s) => { const n = document.querySelector(s); return !!n && getComputedStyle(n).display !== 'none' && n.getBoundingClientRect().height > 0; };
+const writes = (p) => (window.__c3demoWrites || []).filter((w) => w.path === p || w.url === p || String(w.path || w.url || '').startsWith(p)).length;
+
+(async () => {
+  const exe = findBrowser();
+  if (!exe) { console.log('✗ no Chrome/Chromium on this machine — the c3-phone suite cannot run'); return finish(1); }
+  let chromium;
+  try { ({ chromium } = require('playwright-core')); } catch { console.log('✗ playwright-core is not installed — the c3-phone 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 errors = [];
+  const ctxOf = async (w) => browser.newContext({ viewport: { width: w, height: 860 } });
+  const open = async (ctx, url, ready) => {
+    const page = await ctx.newPage();
+    page.on('pageerror', (e) => errors.push(String((e && e.message) || e)));
+    await page.goto(BASE + url, { waitUntil: 'load' });
+    await waitFor(page, ready || (() => !!document.querySelector('[data-c3ph-moment]')));
+    return page;
+  };
+  const moment = (page) => page.evaluate(() => document.querySelector('[data-c3ph]')?.dataset.moment || '');
+
+  /* ── phone, morning ── */
+  const pctx = await ctxOf(400);
+  let page = await open(pctx, '/c3.html?demo=1');
+  ok('phone: the companion shows at 400 wide', await page.evaluate(shown, '[data-c3ph]'));
+  ok('phone: the desktop grid is hidden', !(await page.evaluate(shown, '.c3grid')));
+  ok('phone: no sideways scroll', await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1));
+  ok('moments: 08:12 is morning', (await moment(page)) === 'morning', await moment(page));
+  ok('phone: the ask bar and the red Record button are in the bottom bar', await page.evaluate(() => !!document.querySelector('[data-c3ph-foot] [data-c3ph-input]') && !!document.querySelector('[data-c3ph-foot] [data-c3ph-record]')));
+
+  /* ── done on the waiting item ── */
+  const hasWaiting = await waitFor(page, () => !!document.querySelector('[data-c3ph-waiting] [data-c3ph-done]'), null, 10000);
+  ok('done: a waiting card with Done shows', hasWaiting);
+  if (hasWaiting) {
+    const before = await page.evaluate(writes, '/api/pm-items/done');
+    await page.click('[data-c3ph-waiting] [data-c3ph-done]');
+    ok('done: Done records a write to /api/pm-items/done', await waitFor(page, (n) => ((window.__c3demoWrites || []).filter((w) => String(w.path || w.url || '').startsWith('/api/pm-items/done')).length) > n, before, 5000));
+  }
+
+  /* ── tell PMOS ── */
+  await page.fill('[data-c3ph-input]', 'Ask Maya about the beta date');
+  await page.press('[data-c3ph-input]', 'Enter');
+  ok('tell: the text is filed as a capture', await waitFor(page, () => (window.__c3demoWrites || []).some((w) => w.path === '/api/capture' && w.body && /beta date/.test(w.body.text)), null, 5000));
+  ok('tell: the bar is cleared', (await page.inputValue('[data-c3ph-input]')) === '');
+
+  /* ── record ── */
+  await page.click('[data-c3ph-record]');
+  ok('record: the recording line shows with Stop', await waitFor(page, () => !!document.querySelector('[data-c3ph-recbar] [data-c3ph-stop]'), null, 8000));
+  ok('record: the ask bar gives way while recording', !(await page.evaluate(() => !!document.querySelector('[data-c3ph-foot] [data-c3ph-input]'))));
+  if (await page.$('[data-c3ph-stop]')) await page.click('[data-c3ph-stop]');
+  ok('record: Stop brings the bar back', await waitFor(page, () => !!document.querySelector('[data-c3ph-foot] [data-c3ph-input]') && !document.querySelector('[data-c3ph-recbar]'), null, 8000));
+  await page.close();
+
+  /* ── moments by the clock ── */
+  page = await open(pctx, '/c3.html?demo=1&at=10:10');
+  ok('moments: 10:10 is before Checkout sync', (await moment(page)) === 'before' && /Checkout sync/.test(await page.textContent('[data-c3ph-moment]')), await moment(page));
+  await page.close();
+  page = await open(pctx, '/c3.html?demo=1&at=10:45');
+  ok('moments: 10:45 is in the meeting', (await moment(page)) === 'meeting', await moment(page));
+  ok('moments: the meeting card offers to record it', await page.evaluate(() => !!document.querySelector('[data-c3ph-moment] [data-c3ph-rec-meeting]') && !!document.querySelector('[data-c3ph-moment] [data-c3ph-norec]')));
+  ok('moments: button icons in the moment card stay small', await page.evaluate(() => [...document.querySelectorAll('[data-c3ph-moment] .pmc-btn svg')].every((s) => s.getBoundingClientRect().width <= 20)));
+  await page.click('[data-c3ph-rec-meeting]');
+  ok('moments: Record starts recording Checkout sync', await waitFor(page, () => /Checkout sync/.test(document.querySelector('[data-c3ph-recbar]')?.textContent || ''), null, 8000));
+  ok('moments: while recording, the card opens the meeting companion', await waitFor(page, () => !!document.querySelector('[data-c3ph-moment] [data-c3ph-focus]'), null, 5000));
+  if (await page.$('[data-c3ph-stop]')) await page.click('[data-c3ph-stop]');
+
+  await page.close();
+
+  /* ── just ended: the debrief from the recording's notes, as on the desktop ── */
+  page = await open(pctx, '/c3.html?demo=1&at=11:25');
+  ok('debrief: 11:25 is just after Checkout sync', (await moment(page)) === 'after', await moment(page));
+  ok('debrief: the card shows the decisions and actions from the recording', await waitFor(page, () => { const c = document.querySelector('[data-c3ph-moment="after"]'); return c && c.dataset.c3phDebriefState === 'ready' && !!c.querySelector('[data-c3ph-debrief="decisions"]') && !!c.querySelector('[data-c3ph-debrief="actions"]') && /31 Oct/.test(c.textContent); }, null, 8000));
+  await page.close();
+  page = await open(pctx, '/c3.html?demo=1&at=17:10');
+  ok('debrief: a meeting with no recording asks you to tell PMOS', await waitFor(page, () => { const c = document.querySelector('[data-c3ph-moment="after"]'); return c && c.dataset.c3phDebriefState === 'none' && !!c.querySelector('[data-c3ph-tellafter]'); }, null, 8000));
+  await page.close();
+  page = await open(pctx, '/c3.html?demo=1&at=10:45');
+
+  /* ── full console and back ── */
+  await page.click('[data-c3ph-desk]');
+  ok('desk: Full console shows the desktop grid', await waitFor(page, () => { const g = document.querySelector('.c3grid'); return !!g && getComputedStyle(g).display !== 'none' && !document.querySelector('[data-c3ph]'); }, null, 5000));
+  await page.reload({ waitUntil: 'load' });
+  await waitFor(page, () => !!document.querySelector('nav.c3tabs [role="tab"]'));
+  ok('desk: the choice survives a reload', await page.evaluate(() => !document.querySelector('[data-c3ph]')));
+  const more = await page.$('[data-c3pg="more"]');
+  if (more) {
+    await more.click();
+    const item = await page.$('[data-a="phcomp"]');
+    ok('desk: More offers Phone companion', !!item);
+    if (item) { await item.click(); ok('desk: Phone companion brings the companion back', await waitFor(page, () => !!document.querySelector('[data-c3ph-moment]'), null, 5000)); }
+  } else ok('desk: the More button is found', false);
+  await page.close();
+  await pctx.close();
+
+  /* ── desktop ── */
+  const dctx = await ctxOf(1280);
+  page = await open(dctx, '/c3.html?demo=1', () => !!document.querySelector('nav.c3tabs [role="tab"]'));
+  ok('desktop: no companion at 1280 wide', await page.evaluate(() => !document.querySelector('[data-c3ph]') && !document.querySelector('.c3.c3-phone-on')));
+  ok('desktop: the grid shows', await page.evaluate(shown, '.c3grid'));
+  await dctx.close();
+
+  ok('no script error', errors.length === 0, errors.join(' | '));
+  finish();
+})();

package/workspace/c3-quiet-test.js

@@ -9,7 +9,7 @@
  *   more      Backlog, Releases, Docs and Sprints show only after More; each still opens
  *   calendar  one Layers button shows and hides the layer chips
  *   reports   no deck is drawn
- *   phone     at 400 wide nothing changes: the title shows and no dot is drawn (the phone gets its own companion design)
+ *   phone     at 400 wide with Full console chosen, nothing changes: the title shows and no dot is drawn (c3-phone-test.js tests the companion)
  * No script error may be raised.
  */
 const path = require('path');
@@ -45,6 +45,7 @@ const shown = (s) => { const n = document.querySelector(s); return !!n && getCom
   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 });
+  require('./lib/c3-full-console').fullConsole(browser);   // the desktop layout at phone width (c3-phone-companion)
   const errors = [];
   const open = async (w, url) => {
     const ctx = await browser.newContext({ viewport: { width: w, height: 860 } });

package/workspace/c3-reports-test.js

@@ -91,6 +91,7 @@ const DEF_P = ['north', 'outcomes', 'signals', 'delivery', 'bets', 'synergy', 'm
   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 });
+  require('./lib/c3-full-console').fullConsole(browser);   // the desktop layout at phone width (c3-phone-companion)
 
   const errors = [];
   const watch = (page) => {

package/workspace/c3-sessions-panel-test.js

@@ -177,6 +177,8 @@ function startShell(name) {
   /* ── D: End asks first, then ends ── */
   await page.click('[data-c3pg="agent-button"]');
   ok('D0 the panel opens again', await waitFor(page, (s) => !!document.querySelector(s), sel));
+  ok('D0b it opens on the session opened last: its row is open and marked', await waitFor(page, (i) => { const li = document.querySelector(`[data-c3t="mine"] [data-run="${i}"]`); const end = document.querySelector(`[data-end-session="${i}"]`); return !!li && li.hasAttribute('data-last-open') && !!end && end.offsetParent !== null; }, id)
+    && await page.evaluate((i) => localStorage.getItem('pmos.workspace.c3.last-session') === i, id));
   if (!(await page.isVisible(`[data-end-session="${id}"]`).catch(() => false))) await page.click(sel + ' .nb');
   await page.click(`[data-end-session="${id}"]`);
   ok('D1 End asks first', await waitFor(page, (i) => !!document.querySelector(`[data-end-confirm="${i}"]`), id));

package/workspace/c3-work-test.js

@@ -60,6 +60,7 @@ const W = '[data-pm-work]';
   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 });
+  require('./lib/c3-full-console').fullConsole(browser);   // the desktop layout at phone width (c3-phone-companion)
   const ctx = await browser.newContext({ viewport: { width: 1440, height: 1000 } });
   const page = await ctx.newPage();
   const errors = [];

package/workspace/guide/console3-sessions.md

@@ -9,6 +9,8 @@ timestamp: 2026-10-13
 
 Press the **Sessions** button in the console3 header to open the panel. It is the bolt icon with no label. Point at it to see its name. When a session needs you, a count shows on it. It shows your sessions in four groups: **On a card**, **Started by me**, **Past (7 days)** and **Automatic**.
 
+The panel opens on the session that you opened last. Its row is open, so you can read the conversation and send a message without searching for it. A session counts as opened when you open its row or its terminal.
+
 ## The dock
 
 The dock is folded when you first open the console. To open it, press Ctrl J (⌘J on a Mac), or use **Open the dock** in the **More** menu. The browser keeps your choice: when you leave the dock open, it opens on the Briefing next time. On the other tabs it is folded away, and no rail of buttons is left at the right edge.

package/workspace/guide/index.md

@@ -48,6 +48,7 @@ On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 - [People](people.md): the people you work with in a repository, how they get there, and `pmos people`.
 - [Docs](docs.md): whether each linked document is the same as, ahead of or behind its Google Docs and Confluence copy.
 - [Calendar popup](calendar-popup.md): open the full calendar over any page of the console with the calendar button or the C key, and close it.
+- [The phone companion](phone-companion.md): what the console shows at phone width: one moment of your day, your items one at a time, Tell PMOS and Record.
 - [Layout](layout.md): the frame, the keys and the rule for where a list or a detail opens.
 - [The Calendar tab of the console page](console-calendar.md): the zooms, the layer chips, the markers, the context of a meeting and free time.
 - [Statuses](statuses.md): what each status means, where it comes from, and what you can change.

package/workspace/guide/phone-companion.md

@@ -0,0 +1,47 @@
+---
+type: Guide
+title: "Guide: the phone companion"
+description: "At phone width the console shows a companion: one moment of your day, your items one at a time, Tell PMOS and Record."
+timestamp: 2026-10-13
+---
+
+# Guide: the phone companion
+
+When the console (`/`) is 600 pixels wide or less, for example on a phone, it shows the companion and not the desktop pages. The companion is not a small copy of the desktop. It shows the one thing that is useful now, and it keeps decisions for your computer.
+
+## The moment card
+
+The top card shows where you are in your day and why it is useful now. PMOS chooses the moment from today's meetings and the clock:
+
+| Moment | When | What the card shows |
+|---|---|---|
+| Your day | Before noon, with no meeting in the next 30 minutes | The next meeting, the number of your open items and the number of decisions that wait for your computer |
+| Before you walk in | The next meeting starts in 30 minutes or less | What is prepared for it, and the items to close first, each with **Done** |
+| In the meeting | A meeting is in progress | **Record this meeting?** with **Record** and **Not this one**. When it records, **Open the meeting companion** opens the meeting focus page. |
+| Just ended | A meeting ended less than 20 minutes ago | **What came out of it?** If you recorded the meeting, the card shows the summary, the decisions, the actions and the open questions from its notes, the same notes as on the Notes page. While PMOS writes the notes, the card says so. If you did not record it, **Tell PMOS** puts the meeting name in the bar so you can type the result. |
+| Free time | 15 minutes or more before the next meeting | The items that fit in the time: overdue items first, then items due today, at most two. Each has **Done** and **Later today**. |
+| Wrapping up | From 17:00, or after noon with no meeting left | What is still open and what waits for your computer |
+
+When the moment changes, a short message shows at the top for 6 seconds. The message shows only while the page is open. The companion does not send notifications.
+
+## Waiting on you
+
+Under the moment card, your own items show one at a time ("1 of 4"). **Done** marks the item done; the message that follows has **Undo**. **Later today** shows the item again later. **Next** shows the next item. Under the card, **Later today** lists the rest of today's meetings.
+
+## Tell PMOS
+
+Type a note, a to-do or an idea in the bar at the bottom and press Enter. PMOS puts it in your Work inbox. The bar does not answer questions. The small microphone puts the cursor in the bar; use the microphone of your phone's keyboard to speak. No audio goes to PMOS from this button.
+
+## Record
+
+The red button records a conversation or a meeting with the same recorder as **Record** on the desktop. While it records, the bar shows the name, the time and **Stop**.
+
+## The full console
+
+**Full console** at the top shows the desktop pages on this device, and the device keeps this choice. To go back, open **More** and choose **Phone companion**. In a window wider than 600 pixels the console always shows the desktop pages.
+
+## Limits
+
+- No notification on the lock screen, and no spoken brief.
+- No recommendation for a decision. Decisions with options wait for your computer.
+- To make tasks from the notes of a meeting, use the Notes page on your computer.

package/workspace/lib/c3-full-console.js

@@ -0,0 +1,15 @@
+'use strict';
+/* lib/c3-full-console.js — for browser suites that test the console's desktop layout at phone width.
+ * Since c3-phone-companion, console3 at 600px or less shows the phone companion. The desktop layout stays reachable there with
+ * "Full console", which stores pmos.c3.phone = 'desk' on the device. fullConsole(browser) makes every new context start with
+ * that choice, so a suite that resizes to 400 wide still tests the desktop layout. c3-phone-test.js tests the companion itself. */
+function fullConsole(browser) {
+  const make = browser.newContext.bind(browser);
+  browser.newContext = async (...args) => {
+    const ctx = await make(...args);
+    await ctx.addInitScript(() => { try { localStorage.setItem('pmos.c3.phone', 'desk'); } catch { /* no storage */ } });
+    return ctx;
+  };
+  return browser;
+}
+module.exports = { fullConsole };

package/workspace/package-lock.json

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

package/workspace/package.json

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

@@ -0,0 +1,14 @@
+/* pm/c3-demo-phone.js — demo only (?demo=1): the notes of the recorded Checkout sync, for the phone companion's "Just ended"
+ * card (c3-phone.js). The shapes are the real ones: a GET /api/notes row and the note of GET /api/notes/one with final_notes. */
+const NOTE = {
+  id: 'note-demo-checkout', title: 'Checkout sync', private: false, state: 'ended', updated_at: '2026-10-08T11:16:00Z',
+  meeting: { kind: 'event', event_id: 'm2', title: 'Checkout sync' },
+  final_notes: {
+    overview: 'The v2 date moves to 31 Oct because the sandbox keys are late. Beta stays on 30 Oct for the two partners already set up.',
+    decisions: [{ text: 'Checkout v2 ships on 31 Oct, not 24 Oct', why: 'Sandbox keys arrive two days late' }, { text: 'Beta stays on 30 Oct for the two partners already set up' }],
+    actions: [{ text: 'Send Priya the revised Checkout v2 date', owner: 'Wawan', due: '9 Oct' }, { text: 'Ask Dara for the sandbox keys date in writing', owner: 'Dara', due: '10 Oct' }],
+    questions: [{ text: 'Does the 31 Oct date move the IDPF 3.2 release?' }],
+  },
+};
+export const demoNoteFor = (m) => (m && (m.id === 'm2' || m.title === NOTE.title) ? NOTE : null);
+export const demoNote = (id) => (id === NOTE.id ? { ok: true, note: NOTE } : null);

package/workspace/public/pm/c3-phone-model.js

@@ -0,0 +1,55 @@
+/* pm/c3-phone-model.js — which moment of the day the phone companion is in, and what it brings (initiative c3-phone-companion).
+ * Pure: it reads today's meetings and the PM's own open items (GET /api/brief-page) and a clock, and returns one moment. No DOM, no fetch.
+ *
+ *   momentOf({ today, needs, now })  →  { kind, meeting?, next?, minutes?, fits?, later }
+ *     kind 'meeting'  a meeting is under way (start ≤ now < end)                      meeting = that one
+ *          'before'   the next meeting starts within BEFORE_MIN minutes                 meeting = the next one, minutes = until it starts
+ *          'after'    a meeting ended less than AFTER_MIN minutes ago, nothing under way meeting = the one that ended
+ *          'gap'      a free stretch of GAP_MIN minutes or more before the next meeting minutes = free minutes, fits = items that fit
+ *          'morning'  before noon with no meeting under way or near                   next = the next meeting, or null
+ *          'wrap'     from WRAP_HOUR on, or no meeting left today after noon          next = null
+ *     later  the meetings still to come after the one the moment is about (time order), for "I'll bring up later".
+ *   fitsIn(needs, minutes)  the own items worth doing in a free stretch: overdue first (most late first), then due today; at most two.
+ * The meeting rows are the brief page's today[] rows: { id, title, start, end, people, initiative, prepared, before }. */
+
+export const BEFORE_MIN = 30;
+export const AFTER_MIN = 20;
+export const GAP_MIN = 15;
+export const WRAP_HOUR = 17;
+
+const ms = (iso) => Date.parse(iso);
+const ok = (m) => m && m.id && !Number.isNaN(ms(m.start)) && !Number.isNaN(ms(m.end || m.start));
+
+export function fitsIn(needs, minutes) {
+  if (!(minutes >= GAP_MIN)) return [];
+  const own = (needs || []).filter((n) => n && (n.kind === 'overdue' || n.kind === 'due-today'));
+  own.sort((a, b) => (a.kind === b.kind ? (b.days_late || 0) - (a.days_late || 0) : a.kind === 'overdue' ? -1 : 1));
+  return own.slice(0, 2);
+}
+
+export function momentOf({ today, needs, now } = {}) {
+  const t = (now instanceof Date ? now : new Date(now || Date.now())).getTime();
+  const hour = new Date(t).getHours();
+  const rows = (today || []).filter(ok).slice().sort((a, b) => ms(a.start) - ms(b.start));
+  const end = (m) => ms(m.end || m.start);
+  const cur = rows.find((m) => ms(m.start) <= t && t < end(m));
+  const upcoming = rows.filter((m) => ms(m.start) > t);
+  const next = upcoming[0] || null;
+  const laterThan = (m) => upcoming.filter((x) => x !== m);
+  if (cur) return { kind: 'meeting', meeting: cur, minutes: Math.round((end(cur) - t) / 60000), later: upcoming };
+  const until = next ? Math.round((ms(next.start) - t) / 60000) : null;
+  if (next && until <= BEFORE_MIN) return { kind: 'before', meeting: next, minutes: until, later: laterThan(next) };
+  const ended = rows.filter((m) => end(m) <= t && t - end(m) < AFTER_MIN * 60000).pop();
+  if (ended) return { kind: 'after', meeting: ended, later: upcoming };
+  if (hour >= WRAP_HOUR || (!next && hour >= 12)) return { kind: 'wrap', next: null, later: upcoming };
+  if (next && until >= GAP_MIN && rows.some((m) => end(m) <= t)) return { kind: 'gap', next, minutes: until, fits: fitsIn(needs, until), later: upcoming };
+  if (hour < 12) return { kind: 'morning', next, later: upcoming };
+  return { kind: 'gap', next, minutes: until, fits: fitsIn(needs, until || 0), later: upcoming };
+}
+
+/** "in 25 min", "in 1 h 5 min" */
+export function inText(minutes) {
+  const m = Math.max(0, Math.round(minutes || 0));
+  if (m < 60) return 'in ' + m + ' min';
+  return 'in ' + Math.floor(m / 60) + ' h' + (m % 60 ? ' ' + (m % 60) + ' min' : '');
+}

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

@@ -0,0 +1,49 @@
+/* pm/c3-phone.css — the phone companion (c3-phone-companion, PM-approved 2026-10-12, design version 4). Linked once by c3-phone.js.
+ * In phone mode the root carries .c3-phone-on: the desktop frame (header, tabs, panes, dock) is not drawn and the companion fills the
+ * screen. One moment card, one waiting card, a short "later today" list, and a bottom bar with "Tell PMOS" and the red Record button.
+ * Everything is scoped under .c3 and uses tokens only. */
+.c3.c3-phone-on .c3grid{display:none !important}
+.c3.c3-phone-on{min-height:100dvh}
+.c3 .c3ph{display:flex;flex-direction:column;min-height:100dvh;background:var(--background)}
+.c3 .c3ph-hd{display:flex;align-items:center;justify-content:space-between;gap:8px;padding:calc(10px + env(safe-area-inset-top)) 16px 10px;position:sticky;top:0;background:var(--background);z-index:2}
+.c3 .c3ph-hd b{font-size:var(--fs-4)}
+.c3 .c3ph-hdr{display:flex;align-items:center;gap:8px}
+.c3 .c3ph-dotn{display:inline-flex;align-items:center;gap:4px;font:var(--fs-1) var(--mono);color:var(--muted-foreground)}
+.c3 .c3ph-body{flex:1;display:grid;gap:12px;align-content:start;padding:0 12px 16px}
+.c3 .c3ph-card{display:grid;gap:8px;padding:14px}
+.c3 .c3ph-card.lead{border-color:var(--acc)}
+.c3 .c3ph-why,.c3 .c3ph-step{font:var(--fs-1) var(--mono);color:var(--muted-foreground);display:flex;align-items:center;gap:6px}
+.c3 .c3ph-why{color:var(--acc)}
+.c3 .c3ph-big{font-size:var(--fs-5);font-weight:600;line-height:1.3}
+.c3 .c3ph-tt{font-size:var(--fs-3);line-height:1.4}
+.c3 .c3ph-line{font-size:var(--fs-2);color:var(--muted-foreground);line-height:1.45}
+.c3 .c3ph-rec-why{font-size:var(--fs-2);line-height:1.45;background:var(--muted);border-radius:8px;padding:8px 10px}
+.c3 .c3ph-prep{display:flex;gap:6px;align-items:flex-start;font-size:var(--fs-2);line-height:1.45}
+.c3 .c3ph-before,.c3 .c3ph-fit{display:grid;gap:6px;padding-top:8px;border-top:1px solid var(--border);font-size:var(--fs-2)}
+.c3 .c3ph-before{grid-template-columns:1fr auto;align-items:center}
+.c3 .c3ph-acts{display:grid;gap:8px}
+.c3 .c3ph-acts.two{grid-template-columns:1fr 1fr}
+.c3 .c3ph-b{min-height:44px;justify-content:center}
+.c3 .c3ph-cnt{display:flex;justify-content:space-between;font-weight:600;font-size:var(--fs-2)}
+.c3 .c3ph-cnt .dim{font-weight:400;font-family:var(--mono)}
+.c3 .c3ph-later{display:grid;gap:4px;font-size:var(--fs-2);color:var(--muted-foreground);padding:0 4px}
+.c3 .c3ph-later > div{display:flex;gap:10px}
+.c3 .c3ph-later .mono{font-family:var(--mono);min-width:42px}
+.c3 .c3ph-ft{position:sticky;bottom:0;display:flex;align-items:center;gap:10px;padding:8px 12px calc(12px + env(safe-area-inset-bottom));border-top:1px solid var(--border);background:var(--card);z-index:2}
+.c3 .c3ph-ask{flex:1;display:flex;align-items:center;gap:8px;border:1px solid var(--border);border-radius:8px;padding:0 4px 0 12px;min-height:44px;color:var(--muted-foreground);background:var(--background)}
+.c3 .c3ph-ask input.c3ph-in{flex:1;min-width:0;border:0;background:transparent;font-family:inherit;font-size:var(--fs-3);color:var(--foreground);padding:10px 0;outline:none;border-radius:0}
+.c3 .c3ph-ask:focus-within{border-color:var(--acc)}
+.c3 .c3ph-recdot{width:44px;height:44px;border:2px solid var(--destructive);display:grid;place-items:center;flex:none;padding:0}
+.c3 .c3ph-reddot{width:18px;height:18px;border-radius:50%;background:var(--destructive)}
+.c3 .c3ph-recbar{flex:1;display:flex;align-items:center;gap:10px;min-height:44px}
+.c3 .c3ph-rt{flex:1;min-width:0;display:grid}
+.c3 .c3ph-rt b{color:var(--destructive);font-size:var(--fs-3)}
+.c3 .c3ph-rt .dim{font-size:var(--fs-2);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.c3 .c3ph-dot{width:12px;height:12px;border-radius:50%;background:var(--destructive);flex:none;animation:c3phblink 1.2s infinite}
+.c3 .c3ph-dot.paused{animation:none;opacity:.5}
+@keyframes c3phblink{50%{opacity:.3}}
+@media (prefers-reduced-motion:reduce){.c3 .c3ph-dot{animation:none}}
+.c3 .c3ph-bnhost{position:sticky;top:52px;z-index:3;padding:0 12px}
+.c3 .c3ph-banner{display:grid;gap:2px;background:var(--card);border:1px solid var(--border);border-radius:8px;padding:10px 12px;margin-bottom:8px;box-shadow:var(--sh3);cursor:pointer}
+/* the focus page in its compact form fills the phone */
+.c3.c3-phone-on .c3focus.fc-pop{position:fixed;inset:0;z-index:20}

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

@@ -0,0 +1,269 @@
+/* pm/c3-phone.js — the phone companion (initiative c3-phone-companion). Below 601px wide, console3 shows this instead of a small copy of
+ * the desktop pages. Approved design: version 4 of the mockup named in planning/initiatives/c3-phone-companion.md.
+ *
+ * It has no tabs and no inbox to visit. It brings the one thing that matters now (c3-phone-model.js momentOf), then the PM's own items one
+ * at a time, then what comes later today. Two controls sit at the bottom: "Tell PMOS" and the red Record button.
+ *   moment card   meeting under way: "Record this meeting?" (Record / Not this one); recording: the meeting companion (c3-focus.js, compact)
+ *                 before a meeting: when it starts, who, what is prepared, the "before you go" items with Done
+ *                 just ended: tell PMOS what came out of it          a free gap: the own items that fit, with Done and Later today
+ *                 morning: the next meeting and how much waits      wrap: what is still open, what waits for the desk
+ *   waiting card  the own items from GET /api/brief-page needs, one at a time: Done (POST /api/pm-items/done, Undo: /reopen),
+ *                 Later today and Tomorrow (POST /api/pm-items/notyet). Decisions are not answered on the phone: they wait for the desk.
+ *   Tell PMOS     a line of text, filed by POST /api/capture { ws, text }: it lands in the Work inbox, where triage files it. The small mic
+ *                 points to the keyboard's own dictation; this page does not send audio anywhere.
+ *   Record        the red button records a conversation or a meeting, the same recorder as the desktop Record control (note-dock.js).
+ *                 While it records, the bar shows the clock and Stop. In demo mode it drives the simulated recorder and saves nothing.
+ * "Full console" switches this device to the desktop layout (kept on the device); the desktop More menu has "Phone companion" to come back.
+ * The moment is worked out again every minute; when it changes, a short banner says so. ?at=HH:MM sets the clock in demo mode only. */
+import { el } from './dom.js';
+import { button, iconButton } from './primitives.js';
+import { pmPost, pmGet } from './http.js';
+import { ensureC3Css, c3ic } from './pm-work-view.js';
+import { onBriefPage, loadBriefPage } from './c3-brief-data.js';
+import { onBriefing, loadBriefing } from './shell-ticker.js';
+import { toast } from './c3-toast.js';
+import { momentOf, inText } from './c3-phone-model.js';
+
+const CSS_ID = 'c3-phone-css';
+const p2 = (n) => String(n).padStart(2, '0');
+const hm = (iso) => { const d = new Date(iso); return p2(d.getHours()) + ':' + p2(d.getMinutes()); };
+const first = (n) => String(n || '').trim().split(/\s+/)[0];
+const WD = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const MO = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const clockOf = (msec) => { const s = Math.max(0, Math.floor(msec / 1000)); return Math.floor(s / 60) + ':' + p2(s % 60); };
+
+function ensureCss() {
+  if (document.getElementById(CSS_ID)) return;
+  document.head.appendChild(el('link', { id: CSS_ID, rel: 'stylesheet', href: '/pm/c3-phone.css' }));
+}
+
+/** Is this device in phone mode? Phone width, and the PM has not chosen the full console on it. */
+export function phoneWanted(store) {
+  if (typeof matchMedia !== 'function' || !matchMedia('(max-width:600px)').matches) return false;
+  return !(store && store.get('pmos.c3.phone') === 'desk');
+}
+
+export function mountPhone(root, ctx = {}) {
+  ensureC3Css(); ensureCss();
+  const demo = !!ctx.demo;
+  const q = new URLSearchParams(location.search);
+  const at = demo && /^\d{1,2}:\d{2}$/.test(q.get('at') || '') ? q.get('at').split(':').map(Number) : null;
+  const now = () => { const d = new Date(); if (at) d.setHours(at[0], at[1], 0, 0); return d; };
+  const S = { page: null, briefing: null, gone: new Set(), skipped: new Set(), noRec: new Set(), debrief: {}, kindKey: '', banner: null, rec: null, recKey: '' };
+
+  const host = el('div', { class: 'c3ph', 'data-c3ph': '', role: 'main', 'aria-label': 'PMOS companion' });
+  const head = el('div', { class: 'c3ph-hd' });
+  const body = el('div', { class: 'c3ph-body', 'data-c3ph-body': '' });
+  const bannerHost = el('div', { class: 'c3ph-bnhost' });
+  const input = el('input', { type: 'text', class: 'c3ph-in', 'data-c3ph-input': '', maxlength: '400', autocomplete: 'off', placeholder: 'Tell PMOS: a note, a to-do, an idea', 'aria-label': 'Tell PMOS: a note, a to-do or an idea' });
+  const form = el('form', { class: 'c3ph-ask', 'data-c3ph-ask': '' }, c3ic('spark', 'sm'), input,
+    iconButton({ icon: 'mic', ariaLabel: 'Dictate', size: 'sm', attrs: { 'data-c3ph-dictate': '' }, onClick: () => { input.focus(); toast('Use the mic on your keyboard to talk. PMOS files what you say.'); } }));
+  const recBtn = button({ label: '', variant: 'outline', attrs: { class: 'c3ph-recdot', 'data-c3ph-record': '', 'aria-label': 'Record a conversation or meeting', title: 'Record a conversation or meeting' }, onClick: () => startRec(null) });
+  recBtn.replaceChildren(el('span', { class: 'c3ph-reddot', 'aria-hidden': 'true' }));
+  const foot = el('div', { class: 'c3ph-ft', 'data-c3ph-foot': '' });
+  host.append(head, bannerHost, body, foot);
+  root.append(host);
+
+  /* ── recording: the desktop recorder (note-dock.js), or the demo's simulated one ── */
+  let dock = null;
+  const recLib = demo ? import('./shell-recording.js').then((m) => ({ state: () => m.simDock.recordState(), now: () => m.simDock.now(), start: (t) => m.simStart(t), stop: () => m.simDock.stopNow() }))
+    : import('./note-dock.js').then((m) => { m.mountDock && m.mountDock(); return { state: () => m.recordState(), now: () => Date.now(), start: (t, ev) => (ev ? m.recordEvent(ev) : m.recordNew()), stop: () => m.stopNow() }; });
+  recLib.then((d) => { dock = d; syncRec(); }).catch(() => { recBtn.hidden = true; });
+  function recState() { try { return dock ? dock.state() : { mode: 'idle' }; } catch { return { mode: 'idle' }; } }
+  function startRec(m) {
+    if (!dock) { toast('The recorder is not ready yet.'); return; }
+    if (recState().mode !== 'idle') { toast('Stop the recording first.'); return; }
+    Promise.resolve(dock.start(m ? m.title : 'Conversation', m || null)).then(() => { syncRec(); draw(); });
+  }
+  function syncRec() {
+    const st = recState();
+    const key = st.mode + ':' + (st.id || '') + ':' + (st.title || '');
+    if (key !== S.recKey) {
+      S.recKey = key;
+      if (st.mode === 'idle') foot.replaceChildren(form, recBtn);
+      else {
+        S.clock = el('span', { 'data-c3ph-clock': '' });
+        foot.replaceChildren(el('div', { class: 'c3ph-recbar', 'data-c3ph-recbar': st.mode, role: 'status' },
+          el('span', { class: 'c3ph-dot' + (st.mode === 'paused' ? ' paused' : '') }),
+          el('div', { class: 'c3ph-rt' }, el('b', null, st.mode === 'paused' ? 'Paused' : 'Recording'), el('span', { class: 'dim' }, (st.title || 'Conversation') + ' · ', S.clock)),
+          button({ label: 'Stop', variant: 'outline', size: 'sm', icon: 'square', attrs: { 'data-c3ph-stop': '' }, onClick: () => Promise.resolve(dock.stop()).then(() => { syncRec(); draw(); }) })));
+      }
+    }
+    if (S.clock) S.clock.textContent = st.mode === 'recording' && st.started ? clockOf(dock.now() - st.started) : st.mode === 'paused' ? 'paused' : '';
+  }
+
+  /* ── writes ── */
+  const post = (path, b) => pmPost(path, b).catch(() => ({ ok: false }));
+  function itemDone(n) {
+    S.gone.add(n.id); draw();
+    post('/api/pm-items/done', { id: n.id }).then((r) => { if (r && r.ok === false) { S.gone.delete(n.id); draw(); toast('That did not go through.'); } });
+    toast('Done: ' + n.headline, () => { S.gone.delete(n.id); draw(); post('/api/pm-items/reopen', { id: n.id }); });
+  }
+  function itemLater(n, when) {
+    S.gone.add(n.id); draw();
+    post('/api/pm-items/notyet', { id: n.id, when }).then((r) => { if (r && r.ok === false) { S.gone.delete(n.id); draw(); toast('That did not go through.'); } });
+    toast(when === 'tomorrow' ? 'Back tomorrow' : 'Back later today');
+  }
+  form.addEventListener('submit', (e) => {
+    e.preventDefault();
+    const text = input.value.trim(); if (!text) return;
+    input.value = ''; input.blur();
+    if (demo) { (window.__c3demoWrites = window.__c3demoWrites || []).push({ path: '/api/capture', body: { ws: ctx.ws, text } }); toast('Filed in your Work inbox. (Demo: nothing is saved.)'); return; }
+    post('/api/capture', { ws: ctx.ws, text }).then((r) => toast(r && r.ok !== false ? 'Filed in your Work inbox. PMOS sorts it.' : 'That was not filed' + (r && r.error ? ': ' + r.error : '.')));
+  });
+
+  /* ── the debrief of a meeting that just ended: the notes of its recording (GET /api/notes, /api/notes/one), as on the desktop ── */
+  function debriefOf(m) {
+    const k = m.id;
+    const have = S.debrief[k];
+    if (have && ((have.state === 'ready' && have.parts.from === 'final') || Date.now() - have.at < 30000)) return have;
+    if (!have || have.state !== 'loading') {
+      S.debrief[k] = { state: have ? have.state : 'loading', parts: have && have.parts, at: Date.now() };
+      readDebrief(m).then((d) => { S.debrief[k] = { ...d, at: Date.now() }; draw(); }, () => { S.debrief[k] = { state: 'none', at: Date.now() }; draw(); });
+    }
+    return S.debrief[k];
+  }
+  async function readDebrief(m) {
+    const [links, dn] = await Promise.all([demo ? import('./c3-demo-phone.js') : import('./notes-links.js'), import('./dest-notes.js')]);
+    let row;
+    if (demo) row = links.demoNoteFor(m);
+    else { await links.refreshNotes(); row = links.notesFor(m).slice().sort((a, b) => String(b.updated_at).localeCompare(String(a.updated_at)))[0]; }
+    if (!row) return { state: 'none' };
+    if (row.private) return { state: 'private' };
+    const one = demo ? links.demoNote(row.id) : await pmGet('/api/notes/one?id=' + encodeURIComponent(row.id));
+    const n = one && one.note;
+    if (!n) return { state: 'none' };
+    const parts = dn.partsOf(n);
+    if (!parts.overview && !parts.decisions.length && !parts.actions.length && !parts.questions.length) return { state: 'writing' };
+    return { state: 'ready', parts };
+  }
+
+  /* ── drawing ── */
+  const why = (t) => el('span', { class: 'c3ph-why' }, c3ic('spark', 'sm'), t);
+  const big = (t) => el('div', { class: 'c3ph-big' }, t);
+  const line = (t, attrs) => el('div', { class: 'c3ph-line', ...(attrs || {}) }, t);
+  const acts = (...b) => el('div', { class: 'c3ph-acts' + (b.filter(Boolean).length === 2 ? ' two' : '') }, ...b.filter(Boolean));
+  const card = (hero, attrs, ...kids) => el('section', { class: 'card c3ph-card' + (hero ? ' lead' : ''), ...(attrs || {}) }, ...kids);
+  const btn = (label, variant, icon, attrs, onClick) => button({ label, variant, icon, attrs: { ...(attrs || {}), class: 'c3ph-b' }, onClick });
+  const who = (m) => (m.people && m.people.length ? m.people.map(first).join(', ') : '');
+  const own = () => ((S.page && S.page.needs) || []).filter((n) => n && n.id && !S.gone.has(n.id));
+  const decisions = () => ((S.briefing && S.briefing.needs) || []).filter((n) => n && (n.card || (n.opts || n.options || []).length) && !n.itemId).length;
+
+  function itemCard(n, hero) {
+    const late = n.kind === 'overdue' ? (n.days_late === 1 ? '1 day late' : n.days_late + ' days late') : n.kind === 'due-today' ? 'Due today' : n.person ? 'Talk to ' + first(n.person) : 'Outside PMOS';
+    return [el('span', { class: 'c3ph-step' }, late.toUpperCase()), el('b', { class: 'c3ph-tt' }, n.headline),
+      n.evidence && n.evidence.text ? line('Looks done: ' + n.evidence.text + '.') : null,
+      acts(btn(n.evidence ? 'Confirm done' : 'Done', hero ? 'primary' : 'outline', 'check', { 'data-c3ph-done': n.id }, () => itemDone(n)),
+        btn('Later today', 'ghost', 'clock', { 'data-c3ph-later': n.id }, () => itemLater(n, 'later-today')))];
+  }
+
+  function momentCard(mo) {
+    const m = mo.meeting;
+    if (mo.kind === 'meeting') {
+      const st = recState();
+      const recording = st.mode !== 'idle';
+      const open = btn('Open the meeting companion', recording ? 'primary' : 'outline', 'target', { 'data-c3ph-focus': m.id }, () => import('./c3-focus.js').then((f) => f.openFocus({ event: { id: m.id, start: m.start }, pop: true })).catch(() => toast('The meeting companion did not open.')));
+      if (recording) return card(true, { 'data-c3ph-moment': 'meeting' }, why('Under way · ends ' + inText(mo.minutes)), big(m.title), line('Recording. PMOS follows the talk and writes the notes.'), acts(open));
+      if (S.noRec.has(m.id)) return card(true, { 'data-c3ph-moment': 'meeting' }, why('Under way · ends ' + inText(mo.minutes)), big(m.title), line('Not recording. PMOS follows the agenda and what you mark.'), acts(open, btn('Record from now', 'ghost', 'mic', { 'data-c3ph-rec-meeting': m.id }, () => startRec(m))));
+      return card(true, { 'data-c3ph-moment': 'meeting' }, why('Starting now' + (who(m) ? ' · ' + who(m) : '')), big('Record ' + m.title + '?'),
+        el('div', { class: 'c3ph-rec-why' }, 'Recording lets PMOS follow the talk, bring up what you need at the right topic, and write the notes for you.'),
+        acts(btn('Record', 'primary', 'mic', { 'data-c3ph-rec-meeting': m.id }, () => startRec(m)), btn('Not this one', 'ghost', null, { 'data-c3ph-norec': m.id }, () => { S.noRec.add(m.id); draw(); })));
+    }
+    if (mo.kind === 'before') {
+      const before = (m.before || []).filter((x) => !S.gone.has(x.id));
+      return card(true, { 'data-c3ph-moment': 'before' }, why('Starts ' + inText(mo.minutes) + ' · ' + hm(m.start)), big(m.title),
+        who(m) || m.initiative ? line([who(m), m.initiative].filter(Boolean).join(' · ')) : null,
+        ...(m.prepared || []).map((x) => el('div', { class: 'c3ph-prep' }, c3ic(x.kind === 'prep' ? 'spark' : 'doc', 'sm'), x.text)),
+        ...before.map((x) => el('div', { class: 'c3ph-before', 'data-c3ph-before': x.id }, el('span', null, 'Before you go: ' + x.title),
+          btn('Done', 'outline', 'check', { 'data-c3ph-done': x.id }, () => itemDone({ id: x.id, headline: x.title })))),
+        !(m.prepared || []).length && !before.length ? line('Nothing is prepared for it.') : null,
+        line('When it starts, PMOS asks to record it.', { 'data-c3ph-recnote': '' }));
+    }
+    if (mo.kind === 'after') {
+      const db = debriefOf(m);
+      const head = [why('Just ended · ' + hm(m.end || m.start)), big('What came out of ' + m.title + '?')];
+      const tell = btn(db.state === 'ready' ? 'Add something' : 'Tell PMOS', db.state === 'ready' ? 'outline' : 'primary', 'notebook-pen', { 'data-c3ph-tellafter': m.id }, () => { input.value = 'From ' + m.title + ': '; input.focus(); });
+      if (db.state === 'ready') {
+        const p = db.parts;
+        const list = (label, rows, fmt) => (rows.length ? el('div', { class: 'c3ph-fit', 'data-c3ph-debrief': label.toLowerCase() }, el('b', null, label + ' · ' + rows.length), ...rows.slice(0, 3).map((x) => el('div', { class: 'c3ph-line' }, fmt(x)))) : null);
+        return card(true, { 'data-c3ph-moment': 'after', 'data-c3ph-debrief-state': 'ready' }, ...head,
+          p.overview ? line(p.overview.length > 220 ? p.overview.slice(0, 217) + '…' : p.overview) : null,
+          list('Decisions', p.decisions, (x) => x.text),
+          list('Actions', p.actions, (x) => [x.text, x.owner ? ' · ' + x.owner : '', x.due ? ' · due ' + x.due : ''].join('')),
+          list('Open questions', p.questions, (x) => x.text),
+          line(p.from === 'final' ? 'From the recording. Make tasks from it on your computer.' : 'Caught while recording. The final notes follow.'),
+          acts(tell));
+      }
+      return card(true, { 'data-c3ph-moment': 'after', 'data-c3ph-debrief-state': db.state }, ...head,
+        line(db.state === 'writing' ? 'PMOS is writing the notes from the recording. Decisions and actions show here when they are ready.'
+          : db.state === 'private' ? 'The notes of this meeting are private. Open them on your computer.'
+          : db.state === 'loading' ? 'Looking for the notes of this meeting.'
+          : 'Not recorded. Tell PMOS the decisions and actions. They land in your Work inbox.'),
+        db.state === 'writing' || db.state === 'private' ? null : acts(tell));
+    }
+    if (mo.kind === 'gap') {
+      const fits = (mo.fits || []).filter((n) => !S.gone.has(n.id));
+      return card(true, { 'data-c3ph-moment': 'gap' }, why(mo.next ? 'Until ' + mo.next.title + ' at ' + hm(mo.next.start) : 'No more meetings today'),
+        big(mo.minutes ? mo.minutes + ' free minutes' : 'A free stretch'),
+        ...(fits.length ? fits.map((n) => el('div', { class: 'c3ph-fit', 'data-c3ph-fit': n.id }, ...itemCard(n, false))) : [line('Nothing of yours is due. A good moment to prepare the next meeting.')]));
+    }
+    if (mo.kind === 'morning') {
+      const o = own();
+      return card(true, { 'data-c3ph-moment': 'morning' }, why('Your day'), big(mo.next ? mo.next.title + ' at ' + hm(mo.next.start) : 'No meetings today'),
+        line([mo.next ? 'First up, ' + inText((Date.parse(mo.next.start) - now().getTime()) / 60000) + '.' : null, o.length ? o.length + (o.length === 1 ? ' thing of yours waits.' : ' things of yours wait.') : 'Nothing of yours is due.', decisions() ? decisions() + (decisions() === 1 ? ' decision waits' : ' decisions wait') + ' for your desk.' : null].filter(Boolean).join(' ')));
+    }
+    const o = own();
+    return card(true, { 'data-c3ph-moment': 'wrap' }, why('Wrapping up'), big(o.length ? o.length + ' still open today' : 'Nothing left for today'),
+      line(decisions() ? decisions() + (decisions() === 1 ? ' decision waits' : ' decisions wait') + ' for your desk. It opens first on your Briefing.' : 'Nothing waits for your desk.'));
+  }
+
+  function waitingCard(mo) {
+    const skipIds = new Set(((mo.kind === 'gap' && mo.fits) || []).map((n) => n.id));
+    const list = own().filter((n) => !skipIds.has(n.id) && !S.skipped.has(n.id));
+    if (!list.length) return null;
+    const n = list[0];
+    return card(false, { 'data-c3ph-waiting': n.id }, el('div', { class: 'c3ph-cnt' }, el('span', null, 'Waiting on you'), el('span', { class: 'dim' }, '1 of ' + list.length)),
+      ...itemCard(n, false), list.length > 1 ? button({ label: 'Next', variant: 'ghost', size: 'sm', iconEnd: 'chevron-right', attrs: { 'data-c3ph-skip': n.id }, onClick: () => { S.skipped.add(n.id); draw(); } }) : null);
+  }
+
+  function laterList(mo) {
+    const rows = (mo.later || []).slice(0, 3);
+    if (!rows.length) return null;
+    return el('div', { class: 'c3ph-later', 'data-c3ph-later-list': '' }, el('span', { class: 'c3ph-step' }, 'LATER TODAY'),
+      ...rows.map((m) => el('div', { 'data-c3ph-later-row': m.id }, el('span', { class: 'mono' }, hm(m.start)), el('span', null, m.title))));
+  }
+
+  function headLine() {
+    const d = now();
+    const n = own().length;
+    head.replaceChildren(el('b', null, WD[d.getDay()] + ' ' + d.getDate() + ' ' + MO[d.getMonth()]),
+      el('span', { class: 'c3ph-hdr' }, n ? el('span', { class: 'c3ph-dotn', 'data-c3ph-count': String(n) }, c3ic('inbox', 'sm'), n + ' waiting') : null,
+        button({ label: 'Full console', variant: 'ghost', size: 'sm', attrs: { 'data-c3ph-desk': '' }, onClick: () => ctx.onDesk && ctx.onDesk() })));
+  }
+
+  const BANNER = { meeting: (m) => m.title + ' has started', before: (m, mo) => m.title + ' starts ' + inText(mo.minutes), after: (m) => m.title + ' just ended', gap: (m, mo) => (mo.minutes || 0) + ' free minutes', wrap: () => 'Time to wrap up', morning: () => 'Good morning' };
+  function draw() {
+    if (!S.page) { body.replaceChildren(card(false, { 'data-c3ph-state': 'loading' }, line('Reading your day.'))); headLine(); return; }
+    if (S.page.ok === false) { body.replaceChildren(card(false, { 'data-c3ph-state': 'error' }, line('Your day could not be read: ' + (S.page.error || 'unreadable')))); headLine(); return; }
+    const mo = momentOf({ today: S.page.today || [], needs: own(), now: now() });
+    const key = mo.kind + ':' + ((mo.meeting && mo.meeting.id) || '');
+    if (S.kindKey && key !== S.kindKey) {
+      const t = BANNER[mo.kind](mo.meeting || mo.next || {}, mo);
+      bannerHost.replaceChildren(el('div', { class: 'c3ph-banner', role: 'status', 'data-c3ph-banner': mo.kind, onclick: () => bannerHost.replaceChildren() }, el('span', { class: 'c3ph-step' }, 'PMOS'), el('b', null, t)));
+      clearTimeout(S.banner); S.banner = setTimeout(() => bannerHost.replaceChildren(), 6000);
+    }
+    S.kindKey = key;
+    host.dataset.moment = mo.kind;
+    headLine();
+    body.replaceChildren(momentCard(mo), waitingCard(mo) || el('span'), laterList(mo) || el('span'));
+  }
+
+  const off1 = onBriefPage((j) => { S.page = j; draw(); });
+  const off2 = onBriefing((b) => { S.briefing = b; if (S.page) draw(); });
+  loadBriefPage(); loadBriefing();
+  draw();
+  const t1 = setInterval(syncRec, 1000);
+  const t2 = setInterval(draw, 60000);
+  const t3 = setInterval(() => loadBriefPage(), 5 * 60000);
+  return { host, refresh: draw, dispose() { clearInterval(t1); clearInterval(t2); clearInterval(t3); off1(); off2(); host.remove(); } };
+}

package/workspace/public/pm/c3-session-term.js

@@ -19,6 +19,10 @@ const store = {
 export const SIZE_KEY = 'pmos.workspace.c3.term-size';
 export const PAD_KEY = 'pmos.workspace.c3.term-pad';
 export const PAD_H_KEY = 'pmos.workspace.c3.term-pad-h';
+/* the session the PM opened last (its terminal here, or its row in the Sessions panel): the panel opens on it */
+export const LAST_SESSION_KEY = 'pmos.workspace.c3.last-session';
+export const rememberSession = (id) => { if (id) store.set(LAST_SESSION_KEY, String(id)); };
+export const lastSession = () => store.get(LAST_SESSION_KEY) || null;
 const PAD_ROWS = 4;   // the default height
 /** The pad's height in rows: at least 2, and at most what leaves the terminal its room in a column `room` px high with `lh` px rows. Pure, for Node. */
 export const clampPad = (rows, room, lh) => Math.max(2, Math.min(Math.round(rows), Math.max(2, Math.floor((room - 200) / (lh || 18)))));
@@ -122,6 +126,7 @@ function makePad(id, term, tab) {
 
 export async function openSessionTerm({ id, name } = {}) {
   if (!id) return null;
+  rememberSession(id);
   if (!name) { const r = await pmGet('/api/sessions').catch(() => null); const x = r && Array.isArray(r.sessions) ? r.sessions.find((y) => y.id === id) : null; name = x ? x.name : id; }
   const [ok, term] = await Promise.all([loadVendor(), import('./tab-term.js').catch(() => null)]);
   if (!ok || !term) { toast({ text: 'The terminal could not be loaded on this page.', tone: 'error' }); return null; }

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

@@ -50,6 +50,7 @@ import { freshnessLine } from './freshness-line.js';
 import { mountInitiatives } from './c3-initiatives.js';
 import { mountSettings, gearIcon, applyLook } from './c3-settings.js';
 import { mountQuiet } from './c3-quiet.js';
+import { mountPhone, phoneWanted } from './c3-phone.js';
 
 /* In demo mode each tab's deck asks for its own cards (the mockup draws a different deck per tab); real mode sends no scope. Reports always sends its own (repTab). */
 const sc = (name) => (DEMO ? name : undefined);
@@ -138,6 +139,7 @@ function toggleMore() {
     item('alert', 'Incident day', () => toggleIncident(), S.incident, S.demo ? { 'data-a': 'inc' } : { 'data-a': 'inc', disabled: true, title: 'No incident feed is connected, so this page shows no incident.' }),
     item('spark', 'Agent playbooks', () => openPlaybooks(), false, { 'data-a': 'pbopen' }),
     item('phone', 'Phone preview', () => togglePreview(), !!S.preview, { 'data-a': 'phone' }),
+    S.root.classList.contains('ph') && store.get('pmos.c3.phone') === 'desk' ? item('phone', 'Phone companion', () => { store.set('pmos.c3.phone', ''); syncPhone(); }, false, { 'data-a': 'phcomp' }) : null,
     item(S.theme === 'dark' ? 'sun' : 'moon', S.theme === 'dark' ? 'Light theme' : 'Dark theme', () => setTheme(S.theme === 'dark' ? 'light' : 'dark')),
     ((b) => { b.firstChild.replaceWith(gearIcon('sm')); return b; })(item('info', 'Settings', () => showTab('settings', true), false, { 'data-a': 'settings' })),
     item('term', S.dockOpen ? 'Fold the dock' : 'Open the dock', () => { S.dockOpen = !S.dockOpen; keepDock(); syncDock(); }, false, { 'data-a': 'dockt' }, 'Ctrl J'),
@@ -150,6 +152,18 @@ function toggleMore() {
   document.addEventListener('keydown', S.menuOff); document.addEventListener('pointerdown', S.menuOff);
   const first = S.menu.querySelector('.c3pg-mi:not([disabled])'); if (first) first.focus();
 }
+/* The phone companion (c3-phone.js): at 600px or less, unless the PM chose the full console on this device, it fills the page and the
+ * desktop grid is hidden. "Full console" stores that choice; the More menu's "Phone companion" clears it. */
+function syncPhone() {
+  const want = phoneWanted(store);
+  if (want && !S.phone) {
+    S.root.classList.add('c3-phone-on');
+    S.phone = mountPhone(S.root, { ws: S.ws, demo: S.demo, onDesk: () => { store.set('pmos.c3.phone', 'desk'); syncPhone(); } });
+  } else if (!want && S.phone) {
+    S.phone.dispose(); S.phone = null;
+    S.root.classList.remove('c3-phone-on');
+  }
+}
 function closeMore() {
   if (!S.menu) return;
   document.removeEventListener('keydown', S.menuOff); document.removeEventListener('pointerdown', S.menuOff);
@@ -607,6 +621,8 @@ async function boot() {
   mountDaypart(root, root.querySelector('.c3top'));
   mountAmbient(root);   // the ambient motion canvas, once, behind the grid
   mountQuiet(root);     // the quiet layout: two rows above the content, no teaching sentences (c3-quiet-pages)
+  syncPhone();          // at phone width the companion replaces the desktop frame (c3-phone-companion)
+  if (typeof matchMedia === 'function') matchMedia('(max-width:600px)').addEventListener('change', syncPhone);
 
   S.dock.setWorkspaces(S.workspaces, S.ws);
   mountBell(S.bellHost, { go: (_, t) => goTarget(t) });

package/workspace/public/pm/sessions-panel.js

@@ -16,6 +16,7 @@ import { toast } from './c3-toast.js';
 import { pmPost } from './http.js';
 import { button } from './primitives.js';
 import { chatFeed } from './c3-session-chat.js';
+import { rememberSession, lastSession } from './c3-session-term.js';
 
 const live = new WeakMap();
 const DOT = { working: 'w', queued: 'w', asking: 'n', permission: 'n', attention: 'n', not_started: 'n', failed: 'b', quiet: '', paused: 'n', done: '' };
@@ -56,7 +57,7 @@ function row(st, s, card, parts) {
   li.style.gridTemplateColumns = 'auto minmax(0,1fr) auto';
   xp.style.gridColumn = '1 / -1';
   const key = 'r-' + s.id;
-  attachExpand(li, xp, { key, initial: st.open.has(key), onToggle: (on) => { if (on) st.open.add(key); else st.open.delete(key); } });
+  attachExpand(li, xp, { key, initial: st.open.has(key), onToggle: (on) => { if (on) { st.open.add(key); rememberSession(s.id); } else st.open.delete(key); } });
   return li;
 }
 const dim = (t) => el('span', { class: 'dim mono', style: 'font-size:var(--fs-2)' }, t);
@@ -180,7 +181,9 @@ export function mountSessions(host, ctx = {}) {
   disposeSessions(host);
   if (ctx && ctx.FIXTURE) return;
   ensureC3Css();
-  const st = { src: source(), data: null, showAuto: false, last: '', gone: false, timer: null, refresh: null, redraw: null, open: new Set(), confirm: null,
+  // the panel opens on the session the PM opened last: its row starts open, and the first draw brings it into view
+  const lastId = lastSession();
+  const st = { src: source(), data: null, showAuto: false, last: '', gone: false, timer: null, refresh: null, redraw: null, open: new Set(lastId ? ['r-' + lastId] : []), confirm: null, reveal: lastId,
     openSession: (id) => { const r = st.data && st.data.groups ? [].concat(...Object.values(st.data.groups).filter(Array.isArray)).find((x) => x.id === id) : null;
       import('./c3-session-term.js').then((m) => m.openSessionTerm({ id, name: r ? r.name : id })); } };
   if (st.src.demo) st.openSession = () => toast('In the real workspace this opens the CLI session.');
@@ -194,6 +197,11 @@ export function mountSessions(host, ctx = {}) {
     st.last = key; st.data = r;
     if (r.ok && ctx.onNeeds) ctx.onNeeds(needsYou(r));
     if (!busy()) draw(host, st); else st.last = '';
+    if (st.reveal && r.ok) {
+      const li = host.querySelector(`[data-run="${CSS.escape(st.reveal)}"]`);
+      st.reveal = null;
+      if (li) { li.setAttribute('data-last-open', ''); requestAnimationFrame(() => li.scrollIntoView({ block: 'nearest' })); }
+    }
   };
   st.timer = setInterval(() => { if (!busy()) st.refresh(); }, 5000);
   if (st.src.subscribe) st.unsub = st.src.subscribe(() => st.refresh());

package/workspace/test-files.json

@@ -78,7 +78,8 @@
     "briefing-icons.test.js",
     "needs-overdue.test.js",
     "briefing-scope.test.js",
-    "settings-store.test.js"
+    "settings-store.test.js",
+    "c3-phone-model.test.js"
   ],
   "panels": [
     "pm-shell-test.js",
@@ -145,7 +146,8 @@
     "c3-scan-test.js",
     "c3-sessions-panel-test.js",
     "c3-updates-test.js",
-    "c3-quiet-test.js"
+    "c3-quiet-test.js",
+    "c3-phone-test.js"
   ],
   "ui": [
     "ui-test.js"
@@ -287,7 +289,9 @@
     "c3-settings-test.js": 25,
     "c3-sessions-panel-test.js": 20,
     "c3-updates-test.js": 20,
-    "c3-quiet-test.js": 30
+    "c3-quiet-test.js": 30,
+    "c3-phone-model.test.js": 1,
+    "c3-phone-test.js": 20
   },
   "_comment_seconds": "Measured wall time of each suite run alone (4-CPU sandbox, 2026-10-05). Only the ORDER uses it: the slowest suites start first, and --shard deals suites to the least-loaded shard so the shards finish together. A wrong or missing number never skips a suite; a missing one counts as 10."
 }