create-pmos 0.194.0 → 0.196.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.194.0",
+  "version": "0.196.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@dcb0b7b
+kernel-source: pmos@7bac547
 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-13T08:20:29Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T09:00:15Z"}
 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-13T08:20:29Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T09:00:15Z"}
 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-13T08:20:29Z"}
+generated: {by: process:create-pmos, at: "2026-10-13T09:00:15Z"}
 status: stable
 ---
 

package/workspace/c3-core-docs-test.js

@@ -49,6 +49,24 @@ const { harness } = require('./c3-ini-harness');
   ok('R3 Issue it says nothing was sent and closes the sheet', await until(async () => /Issued\. Nothing was sent/.test(await toast()) && !(await sheetOpen())));
   ok('R4 the row is up to date and the draft is gone from the waiting list', await until(async () => (await rowState('invest')) === 'ok' && (await st(() => document.querySelectorAll('[data-cd="drafts"] [data-cd-wait]').length)) === 1));
 
+  /* ── a next step on every row (PRD amendment 2026-10-13): the OKRs, the scan and the status report not started ── */
+  await st(() => Promise.all(['okrs', 'scan', 'status'].map((key) => fetch('/api/core-docs/drop', { method: 'POST', body: JSON.stringify({ scope: 'portfolio', key, slot: 'x' }) }))));
+  await page.click('[data-ini="pf-tabs"] [data-ini-tab="overview"]');
+  await until(() => st(() => !!document.querySelector('[data-ini="boards"]')));
+  await page.click('[data-ini="pf-tabs"] [data-ini-tab="docs"]');
+  await settle('[data-cd-row="okrs"][data-cd-st="missing"]');
+  const btn = (sel) => st((x) => { const n = document.querySelector(x); return n ? n.textContent.trim() : ''; }, sel);
+  ok('X1 the OKRs offer Propose them, the scan Run a scan, the status report Set it up', (await btn('[data-cd-draft="okrs"]')) === 'Propose them' && (await btn('[data-cd-go="scan"]')) === 'Run a scan' && (await btn('[data-cd-go="status"]')) === 'Set it up');
+  await page.click('[data-cd-draft="okrs"]');
+  ok('X2 Propose them starts a draft of the OKRs', await waitToast(/PMOS is drafting the okrs and health budgets/));
+  ok('X3 the OKRs row shows "Agent drafting"', await until(async () => (await rowState('okrs')) === 'running'));
+  await page.click('[data-cd-go="scan"]');
+  ok('X4 Run a scan opens the Portfolio Overview, where Horizon scan lives', await until(() => st(() => !!document.querySelector('[data-ini="boards"]') && !document.querySelector('[data-cd="core"]'))));
+  await page.click('[data-ini="pf-tabs"] [data-ini-tab="docs"]');
+  await settle('[data-cd-go="status"]');
+  await page.click('[data-cd-go="status"]');
+  ok('X5 Set it up opens Reports', await until(() => st(() => { const t = document.querySelector('[data-c3-tab="rep"]'); return !!t && t.getAttribute('aria-selected') === 'true'; })));
+
   /* ── a board: IDPF ── */
   await open('board:idpf:docs');
   await settle('[data-cd="core"]');

package/workspace/guide/core-documents.md

@@ -29,11 +29,19 @@ Risks are written once, on the initiative. Board risks and cross-board risks col
 | Due | The cadence passed, or the current stage needs the document and it is not there. |
 | Draft ready | PMOS drafted it. It waits for you. |
 | Not started | Nothing is there, and the level needs it now. |
+| None yet | Nothing is there yet, and this fills as the work goes: the decision log, kill conditions, market and user context. |
 | Comes later | The initiative has not reached the stage that needs it. |
 | Stale | It was issued before a change it depends on: a stage move (initiative risks, launch checklist, status update), a newer risk list or outcome review (rolled-up documents), or a change to the board settings (board charter). |
 
 A row with no source and no document is "Not started" and has no date. PMOS does not guess a date or a warning.
 
+A row that is not started always has a next step:
+
+- **Draft it**: PMOS drafts a document it keeps itself.
+- **Propose them** (OKRs and health budgets): with no OKR files, PMOS drafts proposed key results and health budgets for you to review and issue. Once OKR files exist, they are the source.
+- **Run a scan** (Horizon scan reports): opens the Portfolio Overview at Horizon scan, where Scan now is.
+- **Set it up** (status reports): opens Reports, where you set up the report.
+
 ## How PMOS drafts a document
 
 - **When you ask.** Press **Draft it** on a row, or **Ask PMOS to change it** on a draft. PMOS starts one background run. The run reads the sources of that document and writes one draft. It has no tool that sends, posts or edits.

package/workspace/guide/initiative-boards.md

@@ -105,9 +105,10 @@ Each level has a set of core documents. A level answers one question for one rea
 - **Board:** the **Docs** tab starts with the core documents. The sprint review and the release notes show only when Build and deliver is on. The documents linked to the board follow under **Other documents**.
 - **Initiative:** the **Docs** tab has one section for each of Discover, Plan, Do and Learn. The current section lists its documents. A finished section, or one not reached yet, folds to one line.
 
-Each row shows what the document is for, its state, how often it changes, who reads it and who writes it. The states are Up to date, Due, Draft ready, Not started, Out of date and Comes later. Press a row to open the document, the tab, the stage tool or Reports that holds it.
+Each row shows what the document is for, its state, how often it changes, who reads it and who writes it. The states are Up to date, Due, Draft ready, Not started, None yet, Out of date and Comes later. Press a row to open the document, the tab, the stage tool or Reports that holds it.
 
 - **Draft it:** on a document that is not started, PMOS drafts it. The row shows "Agent drafting" until the draft is ready.
