create-pmos 0.134.0 → 0.136.0

package/workspace/lib/engine/trust/plan.js

@@ -0,0 +1,5 @@
+// Ported verbatim from the PM's sample (prototype/pmos-console-handoff/sample/plan.js on feat/console3-merge); source of truth for this control. Only the fixture path (PF) and this header differ.
+const D=86400000,day=s=>Date.parse(s+'T00:00:00Z'),fmt=ms=>new Date(ms).toISOString().slice(0,10);
+const fold=(events,cut)=>{const s={};for(const e of events){if(cut&&e.snap>cut)continue;if(e.kind==='add')s[e.ticket]={...e.fields,origin:e.by,edits:0};else if(e.kind==='status'&&s[e.ticket]){s[e.ticket].status=e.fields.status}else if(s[e.ticket]){Object.assign(s[e.ticket],e.fields);s[e.ticket].edits++}}return s};
+const plan=(s,start)=>{const end={};const go=(k,seen=[])=>{if(seen.includes(k))throw new Error('dependency cycle at '+k);return end[k]??(end[k]=Math.max(day(start),...(s[k].deps||[]).map(d=>{if(!s[d])throw new Error(k+' depends on unknown '+d);return go(d,[...seen,k])}))+s[k].dur*D)};Object.keys(s).forEach(k=>go(k));return{end,forecast:Math.max(...Object.values(end))}};
+module.exports={fold,plan,day,fmt,D};

package/workspace/lib/engine/trust/trust.js

@@ -0,0 +1,21 @@
+// Ported verbatim from the PM's sample (prototype/pmos-console-handoff/sample/trust.js on feat/console3-merge); source of truth for this control. Only the fixture path (PF) and this header differ.
+// Claim checker: every claim carries one label and what that label requires. Strictness depends on the destination.
+module.exports.checkReport=function(rep,rules,ctx,dest){
+ const R=rules.destinations[dest],rows=[];
+ for(const c of rep.sections){let v='ok',why='';const set=(lvl,msg)=>{if(v==='block')return;if(lvl==='block'||v==='ok'){v=lvl;why=msg}};
+  const def=rules.basis[c.basis];
+  if(!c.basis||!def)set(R.unlabelled,'no label (fact, cited, reported, estimate, assumption or judgement)');
+  else if(!R.allow.includes(c.basis))set('block',c.basis+' is not allowed for '+dest);
+  else if((c.source||'').startsWith('import:')&&c.basis!=='reported')set('block','source is an untrusted import; the claim must be labelled reported');
+  else{const miss=def.needs.filter(k=>!c[k]);if(miss.length)set(R.incomplete,'missing '+miss.join(', '));
+   if(c.basis==='fact'||c.basis==='cited'){const m=(c.source||'').split('@');
+    if(m[0]==='forecast'||m[0]==='points'){if(!ctx.snaps.includes(m[1]))set('block','no such check '+m[1]);else if(m[1]<ctx.last)set(R.stale,'source is the '+m[1]+' check; latest is '+ctx.last)}
+    else if(!ctx.docs[m[0]])set('block','source '+m[0]+' does not exist');
+    else if(m[1]&&+m[1]<ctx.docs[m[0]].rev)set(R.stale,m[0]+' is now rev '+ctx.docs[m[0]].rev+'; claim used rev '+m[1])}
+   if(c.basis==='assumption'&&c.review_by&&c.review_by<ctx.now)set(R.overdue_assumption,'review date '+c.review_by+' has passed')}
+  rows.push({id:c.id,basis:c.basis||'(none)',claim:c.claim,verdict:v,why})}
+ // bad news rule: every tripped signal must be covered by a section
+ const covered=new Set(rep.sections.flatMap(s=>s.covers||[]));const omitted=(ctx.tripped||[]).filter(x=>!covered.has(x));
+ if(omitted.length&&R.unlabelled==='block')rows.push({id:'omitted',basis:'(rule)',claim:'Report omits tripped signal: '+omitted.join(', '),verdict:'block',why:'a report must cover every tripped signal'});
+ const blocked=rows.filter(r=>r.verdict==='block').length;
+ return{rows,send:blocked===0?'allowed':'blocked ('+blocked+' claim'+(blocked>1?'s':'')+')',label_visible:R.label_visible}};

package/workspace/lib/engine/truth-table.js

