create-pmos 0.77.0 → 0.79.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.77.0",
+  "version": "0.79.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@721ae05
+kernel-source: pmos@4b6af6a
 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:24:50Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T12:01:33Z"}
 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:24:50Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T12:01:33Z"}
 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:24:50Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T12:01:33Z"}
 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

@@ -1,7 +1,7 @@
 ---
 type: Guide
 title: "Guide: notes"
-description: "How to take notes in a meeting: one note top to bottom, typed notes as timed lines, key points written each minute and labelled by Jev, delete a note; listen to your microphone and the meeting on this machine, see decisions, actions and questions caught as they are said, check them against the repository, correct and tag lines, see what changed in your notes, replay the meeting, link a note to its meeting and its initiative, and get a summary."
+description: "How to take notes in a meeting: one note top to bottom, typed notes as timed lines, key points written each minute and labelled by Jev, delete a note; final notes written after Stop from the whole recording, with speakers and a quote for each item, and Wispr Flow's notes beside them; listen to your microphone and the meeting on this machine, see decisions, actions and questions caught as they are said, check them against the repository, correct and tag lines, see what changed in your notes, replay the meeting, link a note to its meeting and its initiative, and get a summary."
 timestamp: 2026-10-07
 ---
 
@@ -33,11 +33,39 @@ Every minute, your agent session reads that minute of the transcript, with the m
 
 When the agent session does not write a minute's points within two minutes, that minute's lines are labelled as below. When no agent session can start, or the note is private, the lines are labelled on this machine, and Jev labels the clear ones once a minute. A line that ends in the middle of a sentence waits for the rest of it.
 
-After **Stop**, your agent session writes the **Overview** at the top. Until it is written, and when no agent session can start, the overview is picked from what was said, on this machine. Facts and statements with a number go under **Facts mentioned**.
+After **Stop**, the final notes replace this live draft. See [Final notes after Stop](#final-notes-after-stop). Until they are written, and when no agent session can start, the overview is picked from what was said, on this machine. Facts and statements with a number go under **Facts mentioned**.
 
 - To remove an item that does not belong, press the **x** beside it. To take a line out of the summary, press the **x** beside it in the summary.
 - When a caught line is about something in the repository, the closest file shows beside it: **see** the file, a check mark when Jev finds that the file says the same, or **≠** the file when Jev finds that the line says something different. Point at the mark to see the file and the line.
 
+## Final notes after Stop
+
+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.
+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.
+
+For a 30-minute meeting on an M1, this takes about 3 to 10 minutes. Until it is done, the note shows the live notes and says what it is doing.
+
+- 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.
+
+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.
+
+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.
+
+## Wispr Flow notes
+
+When you also record the meeting with Wispr Flow, PMOS fetches Wispr Flow's notes and shows them under **Wispr Flow notes**, below yours.
+
+1. Five minutes after **Stop**, PMOS starts an agent session that looks for this meeting in Wispr Flow, by its time and title.
+2. When Wispr Flow has no notes yet, PMOS asks again every two minutes, for up to 20 minutes.
+3. When it finds them, the summary shows in the note, with **Open in Wispr Flow**.
+
+This needs the Wispr Flow connector in your agent session: add it in Claude Code once and sign in to Wispr Flow in the browser. Cloud Sync must be on in Wispr Flow. PMOS itself sends no request to Wispr Flow. To stop it, clear **Fetch Wispr Flow notes after the meeting** in the settings. A private note is never looked up.
+
 ## Set up local transcription
 
 Local transcription uses whisper.cpp, a free program that runs on your machine. A Mac with Apple silicon (M1 or later) and 8 GB of memory is enough. The model is about 1.6 GB on disk and uses about 3 GB of memory while it runs.
@@ -119,6 +147,7 @@ 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 **Summary by agent**, when you press it, receive any text from a note.
+- 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.
 
 Live notes is a different tool: it maps each talking point to an initiative. See [Live notes](live-notes.md).