+- **Propose them, Run a scan, Set it up:** a row read from its own source offers the step that makes that source: OKRs are proposed as a draft, Horizon scan opens Scan now, and a status report opens Reports.
 - **Review the draft:** opens the draft in the document sheet. Above the draft, **Issue it** makes the draft the current document. **Ask PMOS to change it** asks for a new draft. PMOS sends nothing to anyone.
 - The Briefing shows one row for each level that has drafts waiting. Press the row to open that Docs view.
 

package/workspace/lib/core-docs.js

@@ -46,11 +46,11 @@ const LEVEL = Object.freeze({
   initiative: Object.freeze({ question: 'What are we building, why, and did it work?', reader: 'the PM, the builders and the reviewers', rhythm: 'at each stage' }),
 });
 
-const e = (level, o) => Object.freeze({ level, reader: null, cadence: null, build: false, cat: null, isNew: false, days: null, rollup: null, tool: null, ...o });
+const e = (level, o) => Object.freeze({ level, reader: null, cadence: null, build: false, cat: null, isNew: false, days: null, rollup: null, tool: null, store: false, ...o });
 const SETS = Object.freeze({
   portfolio: Object.freeze([
     e('portfolio', { key: 'strategy', title: 'Product strategy', ic: 'target', for: 'Vision, where we play and what we will not do. Every board and key result traces to it.', reader: 'Leadership, every PM', cadence: 'Yearly, reviewed each quarter', by: 'you', kind: 'doc', days: 91, isNew: true }),
-    e('portfolio', { key: 'okrs', title: 'OKRs and health budgets', ic: 'flag', for: 'The key results initiatives anchor to, and the budgets maintenance work runs on.', reader: 'Leadership, PMs', cadence: 'Quarterly', by: 'proposes', kind: 'derived' }),
+    e('portfolio', { key: 'okrs', title: 'OKRs and health budgets', ic: 'flag', for: 'The key results initiatives anchor to, and the budgets maintenance work runs on.', reader: 'Leadership, PMs', cadence: 'Quarterly', by: 'proposes', kind: 'derived', store: true, days: 91 }),
     e('portfolio', { key: 'roadmap', title: 'Portfolio roadmap', ic: 'cal', for: 'Bets by quarter (Now, Next, Later) and the key result each serves. A sendable copy of the Roadmap.', reader: 'Leadership, stakeholders', cadence: 'Monthly', by: 'drafts', kind: 'doc', days: 30 }),
     e('portfolio', { key: 'invest', title: 'Investment mix', ic: 'cols', for: 'Where the effort goes: by board, by key result, and feature work against upkeep.', reader: 'Leadership', cadence: 'Quarterly', by: 'drafts', kind: 'doc', days: 91, isNew: true }),
     e('portfolio', { key: 'scan', title: 'Horizon scan reports', ic: 'search', for: 'Benchmark, competitive, insight and productivity reports, each with proposals.', reader: 'PMs, leadership', cadence: 'Weekly scan', by: 'drafts', kind: 'derived' }),
@@ -120,6 +120,10 @@ const levelOfScope = (scope) => { const p = parseScope(scope); return p ? p.leve
 const scopeDir = (scope) => String(scope).replace(':', '-');
 /** A doc entry PMOS may draft: kind doc, and not one the PM writes. */
 const draftable = (entry) => !!entry && entry.kind === 'doc' && entry.by !== 'you';
+/** A derived entry with `store` (the OKRs) is read from its own source, and PMOS may propose it as a core document while that source is absent. */
+const storable = (entry) => !!entry && (entry.kind === 'doc' || !!entry.store);
+/** A derived entry that fills as the work goes: with no source yet it is "none", not missing (portfolio and board only). */
+const FILLS = Object.freeze(['files', 'watches', 'keeps']);
 
 /** The entries of one level. `build`: the board has Build and deliver; `wfTpl`: the initiative's workflow template; `has(key)`: the
  * initiative already has that document (a build-only entry it has stays). */
@@ -189,6 +193,8 @@ function sourceState(entry, facts) {
     return { ...out, st: 'ok', when, due: src.next || null, open };
   }
   // derived
+  if (!src && entry.store) return docState(entry, facts);
+  if (!src && entry.level !== 'initiative' && FILLS.includes(entry.by)) return { ...out, st: 'none' };
   if (!src) return { ...out, st: absent(entry, facts), open: entry.tool && entry.level === 'initiative' && catState(entry, facts) !== 'later' ? { tool: entry.tool } : null };
   const res = { ...out, st: src.st || 'ok', when: src.when || null, due: src.due || null, flag: src.flag || null, open: src.open || null };
   if (entry.level === 'initiative' && STALE_ON_MOVE.includes(entry.key) && src.atMs != null && facts.movedAt != null && facts.movedAt > src.atMs) {
@@ -254,7 +260,7 @@ function checkEntry(scope, key) {
   if (!p) return refuse(400, 'scope must be portfolio, board:<id> or initiative:<id>');
   const entry = entryOf(p.level, key);
   if (!entry) return refuse(400, `key must be one of ${SETS[p.level].map((x) => x.key).join(', ')} for the ${p.level} level`);
-  if (entry.kind !== 'doc') return refuse(400, `${entry.title} is not a document PMOS keeps here: it is read from its own source`);
+  if (!storable(entry)) return refuse(400, `${entry.title} is not a document PMOS keeps here: it is read from its own source`);
   return { ok: true, entry, level: p.level, id: p.id };
 }
 const scopeLabel = (scope, label) => { const p = parseScope(scope); return !p ? String(scope) : p.level === 'portfolio' ? 'Portfolio' : (label || p.id); };
@@ -562,6 +568,17 @@ function gather(ctx, w, { level, board: boardId, id, now = Date.now() } = {}) {
   return { ok: true, facts: { level, scope: `initiative:${id}`, now, store, row, board: { id: board.id, name: board.name, build: !!board.build }, list } };
 }
 
+/** The next step of a row that is not started: draft it, propose it, or go where its source is made. Null otherwise. */
+function actOf(entry, st) {
+  if (st === 'stale' && draftable(entry)) return { label: 'Draft it', do: 'draft' };
+  if (st !== 'missing') return null;
+  if (draftable(entry)) return { label: 'Draft it', do: 'draft' };
+  if (entry.store && entry.by !== 'you') return { label: 'Propose them', do: 'draft' };
+  if (entry.key === 'scan') return { label: 'Run a scan', go: 'scan' };
+  if (entry.kind === 'report' && entry.level !== 'initiative') return { label: 'Set it up', go: 'reports' };
+  return null;
+}
+
 /** The GET body. `running(scope, key)` → true while a core-doc run drafts that entry. */
 function answer(facts, { running = () => false } = {}) {
   const L = LEVEL[facts.level];
@@ -569,7 +586,7 @@ function answer(facts, { running = () => false } = {}) {
   const docs = list.map(({ entry: x, st, when, due, flag, staleWhy, open, draft }) => ({
     key: x.key, title: x.title, ic: x.ic, for: x.for, reader: x.reader, cadence: x.cadence, by: x.by, kind: x.kind, cat: x.cat, isNew: !!x.isNew,
     st, when: when || null, due: due || null, flag: flag || null, staleWhy: staleWhy || null, open: open || null, draft: draft || null,
-    running: !!running(facts.scope, x.key),
+    act: actOf(x, st), running: !!running(facts.scope, x.key),
   }));
   const ini = facts.level === 'initiative';
   return {
@@ -628,6 +645,8 @@ const GUIDE = Object.freeze({
     sections: ['Headline (points committed and finished, as a percentage)', 'Finished', 'Carried over (a table: Item, Points, Why)', 'For the next sprint'] },
   retro: { sources: ['The learnings of the closed initiatives on this board (the stage tools)', 'Their issued outcome reviews: <state>/core-docs/initiative-<id>/outcome/', 'The issued sprint reviews: <state>/core-docs/board-<id>/sprint/'],
     sections: ['Patterns (each with the initiatives it comes from)', 'Keep, change, try (a table)'] },
+  okrs: { sources: ['The product strategy, if one is issued: <state>/core-docs/portfolio/strategy/', 'The boards and their initiatives with their anchors (`pmos board`)', 'planning/okrs/health-budgets.md, if any', 'The KR metric records and their readings (planning/records/kr-metrics.jsonl, `pmos measure`), if any'],
+    sections: ['A short line: these are proposals for the PM to change, keep or drop', 'Objectives, each with two to four key results (a table: Key result, Metric, Now, Target, Initiatives that serve it); write "not known" where no reading exists', 'Health budgets for upkeep work (a table: Budget, What it covers, Limit)', 'Initiatives with no key result to anchor to, if any'] },
   risks: { sources: ['The initiative record and every file it names (PRD, design, rubric)', 'The Jira snapshot of the initiative, if any (blocked and late tickets)', 'Meeting notes and requirement notes that name the initiative'],
     sections: ['A table: Risk, Impact (High, Medium, Low), Likelihood, Next step, Owner, Since', 'Waits on other boards, if any'] },
   outcome: { sources: ['The key result readings since the release (`pmos measure` records)', 'The release that shipped it (the releases ledger)', 'The initiative bet, its kill conditions and its learnings (the stage tools)', 'Support tickets and notes that name it, if any'],
@@ -669,7 +688,7 @@ function runPrompt(entry, scope, { today, label } = {}) {
 
 module.exports = {
   LEDGER, DIR, LEVELS, LEVEL, SETS, CATS, KINDS, EVENTS, BY, RESEARCH_KEEP, BUILD_ONLY_INI, STALE_ON_MOVE, ID_RE, SLOT_RE, GUIDE,
-  entryOf, parseScope, levelOfScope, scopeDir, scopeLabel, draftable, setFor, stateOf, summaryOf, localDay, addDays,
+  entryOf, parseScope, levelOfScope, scopeDir, scopeLabel, draftable, storable, actOf, FILLS, setFor, stateOf, summaryOf, localDay, addDays,
   ledgerFile, readLines, append, fold, storeOf, checkEntry, writeDraft, issue, drop, frontmatterOf,
   gather, answer, initiativeDocs, initiativeSet, driverLists, runPrompt,
 };

package/workspace/lib/coredoc-cli.js

@@ -22,7 +22,7 @@ const USAGE = [
   'usage: pmos coredoc write — the core documents of a portfolio, a board or an initiative',
   '  pmos coredoc write --scope <portfolio|board:<id>|initiative:<id>> --key <key> --file <path|->',
   '      Write ONE draft of a core document (the markdown from the file, or standard input with -). It waits for the PM, who issues it.',
-  '      Keys: ' + CD.LEVELS.map((l) => `${l}: ${CD.SETS[l].filter((x) => x.kind === 'doc').map((x) => x.key).join(', ')}`).join(' · '),
+  '      Keys: ' + CD.LEVELS.map((l) => `${l}: ${CD.SETS[l].filter(CD.storable).map((x) => x.key).join(', ')}`).join(' · '),
   '  every command: [--json] [--root <dir>]. Nothing is sent.',
 ];
 const BOOL = new Set(['json', 'help']);

package/workspace/lib/notes-final.js

@@ -5,7 +5,7 @@
  *   setupCommand(runtimeDir)    → the shell commands the PM runs once for the better engine, speech detection and speakers
  *   createFinal({ runtimeDir, onDone, onState, run?, detect?, qwen? }) → { queue(id, opts), cancel(id), state(id), idle() }
  *   parseWhisper(json) · parseParakeet(json) · splitAtPauses(pcm) · assignSpeakers(segs, diar) · dropEcho(mic, meeting)
- *   mergeSources(parts)
+ *   mergeSources(parts) · dropSilent(segments, pcm)
  *   transcribeClip(runtimeDir, pcm, { prompt }) → { ok, engine, segments }   one stretch through the same engine (notes-live-settle)
  *
  * WHY. The live transcript is cut every few seconds so that lines appear while people talk. A cut that short gives Whisper
@@ -26,7 +26,8 @@
  *      speakers: Speaker 1, Speaker 2 and so on. The microphone is the PM. In a room with one microphone and no meeting
  *      audio, the microphone is split instead.
  *   4. The sources are merged in time order. A microphone line that repeats a meeting line said at the same moment is the
- *      meeting heard through the PM's speakers, and is dropped.
+ *      meeting heard through the PM's speakers, and is dropped. A line with no speech under it, and a short line said again
+ *      and again in one source, are the engine writing on quiet audio, and are dropped too (dropSilent, notes-live-guard dropLoops).
  * The result goes to `onDone(id, final)`; lib/routes-notes.js stores it on the note and then asks the PM's agent session for
  * the notes. One job runs at a time, so the model and the speaker separation never share the memory of an 8 GB machine.
  *
@@ -41,6 +42,7 @@ const { execFile } = require('child_process');
 const whisper = require('./notes-whisper.js');
 const notesAudio = require('./notes-audio.js');
 const notesQwen = require('./notes-qwen.js');
+const liveGuard = require('./notes-live-guard.js');
 
 const RUN_TIMEOUT_MS = 45 * 60 * 1000;
 const PARAKEET_MODEL = 'mlx-community/parakeet-tdt-0.6b-v2';
@@ -130,15 +132,19 @@ function parseParakeet(json) {
 /** The pieces Qwen3-ASR transcribes one at a time: [{ start, end }] in ms. A piece ends at a pause of PIECE_PAUSE_MS once it
  * is PIECE_MIN_MS long, or at its quietest frame between PIECE_MIN_MS and PIECE_MAX_MS. Quiet at either end is left out,
  * and a piece with less than PIECE_MIN_VOICED_MS of speech is dropped. */
-function splitAtPauses(pcm, rate = whisper.RATE) {
+/** The loudness of each 100 ms frame and whether it is speech. A frame is speech above three times the room's quiet (the 10th
+ * percentile), but never above a third of the loud frames (the 90th), so a recording that is speech from end to end still has
+ * its pauses. */
+function voicedFrames(pcm, rate = whisper.RATE) {
   const lv = whisper.levels(pcm, rate);
-  const F = 100;
-  // a frame is speech above three times the room's quiet (the 10th percentile), but never above a third of the loud frames
-  // (the 90th), so a recording that is speech from end to end still has its pauses
   const sorted = lv.filter((v) => v > 0).sort((x, y) => x - y);
   const at = (q) => (sorted.length ? sorted[Math.floor((sorted.length - 1) * q)] : 0);
   const floor = Math.max(180, Math.min(at(0.1) * 3, at(0.9) * 0.3));
-  const voiced = lv.map((v) => v > floor);
+  return { lv, voiced: lv.map((v) => v > floor) };
+}
+function splitAtPauses(pcm, rate = whisper.RATE) {
+  const { lv, voiced } = voicedFrames(pcm, rate);
+  const F = 100;
   const out = [];
   let i = 0;
   while (i < lv.length) {
@@ -163,6 +169,24 @@ function splitAtPauses(pcm, rate = whisper.RATE) {
   return out;
 }
 
+/** The segments that have speech under them (notes-silence-loops). Whisper reads the whole file in 30-second windows, and on a
+ * window with nobody speaking it can still write a line, often the same one each time ("Off, Briefing." every half minute). A
+ * segment with less than PIECE_MIN_VOICED_MS of speech between its start and end (SEGMENT_SLACK_MS either side, as the
+ * engine's times are not exact) was said by nobody, and is dropped. A segment with no times is kept. */
+const SEGMENT_SLACK_MS = 500;
+function dropSilent(segments, pcm, rate = whisper.RATE) {
+  if (!pcm || !pcm.length) return segments || [];
+  const { voiced } = voicedFrames(pcm, rate);
+  const F = 100;
+  return (segments || []).filter((g) => {
+    if (!(g.end > g.start)) return true;
+    const a = Math.max(0, Math.floor((g.start - SEGMENT_SLACK_MS) / F)); const b = Math.min(voiced.length, Math.ceil((g.end + SEGMENT_SLACK_MS) / F));
+    if (a >= voiced.length) return true;     // past the end of the audio: the times are not this file's, so they say nothing
+    let v = 0; for (let k = a; k < b; k++) if (voiced[k]) v++;
+    return v * F >= PIECE_MIN_VOICED_MS;
+  });
+}
+
 /** Each segment gets the speaker who talks most during it. `diar`: [{ start, end, speaker }] in seconds. Speakers are
  * numbered in the order they first speak. → segments with `spk` (0, 1, …) and the number of speakers. */
 function assignSpeakers(segs, diar) {
@@ -208,7 +232,8 @@ function mergeSources(parts) {
   if (mic && meet) mic.segments = dropEcho(mic.segments, meet.segments);
   const out = [];
   for (const p of parts) {
-    for (const g of p.segments) {
+    // a short line said again and again in one source is the engine looping on quiet audio (notes-silence-loops)
+    for (const g of liveGuard.dropLoops(p.segments)) {
       const spk = p.speakers > 1 && g.spk !== null && g.spk !== undefined ? p.source + '-' + (g.spk + 1) : p.source;
       out.push({ t: g.start, end: g.end, text: g.text, source: p.source, spk });
     }
@@ -290,6 +315,8 @@ async function bestTranscript({ run, qwen }, d, pcmFile, wav, tmp, { prompt = ''
       : e === 'parakeet' ? await transcribeParakeet(run, d, wav, tmp) : await transcribeWhisper(run, d, wav, tmp, { lang: d.lang, prompt });
     if (r.ok) break;
   }
+  // Qwen3-ASR is given only the pieces with speech; Whisper and Parakeet read the whole file, quiet stretches included
+  if (r.ok && r.engine !== 'qwen') { try { r = { ...r, segments: dropSilent(r.segments, fs.readFileSync(pcmFile)) }; } catch { /* no samples to check */ } }
   return r;
 }
 /**
@@ -394,5 +421,5 @@ function createFinal({ runtimeDir, onDone, onState = () => {}, run = runProgram,
   };
 }
 
-module.exports = { detect, setupCommand, createFinal, transcribeClip, runProgram, parseWhisper, parseParakeet, splitAtPauses, assignSpeakers, dropEcho, mergeSources, finalDir,
+module.exports = { detect, setupCommand, createFinal, transcribeClip, runProgram, parseWhisper, parseParakeet, splitAtPauses, assignSpeakers, dropEcho, mergeSources, dropSilent, finalDir,
   PARAKEET_MODEL, VAD_FILE, DIARIZE_THRESHOLD };

package/workspace/lib/notes-live-guard.js

@@ -5,6 +5,8 @@
  *   repeats(text, previous) → true when a cut only says again what the line before it said
  *   onceEach(text) → the text with a sentence repeated back to back kept once
  *   looksForeign(text, reported) → true when a cut that should be English came back in another language
+ *   loopKey(text) → the key a short line is counted under for the loop guard, or '' when the line is never counted
+ *   dropLoops(lines) → the lines without the short lines said LOOP_TIMES times or more (Whisper's loop on quiet audio)
  *
  * ECHO. On speakers the remote voice also reaches the microphone, so the microphone's cut holds the meeting's words a second
  * time. lib/notes-final.js drops such lines after Stop (dropEcho); this is the same rule, live: a run of ECHO_RUN or more words
@@ -16,6 +18,12 @@
  * the previous line's words, or end it, adds nothing. A short reply ("Yes.") said again later is kept: a short line counts
  * as a repeat only within REPEAT_MS.
  *
+ * LOOPS (notes-silence-loops). On a long quiet stretch, or on a voice too far from the microphone to make out, Whisper writes
+ * the same short line again and again, often words from its --prompt: "Off, Briefing." every half minute for a quarter of an
+ * hour. The lines are far apart, so the repetition guard above does not see them. A short line (LOOP_MAX_WORDS words or fewer)
+ * that comes back word for word LOOP_TIMES times or more in one source of one note is such a loop, and every copy goes. Lines made
+ * only of backchannel words ("Yeah, yeah.", "Okay.", "Thank you.") are never counted: people do say those many times.
+ *
  * LANGUAGE (decision 8 of the console3 feedback plan: accented English is always English). A cut is foreign when the engine
  * says another language, when most of its letters are not Latin, or when most of its words are Indonesian function words.
  */
@@ -24,6 +32,13 @@ const ECHO_WORDS = 0.5;
 const ECHO_RUN = 4;
 const ECHO_SLACK_MS = 1500;
 const REPEAT_MS = 15000;
+const LOOP_MAX_WORDS = 8;
+const LOOP_TIMES = 3;
+// words people say many times in a meeting; a line made only of them is never taken for a loop
+const BACKCHANNEL = new Set(['yeah', 'yes', 'yep', 'yup', 'no', 'nope', 'ok', 'okay', 'right', 'sure', 'alright', 'thanks', 'thank', 'you',
+  'mm', 'mhm', 'hmm', 'uh', 'um', 'huh', 'oh', 'ah', 'so', 'and', 'but', 'well', 'i', 'see', 'got', 'it', 'good', 'great', 'cool', 'nice',
+  'exactly', 'true', 'correct', 'sorry', 'hi', 'hello', 'bye', 'agree', 'agreed', 'indeed', 'fine', 'perfect', 'wow', 'really', 'for', 'very',
+  'much', 'ya', 'iya', 'oke', 'betul', 'sip']);
 
 const norm = (w) => String(w || '').toLowerCase().replace(/[^\p{L}\p{N}']/gu, '');
 const tokens = (text) => String(text || '').split(/\s+/).filter(Boolean);
@@ -98,6 +113,20 @@ function onceEach(text) {
   return out.join('').trim();
 }
 
+/** The key a short line is counted under: its words, lower case, without punctuation. '' for a line that is long, empty, or
+ * only backchannel words, which the loop guard never counts. */
+function loopKey(text) {
+  const w = tokens(text).map(norm).filter(Boolean);
+  if (!w.length || w.length > LOOP_MAX_WORDS || w.every((x) => BACKCHANNEL.has(x))) return '';
+  return w.join(' ');
+}
+/** `lines`: [{ text, … }] of one source. → the same lines without every copy of a short line said `times` times or more. */
+function dropLoops(lines, { times = LOOP_TIMES } = {}) {
+  const count = new Map();
+  for (const l of lines || []) { const k = loopKey(l && l.text); if (k) count.set(k, (count.get(k) || 0) + 1); }
+  return (lines || []).filter((l) => { const k = loopKey(l && l.text); return !k || count.get(k) < times; });
+}
+
 const ID_WORDS = new Set(['yang', 'dan', 'di', 'ini', 'itu', 'tidak', 'dengan', 'untuk', 'ada', 'saya', 'kita', 'kami', 'akan', 'sudah', 'belum', 'juga',
   'dari', 'ke', 'karena', 'jadi', 'bisa', 'apa', 'kalau', 'tapi', 'atau', 'nya', 'lagi', 'harus', 'sama', 'mau', 'gak', 'nggak', 'ya', 'kamu', 'mereka', 'dia', 'pada', 'dalam', 'seperti', 'lebih', 'masih', 'aja', 'saja']);
 /** Did a cut that should be English come back in another language? `reported` is the engine's language name, when it says one. */
@@ -114,4 +143,4 @@ function looksForeign(text, reported) {
   return false;
 }
 
-module.exports = { stripEcho, repeats, onceEach, looksForeign, sameWords, ECHO_OVERLAP, ECHO_WORDS, ECHO_RUN, REPEAT_MS };
+module.exports = { stripEcho, repeats, onceEach, looksForeign, sameWords, loopKey, dropLoops, LOOP_TIMES, LOOP_MAX_WORDS, ECHO_OVERLAP, ECHO_WORDS, ECHO_RUN, REPEAT_MS };

package/workspace/lib/notes-whisper.js

@@ -32,7 +32,9 @@
  *
  * GUARDS (notes-recording-reliability, lib/notes-live-guard.js). A cut that repeats the line before it is dropped, a sentence
  * repeated back to back is kept once, the meeting's words are taken out of the microphone's line (the echo through the PM's
- * speakers), and with English chosen a cut that comes back in another language is run again in English.
+ * speakers), and with English chosen a cut that comes back in another language is run again in English. A short line that
+ * comes back word for word for the LOOP_TIMES-th time in a note's source is Whisper looping on quiet audio, and is dropped
+ * (the first copies stay live; the final pass after Stop drops them all).
  *
  * INVENTED LINES. whisper.cpp's no-speech threshold (`-nth`) drops segments it thinks are silence. A cut that is mostly
  * quiet and comes back as only "Thank you." or "you" is a known invention and is dropped (cleanText). A program too old
@@ -266,6 +268,7 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, onCut = ()
   echo = true, holdMs = HOLD_MS, recent = null, lastLine = null }) {
   const bufs = new Map();     // `${id}|${source}` → { id, source, chunks, ms, voicedMs, quietMs, t, noise }
   const lastText = new Map(); // `${id}|${source}` → { text, t }: the last line heard there, for the repetition guard
+  const said = new Map();     // `${id}|${source}` → Map(loopKey → times written), for the loop guard
   const vocabOf = (job) => { if (typeof vocab !== 'function') return prompt || ''; try { return String(vocab({ id: job.id, source: job.source }) || ''); } catch { return prompt || ''; } };
   const noiseOf = new Map();  // source → the quiet level last measured, so a new cut starts from it
   let queue = Promise.resolve();
@@ -302,6 +305,12 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, onCut = ()
     let prev = lastText.get(key);
     if (!prev && typeof lastLine === 'function') { try { prev = lastLine(job.id, job.source) || null; } catch { prev = null; } }
     if (liveGuard.repeats(text, prev, job.t)) return;
+    const lk = liveGuard.loopKey(text);
+    if (lk) {
+      const m = said.get(key) || new Map(); said.set(key, m);
+      const n = (m.get(lk) || 0) + 1; m.set(lk, n);
+      if (n >= liveGuard.LOOP_TIMES) return;
+    }
     lastText.set(key, { text, t: job.t });
     remember(job, text);
     await onText({ ...job, text, ...(extra || {}) });
@@ -438,6 +447,7 @@ function createTranscriber({ runtimeDir, onText, onError = () => {}, onCut = ()
   function drop(id) {
     for (const [k, b] of Array.from(bufs.entries())) if (b.id === id) bufs.delete(k);
     for (const k of Array.from(lastText.keys())) if (k.startsWith(id + '|')) lastText.delete(k);
+    for (const k of Array.from(said.keys())) if (k.startsWith(id + '|')) said.delete(k);
     for (let i = held.length - 1; i >= 0; i--) if (held[i].job.id === id) held.splice(i, 1);
     heard.delete(id); meetingAt.delete(id); meetingTo.delete(id);
     for (const k of Array.from(cutEnd.keys())) if (k.startsWith(id + '|')) cutEnd.delete(k);

package/workspace/lib/routes-core-docs.js

@@ -151,7 +151,7 @@ async function handle(req, res, url, ctx) {
   if (sub === 'draft') {
     const r = resolve(ctx, w, scope, key, now);
     if (!r.ok) return send(bad(r.status || 400, r.error));
-    if (r.entry.kind !== 'doc') return send(bad(400, `${r.entry.title} is read from its own source; there is nothing to draft here`));
+    if (!CD.storable(r.entry)) return send(bad(400, `${r.entry.title} is read from its own source; there is nothing to draft here`));
     if (r.entry.by === 'you') return send(bad(400, `You write the ${r.entry.title.toLowerCase()}. PMOS only checks it`));
     if (r.level === 'board' && r.entry.build && !r.facts.board.build) return send(bad(400, `${r.entry.title} is only for a board with Build and deliver`));
     if (r.level === 'initiative' && !r.facts.list.some((x) => x.entry.key === key)) return send(bad(400, `${r.entry.title} is not in this initiative's set`));

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.194.0",
+  "version": "0.196.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-core-docs.js

@@ -7,10 +7,10 @@
  * The server holds the sets, the states and the drafts; this file draws them and holds nothing.
  *
  *   coreDocs(env)    -> { left, right, dispose }   two hosts to put in the columns of cols(): the sections and the cards. env =
- *                      { api, level, board?, id?, ws, today, toast, nav: { tab(tab), tool(tool), reports() }, boardRow?, iniDocs?: { docs, initiatives } }
+ *                      { api, level, board?, id?, ws, today, toast, nav: { tab(tab), tool(tool), reports(), scan()? }, boardRow?, iniDocs?: { docs, initiatives } }
  *   needsLoc(row)    -> the `init=` address of the Docs view a Briefing row (kind core-doc-drafts) opens
  *   segBadge(n)      the count badge of the Portfolio's Documents segment
- * A press on a row opens `open`: { path } the document sheet, { tab } the board tab, { tool } the initiative's Overview tool, { reports } Reports.
+ * A press on a row opens `open`: { path } the document sheet, { tab } the board tab, { tool } the initiative's Overview tool, { reports } Reports. A row not started carries `act`: { do: 'draft' } (Draft it, Propose them) or { go: 'scan' | 'reports' } (Run a scan, Set it up).
  * Review the draft opens the draft in the document sheet. The sheet holds the actions: a panel above the draft (docAbove, the sheet's own hook)
  * with Issue it and Ask PMOS to change it, which asks for a new draft. Nothing is sent to anyone; the PM's press issues it. */
 import { el } from './dom.js';
@@ -91,6 +91,7 @@ function stChip(d) {
     case 'draft': return el('span', { class: 'st cd-ag', ...a }, icon('spark', 'sm'), 'Draft ready' + (d.due ? ', due ' + day(d.due) : ''));
     case 'missing': return st('bad', 'alert', 'Not started', a);
     case 'stale': return st('warn', 'clock', 'Out of date', a);
+    case 'none': return el('span', { class: 'chip2 dim', ...a }, 'None yet');
     default: return el('span', { class: 'chip2 dim', ...a }, 'Comes later');
   }
 }
@@ -140,7 +141,8 @@ function coreRow(env, d, redraw) {
     d.flag ? st('warn', 'alert', d.flag) : null, d.staleWhy && d.st === 'stale' ? chip(d.staleWhy) : null];
   let action = null;
   if (!d.running && d.st === 'draft') action = pbtn('primary', 'Review the draft', 'spark', { 'data-cd-review': d.key, onclick: review(env, d, redraw) });
-  else if (!d.running && d.kind === 'doc' && d.by !== 'you' && (d.st === 'missing' || d.st === 'stale')) action = pbtn('outline', 'Draft it', 'spark', { 'data-cd-draft': d.key, onclick: () => draftIt(env, d, redraw) });
+  else if (!d.running && d.act && d.act.do === 'draft') action = pbtn('outline', d.act.label, 'spark', { 'data-cd-draft': d.key, onclick: () => draftIt(env, d, redraw) });
+  else if (!d.running && d.act && d.act.go && env.nav[d.act.go]) action = pbtn('outline', d.act.label, d.act.go === 'scan' ? 'search' : 'report', { 'data-cd-go': d.key, onclick: () => env.nav[d.act.go]() });
   return nrow({ ic: d.ic || 'doc', hot: isAgent(d) || d.st === 'missing', title: [d.title, d.isNew ? [' ', tag('new')] : null], onOpen: open || undefined, openLabel: open ? 'Open ' + d.title : undefined,
     titleAttrs: { 'data-cd-open': d.key }, sub: d['for'] || '',
     chips: [stChip(d), d.cadence ? chip(icon('cal', 'sm'), d.cadence) : null, d.reader ? chip(icon('user', 'sm'), d.reader) : null, byChip(d.by), ...meta],

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

@@ -20,7 +20,7 @@ const RHYTHM = { portfolio: 'each quarter, with a monthly pulse', board: 'every
 /* the core sets: key, title, ic, for, reader, cadence, by, kind (doc | live | report), cat, isNew, state, when, due, flag, home */
 const PF = [
   { key: 'strategy', title: 'Product strategy', ic: 'target', for: 'Vision, where we play and what we will not do. Every board and key result traces to it.', reader: 'Leadership, every PM', cadence: 'Yearly, reviewed each quarter', by: 'you', st: 'ok', w: -9, flag: '2 key results do not trace to it', isNew: true },
-  { key: 'okrs', title: 'OKRs and health budgets', ic: 'flag', for: 'The key results initiatives anchor to, and the budgets maintenance work runs on.', reader: 'Leadership, PMs', cadence: 'Quarterly', by: 'proposes', st: 'ok', w: -12 },
+  { key: 'okrs', title: 'OKRs and health budgets', ic: 'flag', for: 'The key results initiatives anchor to, and the budgets maintenance work runs on.', reader: 'Leadership, PMs', cadence: 'Quarterly', by: 'proposes', st: 'ok', w: -12, kind: 'derived', store: true },
   { key: 'roadmap', title: 'Portfolio roadmap', ic: 'cal', for: 'Bets by quarter (Now, Next, Later) and the key result each serves. A sendable copy of the Roadmap.', reader: 'Leadership, stakeholders', cadence: 'Monthly', by: 'drafts', st: 'draft', w: 0, due: 4 },
   { key: 'invest', title: 'Investment mix', ic: 'cols', for: 'Where the effort goes: by board, by key result, and feature work against upkeep.', reader: 'Leadership', cadence: 'Quarterly', by: 'drafts', st: 'draft', w: 0, due: 4, isNew: true },
   { key: 'scan', title: 'Horizon scan reports', ic: 'search', for: 'Benchmark, competitive, insight and productivity reports, each with proposals.', reader: 'PMs, leadership', cadence: 'Weekly scan', by: 'drafts', st: 'ok', w: -1, kind: 'report' },
@@ -99,6 +99,16 @@ function iniInfo(id) {
   return { id, board: r.board, stage: r.stage, cat: stage.cat || 'Plan', wfTpl: r.template || (b && b.template) || 'product' };
 }
 
+/** The next step of a row not started, as lib/core-docs.js actOf. */
+function actOf(e, stt) {
+  const kind = e.kind || 'doc';
+  if (kind === 'doc' && e.by !== 'you' && (stt === 'missing' || stt === 'stale')) return { label: 'Draft it', do: 'draft' };
+  if (stt !== 'missing') return null;
+  if (e.store && e.by !== 'you') return { label: 'Propose them', do: 'draft' };
+  if (e.key === 'scan') return { label: 'Run a scan', go: 'scan' };
+  if (kind === 'report' && !e.cat) return { label: 'Set it up', go: 'reports' };
+  return null;
+}
 function entryOf(scope, e, base) {
   const o = OV.get(ovKey(scope, e.key)) || {};
   const stt = o.st || base.st;
@@ -109,7 +119,7 @@ function entryOf(scope, e, base) {
   else if (stt === 'draft') open = { path: draft.path };
   else if (stt === 'ok' || stt === 'due' || stt === 'stale') open = when ? { path: pathOf(scope, e.key, when) } : null;
   return { key: e.key, title: e.title, ic: e.ic, for: e.for, reader: e.reader || null, cadence: e.cadence || null, by: e.by, kind: e.kind || 'doc', cat: e.cat || null, isNew: !!e.isNew,
-    st: stt, when: when || null, due: base.due != null ? (typeof base.due === 'number' ? ymd(base.due) : base.due) : null, flag: o.st ? null : base.flag || null, staleWhy: null, open, draft, running: !!o.running };
+    st: stt, when: when || null, due: base.due != null ? (typeof base.due === 'number' ? ymd(base.due) : base.due) : null, flag: o.st ? null : base.flag || null, staleWhy: null, open, draft, act: actOf(e, stt), running: !!o.running };
 }
 const summaryOf = (docs) => { const n = (s) => docs.filter((d) => d.st === s).length; return { draft: n('draft'), due: n('due'), missing: n('missing'), stale: n('stale') }; };
 

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

@@ -248,7 +248,9 @@ export function mountInitiatives(pane, opts) {
     const total = boards.reduce((n, b) => n + ((b.counts || {}).total || 0), 0);
     const badge = segBadge(0);
     const lhHost = el('div', { class: 'cd-host' });
-    const cd = coreDocs({ api: pageApi, level: 'portfolio', ws: opts.ws || (boards[0] && boards[0].ws) || '', today: P.today, toast, nav: { reports: () => (opts.showTab || (() => {}))('rep'), tab: () => {}, tool: () => {} },
+    const cd = coreDocs({ api: pageApi, level: 'portfolio', ws: opts.ws || (boards[0] && boards[0].ws) || '', today: P.today, toast, nav: { reports: () => (opts.showTab || (() => {}))('rep'), tab: () => {}, tool: () => {},
+        // Run a scan: the Horizon scan section, with Scan now, lives on the Portfolio Overview.
+        scan: () => { go({ view: 'portfolio' }); setTimeout(() => { const h = root.querySelector('[data-scan-setup]'); if (h && h.scrollIntoView) h.scrollIntoView({ block: 'start' }); }, 400); } },
       onData: (r) => { setBadge(badge, r); put(lhHost, lh('doc', 'Portfolio documents', PORTFOLIO + ': the documents leadership reads to judge the bets. ' + (r.docs.filter((d) => d.st === 'draft').length ? plural(r.docs.filter((d) => d.st === 'draft').length, 'draft') + ' to review, ' : '') + r.docs.filter((d) => d.st === 'due').length + ' due.')); } });
     P.dispose = () => cd.dispose();
     put(root, pathCrumbs(null, null, el('div', { class: 'chips2' }, mono(plural(boards.length, 'board') + ' · ' + plural(total, 'initiative') + ' · ' + plural(asks, 'new ask')), pbtn('primary', 'New board', 'plus', { 'data-ini': 'new-board', onclick: () => openNewBoard() }))),

package/workspace/test-lists/notes-silence-loops.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "notes-silence-loops: Whisper looping on quiet audio. The loop guard (live and in the final pass) and the final pass dropping segments with no speech under them (notes-loops.test.js).",
+  "modules": ["notes-loops.test.js"],
+  "seconds": { "notes-loops.test.js": 3 }
+}