@@ -0,0 +1,57 @@
+'use strict';
+// console3 wave B4: the who-holds-what truth table. Pure. No I/O, no send.
+// messages: [{ id?, to, at, claims: [{ id, text?, value? }] }]   (what each person was told)
+// truth:    { [claimId]: { value, text?, changed_at? } }          (what is true now)
+// Only claims present in messages are listed. A claim is never invented.
+// State per told claim (the person's latest message on that claim):
+//   contradicted  the truth has a value and it differs from the value told
+//   stale         the truth changed after the message, or the truth for the claim is not known
+//   in sync       the truth holds the value told and has not changed since
+const V = require('./derived/derive.js');
+// BACKED BY THE PM'S SAMPLE: whoHoldsWhatFromPlan below is reader.js section 7 (derive.heldVsTrue): the truth is DERIVED from the
+// plan, 'ship-date' = the forecast and 'ticket:<id>' = that ticket's end, and a claim is in sync or N days apart.
+// REPO-WRITTEN, no sample equivalent: whoHoldsWhat, the generic claim table with the 'stale' state (truth changed after the send).
+const same = (a, b) => JSON.stringify(a === undefined ? null : a) === JSON.stringify(b === undefined ? null : b);
+const ts = (v) => { const t = Date.parse(v); return Number.isNaN(t) ? null : t; };
+
+function stateOf(told, at, now) {
+  if (!now || typeof now !== 'object') return 'stale';
+  if ('value' in now && told.value !== undefined && !same(told.value, now.value)) return 'contradicted';
+  if (told.value === undefined && 'text' in now && told.text !== undefined && told.text !== now.text) return 'contradicted';
+  const changed = ts(now.changed_at), sent = ts(at);
+  if (changed !== null && (sent === null || changed > sent)) return 'stale';
+  return 'in sync';
+}
+
+const RANK = { 'in sync': 0, stale: 1, contradicted: 2 };
+
+function whoHoldsWhat(messages = [], truth = {}) {
+  const people = new Map();
+  const list = (Array.isArray(messages) ? messages : []).slice().sort((a, b) => (ts(a && a.at) || 0) - (ts(b && b.at) || 0));
+  for (const m of list) {
+    if (!m || !m.to || !Array.isArray(m.claims)) continue;
+    if (!people.has(m.to)) people.set(m.to, new Map());
+    for (const c of m.claims) {
+      if (!c || !c.id) continue;
+      people.get(m.to).set(c.id, { ...c, at: m.at || null }); // the later message replaces the earlier one
+    }
+  }
+  const t = truth && typeof truth === 'object' ? truth : {};
+  return [...people.entries()].map(([person, held]) => {
+    const claims = [...held.values()].map((c) => {
+      const now = Object.prototype.hasOwnProperty.call(t, c.id) ? t[c.id] : null;
+      return {
+        id: c.id, text: c.text || null, told_at: c.at, told_value: c.value === undefined ? null : c.value,
+        truth_value: now && 'value' in now ? now.value : null, state: stateOf(c, c.at, now),
+      };
+    });
+    const worst = claims.reduce((w, c) => (RANK[c.state] > RANK[w] ? c.state : w), 'in sync');
+    return { person, claims, state: worst };
+  });
+}
+
+// messages: sent.jsonl records { to, claims: [{ subject, value }] }; pl: derived/plan.js plan(state, start).
+// Returns one row per told claim: { to, subject, told, true, gap, state } with state 'in sync' | '<n>d apart' | 'unknown'.
+const whoHoldsWhatFromPlan = (messages, pl) => V.heldVsTrue(Array.isArray(messages) ? messages : [], pl);
+
+module.exports = { whoHoldsWhatFromPlan, whoHoldsWhat, STATES: Object.keys(RANK) };

package/workspace/lib/engine/workspace-lib.js

@@ -0,0 +1,24 @@
+'use strict';
+/* workspace-lib.js — where a workspace/lib/ module is, for a script that runs in a checkout AND as a copy in a workspace
+ * package (incident workspace-package-script-closure).
+ *
+ *   require(workspaceLib('plan-items.js'))
+ *
+ * Some scripts share a fold with the workspace (the plan items, the item steps). In a checkout that module is at
+ * workspace/lib/<name>. In a package the script is a copy that scripts/vendor-workspace-engine.js put in lib/engine/,
+ * and this file is lib/engine/workspace-lib.js, so the module is the bundle's own lib/<name>, one folder up. A plain relative
+ * require of ../workspace/lib/x.js resolves in the first place only, and the vendor step refuses it.
+ *
+ * Both places are tried, the checkout first. When neither exists the checkout path is returned, and require() names it.
+ */
+const fs = require('fs');
+const path = require('path');
+
+function workspaceLib(name) {
+  const n = String(name || '');
+  if (!/^[a-z0-9][a-z0-9-]*\.js$/.test(n)) throw new Error(`workspaceLib: '${n}' must be a file name in workspace/lib/, such as 'plan-items.js'`);
+  const candidates = [path.join(__dirname, '..', 'workspace', 'lib', n), path.join(__dirname, '..', n)];
+  return candidates.find((p) => fs.existsSync(p)) || candidates[0];
+}
+
+module.exports = { workspaceLib };

package/workspace/lib/factory-join.js

@@ -53,7 +53,7 @@
 const fs = require('fs');
 const path = require('path');
 
