create-pmos 0.77.0 → 0.79.0

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

@@ -720,6 +720,8 @@ function computeWorkflowDerived(id, opts) {
     return Number.isFinite(t) ? t : null;
   })();
   const steps = [];
+  // Steps the PM cut or made optional on 2026-10-07 (planning/initiatives/sdlc-step-cuts.md).
+  const CUT_NOTE = 'cut by the PM 2026-10-07 (sdlc-step-cuts)';
 
   // ── route ─ the lane is chosen and the two intake questions are answered ─────────────────────
   const sRoute = specimenRoute(fm.specimen_test);
@@ -731,6 +733,9 @@ function computeWorkflowDerived(id, opts) {
     if (!missing.length) {
       steps.push(step('route', 'route', 'done',
         `${lane} lane · specimen test ${sRoute} · surface ${fRoute}`));
+    } else if (effLane !== 'feature') {
+      // The routing questions are asked of feature work only.
+      steps.push(step('route', 'route', 'done', `${lane} lane — routing questions are for features only (${CUT_NOTE})`));
     } else if (legacy) {
       steps.push(step('route', 'route', 'unknown',
         `${lane} lane · ${missing.join(' + ')} not declared (record predates ${ENFORCED_FROM})`));
@@ -875,41 +880,21 @@ function computeWorkflowDerived(id, opts) {
     }
   }
 
-  // ── understand ─ O4: an existing surface is explained BEFORE it is specified ─────────────────
+  // ── understand ─ O4, made optional (sdlc-step-cuts) ───────────────────────────────────────
+  // An explain-surface pass that exists is shown; a missing one never blocks.
   {
     const expl = String(fm.explainer_path || '').trim();
-    if (fRoute !== 'existing') {
-      steps.push(step('understand', 'understand', 'na',
-        fRoute === 'greenfield' ? 'greenfield — nothing existing to explain first' : 'surface check not declared'));
-    } else if (!expl) {
-      steps.push(step('understand', 'understand', legacy ? 'unknown' : 'blocked',
-        'surface_check says existing but no explainer_path is set',
-        'run build-skills/explain-surface.skill in a FRESH context (not the agent that will write the spec), then set explainer_path:',
-        { blocking: !legacy, rule: 'O4' }));
-    } else if (!fs.existsSync(path.join(root, expl))) {
-      steps.push(step('understand', 'understand', legacy ? 'unknown' : 'blocked',
-        `explainer_path '${expl}' does not exist in the repo`,
-        'set explainer_path to a real explain-surface output',
-        { blocking: !legacy, rule: 'O4' }));
+    if (expl && fs.existsSync(path.join(root, expl))) {
+      steps.push(step('understand', 'understand', 'done', `${expl} — optional surface explainer`));
     } else {
-      const eIdx = firstAppearance(root, range, expl);
-      const ok = ordered(eIdx, prdIdx);
-      if (ok === null) {
-        steps.push(step('understand', 'understand', 'unknown',
-          `${expl} present; order undecidable (${range.ok ? 'no spec artifact to order against' : range.reason})`));
-      } else if (ok) {
-        steps.push(step('understand', 'understand', 'done', `${expl} — first-appeared before ${prd}`));
-      } else {
-        steps.push(step('understand', 'understand', legacy ? 'unknown' : 'blocked',
-          `ORDER VIOLATION — the spec (${prd}) first-appeared BEFORE the explainer (${expl})`,
-          'without the pass first, the AGENT acquires the understanding and the PM approves a spec built on facts they never saw',
-          { blocking: !legacy, rule: 'O4' }));
-      }
+      steps.push(step('understand', 'understand', 'na', `the surface explainer is optional — ${CUT_NOTE}`));
     }
   }
 
   // ── spec ─ the lane's artifacts, and O1/O2: they precede the build ───────────────────────────
-  const needsRubric = effLane === 'feature';
+  // A feature PRD's done-criteria section can serve as its rubric (sdlc-step-cuts), so a separate
+  // rubric file is optional in every lane. One that is declared must still exist.
+  const needsRubric = false;
   {
     const wants = {
       feature: 'a PRD', discovery: 'a spike brief', incident: 'an incident record',
@@ -925,7 +910,7 @@ function computeWorkflowDerived(id, opts) {
     } else if (!prd) {
       steps.push(step('spec', 'spec', 'blocked', `no prd_path — the ${effLane} lane needs ${wants}`,
         effLane === 'feature'
-          ? 'author the PRD (skills/core/prd.skill) and the rubric alongside it (D13), then set prd_path + rubric_path'
+          ? 'author the PRD (skills/core/prd.skill) with its done-criteria (D13), then set prd_path'
           : `author ${wants} and set prd_path in ${recRel}`,
         { blocking: true, rule: 'R2' }));
     } else if (prdIdx === null) {
@@ -970,88 +955,24 @@ function computeWorkflowDerived(id, opts) {
   const runs = cachedJsonl(path.join(L.runsDir, L.runsFile)).filter((r) => r && r.initiative_id === id);
   const runsRel = path.relative(root, path.join(L.runsDir, L.runsFile));
 
-  // ── priors ─ O7: the episodic read is CITED, and the citation is checked ─────────────────────
-  // AGENTS.md step 3 mandates reading this initiative's earlier runs BEFORE acting — the one kernel
-  // invariant that was still asserted only in prose. Nothing can derive that a file was READ, and
-  // this rule does not pretend to: what it derives is the three things that ARE decidable from the
-  // record, and together they are what separates it from a checkbox.
-  //   1. whether earlier runs existed at all      — the rule is vacuous on a first run, and says so
-  //   2. whether the run declared what it consulted
-  //   3. whether the ids it named are REAL and actually EARLIER
-  // (3) is the part that matters. O5's `PM_approved: true` is a bare boolean, satisfiable by typing
-  // it; a fabricated `priors` list fails against the corpus it claims to have read. The rule is
-  // NON-BLOCKING for the same reason O5/O6 are: it cannot be true before a run exists, and a rule
-  // enforced at a moment it cannot be satisfied only teaches people to reach for the escape hatch.
-  {
-    const latest = runs.length ? runs[runs.length - 1] : null;
-    const earlier = runs.slice(0, -1);
-    const cite = priorsCitation(latest);
-    const how = `consult this initiative's earlier runs BEFORE acting (AGENTS.md step 3) and cite them as \`priors\` on the run in ${runsRel}`;
-    if (!latest) {
-      steps.push(step('priors', 'priors', 'pending', 'no run logged for this initiative yet', how, { rule: 'O7' }));
-    } else if (!earlier.length) {
-      // Not a pass — there was nothing to pass. A tick here would be the watermelon this engine exists to prevent.
-      steps.push(step('priors', 'priors', 'na',
-        `${latest.run_id} is the first run on this initiative — no priors to consult`));
-    } else if (cite.malformed) {
-      steps.push(step('priors', 'priors', legacy ? 'pending' : 'blocked',
-        `${latest.run_id} has a malformed priors citation — ${cite.malformed}`,
-        `use \`priors: ["<run_id>", …]\` or \`priors: {consulted: [...], note: "…"}\` in ${runsRel}`,
-        { rule: 'O7' }));
-    } else if (!cite.declared) {
-      steps.push(step('priors', 'priors', legacy ? 'pending' : 'blocked',
-        `${latest.run_id} follows ${earlier.length} earlier run(s) on this initiative and cites no priors`,
-        how, { rule: 'O7' }));
-    } else {
-      const byId = new Map(runs.map((r) => [String(r.run_id), r]));
-      const earlierIds = new Set(earlier.map((r) => String(r.run_id)));
-      const missing = cite.consulted.filter((x) => !byId.has(x));
-      const notEarlier = cite.consulted.filter((x) => byId.has(x) && !earlierIds.has(x));
-      if (missing.length) {
-        // The check a declared field would otherwise never get. A citation naming a run that does not
-        // exist reports a read that cannot have happened — worse than an absent citation, because it
-        // reads as compliance on the board.
-        steps.push(step('priors', 'priors', legacy ? 'pending' : 'blocked',
-          `${latest.run_id} cites prior run(s) that do not exist on this initiative: ${missing.join(', ')}`,
-          `cite run_ids that are actually in ${runsRel} — a citation naming nothing reports a read that cannot have happened`,
-          { rule: 'O7' }));
-      } else if (notEarlier.length) {
-        steps.push(step('priors', 'priors', legacy ? 'pending' : 'blocked',
-          `${latest.run_id} cites ${notEarlier.join(', ')}, which ${notEarlier.length > 1 ? 'are' : 'is'} not EARLIER than it`,
-          'a run cannot consult itself or a run that came after it — cite only runs logged before this one',
-          { rule: 'O7' }));
-      } else if (!cite.consulted.length && !cite.note) {
-        steps.push(step('priors', 'priors', legacy ? 'pending' : 'blocked',
-          `${latest.run_id} declares an empty priors list with no note, over ${earlier.length} earlier run(s)`,
-          'an empty list with no reason is indistinguishable from not looking — say which priors were read, or say in `note` why none applied',
-          { rule: 'O7' }));
-      } else if (!cite.consulted.length) {
-        // Allowed, and deliberately not silent: the machine cannot judge whether the priors were
-        // genuinely irrelevant, so it surfaces the claim verbatim for the PM instead of ticking.
-        steps.push(step('priors', 'priors', 'done',
-          `${latest.run_id} consulted none of ${earlier.length} earlier run(s) — declared irrelevant: ${cite.note}`));
-      } else {
-        steps.push(step('priors', 'priors', 'done',
-          `${latest.run_id} cites ${cite.consulted.length} prior run(s): ${cite.consulted.join(', ')}${cite.note ? ` — ${cite.note}` : ''}`));
-      }
-    }
-  }
+  // ── priors ─ O7, cut (sdlc-step-cuts) ───────────────────────────────────────────────────────
+  // Reading earlier runs is still good practice; citing them is no longer checked.
+  steps.push(step('priors', 'priors', 'na', `prior-run citation is not required — ${CUT_NOTE}`));
 
-  // ── contract ─ O5: PM-approved done-criteria before the build. Reported, never CI-blocking ────
+  // ── contract ─ O5: PM-approved done-criteria. Reported, never blocking ─────────────────────
+  // Since sdlc-step-cuts only the feature lane asks for it, and a missing sign-off is pending, not
+  // blocked: the PM's approval of the PRD and the acceptance at the end are the sign-offs that count.
   const approved = runs.find((r) => r.pre_run_contract && r.pre_run_contract.PM_approved === true);
   {
     if (approved) {
       steps.push(step('contract', 'contract', 'done',
         `PM-approved pre_run_contract on run ${approved.run_id}${approved.pre_run_contract.approved_by ? ` (by ${approved.pre_run_contract.approved_by})` : ''}`));
-    } else if (runs.length) {
-      steps.push(step('contract', 'contract', legacy ? 'pending' : 'blocked',
-        `${runs.length} run(s) logged, none with pre_run_contract.PM_approved: true`,
-        `agree numbered done_criteria + test_method with the PM and record the approval in ${runsRel}`,
-        { rule: 'O5' }));
+    } else if (effLane !== 'feature') {
+      steps.push(step('contract', 'contract', 'na', `${effLane} lane — the PM's acceptance stands in for a contract sign-off (${CUT_NOTE})`));
     } else {
       steps.push(step('contract', 'contract', 'pending',
-        'no run logged for this initiative yet',
-        `agree done_criteria + test_method BEFORE building and append the run to ${runsRel} with PM_approved: true`,
+        runs.length ? `${runs.length} run(s) logged, none with pre_run_contract.PM_approved: true` : 'no run logged for this initiative yet',
+        `agree done_criteria + test_method with the PM (approving the PRD counts) and record it in ${runsRel}`,
         { rule: 'O5' }));
     }
   }
@@ -1143,41 +1064,32 @@ function computeWorkflowDerived(id, opts) {
        * fix that made a chore's gate visible ADDED one. The module's own rule, repeated in three
        * files — "a skip is an honest RECORD that verification did not happen; it is not
        * verification" — now applies to the surface that reports it. */
+      // The Review Gate runs on request since sdlc-step-cuts: a skip is n/a, and a FAIL is reported
+      // for the PM to weigh at acceptance rather than holding the gate shut.
       if (verdict === 'SKIPPED') {
-        steps.push(step('review', 'review', 'pending', label,
-          'the gate was skipped, so it is still owed — commission an independent evaluator and record a real verdict',
-          { rule: 'R3' }));
+        steps.push(step('review', 'review', 'na', `${label} — skipped; the Review Gate runs on request (${CUT_NOTE})`));
       } else if (verdict === 'FAIL') {
-        steps.push(step('review', 'review', 'blocked', label,
-          'the Review Gate FAILED — remediate the findings and record a new verdict', { rule: 'R3' }));
+        steps.push(step('review', 'review', 'pending', label,
+          'the Review Gate FAILED — weigh the findings at acceptance, or remediate and record a new verdict', { rule: 'R3' }));
       } else {
         steps.push(step('review', 'review', 'done', label));
       }
     } else {
-      steps.push(step('review', 'review', 'pending', 'no Review-Gate verdict recorded',
-        'score the build against the rubric (build-skills/evaluator.skill), then append to evals.jsonl',
-        { rule: 'R3' }));
+      steps.push(step('review', 'review', 'na', `no Review-Gate verdict — it runs on request (${CUT_NOTE})`));
     }
   }
 
-  // ── explain ─ O6: the run is explained AFTER the build and BEFORE acceptance ─────────────────
+  // ── explain ─ O6, made optional (sdlc-step-cuts) ────────────────────────────────────────────
+  // A run explainer that exists is shown; a missing one never blocks acceptance.
   {
     let found = null;
     for (const r of runs) {
       const p = path.join(L.explainers, `${r.run_id}-explainer.md`);
       if (fs.existsSync(p)) { found = path.relative(root, p); break; }
     }
-    if (found) {
-      steps.push(step('explain', 'explain', 'done', found));
-    } else if (!runs.length) {
-      steps.push(step('explain', 'explain', 'pending', 'no run to explain yet',
-        'log the run first, then run build-skills/explain-run.skill against its diff', { rule: 'O6' }));
-    } else {
-      steps.push(step('explain', 'explain', legacy ? 'pending' : 'blocked',
-        `no explainer at ${path.relative(root, L.explainers)}/${runs[runs.length - 1].run_id}-explainer.md`,
-        'run build-skills/explain-run.skill — raw-transcript vigilance degrades within ~30 min, so the explainer is what the PM actually reviews',
-        { rule: 'O6' }));
-    }
+    steps.push(found
+      ? step('explain', 'explain', 'done', found)
+      : step('explain', 'explain', 'na', `the run explainer is optional — ${CUT_NOTE}`));
   }
 
   // ── accept ─ the human PM, final and non-delegable (D12) ─────────────────────────────────────

package/workspace/lib/notes-audio.js

@@ -4,6 +4,7 @@
  *   write(runtimeDir, { id, source, pcm, t })   add one chunk of 16 kHz mono 16-bit samples at meeting time t (ms)
  *   info(runtimeDir, id) → { bytes, ms } | null
  *   remove(runtimeDir, id)                      delete the note's audio
+ *   sources(runtimeDir, id) → [{ source, file, bytes, ms }]   each source's own samples (Run 9)
  *   serve(req, res, runtimeDir, id)             the audio as a WAV file, with byte ranges so the page can seek
  *   getKeep(runtimeDir) · setKeep(runtimeDir, bool)   "Keep the audio for replay", on by default, for this machine
  *
@@ -13,6 +14,10 @@
  * arrives on time or early, so the small jitter of the page's timer leaves no clicks; a chunk that arrives much later (Listen again)
  * is placed at its own time, and the gap stays silent.
  *
+ * EACH SOURCE APART (Run 9). Each source is also written to its own file, `<id>.mic.pcm` and `<id>.meeting.pcm`, at the same
+ * place and with nothing added, so the final pass after Stop (lib/notes-final.js) can tell the PM's microphone from the
+ * meeting. remove deletes all three.
+ *
  * WHAT IT NEVER DOES. It sends nothing and opens no network module. The routes (lib/routes-notes.js) write nothing for a
  * private note, delete the file when a note is made private or deleted, and write nothing when the PM switches keeping off.
  */
@@ -27,6 +32,8 @@ const ID_RE = /^n-[0-9a-z]{4,16}-[0-9a-f]{4}$/;
 
 const dirOf = (runtimeDir) => path.join(runtimeDir, 'notes', 'recordings');
 const fileOf = (runtimeDir, id) => path.join(dirOf(runtimeDir), id + '.pcm');
+const SOURCES = ['mic', 'meeting'];
+const sourceFileOf = (runtimeDir, id, source) => path.join(dirOf(runtimeDir), id + '.' + source + '.pcm');
 const settingsFile = (runtimeDir) => path.join(runtimeDir, 'notes', 'audio-settings.json');
 const next = new Map();                     // `${file}|${source}` → the byte offset where that source's last chunk ended
 
@@ -43,8 +50,9 @@ function setKeep(runtimeDir, keep) {
   return { ok: true, keep };
 }
 
-/** Add one chunk at meeting time `t`. Samples already there (the other source) are added to, and clipped. */
-function write(runtimeDir, { id, source, pcm, t }) {
+/** Add one chunk at meeting time `t`. Samples already there (the other source) are added to, and clipped. With `mixed:
+ * false` only the source's own file is written: the PM keeps no audio for replay, and the final pass deletes it when done. */
+function write(runtimeDir, { id, source, pcm, t, mixed = true }) {
   if (!ID_RE.test(String(id || '')) || !pcm || !pcm.length || pcm.length % 2) return { ok: false, error: 'nothing to keep' };
   const f = fileOf(runtimeDir, id);
   const key = f + '|' + source;
@@ -55,14 +63,21 @@ function write(runtimeDir, { id, source, pcm, t }) {
   if (at >= MAX_BYTES) return { ok: true, kept: false };
   const len = Math.min(pcm.length, MAX_BYTES - at);
   fs.mkdirSync(dirOf(runtimeDir), { recursive: true });
-  const fd = fs.openSync(f, fs.existsSync(f) ? 'r+' : 'w+', 0o600);
-  try {
-    const old = Buffer.alloc(len);
-    fs.readSync(fd, old, 0, len, at);
-    const out = Buffer.alloc(len);
-    for (let i = 0; i < len; i += 2) out.writeInt16LE(Math.max(-32768, Math.min(32767, old.readInt16LE(i) + pcm.readInt16LE(i))), i);
-    fs.writeSync(fd, out, 0, len, at);
-  } finally { fs.closeSync(fd); }
+  if (mixed) {
+    const fd = fs.openSync(f, fs.existsSync(f) ? 'r+' : 'w+', 0o600);
+    try {
+      const old = Buffer.alloc(len);
+      fs.readSync(fd, old, 0, len, at);
+      const out = Buffer.alloc(len);
+      for (let i = 0; i < len; i += 2) out.writeInt16LE(Math.max(-32768, Math.min(32767, old.readInt16LE(i) + pcm.readInt16LE(i))), i);
+      fs.writeSync(fd, out, 0, len, at);
+    } finally { fs.closeSync(fd); }
+  }
+  if (SOURCES.includes(source)) {
+    const sf = sourceFileOf(runtimeDir, id, source);
+    const sd = fs.openSync(sf, fs.existsSync(sf) ? 'r+' : 'w+', 0o600);
+    try { fs.writeSync(sd, pcm, 0, len, at); } finally { fs.closeSync(sd); }
+  }
   next.set(key, at + len);
   return { ok: true, kept: true, at_ms: at / BYTES_PER_MS };
 }
@@ -71,11 +86,26 @@ function info(runtimeDir, id) {
   if (!ID_RE.test(String(id || ''))) return null;
   try { const st = fs.statSync(fileOf(runtimeDir, id)); return st.size ? { bytes: st.size, ms: Math.round(st.size / BYTES_PER_MS) } : null; } catch { return null; }
 }
+function removeSources(runtimeDir, id) {
+  if (!ID_RE.test(String(id || ''))) return;
+  for (const src of SOURCES) { try { fs.unlinkSync(sourceFileOf(runtimeDir, id, src)); } catch { /* none */ } }
+}
 function remove(runtimeDir, id) {
   if (!ID_RE.test(String(id || ''))) return false;
   for (const k of [...next.keys()]) if (k.startsWith(fileOf(runtimeDir, id) + '|')) next.delete(k);
+  for (const src of SOURCES) { try { fs.unlinkSync(sourceFileOf(runtimeDir, id, src)); } catch { /* none */ } }
   try { fs.unlinkSync(fileOf(runtimeDir, id)); return true; } catch { return false; }
 }
+/** The note's audio, one file per source: [{ source, file, bytes, ms }], the sources that were heard. */
+function sources(runtimeDir, id) {
+  if (!ID_RE.test(String(id || ''))) return [];
+  const out = [];
+  for (const source of SOURCES) {
+    const file = sourceFileOf(runtimeDir, id, source);
+    try { const st = fs.statSync(file); if (st.size) out.push({ source, file, bytes: st.size, ms: Math.round(st.size / BYTES_PER_MS) }); } catch { /* not heard */ }
+  }
+  return out;
+}
 
 function wavHeader(dataBytes) {
   const h = Buffer.alloc(44);
@@ -108,4 +138,4 @@ function serve(req, res, runtimeDir, id) {
   fs.createReadStream(fileOf(runtimeDir, id), { start: from, end: to }).on('error', () => res.end()).pipe(res);
 }
 
-module.exports = { write, info, remove, serve, getKeep, setKeep, wavHeader, RATE, BYTES_PER_MS, MAX_BYTES };
+module.exports = { write, info, remove, removeSources, sources, serve, getKeep, setKeep, wavHeader, RATE, BYTES_PER_MS, MAX_BYTES };

package/workspace/lib/notes-diarize.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""notes-diarize.py: who spoke when in one audio file, on this machine (meeting-notes Run 9).
+
+    python3 notes-diarize.py --segmentation <model.onnx> --embedding <model.onnx> --wav <file.wav> [--speakers N]
+
+The WAV is 16 kHz mono 16-bit. Prints one JSON object to stdout:
+    {"ok": true, "segments": [{"start": 0.5, "end": 3.2, "speaker": 0}, ...]}
+or {"ok": false, "error": "..."} with exit code 1.
+
+It uses sherpa-onnx's offline speaker diarization (a pyannote segmentation model and a speaker embedding model,
+clustered). It reads no network and writes no file. lib/notes-final.js runs it after Stop, one file at a time.
+"""
+import argparse
+import json
+import sys
+import wave
+
+
+def fail(msg):
+    print(json.dumps({"ok": False, "error": msg}))
+    sys.exit(1)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--segmentation", required=True)
+    ap.add_argument("--embedding", required=True)
+    ap.add_argument("--wav", required=True)
+    ap.add_argument("--speakers", type=int, default=0, help="the number of speakers when known, else 0")
+    ap.add_argument("--threshold", type=float, default=0.5, help="clustering threshold when the number is not known")
+    a = ap.parse_args()
+    try:
+        import numpy as np
+        import sherpa_onnx
+    except Exception as e:  # noqa: BLE001
+        fail("sherpa-onnx is not installed: " + str(e))
+    try:
+        with wave.open(a.wav, "rb") as w:
+            if w.getframerate() != 16000 or w.getnchannels() != 1 or w.getsampwidth() != 2:
+                fail("the audio must be 16 kHz mono 16-bit")
+            samples = np.frombuffer(w.readframes(w.getnframes()), dtype=np.int16).astype(np.float32) / 32768.0
+    except wave.Error as e:
+        fail("cannot read the audio: " + str(e))
+    config = sherpa_onnx.OfflineSpeakerDiarizationConfig(
+        segmentation=sherpa_onnx.OfflineSpeakerSegmentationModelConfig(
+            pyannote=sherpa_onnx.OfflineSpeakerSegmentationPyannoteModelConfig(model=a.segmentation)),
+        embedding=sherpa_onnx.SpeakerEmbeddingExtractorConfig(model=a.embedding),
+        clustering=sherpa_onnx.FastClusteringConfig(num_clusters=a.speakers if a.speakers > 0 else -1, threshold=a.threshold),
+        min_duration_on=0.3,
+        min_duration_off=0.5,
+    )
+    if not config.validate():
+        fail("the diarization models are missing or do not load")
+    sd = sherpa_onnx.OfflineSpeakerDiarization(config)
+    result = sd.process(samples).sort_by_start_time()
+    segs = [{"start": round(r.start, 2), "end": round(r.end, 2), "speaker": int(r.speaker)} for r in result]
+    print(json.dumps({"ok": True, "segments": segs}))
+
+
+if __name__ == "__main__":
+    main()