create-pmos 0.78.0 → 0.80.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.78.0",
+  "version": "0.80.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@1dbce98
+kernel-source: pmos@f4177c6
 assembled: 2026-10-07
 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-07T10:39:13Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T13:06:30Z"}
 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-07T10:39:13Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T13:06:30Z"}
 status: stable
 ---
 

package/payload/scripts/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/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-07T10:39:13Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T13:06:30Z"}
 status: stable
 ---
 

package/workspace/ci-checks.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# The fast workspace checks, run first in the Workspace CI test job (hosted or self-hosted).
+# Usage: bash ci-checks.sh [BASE_REF]   — run from workspace/. With BASE_REF (a pull request's base
+# branch) the guide-sync and conformance checks also read the PR's diff.
+set -euo pipefail
+base="${1:-}"
+cd "$(dirname "$0")"
+
+if [ -n "$base" ]; then
+  git fetch --no-tags -q origin "$base"
+  # guide-sync: a pull request that changes the workspace front end also changes the guide.
+  changed=$(git -C .. diff --name-only "origin/$base"...HEAD)
+  if echo "$changed" | grep -q '^workspace/public/pm/' && ! echo "$changed" | grep -q '^workspace/guide/'; then
+    echo "❌ workspace/public/pm/** changed but workspace/guide/** did not. Update the guide page that describes this behaviour (AGENTS.md, 'The user guide')."; exit 1
+  fi
+  echo "✅ guide-sync holds."
+fi
+
+# token hygiene: no raw hex outside the token-definition blocks.
+shopt -s nullglob
+files=(public/pm/*.css)
+[ ${#files[@]} -gt 0 ] || { echo "❌ no stylesheet found under public/pm/ — this check would silently pass"; exit 1; }
+hits=$(awk '/^:root\{/,/^\}/{next} /^\[data-pm-theme="light"\]\{/,/^\}/{next} 1' "${files[@]}" | grep -nE '#[0-9a-fA-F]{3,6}' || true)
+[ -z "$hits" ] || { echo "❌ raw hex in a component rule (use a semantic token):"; echo "$hits"; exit 1; }
+echo "✅ token hygiene holds across ${#files[@]} stylesheet(s)."
+
+# conformance gate (R28): every line of new files, the added lines of changed ones.
+node conformance-gate.js --self-test
+[ -z "$base" ] || node conformance-gate.js --base "origin/$base"
+
+# isolation: workspace/ never imports from web/.
+hits=$(grep -rnE "(from|import|require).*['\"][^'\"]*/?web/" server.js public test.js 2>/dev/null || true)
+[ -z "$hits" ] || { echo "❌ workspace/ reaches into web/ (behavior-preservation floor):"; echo "$hits"; exit 1; }
+echo "✅ isolation holds."
+
+# test lists: every suite is listed once and the shards cover them all.
+node run-tests.js --check

package/workspace/fixtures/initiatives-api/roadmap.json

@@ -175,8 +175,15 @@
         "line2": ""
       },
       "health": {
-        "level": "on",
-        "reasons": []
+        "level": "at-risk",
+        "reasons": [
+          {
+            "level": "at-risk",
+            "code": "pm-step-owed",
+            "text": "Your acceptance is owed. The last evidence is 128 d old",
+            "source": "planning/initiatives/fx-old.md"
+          }
+        ]
       },
       "progress": {
         "done": 0,

package/workspace/guide/notes.md

@@ -42,7 +42,7 @@ After **Stop**, the final notes replace this live draft. See [Final notes after
 
 The notes taken live are a draft. After **Stop**, the workspace transcribes the whole recording again on this machine, with more time for each sentence, and then your agent session writes the final notes from that transcript and your typed lines.
 
-1. The workspace transcribes your microphone and the meeting apart. It uses **Parakeet** when it is set up and the meeting is in English, else Whisper with beam search, speech detection and the names of this meeting.
+1. The workspace transcribes your microphone and the meeting apart. It uses **Qwen3-ASR** when it is set up, in any of the languages. Else it uses **Parakeet** when it is set up and the meeting is in English, else Whisper with beam search, speech detection and the names of this meeting. When one engine fails, the next one set up is used.
 2. It tells the speakers apart. Your microphone is you. The meeting's voices are **Speaker 1**, **Speaker 2** and so on. When no meeting audio was captured, the voices on your microphone are told apart instead.
 3. Your agent session writes the purpose, the overview, the topics, the decisions, the next steps with an owner, and the open questions. Each item shows its meeting time and **Said:** with the words that support it. An item with no supporting words in the transcript is left out, and the note says how many were left out.
 
@@ -50,9 +50,9 @@ For a 30-minute meeting on an M1, this takes about 3 to 10 minutes. Until it is
 
 - To name a speaker, press the name in the transcript, type the name and press **Save**. The name is kept when the meeting is transcribed again.
 - **Show the live transcript** shows what was heard while listening. **Show the final transcript** goes back.
-- **Transcribe again** in the settings runs the final pass again, for example after you set up Parakeet.
+- **Transcribe again** in the settings runs the final pass again, for example after you set up Qwen3-ASR.
 
-To set up Parakeet, speech detection and speakers, open the settings and press **Set up in a terminal** under **Final notes after Stop**. A terminal opens with the commands typed in. They install ffmpeg and Python with Homebrew, then Parakeet and sherpa-onnx in the workspace's own folder, and download the models (up to about 2.5 GB). Read the commands and press Enter. Without them, the final pass uses Whisper and does not tell speakers apart.
+To set up Qwen3-ASR, Parakeet, speech detection and speakers, open the settings and press **Set up in a terminal** under **Final notes after Stop**. A terminal opens with the commands typed in. They install ffmpeg and Python with Homebrew, then Parakeet, sherpa-onnx and mlx-qwen3-asr in the workspace's own folder, and download the models (about 6 GB in all, of which Qwen3-ASR is about 3 GB). Read the commands and press Enter. Without them, the final pass uses Whisper and does not tell speakers apart.
 
 The kept audio holds your microphone and the meeting apart until the final pass is done. When **Keep the audio for replay** is off, both are deleted after the final pass.
 
@@ -77,7 +77,11 @@ Local transcription uses whisper.cpp, a free program that runs on your machine.
 
 If lines come slowly, choose **Faster (about 550 MB)** under **Model** in the settings, press **Set up in a terminal** and press Enter to download it. It is the same model in a smaller form: it starts and runs faster on an M1 and makes a few more mistakes. **Most accurate (1.6 GB)** is the default.
 
-Whisper writes in the language you choose in the settings under **Language spoken in the meeting**: English unless you change it, or Indonesian. **Detect for each line** lets Whisper guess for each few seconds of speech; it can guess wrong and write a line in another language, so choose the language when you know it.
+The transcript is written in the language you choose in the settings under **Language spoken in the meeting**: English unless you change it, Indonesian or Chinese. **Detect for each line** lets the engine find the language of each few seconds of speech. Whisper can guess wrong and write a line in another language, so with Whisper choose the language when you know it. Qwen3-ASR detects the language better, so with it **Detect for each line** is the choice for a meeting that mixes languages.
+
+### Qwen3-ASR for the live transcript
+
+When Qwen3-ASR is set up (see [Final notes after Stop](#final-notes-after-stop)), the live transcript uses it instead of Whisper. It is more accurate in English and Chinese, and it understands Indonesian and speech that mixes these languages. The workspace starts it once, keeps the model loaded while you listen, and stops it after 10 minutes with nothing to transcribe, which frees the memory. The live transcript uses the smaller model (about 800 MB) and the final pass the larger one (about 2 GB). The settings say which engine the live transcript uses. To go back to Whisper, start the workspace with `PMOS_NOTES_QWEN=off`.
 
 If the download stops, press **Set up in a terminal** again and press Enter. The download continues where it stopped, and a part-downloaded model is never used.
 
@@ -148,6 +152,6 @@ To take notes for a calendar event, open the event's detail on the Agenda and pr
 - Audio never leaves this machine. The page sends it to the workspace on this machine, which gives it to whisper.cpp in a temporary file and deletes that file at once. For replay, the workspace keeps one recording of each note in `notes/recordings/` in the state folder, until you delete the audio, the note, or mark the note private. The browser's own recognition is used only on the device, never in the cloud.
 - Notes are files in the workspace's own folder on this machine (`notes/` in the state folder). They are never written into a repository.
 - Only Jev, with the switches on, and your agent session (the final notes, **Summary by agent**, and the Wispr Flow search) receive any text from a note. The Wispr Flow search receives the meeting's time and title only.
-- The final pass runs Parakeet, Whisper and the speaker models on this machine, from temporary files that it deletes when it is done.
+- The final pass runs Qwen3-ASR, Parakeet, Whisper and the speaker models on this machine, from temporary files that it deletes when it is done.
 
 Live notes is a different tool: it maps each talking point to an initiative. See [Live notes](live-notes.md).

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) ─────────────────────────────────────