create-pmos 0.133.0 → 0.135.0

package/workspace/server.js

@@ -76,6 +76,7 @@ const jevRoute = require('./lib/jev-route.js');     // prompt-model-routing —
 const jevClaims = require('./lib/jev-claims.js');   // D80 — the bridge between the claims ledger and the one TypeSafe module
 const jevCategorize = require('./lib/jev-categorize.js');   // D82 — the bridge between the document categorizer and the one TypeSafe module
 const validateLib = require('./lib/validate.js');
+const headlessLib = require('./lib/headless.js');   // workspace-headless-jobs — which jobs run as `claude -p`, and with which tools
 const liveNotes = require('./lib/live-notes.js');   // jev-live-notes — reads and appends a repository's live-notes ledger; no network
 const jevLive = require('./lib/jev-live.js');      // jev-live-notes Run 7 (D85) — the live view's one bridge to Jev, behind three gates
 const claimsLib = require('./lib/claims.js');
@@ -2512,7 +2513,13 @@ function checkDueSchedules() {
 // PMOS_TICK_MS exists for the suites (same footing as PMOS_LIVENESS_MS): proactive-prepare.test.js
 // used to wait on two real minutes of this clock. Unset, the interval is the 60 seconds it always was.
 const TICK_MS = Math.max(200, Number(process.env.PMOS_TICK_MS) || 60000);
-try { const _tick = setInterval(() => { checkDueSchedules(); proactiveTick(); try { prepareTick({ manual: false }); } catch { /* the next tick tries again */ } try { dayTick(); } catch (e) { warnWriteFail('day run tick', e); } autoSync.tick().catch(() => {}); }, TICK_MS); if (_tick.unref) _tick.unref(); } catch {}
+// console3-dashboard-schedules: a scheduled Reports dashboard makes ONE ready draft in the outbox per slot. Nothing is sent.
+// Loaded on the first tick, as route-modules.js loads it: a checkout without the repository's scripts/ still starts.
+const dashboardScheduleTick = () => {
+  let m; try { m = require('./lib/routes-c3-reports.js'); } catch { return; }
+  m.runDue({ getWs, runtimeDir: STATE }).catch((e) => warnWriteFail('dashboard schedule tick', e));
+};
+try { const _tick = setInterval(() => { checkDueSchedules(); proactiveTick(); try { prepareTick({ manual: false }); } catch { /* the next tick tries again */ } try { dayTick(); } catch (e) { warnWriteFail('day run tick', e); } autoSync.tick().catch(() => {}); dashboardScheduleTick(); }, TICK_MS); if (_tick.unref) _tick.unref(); } catch {}
 
 // ── Sessions: real PTYs, owned by the server, with disk-backed scrollback + metadata. ──
 /** @type {Map<string, {id,ws,name,agent,cwd,state,note,created,pty,buf,cols,rows,clients:Set}>} */
@@ -2552,6 +2559,7 @@ function persist(s) {
     state: s.state, note: s.note || '', created: s.created, tmux: s.tmux || null, origin: s.origin || null };
   if (s.autoDelete) meta.autoDelete = s.autoDelete;
   if (s.autoEnded) meta.autoEnded = true;
+  if (s.headless) meta.headless = s.headless;
   if (s.exitedAt) meta.exitedAt = s.exitedAt;
   // The breakdown item a Hand to agent session is bound to, so a restart keeps the binding (pm-os-absorb Run 1).
   if (s.plan_item) meta.plan_item = s.plan_item;
@@ -2838,6 +2846,7 @@ function sessionList() {
       cwd: path.relative(s.root, s.cwd) || '.', note: s.note || '', origin: s.origin || null,
       automatic: sessionOrigin.isAutomatic(s.origin),   // the workspace started it, not the PM: the dock hides these by default
       auto_delete: s.autoDelete || null,
+      headless: s.headless || null,   // workspace-headless-jobs: a background run with no terminal ('notes' or 'skill')
       plan_item: s.plan_item || null,   // Hand to agent: the breakdown item this session is bound to (pm-os-absorb Run 1)
       // No `token` and no `tokenHash` here, ever: the page never sees a session token (F5; r25-guards.test.js checks it).
       // Derived presentation state, JOINED from both sources: the cadence clock above and the
@@ -3363,7 +3372,80 @@ function sendToSession(id, text) {
   try { firstInput.deliver(s, safeFirstInput(t) + '\r'); return true; } catch { return false; }
 }
 
-function spawnSession({ name, agent, cwd, ws, origin, initialInput, profile, initiative, modelAsk, planItem, workType, autoDelete, launchFlags }) {
+/* A headless run (workspace-headless-jobs). The row is an ordinary session record, so every caller that checks a
+ * session's state keeps working; it has no pty and no tmux, and `child` is the process. The log is read-only. */
+function startHeadless(base, workdir, kind, launchArgs, env, initialInput, addDirs) {
+  const prompt = safeFirstInput(String(initialInput).replace(/\r+$/, ''));
+  const args = headlessLib.argsFor(kind, { modelArgs: launchArgs, addDirs: Array.isArray(addDirs) ? addDirs : [] });
+  const s = { ...base, cwd: workdir, state: 'working', pty: null, tmux: null, headless: kind, child: null,
+    note: '', buf: '', cols: 80, rows: 24, clients: new Set(), created: nowISO(), lastOutputAt: Date.now() };
+  const say = (text) => {
+    const d = String(text).replace(/\r?\n/g, '\r\n');
+    appendBuf(s, d);
+    for (const c of s.clients) if (c.readyState === 1) c.send(JSON.stringify({ t: 'data', id: s.id, data: d }));
+  };
+  sessions.set(s.id, s);
+  say(`\x1b[38;5;244mRunning in the background (no terminal). The result shows here when it finishes.\x1b[0m\n`);
+  let child;
+  // detached: its own process group, so stopping it also stops what it started (an MCP server, a script) and no
+  // grandchild keeps the output pipes open after the run is stopped.
+  try { child = spawn(base.agent, args, { cwd: workdir, env, stdio: ['pipe', 'pipe', 'pipe'], detached: true }); }
+  catch (e) {
+    s.state = 'exited'; s.note = spawnFailureAdvice(e, base.agent, false);
+    say(`\x1b[38;5;203m✗ ${s.note}\x1b[0m\n`); persist(s); pushSessions(); pushWorkspaces(); return s;
+  }
+  s.child = child;
+  let out = '', err = '', timedOut = false;
+  const CAP = 5 * 1024 * 1024;
+  child.stdout.on('data', (d) => { if (out.length < CAP) out += d; s.lastOutputAt = Date.now(); });
+  child.stderr.on('data', (d) => { if (err.length < 65536) err += d; });
+  child.on('error', (e) => { err += String(e && e.message || e); });
+  const timer = setTimeout(() => {
+    timedOut = true;
+    killHeadless(child, 'SIGTERM');
+    const hard = setTimeout(() => killHeadless(child, 'SIGKILL'), 5000);
+    if (hard.unref) hard.unref();
+  }, headlessLib.timeoutMs());
+  if (timer.unref) timer.unref();
+  // A headless run prints nothing until it ends, and a quiet row reads as waiting on the PM (lib/harness.js deriveState).
+  // While the process lives, it is working: keep its output clock current.
+  const beat = setInterval(() => { s.lastOutputAt = Date.now(); }, 5000);
+  if (beat.unref) beat.unref();
+  child.on('close', (code, signal) => {
+    clearTimeout(timer); clearInterval(beat);
+    s.child = null; s.state = 'exited';
+    const r = headlessLib.parseResult(out);
+    if (r.ok) say(headlessLib.logLines(r, code).join('\n') + '\n');
+    else if (out.trim()) say(r.text + '\n');
+    if (err.trim()) say(`\x1b[38;5;244m${err.trim().split('\n').slice(-20).join('\n')}\x1b[0m\n`);
+    s.note = timedOut ? `stopped: still running after ${Math.max(1, Math.round(headlessLib.timeoutMs() / 60000))} minutes`
+      : s.stoppedByPm ? 'ended by the PM'
+      : signal ? `exited (signal ${signal})`
+      : (code === 0 && r.ok && r.isError) ? 'exited (the run reported an error)'
+      : `exited (code ${code})`;
+    if (s.note !== 'exited (code 0)') say(`\x1b[38;5;203m[${s.note}]\x1b[0m\n`);
+    persist(s); pushSessions();
+  });
+  child.stdin.on('error', () => {});
+  child.stdin.end(prompt);
+  persist(s); pushSessions(); pushWorkspaces();
+  return s;
+}
+/** Stop a headless run; its close handler marks the row exited. → true when there was a process to stop. */
+function stopHeadless(s) {
+  if (!s || !s.child) return false;
+  s.stoppedByPm = true;
+  killHeadless(s.child, 'SIGTERM');
+  const hard = setTimeout(() => { if (s.child) killHeadless(s.child, 'SIGKILL'); }, 5000);
+  if (hard.unref) hard.unref();
+  return true;
+}
+/** Signal a headless run's whole process group; fall back to the process alone. */
+function killHeadless(child, sig) {
+  try { process.kill(-child.pid, sig); } catch { try { child.kill(sig); } catch {} }
+}
+
+function spawnSession({ name, agent, cwd, ws, origin, initialInput, profile, initiative, modelAsk, planItem, workType, autoDelete, launchFlags, addDirs }) {
   const id = nextSessionId();
   /* pm-os-absorb Run 1 — every AGENT session gets a token, `<id>.<8 hex>`, in its environment as PMOS_SESSION, and
    * PMOS_BIN, this workspace's own bin/pmos.js. `pmos item` run inside it is then attributed `agent:<token>` (the token
@@ -3473,6 +3555,11 @@ function spawnSession({ name, agent, cwd, ws, origin, initialInput, profile, ini
       spawnFailureAdvice(Object.assign(new Error(`'${agent}' not found on PATH`), { code: 'ENOENT' }), agent, false));
   }
 
+  // ── the headless path (workspace-headless-jobs): a background job that needs no human runs as `claude -p`, with
+  // no pane, the same environment and model, a fixed tool list and the prompt on stdin (lib/headless.js says which).
+  const hkind = initialInput ? headlessLib.kindFor({ agent, origin: tag, skill: modelAsk && modelAsk.skill }) : null;
+  if (hkind) return startHeadless(base, workdir, hkind, argv, penv, initialInput, addDirs);
+
   // ── the tmux path: the process outlives this server, and we re-attach to it live (R7) ──
   if (TMUX) {
     const tname = freshTmuxName(id);
@@ -4489,7 +4576,7 @@ function writeLayouts(w, doc) {
 // a live one must be killed first (its onExit flips it to exited).
 function removeSession(id) {
   const s = sessions.get(id);
-  if (!s || s.pty) return false;
+  if (!s || s.pty || s.child) return false;
   if (s.tmux) tmuxKillSession(s.tmux);   // best-effort: never orphan a detached tmux session
   try { recordConversation(s); } catch {}   // the conversation outlives the session (surface-batch R5)
   forgetScratchpad(s);                   // the tab's staging text goes with the tab
@@ -5570,6 +5657,8 @@ async function handleRequest(req, res) {
   // disagree about what a normalized document is (markdown-newlines).
   if (p === '/lib/md-normalize.js') return serveFile(res, path.join(__dirname, 'lib', 'md-normalize.js'));
   if (p === '/lib/layout.js') return serveFile(res, path.join(__dirname, 'lib', 'layout.js'));
+  // The report frame and draft text: the Reports page imports it, and the scheduled dashboard run requires it (console3-dashboard-schedules R6).
+  if (p === '/lib/report-frame.js') return serveFile(res, path.join(__dirname, 'lib', 'report-frame.js'));
   if (p === '/lib/mobile-nav.js') return serveFile(res, path.join(__dirname, 'lib', 'mobile-nav.js'));
   if (p === '/lib/session-state.js') return serveFile(res, path.join(__dirname, 'lib', 'session-state.js'));
   if (p === '/lib/tree-share.js') return serveFile(res, path.join(__dirname, 'lib', 'tree-share.js'));
@@ -5776,6 +5865,11 @@ async function handleRequest(req, res) {
     try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
     const sess = sessions.get(String(body.id || ''));
     if (!sess) return json(res, { ok: false, error: 'no such session' }, 404);
+    if (sess.child) {
+      stopHeadless(sess);
+      for (let i = 0; i < 30 && sess.child; i++) await new Promise((r) => setTimeout(r, 100));
+      if (sess.child) return json(res, { ok: true, removed: false, note: 'asked it to end; it has not exited yet — press again to remove it' });
+    }
     if (sess.pty) {
       if (sess.tmux) tmuxKillSession(sess.tmux);
       try { sess.pty.kill(); } catch {}
@@ -8285,7 +8379,7 @@ async function handleRequest(req, res) {
       const dayCheck = body.dayCheck && typeof body.dayCheck === 'object' && !Array.isArray(body.dayCheck) ? { ...cur.dayCheck, ...body.dayCheck } : (body.dayCheck === undefined ? cur.dayCheck : body.dayCheck);
       const bpr = body.placeRepos && typeof body.placeRepos === 'object' && !Array.isArray(body.placeRepos) ? body.placeRepos : null;
       const placeRepos = bpr ? { ...cur.placeRepos, ...Object.fromEntries(Object.entries(bpr).map(([k, v]) => [k, v && typeof v === 'object' && !Array.isArray(v) ? { ...((cur.placeRepos || {})[k] || {}), ...v } : v])) } : cur.placeRepos;
-      const n = proactiveLib.normalizeSettings({ ...cur, ...body, placeRepos, triggers: { ...cur.triggers, ...(body.triggers || {}) }, briefSources: { ...cur.briefSources, ...(body.briefSources || {}) }, scopes, dayCheck });
+      const n = proactiveLib.normalizeSettings({ ...cur, ...body, placeRepos, triggers: { ...cur.triggers, ...(body.triggers || {}) }, briefSources: { ...cur.briefSources, ...(body.briefSources || {}) }, about: { ...(cur.about || {}), ...(body.about && typeof body.about === 'object' && !Array.isArray(body.about) ? body.about : {}) }, scopes, dayCheck });
       if (!n.ok) return json(res, { ok: false, error: n.error }, 400);
       try { fs.mkdirSync(STATE, { recursive: true }); fs.writeFileSync(PRO_SETTINGS(), JSON.stringify(n.settings) + '\n'); }
       catch (e) { warnWriteFail('proactive-settings.json', e); return json(res, { ok: false, error: 'could not save — nothing changed' }, 500); }
@@ -8688,10 +8782,14 @@ async function handleRequest(req, res) {
   // meeting-notes Run 1: the Notes routes keep notes in the per-user runtime directory and start the agent-summary session.
   if (await routeModules.dispatch(req, res, url, { json, readBody, getWs, invalidateNeedsAgg, boardCache, consoleState, stateDirFor, sessionList, initiativeIndex,
     runtimeDir: STATE, spawnSession, jevModelOpts, sendToSession,
+    // workspace-headless-jobs R6: is this session a headless run that is still working?
+    headlessBusy: (id) => { const x = sessions.get(String(id || '')); return !!(x && x.headless && x.child); },
     // initiative my-work: every registered repository, the day runs, and the two presses that start sessions
     workspaceList: () => [...workspaces.values()], readDayRun, myWorkBrief, myWorkRead,
     // workspace-data-freshness: the source table, the facts rebuild and Refresh now's skill sessions
-    freshness, factsRefresh: (root) => factsAsync.refresh(root, { force: true }), startSkill: startSkillSession })) return;
+    freshness, factsRefresh: (root) => factsAsync.refresh(root, { force: true }), startSkill: startSkillSession,
+    // c3-initiative-boards: the PMOS checkout this server is embedded in, whose default board keeps its derived ladder
+    selfRoot: EMBEDDED_SELF ? SELF_ROOT : null })) return;
   res.writeHead(404); res.end('not found');
 }
 
@@ -8979,7 +9077,8 @@ wss.on('connection', (ws) => {
       ws.send(JSON.stringify({ t: 'created', id: s.id }));
     } else if (m.t === 'kill') {
       const s = sessions.get(m.id); if (!s) return;
-      if (s.pty) {
+      if (s.child) stopHeadless(s);                    // a headless run → stop its process (its close handler flips state)
+      else if (s.pty) {
         // A tmux client's .kill() only DETACHES — the process would live on and we'd reattach.
         // To actually end a live session, kill the tmux session itself (onExit then flips state).
         if (s.tmux) tmuxKillSession(s.tmux);

package/workspace/skills/day-check.skill

@@ -22,7 +22,7 @@ Rules that always hold:
 7. AT MOST 30 ITEMS in the stored brief after the merge. Resolve what is done before you add. The workspace refuses a merge that would pass 30.
 
 Procedure:
-1. Run `pmos proactive day`. It shows the stage, the tasks, and the check state (when the last check was, and why this one runs). Run `pmos proactive brief` to read the stored brief: its items with their ids, its events with their ids, and its digests. Run `pmos proactive settings` for the sources, the scopes and the websites. Run `pmos proactive goals` for the goal ids.
+1. Run `pmos proactive day`. It shows the stage, the tasks, and the check state (when the last check was, and why this one runs). Run `pmos proactive brief` to read the stored brief: its items with their ids, its events with their ids, and its digests. Run `pmos proactive settings` for the sources, the scopes, the websites and, when it prints them, the PM's role, work and job description: use those to judge what matters to this PM. Run `pmos proactive goals` for the goal ids.
 2. Read what changed, from the sources that are on and reachable:
    - Calendar: today's events. Note a new event, a moved one, a cancelled one, and a new link or agenda in one.
    - Mentions of the PM since the last check, in Slack, Jira and Confluence, in every place that is not ignored. Keep where, who, the link to the conversation itself and a short paraphrase of what is asked. To tie a Jira issue to an initiative, run `pmos jira which <KEY>` (it reads local files only) and use the initiative it names. A status change of a ticket that `pmos jira which` names is not an item: the Jira status check shows it on the initiative's Jira tickets tab.

package/workspace/skills/jira-sync.skill

@@ -15,17 +15,19 @@ output:
 Rules that always hold:
 1. READ-ONLY on Jira. Use only the Jira search tool. Never create, edit, transition, assign, comment on, link, close or delete an issue. Never write to Confluence or to any other source.
 2. THE ONLY WRITE is `pmos jira sync`, and `pmos people record` once at the end (step 5). Never edit a repository file. Never run `pmos item`. Never write a ledger by hand. Never commit; the PM's Sync carries the files.
-3. LIGHT ON CONTENT. Ask Jira only for these fields: summary, status, the sprint field, subtasks, the Flagged field, and the display names of the assignee and the reporter. Never ask for or copy a description, a comment, an attachment, an email address, any other detail of a person, or a token.
+3. LIGHT ON CONTENT. Ask Jira only for these fields: summary, status, the sprint field, subtasks, the Flagged field, the story points field, the resolution date, and the display names of the assignee and the reporter. Never ask for or copy a description, a comment, an attachment, an email address, any other detail of a person, or a token.
 4. TEMPORARY FILES OUTSIDE THE REPOSITORY. Save each search result in this session's scratch folder, never in the repository, and delete it after the sync.
 5. NOTHING INVENTED. Give `pmos jira sync` exactly what Jira returned. If Jira cannot be reached, list the initiative under "Not reached" and write nothing for it.
 
 Procedure:
 1. If the task names one initiative ("This check: initiative …"), check that one only: run `pmos jira query <initiative>`. Otherwise run `pmos jira query`: each line is an initiative id, a tab and the Jira search (JQL) to run for it. If no initiative has a ticket in Jira, say so in one line and stop.
-2. For each initiative, run its search with the Jira search tool and the fields in rule 3. The sprint is usually a custom field named "Sprint" (often `customfield_10020`); ask for it by name. Fetch every page.
+2. For each initiative, run its search with the Jira search tool and the fields in rule 3. The sprint is usually a custom field named "Sprint" (often `customfield_10020`); ask for it by name. Story points are also a custom field, named "Story Points" or "Story point estimate" (often `customfield_10016`); ask for it by name. Fetch every page.
 3. Save the result as JSON in the scratch folder, for example `<scratch>/jira-<initiative>.json`, as a list with one object per issue:
-   `{"key", "summary", "status", "category", "sprint", "subtasks", "flagged", "reason", "url"}`
+   `{"key", "summary", "status", "category", "sprint", "subtasks", "points", "resolved", "flagged", "reason", "url"}`
    - `category`: the status category, `new`, `indeterminate` or `done`.
-   - `sprint`: `{"name": "Sprint 42", "state": "active"}` for the active sprint, `"future"` for a planned one, or `null` when the issue is in the backlog.
+   - `sprint`: `{"id": "42", "name": "Sprint 42", "state": "active", "start": "2026-10-01", "end": "2026-10-14"}` for the active sprint, `"future"` for a planned one, or `null` when the issue is in the backlog. Copy `id`, `start`, `end` and `completed` (a closed sprint's completion date) from Jira's sprint field; leave out any that Jira does not give.
+   - `points`: the story points as a number, or `null` when none are set.
+   - `resolved`: the resolution date as `YYYY-MM-DD`, or `null` when the issue is not resolved.
    - `subtasks`: `{"done": 2, "total": 5}`.
    - `flagged`: `true` when the issue is flagged; `reason`: the flag's comment or the blocking status, in a few words.
    - `url`: the issue's browse link, `https://<site>.atlassian.net/browse/<KEY>`.

package/workspace/skills/morning-brief.skill

@@ -17,7 +17,7 @@ output:
 
 Rules that always hold:
 1. READ-ONLY on every source. Never send, reply, forward, post, react, comment, create, edit, accept, decline, transition, label, archive, mark read or delete anything in mail, Slack, Jira, Confluence, GitHub, Drive, Figma, a website, calendar, Wispr Flow or any other source.
-2. SETTINGS DECIDE THE SOURCES AND THE SCOPES. Run `pmos proactive settings`. Read a source only if its line under "brief sources" says on. A source that is off is reported as "off". Mail is off unless the PM turned it on. The same command lists the websites and, for Slack, Jira and Confluence, the scope of each channel, project and space (see step 2).
+2. SETTINGS DECIDE THE SOURCES AND THE SCOPES. Run `pmos proactive settings`. Read a source only if its line under "brief sources" says on. A source that is off is reported as "off". Mail is off unless the PM turned it on. When the same command prints "about the PM" and "job description", use the PM's role, work and job description to judge what matters to them and to word why an item is theirs. Never copy that text into the brief. The same command lists the websites and, for Slack, Jira and Confluence, the scope of each channel, project and space (see step 2).
 3. LIGHT ON CONTENT. Never copy a message body, an attachment, a token or a credential. Write what a message says in your own words, in the limits of the field. Skip anything marked private, personal, confidential or HR. At most one short evidence line per item.
 4. NOTHING INVENTED. A source you cannot reach in this session is reported as "not-reached". If nothing is waiting, submit a brief with no items. An honest short brief is correct.
 5. THE ONLY WRITE is `pmos proactive brief submit`, with one exception: when `pmos people settings` prints `calendar names: on`, step 6 records who attends the PM's meetings with `pmos people record`. When it prints `calendar names: off`, record nobody from the calendar and leave "with" out of the memory events. Do not edit repository files and do not commit.

package/workspace/test-files.json

@@ -8,6 +8,7 @@
     "test.js"
   ],
   "modules": [
+    "stage-tools.test.js",
     "report-template-cadence.test.js",
     "proactive.test.js",
     "goals.test.js",
@@ -26,6 +27,7 @@
     "jobs-to-be-done.test.js",
     "pm-items-routes.test.js",
     "work-focus.test.js",
+    "work-evidence.test.js",
     "brief-page.test.js",
     "item-steps.test.js",
     "status-facts-panel.test.js",
@@ -65,7 +67,9 @@
     "glossary.test.js",
     "c3-daypart.test.js",
     "briefing-icons.test.js",
-    "needs-overdue.test.js"
+    "needs-overdue.test.js",
+    "briefing-scope.test.js",
+    "settings-store.test.js"
   ],
   "panels": [
     "pm-shell-test.js",
@@ -119,13 +123,15 @@
     "pm-live-notes-test.js",
     "pm-notes-menu-test.js",
     "pm-record-control-test.js",
+    "pm-c3-record-test.js",
     "pm-r30-test.js",
     "pm-breakdown-test.js",
     "pm-breakdown-phone-test.js",
     "first-paint-count.test.js",
     "pm-card-layout-test.js",
     "pm-portfolio-inline-test.js",
-    "pm-brief-page-test.js"
+    "pm-brief-page-test.js",
+    "c3-settings-test.js"
   ],
   "ui": [
     "ui-test.js"
@@ -149,6 +155,7 @@
     "jobs-to-be-done.test.js": 1,
     "pm-items-routes.test.js": 1,
     "work-focus.test.js": 1,
+    "work-evidence.test.js": 1,
     "brief-page.test.js": 1,
     "pm-brief-page-test.js": 30,
     "item-steps.test.js": 1,
@@ -234,6 +241,7 @@
     "pm-live-notes-test.js": 24,
     "pm-notes-menu-test.js": 10,
     "pm-record-control-test.js": 12,
+    "pm-c3-record-test.js": 12,
     "pm-r30-test.js": 4,
     "ui-test.js": 30,
     "plan-items.test.js": 1,
@@ -247,8 +255,11 @@
     "c3-daypart.test.js": 1,
     "briefing-icons.test.js": 1,
     "needs-overdue.test.js": 1,
+    "briefing-scope.test.js": 1,
     "pm-card-layout-test.js": 20,
-    "pm-portfolio-inline-test.js": 15
+    "pm-portfolio-inline-test.js": 15,
+    "settings-store.test.js": 1,
+    "c3-settings-test.js": 25
   },
   "_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."
 }

package/workspace/test-lists/c3-ib-items.json

@@ -0,0 +1,9 @@
+{
+  "_comment": "c3-ib-items: the Backlog, Board and Timeline tabs of a board on the console3 Initiatives page (Jira items and PMOS tasks mixed, shared filters, reschedule), in demo mode (browser).",
+  "panels": [
+    "c3-ib-items-test.js"
+  ],
+  "seconds": {
+    "c3-ib-items-test.js": 25
+  }
+}

package/workspace/test-lists/c3-ib-more.json

@@ -0,0 +1,9 @@
+{
+  "_comment": "c3-ib-more: the Releases, Docs and Sprints tabs of a board, the six tabs of an initiative and the stage records on its Overview (problem, RICE, launch, kill, learnings, burndown; quiet on a 404) on the console3 Initiatives page, in demo mode (browser).",
+  "panels": [
+    "c3-ib-more-test.js"
+  ],
+  "seconds": {
+    "c3-ib-more-test.js": 25
+  }
+}

package/workspace/test-lists/c3-ib-triage-backlog.json

@@ -0,0 +1,9 @@
+{
+  "_comment": "c3-ib-triage-backlog: the Triage and Backlog tabs of a board on the console3 Initiatives page, in demo mode (browser), with the B2 timings.",
+  "panels": [
+    "c3-ib-triage-backlog-test.js"
+  ],
+  "seconds": {
+    "c3-ib-triage-backlog-test.js": 20
+  }
+}

package/workspace/test-lists/c3-initiative-boards.json

@@ -0,0 +1,6 @@
+{
+  "_comment": "c3-initiative-boards: the pure board model (scripts/boards.js), the /api/boards routes on a scratch server with synthetic repositories, and the console3 Initiatives page (Portfolio, Board, Initiative, workflow editor) in demo mode (browser).",
+  "modules": ["boards-model.test.js", "routes-boards.test.js"],
+  "panels": ["c3-initiatives-test.js"],
+  "seconds": { "boards-model.test.js": 1, "routes-boards.test.js": 6, "c3-initiatives-test.js": 12 }
+}

package/workspace/test-lists/calendar-tidy-up.json

@@ -0,0 +1,6 @@
+{
+  "_comment": "Initiative calendar-tidy-up: GET /api/calendar-views tidy-up suggestions (rules in code, read only) and the Calendar page's Tidy-up chip and panel. Demo fixture /c3.html?demo=1.",
+  "modules": ["calendar-tidy.test.js"],
+  "panels": ["pm-calendar-tidy-test.js"],
+  "seconds": { "calendar-tidy.test.js": 2, "pm-calendar-tidy-test.js": 30 }
+}

package/workspace/test-lists/console3-briefing.json

@@ -0,0 +1,9 @@
+{
+  "_comment": "Initiative console3-briefing-parity: the Briefing page browser suite.",
+  "panels": [
+    "c3-briefing-test.js"
+  ],
+  "seconds": {
+    "c3-briefing-test.js": 40
+  }
+}

package/workspace/test-lists/console3-foundation.json

@@ -0,0 +1,9 @@
+{
+  "_comment": "Initiative console3-foundation: the shell foundation browser suite.",
+  "panels": [
+    "c3-foundation-test.js"
+  ],
+  "seconds": {
+    "c3-foundation-test.js": 40
+  }
+}

package/workspace/test-lists/console3-reports.json

@@ -1,6 +1,6 @@
 {
-  "_comment": "console3 Reports dashboards: the server half (library, defaults, scope filter, layout store, page-press layout route) and the browser suite (scopes, edit, share, library, Drafts tab).",
-  "modules": ["report-dashboards.test.js"],
+  "_comment": "console3 Reports dashboards: the server half (library, defaults, scope filter, layout store, page-press layout route), the outbox discard route Drafts uses, and the browser suite (scopes, edit, share, library, Drafts tab).",
+  "modules": ["report-dashboards.test.js", "outbox-discard.test.js"],
   "panels": ["c3-reports-test.js"],
-  "seconds": { "report-dashboards.test.js": 3, "c3-reports-test.js": 30 }
+  "seconds": { "report-dashboards.test.js": 3, "outbox-discard.test.js": 2, "c3-reports-test.js": 30 }
 }

package/workspace/test-lists/meeting-notes.json

@@ -1,5 +1,5 @@
 {
-  "_comment": "meeting-notes Runs 1 to 10: the Notes engine and routes (notes.test.js), local Whisper, line labels and repository checks (notes-listen.test.js), the final pass after Stop and the Wispr Flow fetch (notes-final.test.js), Qwen3-ASR kept loaded (notes-qwen.test.js), and the Notes view in a browser (pm-notes-test.js), the echo canceller for the replay (notes-echo.test.js, notes-audio-quality Run 2) and the optional cleaned copy of the replay (notes-polish.test.js, Run 3) and the 24 kHz replay (notes-hires.test.js, Run 4), plus the note pop-up patched in place while it listens (pm-note-dock-test.js).",
+  "_comment": "meeting-notes Runs 1 to 10: the Notes engine and routes (notes.test.js), local Whisper, line labels and repository checks (notes-listen.test.js), the final pass after Stop and the Wispr Flow fetch (notes-final.test.js), Qwen3-ASR kept loaded (notes-qwen.test.js), and the Notes view in a browser (pm-notes-test.js), the echo canceller for the replay (notes-echo.test.js, notes-audio-quality Run 2) and the optional cleaned copy of the replay (notes-polish.test.js, Run 3) and the 24 kHz replay (notes-hires.test.js, Run 4), plus the note pop-up patched in place while it listens (pm-note-dock-test.js). notes-recording-reliability adds the duplication fixture (notes-duplication.test.js): duplicated audio and transcript across retry, restart, two tabs and a late chunk, and the live guards. notes-screen-capture adds the screenshots a note keeps of the shared screen (notes-screen.test.js): who may leave a shot, which pictures, listing and serving, deleting, and the optional on-screen text. notes-live-settle adds the replay of a kept meeting and its report (notes-replay.test.js): lines said twice, the live lines' lag, and the settle tier's busy share. notes-screen-capture also adds the screenshots of the shared screen in a browser (pm-notes-screen-test.js).",
   "modules": [
     "notes.test.js",
     "notes-listen.test.js",
@@ -7,11 +7,15 @@
     "notes-qwen.test.js",
     "notes-echo.test.js",
     "notes-polish.test.js",
-    "notes-hires.test.js"
+    "notes-hires.test.js",
+    "notes-duplication.test.js",
+    "notes-screen.test.js",
+    "notes-replay.test.js"
   ],
   "panels": [
     "pm-notes-test.js",
-    "pm-note-dock-test.js"
+    "pm-note-dock-test.js",
+    "pm-notes-screen-test.js"
   ],
   "seconds": {
     "notes.test.js": 12,
@@ -22,6 +26,10 @@
     "pm-note-dock-test.js": 20,
     "notes-echo.test.js": 25,
     "notes-polish.test.js": 3,
-    "notes-hires.test.js": 10
+    "notes-hires.test.js": 10,
+    "notes-duplication.test.js": 25,
+    "pm-notes-screen-test.js": 60,
+    "notes-screen.test.js": 6,
+    "notes-replay.test.js": 20
   }
 }

package/workspace/test-lists/workspace-headless-jobs.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "Initiative workspace-headless-jobs: background agent jobs run as `claude -p` with no terminal pane (lib/headless.js and spawnSession's headless path), against a stub claude.",
+  "modules": ["headless.test.js"],
+  "seconds": { "headless.test.js": 12 }
+}

package/workspace/test-lists/workspace-package-script-closure.json

@@ -0,0 +1,6 @@
+{
+  "_comment": "workspace-package-script-closure: the built create-pmos package, unpacked, loads every route module, runs pmos calendar status and reads facts with no repo scripts/ beside it.",
+  "modules": ["package-closure.test.js"],
+  "panels": [],
+  "seconds": { "package-closure.test.js": 60 }
+}

package/workspace/lib/vendor/workspace/lib/actor.js

@@ -1,91 +0,0 @@
-'use strict';
-/* actor.js — who a write is, read from the CALL PATH, never from a field (pm-os-absorb, PRD R23 and R25).
- *
- *   fromUi()              → { by: 'pm:wawan', via: 'ui' }      the page, after the route's own checks
- *   fromCli({isTTY, env}) → { by, via: 'cli' }                 a bound agent session, else a terminal (the PM), else unknown
- *   isPm(actor) · isAgent(actor) · sessionOf(actor)
- *   pageName(by)          → 'agent:sess-<n>' for 'agent:sess-<n>.<8hex>', else `by` unchanged
- *
- * F5: a ledger line's `by` carries the session token; the page must never see it. Every GET route and every needs
- * provider maps each `by` it answers through pageName (proposals, moves, item owners, report attributions).
- *
- * The placements, measurements and issues writers take their actor from here, so the four ledgers attribute one way.
- * A caller never passes `by` or `via`: a writer that accepted them would make attribution something a caller chooses.
- *
- * THE SESSION-TOKEN MAP (Run 2, slice 2A). server.js gives each agent session a token, `sess-<n>.<8 hex>`, in its PTY
- * environment as PMOS_SESSION. The token itself is never written to disk or sent to the page (D08, F5). server.js
- * persists its SHA-256 (`tokenHash`) in the session's own meta file, so after a restart the map still answers which
- * session a token belongs to and which initiative that session is bound to. The map is read from the files each time
- * (no cache, D33), so a CLI with no server reads the same answer as the server.
- *
- *   tokenHash(token)                       → 64 hex characters, or null for a value that is not a token
- *   sessionForToken(token, { sessDir })    → { session, initiative } | null
- *
- * HONEST LIMIT. A token is an attribution, not a credential: a process that unsets PMOS_SESSION is no longer an agent
- * to fromCli. pm-guard.js requirePmCli asks such a caller to type the id of a PM-only act (X12); CI detection is the
- * backstop for the rest.
- */
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-
-const PM_SLUG = 'wawan';
-const SESSION_RE = /^sess-\d+\.[0-9a-f]{8}$/;
-const BY_RE = /^(?:pm:[a-z0-9_-]{1,40}|agent:unknown|agent:sess-\d+\.[0-9a-f]{8})$/;
-const VIA = ['ui', 'cli'];
-
-const PM = Object.freeze({ by: `pm:${PM_SLUG}`, via: 'ui' });
-
-/** The page. Call it only after the route has run its checks (pm-guard.js requirePmPress for a PM-only act). */
-function fromUi() { return { by: PM.by, via: 'ui' }; }
-
-/**
- * A `pmos <verb>` call. A bound agent session FIRST, by its token: an agent that runs its commands in a PTY (or wraps
- * them with `script`) still has a terminal, and a terminal must not turn its writes into the PM's. Only agent sessions
- * get PMOS_SESSION (server.js spawnSession), so the PM's own shell is a terminal with no token: the PM. Else unknown.
- */
-function fromCli({ isTTY = !!(process.stdin.isTTY && process.stdout.isTTY), env = process.env } = {}) {
-  const tok = env && env.PMOS_SESSION;
-  if (typeof tok === 'string' && SESSION_RE.test(tok)) return { by: `agent:${tok}`, via: 'cli' };
-  if (isTTY) return { by: `pm:${PM_SLUG}`, via: 'cli' };
-  return { by: 'agent:unknown', via: 'cli' };
-}
-
-const valid = (a) => !!a && typeof a.by === 'string' && BY_RE.test(a.by) && VIA.includes(a.via);
-const isPm = (a) => valid(a) && a.by.startsWith('pm:');
-const isAgent = (a) => valid(a) && a.by.startsWith('agent:');
-/** The session token of an agent actor, or null. */
-const sessionOf = (a) => (isAgent(a) && a.by !== 'agent:unknown' ? a.by.slice('agent:'.length) : null);
-
-/** The name the page may show. Strips the session token's secret suffix; anything else passes through. */
-function pageName(by) {
-  if (typeof by !== 'string') return by;
-  const m = /^(agent:sess-\d+)\.[0-9a-f]{8}$/.exec(by);
-  return m ? m[1] : by;
-}
-
-/** The SHA-256 of a session token. The map stores this, never the token. */
-function tokenHash(token) {
-  if (typeof token !== 'string' || !SESSION_RE.test(token)) return null;
-  return crypto.createHash('sha256').update(token).digest('hex');
-}
-
-/**
- * The session a token belongs to, read from the session meta files server.js persists (`<sessDir>/<id>.json`). The id
- * part of the token names the file, and the stored hash must match: a token with the right id and a wrong suffix is not
- * that session. Null when there is no such session or no hash on record. `plan_item` is the item Hand to agent gave the
- * session (null for any other session).
- */
-function sessionForToken(token, { sessDir } = {}) {
-  const h = tokenHash(token);
-  if (!h || typeof sessDir !== 'string' || !sessDir) return null;
-  const id = token.slice(0, token.indexOf('.'));
-  let meta;
-  try { meta = JSON.parse(fs.readFileSync(path.join(sessDir, id + '.json'), 'utf8')); } catch { return null; }
-  if (!meta || meta.id !== id || typeof meta.tokenHash !== 'string' || meta.tokenHash.length !== h.length) return null;
-  if (!crypto.timingSafeEqual(Buffer.from(meta.tokenHash), Buffer.from(h))) return null;
-  const str = (v) => (typeof v === 'string' && v ? v : null);
-  return { session: id, initiative: str(meta.initiative), plan_item: str(meta.plan_item) };
-}
-
-module.exports = { tokenHash, sessionForToken, PM_SLUG, SESSION_RE, BY_RE, VIA, fromUi, fromCli, valid, isPm, isAgent, sessionOf, pageName };