-const WORK_ITEM_PATHS = [path.join(__dirname, '..', '..', 'scripts', 'work-item.js')];
+const WORK_ITEM_PATHS = [path.join(__dirname, '..', '..', 'scripts', 'work-item.js')];   // vendor: checkout-only — its sink guard is workspace/lib/sink.js, outside scripts/; an install reports engine-missing (header)
 const READY = new Set(['verified', 'integrated']);
 const PR_RE = /^(?:https?:\/\/\S+\/pull\/\d+\S*|pr:#?\d+)$/i;
 

package/workspace/lib/facts-async.js

@@ -24,8 +24,9 @@ const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 const repoWatch = require('./repo-watch.js');
+const { repoScript } = require('./repo-script.js');
 
-const CLI = path.resolve(__dirname, '..', '..', 'scripts', 'signals', 'facts-cli.js');
+const CLI = repoScript('signals/facts-cli.js');   // a checkout's scripts/, or the copy vendored into lib/engine/
 const TTL_MS = 5 * 60 * 1000;            // only for a folder with no signature
 const MAX_AGE_MS = 24 * 3600 * 1000;     // an entry this old is rebuilt even when the signature holds
 const SIG_REUSE_MS = 2000;               // a burst of requests asks git once
@@ -41,8 +42,7 @@ const sha1 = (s) => crypto.createHash('sha1').update(s).digest('hex');
 /** The version of the code that derives the facts: a change to it makes every entry stale. */
 function engineVersion() {
   if (engineMemo) return engineMemo;
-  const sig = path.resolve(__dirname, '..', '..', 'scripts');
-  const parts = [CLI, path.join(sig, 'signals', 'facts.js'), path.join(sig, 'workflow-state.js')].map((f) => {
+  const parts = [CLI, repoScript('signals/facts.js'), repoScript('workflow-state.js')].map((f) => {
     try { return sha1(fs.readFileSync(f)); } catch { return '-'; }
   });
   engineMemo = sha1(parts.join('|')).slice(0, 12);
@@ -86,7 +86,7 @@ async function currentSig(root, opts, clock) {
 }
 
 function normalize(facts, today) {
-  try { return require('../../scripts/signals/facts.js').normalizeFacts(facts, today || undefined); } catch { return facts; }
+  try { return require(repoScript('signals/facts.js')).normalizeFacts(facts, today || undefined); } catch { return facts; }
 }
 
 function readFactsAsync(root, opts = {}) {

package/workspace/lib/headless.js

@@ -0,0 +1,95 @@
+'use strict';
+/* headless.js — which agent jobs run as headless Claude Code (`claude -p`) instead of a terminal pane
+ * (initiative workspace-headless-jobs; PM decision 2026-10-11: keep Jev, no direct Claude API, background
+ * jobs that need no human run headless).
+ *
+ *   kindFor({ agent, origin, skill, env })        → 'notes' | 'skill' | null   (null: open a pane, as before)
+ *   argsFor(kind, { modelArgs, addDirs })          → the argv after `claude`
+ *   parseResult(stdout)                            → { ok, text, isError, turns, durationMs, costUsd, denied[] }
+ *   logLines(result, exitCode)                     → the lines the read-only log pane shows at the end
+ *
+ * Pure: no I/O, no process. server.js spawnSession starts the child and keeps the session row.
+ *
+ * A headless run uses the PM's own login, model choice (D75), profile and connectors, exactly as a pane does.
+ * It cannot ask for permission, so each kind gets a FIXED tool list here; a connector tool runs only where the
+ * PM's own Claude Code settings already allow it, and anything else is denied and reported. No bypass flag is
+ * ever passed. `PMOS_HEADLESS=off` sends every job back to a pane.
+ */
+
+// The skills whose every start runs headless: they read, file a result for PMOS, and send nothing out.
+const HEADLESS_SKILLS = Object.freeze([
+  'day-check', 'calendar-sync', 'jira-sync', 'my-work-read', 'report-biweekly', 'report-template',
+  'tracker-refresh', 'measure', 'memory-groom', 'backlog-triage',
+]);
+// The note passes that run headless, by the origin prefix lib/routes-notes.js gives them.
+const HEADLESS_ORIGINS = Object.freeze(['notes-bullets:', 'notes-summary:']);
+
+// What each kind may use. Read-only search is always allowed. The notes passes write their JSON (and rename the .tmp
+// file) in their notes folder, which --add-dir opens to them; the skills also run `pmos` verbs and repository scripts.
+const TOOLS = Object.freeze({
+  notes: Object.freeze(['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash(mv *)']),
+  skill: Object.freeze(['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash(pmos *)', 'Bash(node *)',
+    'Bash(git log *)', 'Bash(git status *)', 'Bash(git diff *)', 'Bash(ls *)', 'Bash(date *)']),
+});
+
+const DEFAULT_TIMEOUT_MS = 20 * 60 * 1000;
+
+function switchedOff(env) {
+  return /^(off|0|false|no)$/i.test(String((env || process.env).PMOS_HEADLESS || '').trim());
+}
+
+function kindFor({ agent, origin, skill, env } = {}) {
+  if (agent !== 'claude' || switchedOff(env)) return null;
+  const o = String(origin || '');
+  if (HEADLESS_ORIGINS.some((p) => o.startsWith(p))) return 'notes';
+  if (skill && HEADLESS_SKILLS.includes(String(skill))) return 'skill';
+  return null;
+}
+
+function argsFor(kind, { modelArgs = [], addDirs = [] } = {}) {
+  const tools = TOOLS[kind];
+  if (!tools) throw new Error('unknown headless kind: ' + kind);
+  const argv = ['-p', '--output-format', 'json', '--no-session-persistence', ...modelArgs, '--allowedTools', tools.join(',')];
+  for (const d of addDirs) if (d) argv.push('--add-dir', String(d));
+  return argv;
+}
+
+function timeoutMs(env) {
+  const n = Number((env || process.env).PMOS_HEADLESS_TIMEOUT_MS);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_TIMEOUT_MS;
+}
+
+/** The last JSON object on stdout (`--output-format json` prints one). Anything unreadable is not a result. */
+function parseResult(stdout) {
+  const text = String(stdout || '').trim();
+  let o = null;
+  try { o = JSON.parse(text); } catch {
+    const at = text.lastIndexOf('\n{');
+    try { o = JSON.parse(at >= 0 ? text.slice(at + 1) : ''); } catch { o = null; }
+  }
+  if (!o || typeof o !== 'object') return { ok: false, text: text.slice(-2000), isError: true, turns: null, durationMs: null, costUsd: null, denied: [] };
+  const denied = Array.isArray(o.permission_denials)
+    ? [...new Set(o.permission_denials.map((d) => d && d.tool_name).filter(Boolean).map(String))] : [];
+  return {
+    ok: true,
+    text: typeof o.result === 'string' ? o.result : '',
+    isError: !!o.is_error || (typeof o.subtype === 'string' && o.subtype !== 'success'),
+    turns: Number.isFinite(o.num_turns) ? o.num_turns : null,
+    durationMs: Number.isFinite(o.duration_ms) ? o.duration_ms : null,
+    costUsd: Number.isFinite(o.total_cost_usd) ? o.total_cost_usd : null,
+    denied,
+  };
+}
+
+function logLines(r, exitCode) {
+  const out = [];
+  if (r.text) out.push(...String(r.text).split('\n'));
+  const facts = [`exit code ${exitCode}`];
+  if (r.durationMs != null) facts.push(`${Math.round(r.durationMs / 1000)} s`);
+  if (r.turns != null) facts.push(`${r.turns} turns`);
+  out.push('', `[${facts.join(' · ')}]`);
+  if (r.denied.length) out.push(`Not allowed in a background run: ${r.denied.join(', ')}. Allow these in Claude Code settings, or set PMOS_HEADLESS=off to use a terminal pane.`);
+  return out;
+}
+
+module.exports = { HEADLESS_SKILLS, HEADLESS_ORIGINS, TOOLS, DEFAULT_TIMEOUT_MS, kindFor, argsFor, timeoutMs, parseResult, logLines, switchedOff };

package/workspace/lib/import-overlay.js

@@ -9,7 +9,8 @@ const path = require('path');
 /** Where scripts/onboarding/ is: the checkout's own, else the copy an installed package vendors under lib/vendor/
  * (scripts/vendor-workspace-engine.js vendorTree). Null when neither is there. */
 function onboardingDir() {
-  for (const d of [path.join(__dirname, '..', '..', 'scripts', 'onboarding'), path.join(__dirname, 'vendor', 'scripts', 'onboarding')]) {
+  const inCheckout = path.dirname(path.join(__dirname, '..', '..', 'scripts', 'onboarding', 'scan.js'));   // vendor: checkout-only (vendorTree copies the onboarding tree)
+  for (const d of [inCheckout, path.join(__dirname, 'vendor', 'scripts', 'onboarding')]) {
     if (fs.existsSync(path.join(d, 'scan.js'))) return d;
   }
   return null;

package/workspace/lib/jira-status.js

@@ -13,8 +13,10 @@
  *   readSnapshot(root, initiative)      → { fetchedAt, query, tickets: Map<key, reading> } | null
  *   which(root, key)                    → the initiative and ticket a key belongs to
  *
- * A READING is { key, summary, status, category: todo|doing|done, sprint: { name, state: active|future|closed } | null,
- * subtasks: { done, total }, fixVersion: [names], flagged, reason, url }. A ticket the search did not return keeps its last reading, marked
+ * A READING is { key, summary, status, category: todo|doing|done, sprint: { name, state: active|future|closed, id?, start?, end?,
+ * completed? } | null, subtasks: { done, total }, fixVersion: [names], points: number | null, resolved: YYYY-MM-DD | null,
+ * flagged, reason, url }. The sprint's dates, `points` and `resolved` feed the sprint burndown (lib/stage-tools.js); a
+ * reading saved before they were carried has none of them, and the burndown says it cannot be drawn. A ticket the search did not return keeps its last reading, marked
  * stale. Titles and statuses only: never a description, a comment or a person.
  *
  * BOUNDARY (J15). No network module, no child process. The only write is the snapshot file.
@@ -83,7 +85,30 @@ function sprintOne(v) {
   const name = clip(oneLine(v.name), 80);
   const state = String(v.state || '').toLowerCase();
   if (!name) return null;
-  return { name, state: SPRINT_STATES.includes(state) ? state : 'active' };
+  const out = { name, state: SPRINT_STATES.includes(state) ? state : 'active' };
+  if ((Number.isInteger(v.id) && v.id > 0) || (isStr(v.id) && /^\d{1,12}$/.test(v.id))) out.id = String(v.id);
+  for (const [k, from] of [['start', ['startDate', 'start']], ['end', ['endDate', 'end']], ['completed', ['completeDate', 'completed']]]) {
+    const d = dayOf(from.map((f) => v[f]).find((x) => x != null));
+    if (d) out[k] = d;
+  }
+  return out;
+}
+/** An ISO date or date-time → YYYY-MM-DD (the date as written, never shifted by a zone), else null. */
+function dayOf(v) {
+  if (!isStr(v)) return null;
+  const m = /^(\d{4}-\d{2}-\d{2})(?:$|[T ])/.exec(v.trim());
+  return m ? m[1] : null;
+}
+/** Story points: a non-negative number, from the flat `points` or a points field Jira names (the custom field id differs per
+ * site; these are the common ones). null when none is set: an unpointed ticket, which the burndown counts apart. */
+const POINT_FIELDS = ['points', 'story_points', 'storyPoints', 'Story Points', 'Story point estimate', 'customfield_10016', 'customfield_10026', 'customfield_10028', 'customfield_10002'];
+function pointsIn(o) {
+  for (const k of POINT_FIELDS) {
+    const v = o[k];
+    if (typeof v === 'number' && Number.isFinite(v) && v >= 0 && v <= 1000) return v;
+    if (isStr(v) && /^\d{1,4}(\.\d+)?$/.test(v.trim())) return Number(v);
+  }
+  return null;
 }
 /** The sprint that matters: the active one, else the next, else the last closed. null is the backlog. */
 function sprintOf(v) {
@@ -134,6 +159,7 @@ function normalizeIssue(x) {
     const status = nameOf(st) || 'Unknown';
     const flagged = flaggedIn(f) || /block|impediment|on hold/i.test(status);
     return { key, summary, status, category: categoryOf(status, st.statusCategory), sprint: sprintIn(f), subtasks: subtasksOf(f.subtasks), fixVersion: fixVersionsOf(f.fixVersions),
+      points: pointsIn(f), resolved: dayOf(f.resolutiondate || f.resolved),
       flagged, reason: flagged ? (flaggedIn(f) ? 'Flagged in Jira' : `Status: ${status}`) : null, url: urlOf(x, key) };
   }
   // The flat shape: what the skill tells the agent to write when it is unsure of the connector's shape.
@@ -142,6 +168,7 @@ function normalizeIssue(x) {
   const status = oneLine(x.status) || 'Unknown';
   const flagged = x.flagged === true || /block|impediment|on hold/i.test(status);
   return { key, summary, status, category: categoryOf(status, x.category), sprint: sprintOf(x.sprint), subtasks: subtasksOf(x.subtasks), fixVersion: fixVersionsOf(x.fixVersions != null ? x.fixVersions : x.fixVersion),
+    points: pointsIn(x), resolved: dayOf(x.resolved || x.resolutiondate),
     flagged, reason: flagged ? clip(oneLine(x.reason || x.flag_reason || (x.flagged === true ? 'Flagged in Jira' : `Status: ${status}`)), 160) : null,
     url: urlOf(x, key) };
 }

package/workspace/lib/notes-capture.js

@@ -8,6 +8,8 @@
  *                                                the live transcription's progress, so a restart transcribes what it had buffered
  *   close(runtimeDir, id)                        Pause or Stop: the capture ends, and the next Listen starts a new one
  *   tokened(runtimeDir, id) → true when the live capture has sent a chunk with its token
+ *   owns(runtimeDir, id, { token }) → { ok, base_ms } | { ok: false, status: 409, error }   is this the live, not-closed capture's token
+ *                                                (a screenshot has no sequence number, so it is checked on the token alone)
  *   remove(runtimeDir, id)
  *
  * WHY. The page sends each source in one-second chunks and sends a chunk again when its answer does not come back. Before this
@@ -111,6 +113,12 @@ function untranscribed(runtimeDir, id, { source, before } = {}) {
   const to = Math.min(before, (s.fed || {})[source] || 0);
   return to > from ? { from, to } : null;
 }
+/** Does this token belong to the note's live capture, one that was not closed by Pause or Stop? Changes nothing. */
+function owns(runtimeDir, id, { token } = {}) {
+  const s = load(runtimeDir, id);
+  if (!s || !s.token || s.closed || s.token !== token) return { ok: false, status: 409, error: 'this meeting is being recorded in another tab or window, or listening stopped' };
+  return { ok: true, base_ms: s.base_ms };
+}
 function tokened(runtimeDir, id, { now = Date.now() } = {}) { const s = load(runtimeDir, id); return isLive(s, now) && !!s.tokened; }
 function close(runtimeDir, id) {
   const s = load(runtimeDir, id);
@@ -125,4 +133,4 @@ function remove(runtimeDir, id) {
   try { fs.unlinkSync(f); } catch { /* none */ }
 }
 
-module.exports = { start, busy, check, mark, setCut, untranscribed, close, tokened, remove, LIVE_MS };
+module.exports = { start, busy, check, mark, setCut, untranscribed, close, tokened, owns, remove, LIVE_MS };

package/workspace/lib/notes-final.js

@@ -6,6 +6,7 @@
  *   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)
+ *   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
  * little context, so names come out wrong and sentences break in two, and nothing in it says who spoke. Meeting tools that
@@ -276,6 +277,40 @@ async function transcribeQwen(qwen, d, pcmFile, tmp, { lang, prompt, live = () =
   }
   return { ok: true, segments, engine: 'qwen', vad: true };
 }
+/** The best engine set up first; when it fails, the next one still can: Qwen3-ASR, Parakeet (English), Whisper. */
+async function bestTranscript({ run, qwen }, d, pcmFile, wav, tmp, { prompt = '', live = () => true } = {}) {
+  const order = [];
+  if (d.qwen) order.push('qwen');
+  if (d.parakeet && d.lang === 'en') order.push('parakeet');
+  if (d.whisper) order.push('whisper');
+  let r = { ok: false, error: 'no engine is set up for the final pass' };
+  for (const e of order) {
+    if (!live()) return r;
+    r = e === 'qwen' ? await transcribeQwen(qwen, d, pcmFile, tmp, { lang: d.lang, prompt, live })
+      : e === 'parakeet' ? await transcribeParakeet(run, d, wav, tmp) : await transcribeWhisper(run, d, wav, tmp, { lang: d.lang, prompt });
+    if (r.ok) break;
+  }
+  return r;
+}
+/**
+ * One stretch of audio (16 kHz mono 16-bit samples) through the final pass's engine, with no speakers and nothing stored
+ * (notes-live-settle: what a settle tier would cost). → { ok, engine, segments } | { ok: false, error }
+ */
+async function transcribeClip(runtimeDir, pcm, { prompt = '', run = runProgram, detect: det = () => detect(runtimeDir),
+  qwen = (args) => notesQwen.runQwen(notesQwen.workerFor(runtimeDir), args) } = {}) {
+  const d = det();
+  if (!d.ready) return { ok: false, error: 'no engine is set up for the final pass' };
+  const tmp = path.join(finalDir(runtimeDir), 'tmp-' + crypto.randomBytes(6).toString('hex'));
+  try {
+    fs.mkdirSync(tmp, { recursive: true, mode: 0o700 });
+    const pcmFile = path.join(tmp, 'clip.pcm'); const wav = path.join(tmp, 'clip.wav');
+    fs.writeFileSync(pcmFile, pcm, { mode: 0o600 });
+    writeWav(pcmFile, wav);
+    return await bestTranscript({ run, qwen }, d, pcmFile, wav, tmp, { prompt });
+  } finally {
+    try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { /* gone */ }
+  }
+}
 async function diarizeFile(run, d, wav) {
   const r = await run(d.diarize.python, [d.diarize.script, '--segmentation', d.diarize.seg, '--embedding', d.diarize.emb, '--wav', wav, '--threshold', DIARIZE_THRESHOLD]);
   let j = null;
@@ -319,18 +354,8 @@ function createFinal({ runtimeDir, onDone, onState = () => {}, run = runProgram,
         const wav = path.join(tmp, s.source + '.wav');
         writeWav(s.file, wav);
         set(id, { state: 'running', step: 'transcribing ' + (s.source === 'mic' ? 'your microphone' : 'the meeting') + ' again' });
-        // the best engine first; when it fails, the next one set up still can: Qwen3-ASR, Parakeet (English), Whisper
-        const order = [];
-        if (d.qwen) order.push('qwen');
-        if (d.parakeet && d.lang === 'en') order.push('parakeet');
-        if (d.whisper) order.push('whisper');
-        let r = { ok: false, error: 'no engine is set up for the final pass' };
-        for (const e of order) {
-          if (!live()) return;
-          r = e === 'qwen' ? await transcribeQwen(qwen, d, s.file, tmp, { lang: d.lang, prompt, live })
-            : e === 'parakeet' ? await transcribeParakeet(run, d, wav, tmp) : await transcribeWhisper(run, d, wav, tmp, { lang: d.lang, prompt });
-          if (r.ok) break;
-        }
+        const r = await bestTranscript({ run, qwen }, d, s.file, wav, tmp, { prompt, live });
+        if (!live()) return;
         if (!r.ok) { set(id, { state: 'failed', reason: r.error }); return; }
         engine = r.engine; vad = vad || r.vad;
         let part = { source: s.source, segments: r.segments, speakers: 1 };
@@ -369,5 +394,5 @@ function createFinal({ runtimeDir, onDone, onState = () => {}, run = runProgram,
   };
 }
 
-module.exports = { detect, setupCommand, createFinal, runProgram, parseWhisper, parseParakeet, splitAtPauses, assignSpeakers, dropEcho, mergeSources, finalDir,
+module.exports = { detect, setupCommand, createFinal, transcribeClip, runProgram, parseWhisper, parseParakeet, splitAtPauses, assignSpeakers, dropEcho, mergeSources, finalDir,
   PARAKEET_MODEL, VAD_FILE, DIARIZE_THRESHOLD };

package/workspace/lib/notes-replay.js

@@ -0,0 +1,125 @@
+'use strict';
+/* notes-replay.js — notes-live-settle Run 1: what a replayed meeting shows, and what a settle tier would cost on this machine.
+ *
+ *   words(text) → [word]                     lower case, letters and digits only
+ *   overlap(a, b) → 0..1                     the share of the shorter line's words that the other line also has
+ *   duplicates(lines, { repeatMs, echoMs }) → [{ kind, a, b, overlap }]   lines said twice: `repeat` (one source, close together)
+ *                                            or `echo` (the microphone and the meeting, at the same moment)
+ *   lag(seen) → { median_ms, p90_ms, max_ms, n }   how long after its audio a live line appeared
+ *   createSettleMeter({ transcribe, windowMs?, pauseMs?, now? }) → { feed(source, pcm), idle(), report(elapsedMs) }
+ *
+ * WHY. The PM reported duplicated audio and a duplicated transcript (notes-recording-reliability). That fix was measured on a
+ * scripted fixture; bin/notes-replay.js plays a real kept meeting through the live path again, and this module says what came out.
+ * The plan's near-realtime correction (console3 feedback plan 3.1, "settle tier") is built only if this machine keeps up: at each
+ * settle point the last WINDOW_MS of a source is transcribed again with the final pass's engine. The meter does that while the
+ * replay runs and measures the share of the meeting's time the engine was busy (`busy_share`, the real-time factor of the settle
+ * tier). The plan's gate: under 0.5, and no settle point skipped because the engine was still busy.
+ *
+ * WHAT IT NEVER DOES. It stores nothing and makes no request; `transcribe` is lib/notes-final.js transcribeClip, local.
+ */
+const whisper = require('./notes-whisper.js');
+
+const RATE = whisper.RATE;
+const REPEAT_MS = 15000;       // a line said again by the same source within this time is a repeat
+const ECHO_MS = 5000;          // a microphone line and a meeting line this close are the same moment
+const MIN_OVERLAP = 0.8;
+const MIN_WORDS = 3;           // a shorter line ("Yes.") said twice is a conversation, not a duplicate, unless it is the same text
+const WINDOW_MS = 30000;       // the plan's 20 to 40 s
+const PAUSE_MS = 1500;         // the plan's settle point: a pause of 1.5 s
+const GATE = 0.5;
+
+const words = (text) => String(text || '').toLowerCase().match(/[\p{L}\p{N}']+/gu) || [];
+function overlap(a, b) {
+  const wa = words(a); const wb = words(b);
+  if (!wa.length || !wb.length) return 0;
+  const [short, long] = wa.length <= wb.length ? [wa, wb] : [wb, wa];
+  const bag = new Map(); for (const w of long) bag.set(w, (bag.get(w) || 0) + 1);
+  let hit = 0; for (const w of short) { const c = bag.get(w) || 0; if (c) { hit++; bag.set(w, c - 1); } }
+  return hit / short.length;
+}
+const endOf = (l) => (Number.isFinite(l.t_end) ? l.t_end : l.t);
+
+/** Lines said twice. `lines` are transcript lines { t, t_end?, text, source }, in any order; dropped lines are left out. */
+function duplicates(lines, { repeatMs = REPEAT_MS, echoMs = ECHO_MS } = {}) {
+  const ls = (lines || []).filter((l) => l && !l.dropped && Number.isFinite(l.t) && words(l.text).length).slice().sort((x, y) => x.t - y.t);
+  const out = [];
+  for (let i = 0; i < ls.length; i++) {
+    for (let j = i + 1; j < ls.length && ls[j].t - endOf(ls[i]) <= Math.max(repeatMs, echoMs); j++) {
+      const a = ls[i]; const b = ls[j];
+      const same = words(a.text).join(' ') === words(b.text).join(' ');
+      const o = overlap(a.text, b.text);
+      const long = Math.min(words(a.text).length, words(b.text).length) >= MIN_WORDS;
+      if (!(same || (long && o >= MIN_OVERLAP))) continue;
+      const gap = b.t - endOf(a);
+      if (a.source === b.source && gap <= repeatMs) out.push({ kind: 'repeat', a, b, overlap: Math.round(o * 100) / 100 });
+      else if (a.source !== b.source && gap <= echoMs) out.push({ kind: 'echo', a, b, overlap: Math.round(o * 100) / 100 });
+    }
+  }
+  return out;
+}
+
+const pct = (xs, q) => { if (!xs.length) return null; const s = xs.slice().sort((x, y) => x - y); return s[Math.min(s.length - 1, Math.floor((s.length - 1) * q))]; };
+/** `seen` is [{ late_ms }], one per live line: how long after the end of its audio the line appeared. */
+function lag(seen) {
+  const xs = (seen || []).map((s) => s.late_ms).filter(Number.isFinite);
+  return { n: xs.length, median_ms: pct(xs, 0.5), p90_ms: pct(xs, 0.9), max_ms: xs.length ? Math.max(...xs) : null };
+}
+
+/**
+ * The settle tier, measured. `feed` is called with each one-second chunk of a source as it is replayed.
+ * A settle point is a pause of PAUSE_MS after speech, or the other source starting to speak; at a settle point the last WINDOW_MS of
+ * that source goes to `transcribe(pcm)`. One run at a time: a settle point that comes while the engine is busy is skipped and counted.
+ */
+function createSettleMeter({ transcribe, windowMs = WINDOW_MS, pauseMs = PAUSE_MS, now = Date.now } = {}) {
+  const st = new Map();    // source → { buf: [Buffer], bytes, voiced: bool, quietMs, floor: [rms] }
+  const runs = []; let skipped = 0; let points = 0; let busy = null; let busyMs = 0; let engine = null; const errors = [];
+  let lastVoiced = null;
+  const keep = Math.round(windowMs * RATE / 1000) * 2;
+  const of = (source) => { if (!st.has(source)) st.set(source, { buf: [], bytes: 0, voiced: false, quietMs: 0, floor: [] }); return st.get(source); };
+  function point(source) {
+    points++;
+    if (busy) { skipped++; return; }
+    const s = of(source);
+    const pcm = Buffer.concat(s.buf).subarray(-keep);
+    const audioMs = (pcm.length / 2 / RATE) * 1000;
+    const began = now();
+    let started; try { started = Promise.resolve(transcribe(pcm)); } catch (e) { started = Promise.reject(e); }
+    busy = started.then((r) => {
+      const took = now() - began; busyMs += took;
+      if (r && r.ok) { engine = r.engine || engine; runs.push({ source, audio_ms: Math.round(audioMs), took_ms: took }); } else errors.push(String((r && r.error) || 'no answer').slice(0, 200));
+    }, (e) => { busyMs += now() - began; errors.push(String((e && e.message) || e).slice(0, 200)); }).finally(() => { busy = null; });
+  }
+  return {
+    feed(source, pcm) {
+      const s = of(source);
+      s.buf.push(pcm); s.bytes += pcm.length;
+      while (s.bytes - s.buf[0].length >= keep) s.bytes -= s.buf.shift().length;
+      // a 100 ms frame is speech above three times the quiet of the last minute before it (its 10th percentile), and never below
+      // 180; until five seconds were heard, above 180
+      for (const v of whisper.levels(pcm)) {
+        const q = s.floor.length >= 50 ? pct(s.floor.filter((x) => x > 0), 0.1) || 0 : 0;
+        s.floor.push(v); if (s.floor.length > 600) s.floor.shift();
+        const voiced = v > Math.max(180, q * 3);
+        if (voiced) {
+          if (lastVoiced && lastVoiced !== source && of(lastVoiced).voiced) { of(lastVoiced).voiced = false; point(lastVoiced); }
+          s.voiced = true; s.quietMs = 0; lastVoiced = source;
+        } else if (s.voiced) {
+          s.quietMs += 100;
+          if (s.quietMs >= pauseMs) { s.voiced = false; point(source); }
+        }
+      }
+    },
+    idle() { return busy || Promise.resolve(); },
+    report(elapsedMs) {
+      const rtf = runs.map((r) => r.took_ms / Math.max(1, r.audio_ms));
+      const share = elapsedMs > 0 ? busyMs / elapsedMs : null;
+      const keepsUp = share !== null && share < GATE && skipped === 0 && runs.length > 0;
+      return { engine, points, runs: runs.length, skipped, errors: errors.slice(0, 5), busy_ms: busyMs, elapsed_ms: elapsedMs,
+        busy_share: share === null ? null : Math.round(share * 1000) / 1000,
+        window_rtf_median: rtf.length ? Math.round(pct(rtf, 0.5) * 1000) / 1000 : null, window_rtf_p90: rtf.length ? Math.round(pct(rtf, 0.9) * 1000) / 1000 : null,
+        gate: GATE, keeps_up: keepsUp };
+    },
+  };
+}
+
+module.exports = { words, overlap, duplicates, lag, createSettleMeter, REPEAT_MS, ECHO_MS, WINDOW_MS, PAUSE_MS, GATE };