create-pmos 0.48.0 → 0.49.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.48.0",
+  "version": "0.49.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@df469ed
-assembled: 2026-10-04
+kernel-source: pmos@676b0dc
+assembled: 2026-10-05
 mode: vendor

package/payload/mods/pmos-cockpit/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-cockpit",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Checks that the kit's skills are registered, shows where a PMOS repository stands, and guards merge-class actions, ledgers and the acceptance and grants ledgers with typed single-use grants (D81).",
   "types": "./types/index.d.ts",
   "author": {

package/payload/mods/pmos-cockpit/README.md

@@ -32,6 +32,15 @@ A grant is one line in `grants.jsonl`. You mint it by typing `/pmos-grant merge:
 
 `/pmos-accept <run_id> pass|fail <note>` records your Acceptance through the same writer, with `pm_label` set. When your own message reads as an approval, a band offers Pass, Fail and Not now for the newest run of the branch's initiative that has no acceptance. Your press writes the row; the note quotes your message. Nothing is written from inferred text.
 
+## Model routing (prompt-model-routing, Run 3)
+
+- **Every prompt is routed before it runs.** When the PMOS workspace started this terminal, it put its own loopback address in `PMOS_ROUTE_URL`. The mod asks that address for the route of each prompt you type and each prompt handed to a sub-agent. The workspace asks Jev only when its three gates are open: a saved key, consent for the repository, and the "route prompts with Jev" switch (D84). All three are on the workspace's validation page. The key stays in the workspace and never reaches this terminal.
+- **The model switches automatically, only on a real answer.** When Jev or a rule decided the tier and it names another model, the mod runs `/model <model>` and then sends your prompt, once, unchanged. A toast names the model and the tier. When only the keyword routes answered, or Jev is off, slow or withheld the prompt, the model stays and you are told why once a session.
+- **What is not routed.** Slash commands, prompts with an attachment or an `@file` mention (a resent prompt would lose them), prompts typed while a turn runs, and prompts under 40 characters, which usually refer back to the conversation.
+- **Sub-agents.** A sub-agent gets the routed model when the Agent call named none. The read-only reviewer stays pinned (D40), and forks inherit.
+- **Cost.** Switching model in the middle of a conversation gives up the prompt cache, so the next turn reads the whole conversation again at full price. `/pmos-route off` stops routing for the session; `/pmos-route status` says whether it is on.
+- **Unmeasured.** Whether Jev picks the right tier is not measured yet. `pmos-model bakeoff` on your labelled prompts is how to find out.
+
 ## Independent review (M14)
 
 `/pmos-review [model]` starts a read-only reviewer for the newest run of the branch's initiative. The reviewer is a subagent with the tools Read, Grep and Glob and nothing else, and it runs on a model of a different family than yours (D40: a judge over-rewards its own family's style). The mod picks the model, or checks the one you name, and refuses when your own model cannot be placed in a family. Only your typed command starts it, and the model you build with is not offered it.
@@ -63,7 +72,7 @@ Before a merge-class action the mod runs the local gate for the branch's initiat
 - **`/pmos-handover confirm`**, or the Commit and push button, writes the note, stages exactly the planned paths, commits and runs `git push -u origin <branch>`. **`confirm local`**, or Commit only, does the same without the push. A confirmation is good for the plan it follows: a new commit, different changed files, another branch or ten minutes all send you back to a new plan, and nothing is written. The mod never skips a hook (a failing one is reported, the note stays on disk and nothing is pushed), never forces, and never retries a failed push; the local commit is kept. With no remote named `origin` it commits only and says so. A run that did not come from you is refused, in all three modes.
 - **The note** is `planning/handovers/<id>.md` in PMOS's own repository and `pmos/state/handovers/<id>.md` in a kit, one per initiative, replaced on each handover (git keeps the old ones). It holds the stage, next step and blocking steps from the ladder, the branch, the head commit, and your words quoted as yours. What git supplies (commit subjects, paths) sits inside one fenced block marked as copied data. It records a snapshot of one branch, not what was tried, dropped or decided in conversation, unless your words say so.
 - **The resume summary** is a band at session start when the branch's initiative has a note: when it was written, at which commit, the stage and next step it recorded, how many commits the branch has moved since (or that the history has changed, after a rebase), and your words cut to 80 characters. It has Dismiss and no other button, and is shown after the blocking bands and the cloud band. `/pmos-status` prints the same facts. It is for you: the prompt section is unchanged, so the model reads the note only if you ask it to.
-- **The one network use.** The push, after your confirmation and through git's own credentials. The mod opens no pull request. A hook, a credential prompt or a protected branch on the remote can still refuse the push.
+- **The one network use.** The push, after your confirmation and through git's own credentials. (Model routing also asks the workspace on its loopback address; see Model routing.) The mod opens no pull request. A hook, a credential prompt or a protected branch on the remote can still refuse the push.
 
 ## What it does not cover
 

package/payload/mods/pmos-cockpit/hooks/lib/route.mjs

@@ -0,0 +1,95 @@
+// Automatic model routing (prompt-model-routing, Run 3; D75 §6 and D84 point 4 as amended by the PM on
+// 2026-10-04). Each prompt the person types, and each prompt handed to a sub-agent, is routed before it
+// runs. The route comes from the workspace, which alone holds the Jev key (D79) and asks Jev only when
+// D84's three gates are open. The mod switches the model only on an answer that Jev or a rule gave; a
+// keyword guess never moves the model, because "no rule matched" is not evidence about the prompt.
+//
+// Everything here is pure. register.tsx asks the workspace, reads the session's model, and runs the switch.
+
+import { REVIEWER_TYPE, familyOf } from './review.mjs';
+
+// A prompt shorter than this usually refers back to the conversation ("yes", "go on", "fix that"), and
+// its text says nothing about how hard the work is. It keeps the model the session is on.
+export const MIN_CHARS = 40;
+// What the mod waits for the workspace's answer, Jev included. The workspace bounds Jev itself; this
+// bounds a workspace that does not answer. After it the prompt goes on unchanged.
+export const ASK_LIMIT_MS = 4000;
+// Only a loopback address the workspace wrote into the terminal's environment is ever asked.
+const ROUTE_URL = /^http:\/\/127\.0\.0\.1:\d{2,5}\/api\/model\/route$/;
+const MODEL = /^[A-Za-z0-9][A-Za-z0-9._:\/\[\]-]{0,99}$/;
+const DECIDING = new Set(['jev', 'rules']);
+
+/** The workspace's route address from PMOS_ROUTE_URL, or null when it is absent or not loopback. */
+export function routeUrl(value) {
+  return typeof value === 'string' && ROUTE_URL.test(value) ? value : null;
+}
+
+/**
+ * Whether a submitted prompt is routed at all.
+ * @param {{ text?: string, attachments?: unknown[], origin?: { kind?: string }, turnId?: string }} e
+ * @returns {{ ok: true } | { ok: false, why: string }}
+ */
+export function shouldRoute(e) {
+  const text = typeof e?.text === 'string' ? e.text : '';
+  if (e?.origin && e.origin.kind !== 'composer') return { ok: false, why: 'not typed by the person' };
+  if (e?.turnId) return { ok: false, why: 'typed while a turn runs; the model is not changed mid-turn' };
+  if (text.trimStart().startsWith('/')) return { ok: false, why: 'a slash command' };
+  if (Array.isArray(e?.attachments) && e.attachments.length) return { ok: false, why: 'it carries an attachment, which a resubmitted prompt would lose' };
+  if (/(^|\s)@[^\s@]/.test(text)) return { ok: false, why: 'it names a file with @, which a resubmitted prompt would not expand' };
+  if (text.trim().length < MIN_CHARS) return { ok: false, why: `under ${MIN_CHARS} characters, so it likely refers back to the conversation` };
+  return { ok: true };
+}
+
+/** The workspace's answer as the mod uses it, or null when it is not one. */
+export function parseRoute(status, text) {
+  if (status !== 200 || typeof text !== 'string') return null;
+  let o; try { o = JSON.parse(text) } catch { return null }
+  if (!o || o.ok !== true) return null;
+  if (o.shadow === true) return { shadow: true, id: typeof o.id === 'string' ? o.id : null };
+  if (typeof o.tier !== 'string' || typeof o.model !== 'string' || !MODEL.test(o.model) || typeof o.stage !== 'string') return null;
+  return { shadow: false, id: typeof o.id === 'string' ? o.id : null, tier: o.tier, model: o.model, stage: o.stage,
+    why: typeof o.why === 'string' ? o.why.slice(0, 200) : '', sent: o.sent === true,
+    gate: o.gate && typeof o.gate.sentence === 'string' ? o.gate.sentence.slice(0, 300) : null,
+    withheld: typeof o.withheld === 'string' ? o.withheld : null };
+}
+
+/** Same model, compared by family so an alias matches its full id ('sonnet' and 'claude-sonnet-5-5'). */
+export function sameModel(current, target) {
+  if (typeof current !== 'string' || typeof target !== 'string') return false;
+  if (current === target) return true;
+  const a = familyOf(current); const b = familyOf(target);
+  return a !== null && a === b;
+}
+
+/**
+ * What to do with a typed prompt, given the workspace's answer and the session's model.
+ * @returns {{ action: 'keep', why: string, tell?: true } | { action: 'switch', model: string, tier: string, why: string }}
+ * `tell` marks a reason the person should hear once a session: Jev was not asked, withheld or silent.
+ */
+export function decide(answer, current) {
+  if (!answer) return { action: 'keep', why: 'the workspace gave no route' };
+  if (answer.shadow) return { action: 'keep', why: 'shadow mode: the route was logged and is not applied' };
+  if (!DECIDING.has(answer.stage)) {
+    const reason = answer.gate ? `Jev was not asked: ${answer.gate.replace(/[.\s]+$/, '')}` : answer.withheld ? `the prompt was withheld from Jev (${answer.withheld})` : 'Jev did not answer';
+    return { action: 'keep', why: `${reason}, so the model stays`, tell: true };
+  }
+  if (sameModel(current, answer.model)) return { action: 'keep', why: `already on the ${answer.tier} tier` };
+  return { action: 'switch', model: answer.model, tier: answer.tier, why: answer.why };
+}
+
+/**
+ * The model to give a sub-agent, or null to leave its spawn alone: when the Agent call named a model,
+ * when the agent is the read-only reviewer (pinned, D40), when it is a fork (forks inherit), or when the
+ * answer did not come from Jev or a rule.
+ */
+export function subagentModel(spawn, answer) {
+  if (!spawn || spawn.model) return null;
+  if (spawn.subagentType === REVIEWER_TYPE || spawn.subagentType === 'fork') return null;
+  if (!answer || answer.shadow || !DECIDING.has(answer.stage)) return null;
+  return answer.model;
+}
+
+/** The one line the person sees when a typed prompt is switched. */
+export function switchNote(d) {
+  return `PMOS routed this prompt to ${d.model} (${d.tier})${d.why ? `: ${d.why}` : ''}. /pmos-route off stops it.`.slice(0, 280);
+}

package/payload/mods/pmos-cockpit/hooks/register.tsx

@@ -18,6 +18,7 @@ import { UNPUSHED_PROBES, cloudBandText, interpretUnpushed } from './lib/unpushe
 import { HANDOVER_PROBES, buildPlan, countSince, interpretSince, notePaths, parseNote, planStillGood, renderNote, resumeText, sinceProbes, subjectsProbe } from './lib/handover.mjs'
 import { carryOut } from './lib/handover-run.mjs'
 import { REVIEWER_AGENT, REVIEWER_PROMPT, REVIEWER_TOOLS, REVIEWER_TYPE, buildReviewPrompt, offerText, parseVerdict, pickReviewerModel, planEval } from './lib/review.mjs'
+import { ASK_LIMIT_MS, decide, parseRoute, routeUrl, shouldRoute, subagentModel, switchNote } from './lib/route.mjs'
 
 const status = atom({ plugin: 'pmos-cockpit', key: 'status' } as const, null)
 const isHidden = atom({ plugin: 'pmos-cockpit', key: 'isHidden' } as const, false)
@@ -40,6 +41,9 @@ const resumeGone = atom({ plugin: 'pmos-cockpit', key: 'resumeGone' } as const,
 // held until a person presses Record or types /pmos-record-review. Neither is ever written to a ledger.
 const review = atom({ plugin: 'pmos-cockpit', key: 'review' } as const, null)
 const reviewOffer = atom({ plugin: 'pmos-cockpit', key: 'reviewOffer' } as const, null)
+// Model routing (prompt-model-routing, Run 3). On by default for the session; /pmos-route off stops it.
+// `told` keeps the "why nothing was switched" toast to once a session.
+const routing = atom({ plugin: 'pmos-cockpit', key: 'routing' } as const, { on: true, told: false })
 // The width the person's terminal draws the band at, seen at the last render. Lost on a reload, which
 // only returns the status line to its default width.
 let lastColumns = 0
@@ -80,6 +84,22 @@ async function readMode($: any): Promise<{ mode: string; signal: string | null }
 
 const isPerson = (e: any): boolean => e?.origin?.kind === 'composer' || e?.origin?.kind === 'bridge'
 
+// Ask the workspace for a prompt's route. The workspace holds the Jev key and asks Jev only when D84's
+// gates are open; the mod never sees the key and reaches no host but the loopback address the workspace
+// put in the terminal's environment. A terminal started outside the workspace has none: nothing is asked.
+async function askRoute($: any, prompt: string, source: 'pm' | 'agent'): Promise<any> {
+  let url: string | null = null
+  try { url = routeUrl(await $.env.get('PMOS_ROUTE_URL')) } catch { url = null }
+  if (url === null) return null
+  try {
+    const root: string = await $.session.root()
+    const ask = $.http.fetch(url, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ root, prompt, source, interactive: true }) })
+      .then((r: any) => parseRoute(r?.status, r?.text)).catch(() => null)
+    const late = $.clock.sleep(ASK_LIMIT_MS).then(() => null).catch(() => null)
+    return await Promise.race([ask, late])
+  } catch { return null }
+}
+
 async function readText($: any, path: string): Promise<string | null> {
   try { return (await $.fs.exists(path)) ? await $.fs.read(path) : null } catch { return null }
 }
@@ -599,6 +619,7 @@ export const register: Register = (on) => {
     await $.command.register({ name: 'pmos-accept', description: 'Record your Acceptance of a run: /pmos-accept <run_id> pass|fail <note>' })
     await $.command.register({ name: 'pmos-review', description: 'Ask a read-only reviewer on another model to judge the newest run: /pmos-review [model]' })
     await $.command.register({ name: 'pmos-record-review', description: 'Record the reviewer verdict that is waiting (the same as pressing Record)' })
+    await $.command.register({ name: 'pmos-route', description: 'Model routing for this session: /pmos-route on | off | status' })
     try {
       await $.agent.register({ name: REVIEWER_AGENT, description: 'Independent read-only reviewer started by /pmos-review. Not for the builder to call.', prompt: REVIEWER_PROMPT, tools: [...REVIEWER_TOOLS] })
     } catch { /* the review command says so when it cannot start the reviewer */ }
@@ -823,7 +844,52 @@ export const register: Register = (on) => {
     if (e.origin?.kind === 'composer' && readsAsApproval(e.text)) {
       try { const o = await buildOffer($, e.text); await update($, offer, () => o) } catch { /* no offer */ }
     }
-    return next(e)
+    // Model routing. A prompt that needs another model enters nothing now: the mod runs `/model` and
+    // then submits the same text as the person's own, so the turn runs on the routed model. Anything
+    // that fails on the way sends the prompt on unchanged; a prompt is never lost or held back.
+    const r: any = await read($, routing)
+    if (!r?.on || !shouldRoute(e).ok) return next(e)
+    const answer = await askRoute($, e.text, 'pm')
+    let current: string | undefined
+    try { current = await $.session.model() } catch { current = undefined }
+    const d: any = decide(answer, current as any)
+    if (d.action !== 'switch') {
+      if (d.tell && !r.told) {
+        await update($, routing, (x: any) => ({ ...x, told: true }))
+        $.ui.toast(`PMOS did not switch the model: ${d.why}.`.slice(0, 280))
+      }
+      return next(e)
+    }
+    const text = e.text
+    $.clock.after(0, () => {
+      void (async () => {
+        try { await $.command.run({ command: 'model', args: d.model }) } catch { /* the prompt still goes, on the current model */ }
+        try { await $.prompt.submit({ text, asUser: true }) } catch { $.ui.toast('PMOS could not send your prompt after switching the model. Send it again.') }
+        $.ui.toast(switchNote(d))
+      })()
+    })
+    return { text }
+  })
+
+  // Every prompt handed to a sub-agent is routed, unless the call named a model or the agent is pinned.
+  on('agent.spawn', async ($, e, next) => {
+    const r: any = await read($, routing)
+    if (!r?.on || e.model || e.subagentType === REVIEWER_TYPE || e.subagentType === 'fork' || typeof e.prompt !== 'string' || !e.prompt.trim()) return next(e)
+    const model = subagentModel(e, await askRoute($, e.prompt, 'agent'))
+    return next(model ? { ...e, model } : e)
+  })
+
+  on('command.run', { command: 'pmos-route' }, async ($, e) => {
+    const arg = String(e.args ?? '').trim()
+    if (arg === 'on' || arg === 'off') {
+      if (arg === 'on' && !isPerson(e)) return { text: 'Routing is turned on only by your own typed command. Nothing changed.' }
+      await update($, routing, (x: any) => ({ ...x, on: arg === 'on' }))
+      return { text: arg === 'on' ? 'Model routing is on for this session: each prompt you type and each sub-agent prompt is routed before it runs.' : 'Model routing is off for this session. The model changes only when you change it.' }
+    }
+    const r: any = await read($, routing)
+    let url: string | null = null
+    try { url = routeUrl(await $.env.get('PMOS_ROUTE_URL')) } catch { url = null }
+    return { text: `Model routing is ${r?.on ? 'on' : 'off'} for this session. ${url ? 'The workspace answers routes; the model switches only when Jev or a rule decided.' : 'This terminal was not started by the PMOS workspace, so no prompt is routed.'}` }
   })
 
   on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {

package/payload/mods/pmos-cockpit/types/index.d.ts

@@ -71,6 +71,6 @@ export type HandoverPlan = {
 
 declare module 'claude-code' {
   interface PluginState {
-    'pmos-cockpit': { status: CockpitStatus | null; isHidden: boolean; offer: { run_id: string; initiative_id: string; message: string } | null; view: ViewState | null; factsCache: FactsCache | null; mode: { mode: 'local' | 'hosted' | 'cloud'; signal: string | null } | null; review: { agentId: string; run_id: string; initiative_id: string; rubric_path: string; model: string } | null; reviewOffer: { run_id: string; initiative_id: string; rubric_path: string; verdict: string; score: number; evaluator_model: string; findings: string } | null; handoverPlan: HandoverPlan | null; resume: { text: string } | null; resumeGone: boolean }
+    'pmos-cockpit': { status: CockpitStatus | null; isHidden: boolean; offer: { run_id: string; initiative_id: string; message: string } | null; view: ViewState | null; factsCache: FactsCache | null; mode: { mode: 'local' | 'hosted' | 'cloud'; signal: string | null } | null; review: { agentId: string; run_id: string; initiative_id: string; rubric_path: string; model: string } | null; reviewOffer: { run_id: string; initiative_id: string; rubric_path: string; verdict: string; score: number; evaluator_model: string; findings: string } | null; handoverPlan: HandoverPlan | null; resume: { text: string } | null; resumeGone: boolean; routing: { on: boolean; told: boolean } }
   }
 }

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-04T21:21:45Z"}
+generated: {by: process:create-pmos, at: "2026-10-05T00:43:02Z"}
 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-04T21:21:45Z"}
+generated: {by: process:create-pmos, at: "2026-10-05T00:43:02Z"}
 status: stable
 ---
 

package/payload/scripts/status-facts.js

@@ -109,8 +109,9 @@ function history(root, L) {
 const norm = (p) => String(p || '').trim().replace(/^\.\//, '').replace(/^\/+/, '');
 
 // ── since_approval ──────────────────────────────────────────────────────────────────────────────
-function sinceApproval({ root, L, fm, runs, accepted }) {
-  const files = ['prd_path', 'rubric_path', 'brief_path'].map((k) => norm(fm[k])).filter((p) => p && !/^[<(…]/.test(p));
+const SPEC_KEYS = ['prd_path', 'rubric_path', 'brief_path'];
+function sinceApproval({ root, L, fm, runs, accepted, keys = SPEC_KEYS }) {
+  const files = [...new Set(keys.map((k) => norm(fm[k])).filter((p) => p && !/^[<(…]/.test(p)))];
   if (!files.length) return null;
   const contractRun = [...(runs || [])].reverse().find((r) => r && r.pre_run_contract && r.pre_run_contract.PM_approved === true);
   const acceptRow = [...(accepted || [])].reverse().find((a) => a && a.accepted === true);
@@ -201,4 +202,13 @@ function compute(c) {
   return { since_approval: since, coverage: cov, record_says: says };
 }
 
-module.exports = { compute, sinceApproval, coverage, recordSays, history };
+// The pm-artifacts profile (D68): the brief and the deliverable after the PM's acceptance. A document repository has
+// no contract runs and no requirement ids, and its stages are not the product-code stage words, so only this one applies.
+function computeArtifacts({ root, L, fm, accepted }) {
+  let since = null;
+  try { since = sinceApproval({ root, L, fm, runs: [], accepted, keys: ['brief_path', 'prd_path', 'doc_path'] }); }
+  catch (e) { since = { status: 'unknown', reason: `since-approval check failed: ${e.message}` }; }
+  return { since_approval: since, coverage: null, record_says: null };
+}
+
+module.exports = { compute, computeArtifacts, sinceApproval, coverage, recordSays, history };

package/payload/scripts/workflow-state.js

@@ -798,7 +798,7 @@ function computeWorkflowDerived(id, opts) {
 
   // ── D68: the pm-artifacts ladder replaces everything after the anchor ─────────────────────────
   if (pmProfile) {
-    return pmLadder({ id, fm, lane, effLane, knownLane, legacy, steps, root, L, recRel, range, inChange, lastActivity });
+    return pmLadder({ id, fm, lane, effLane, knownLane, legacy, steps, root, L, recRel, range, inChange, lastActivity, opts });
   }
 
   const prd = String(fm.prd_path || '').trim();
@@ -1274,7 +1274,7 @@ function computeWorkflowDerived(id, opts) {
  * existence and their order fail CI for a non-legacy record). Review, approval and handoff are never
  * CI-blocking in either track: none can be true before the PR exists.
  */
-function pmLadder({ id, fm, lane, effLane, knownLane, legacy, steps, root, L, recRel, range, inChange, lastActivity }) {
+function pmLadder({ id, fm, lane, effLane, knownLane, legacy, steps, root, L, recRel, range, inChange, lastActivity, opts }) {
   const declared = String(fm.track || '').trim().toLowerCase();
   const track = declared === 'light' || declared === 'governed' ? declared
     : (laneDefs.laneDef('pm-artifacts', effLane) || laneDefs.laneDef('pm-artifacts', 'prd')).track;
@@ -1348,10 +1348,15 @@ function pmLadder({ id, fm, lane, effLane, knownLane, legacy, steps, root, L, re
   const blockers = steps.filter((x) => x.status === 'blocked');
   const gateFailures = blockers.filter((x) => x.blocking);
   const next = steps.find((x) => x.status === 'blocked') || steps.find((x) => x.status === 'pending' && x.next) || null;
+  // status-from-artifacts: a document repository gets the one fact that applies to it — the brief or the deliverable
+  // changed after the PM accepted it. Coverage and the status-line check are product-code facts and stay null here.
+  const facts = (opts && opts.facts === false) ? {}
+    : statusFacts.computeArtifacts({ root, L, fm, accepted });
   return {
     ok: true, id, lane, laneKnown: knownLane, legacy, in_change: inChange,
     last_activity: lastActivity, accepted: accepted.length > 0, stage, record: recRel,
     title: fm.title || id, anchor: fm.parent_kr || null, profile: 'pm-artifacts', track,
+    ...facts,
     steps, blockers: blockers.map((x) => x.key), gate_failures: gateFailures.map((x) => x.rule || x.key),
     next: next ? { step: next.key, why: next.evidence, action: next.next || next.evidence } : null,
     range: range.ok ? { base: range.base, commits: range.shas.length, whole_history: !!range.wholeHistory } : { error: range.reason },

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-04T21:21:45Z"}
+generated: {by: process:create-pmos, at: "2026-10-05T00:43:02Z"}
 status: stable
 ---
 

package/payload/state/log.md

@@ -2,6 +2,6 @@
 
 Newest first, ISO dates.
 
-## 2026-10-04
+## 2026-10-05
 
 - Adopted OKF v0.2 (D73).

package/workspace/guide/index.md

@@ -1,7 +1,7 @@
 ---
 type: Guide
 title: "Guide: start here"
-timestamp: 2026-10-03
+timestamp: 2026-10-04
 ---
 
 # Guide: start here
@@ -38,4 +38,5 @@ The workspace has three columns. [Layout](layout.md) explains where things open.
 - [Scheduled tasks and the command line](scheduled-tasks-and-cli.md): how to make, edit and run scheduled tasks.
 - [Validate a repository](validate-with-typesafe.md): what each kind of document is compared with, how to read the verdict, and what leaves your machine.
 - [Today and the proactive engine](proactive-engine.md): what Today finds, what you can do with an item, the settings, the commands and the limits.
+- [Live notes](live-notes.md): take notes in a meeting, confirm each talking point, and what goes to Jev when you turn it on.
 - [Find knowledge without reading whole files](knowledge-graph.md): what `pmos kg` finds, its commands, how to read its numbers, and its limits.

package/workspace/guide/initiatives-and-next-steps.md

@@ -26,7 +26,9 @@ These lines show facts about the documents that the phases do not show. Each lin
 - **Coverage.** A requirement id in the PRD that the rubric does not mention, or an id in the rubric that the PRD does not have. A mention is not a grade. If the rubric mentions no requirement id, the line says that coverage cannot be found.
 - **Record says.** The `status:` line in the initiative record names a stage that the phases contradict. Edit the record if the line is wrong. The phases do not change.
 
-If a check cannot run, for example in a shallow clone, the line says "Cannot tell" and gives the reason. A missing line means that the check has nothing to compare.
+If a check cannot run, for example in a shallow clone, the line says "Cannot tell" and gives the reason. If no check has anything to compare yet, the section says "Nothing to compare yet" and tells you what each check waits for, such as an approved contract, a feature lane or a stage word in the status line.
+
+In a documents repository (the pm-artifacts profile), only **Since approval** applies. It starts when you accept the work: after that, a commit to the brief or the deliverable shows here. Coverage and Record says are for product-code repositories.
 
 If **read documents for status** is on for the repository, lines that start with **Documents suggest** can follow. They are Jev's answers about the documents of this initiative: a PRD, rubric or brief that may be a stub, or a note that may contradict a requirement. Each line says *very likely*, *likely* or *possible*, says that it is a suggestion and names the model. Open the document to decide. See [Guide: validate a repository](validate-with-typesafe.md).
 

package/workspace/guide/knowledge-graph.md

@@ -92,7 +92,18 @@ After the first confirmed send, the workspace sends only new or changed undeterm
 
 What is sent for each file: the title, the headings and the start of the text, at most 3,000 characters. The file path and the whole file are not sent. A file under an excluded path is not sent. A file whose start looks like a password or a key is not sent.
 
-Jev's answer shows as the category with `(jev)` after it. Point at it to see how sure Jev was, in words. If Jev was not sure, the file stays `undetermined`, and the tooltip names the two categories Jev was between. A Jev category is advisory. Each answer is kept on your computer, outside the repository, and the same text is not sent twice. Nothing is written into the repository.
+Jev's answer shows as the category with `(jev)` after it. Point at it to see how sure Jev was, in words. If Jev was not sure, the file stays `undetermined` with `(jev unsure)` after it, and the tooltip names the two categories Jev was between. A Jev category is advisory. Each answer is kept on your computer, outside the repository, and the same text is not sent twice. Nothing is written into the repository.
+
+After a pass, the Knowledge view shows what happened to each undetermined file. Files with a problem are at the top of the list:
+
+- **failed**: the request did not succeed. The row gives the reason. The file keeps the local result, and the next pass sends it again.
+- **not asked**: sending stopped before this file. The row gives the reason.
+- **unreadable**: the workspace could not read Jev's answer. The file is not sent again until it changes.
+- **unsure**: Jev was not sure. The row names the two categories, and the file stays `undetermined`.
+- **withheld** or **excluded**: the file was not sent. The row says why.
+- **categorized**: Jev gave a category. The row names it.
+
+A line above the list counts the files in the view: decided by the local rules or your corrections, categorized by Jev, and still `undetermined`.
 
 If the service rejects the key two times, cannot be reached three times in a row, or sends three answers in a row that the workspace cannot read, sending stops for this repository. An answer that cannot be read is not sent again. Press **resume** to start again.
 

package/workspace/guide/layout.md

@@ -35,6 +35,8 @@ The detail shows the title, the summary, the chips, the blocker (when the initia
 
 Each tab shows a dot, its title and, under the title, its initiative and its session. Press × on a tab to close it. The `+ session` button is at the right end of the tabs.
 
+If many tabs are open, the strip stays one row and scrolls sideways. Use the mouse wheel on the strip to scroll it. The tab in front always scrolls into view. Press `⇅ tabs at side` to show the tabs as a list down the left of the tabs column. In the list, each tab is one row, with its title, its initiative and session, and ×. The `+ session` button is at the top of the list, and the other controls are at the bottom. Press `⇆ tabs on top` to go back to the strip. The workspace remembers your choice in this browser. A phone and `?layout=legacy` always show the strip.
+
 ## Navigation
 
 The first column holds the list of repositories. Under it is the list for the current mode. When you choose a repository, its initiatives appear there. When you choose an item in the settings and tools drawer, its list replaces the initiatives. Choose a repository again to return to its initiatives.

package/workspace/guide/live-notes.md

@@ -0,0 +1,78 @@
+---
+type: Guide
+title: "Guide: live notes"
+description: "How the Live notes view listens to a meeting, turns what is said into talking points, and lets you confirm each one, with an optional check by Jev."
+timestamp: 2026-10-04
+---
+
+# Guide: live notes
+
+The Live notes view takes notes during a meeting. Each thing that is said becomes a talking point. The workspace guesses which open initiative the point is about. You confirm the guess, change it or reject it, one card at a time. Nothing changes an initiative until you confirm.
+
+## Open the view
+
+1. Select the repository in the navigation column.
+2. Open the menu and select **live notes** under **Library**. The view opens as a tab for that repository.
+3. Press **New session**. A session is one meeting.
+
+If the repository has more than 255 open initiatives, the view asks you to select an anchor first. The session then uses only the initiatives of that anchor.
+
+## Add talking points
+
+You can type the points or let the view listen.
+
+- **Type.** Write one point for each line. Press Enter or **Add**. Shift+Enter starts a new line.
+- **Listen.** Press **Start listening**. The browser recognises speech on this device. No audio leaves the device. The first time, the browser can ask you to download the language. Press **Download for** and the language name.
+
+While the view listens, it shows **● Listening: notes are being taken**. Words that are not final show in grey and are not added. A phrase becomes a point at the end of a sentence or after a pause. Before the phrase becomes a point, the workspace cleans it: it removes filler words (um, uh, er, erm, hmm) and repeated words, adds a capital letter and adds a full stop.
+
+Press **Stop** to stop listening. Press **This meeting is private** to stop listening and mark the session private. Nothing from a private session goes to Jev.
+
+A browser that cannot recognise speech on the device says so. The view never sends audio to a cloud service. Chrome 139 and later can recognise speech on the device.
+
+## Confirm each point
+
+Each point shows as a card. Cards that wait for you are at the top. The card shows the guess and where the guess came from:
+
+| Source | What it means |
+|---|---|
+| local word match | The workspace compared the words of the point with the titles, intents and open questions of the open initiatives. A local guess is never shown above *possible*. |
+| Jev | Jev compared the point with the same titles, intents and open questions. Its band is in words: *very likely*, *likely* or *possible*. |
+| agent session | An agent session placed the point with the `live-notes` command. |
+
+On each card:
+
+1. Select the initiative, or **none of these initiatives**.
+2. Select how the point relates to it: **validates**, **clarifies**, **extends**, **contradicts** or **answers a question**.
+3. For **answers a question**, select which open question it answers. The view refuses **answers a question** without one.
+4. Press **Confirm** or **Reject**.
+
+If you change nothing, Confirm records *accept*. If you change the initiative, the relation or the question, it records *change*. The counter shows how many points are confirmed, changed, rejected, waiting and withheld.
+
+A point that looks like a secret, such as a key or a token, is withheld. The view shows the reason and never the text.
+
+## Check with Jev
+
+**Check with Jev** is off until you turn it on. When it is off, every guess is a local word match and nothing leaves this machine.
+
+Jev checks a point only when all three of these are true:
+
+1. A TypeSafe key is saved (open **validate** in the settings and tools drawer).
+2. Validation is turned on for this repository (also under **validate**).
+3. **Check with Jev** is on in the Live notes view. It applies to this repository only.
+
+If one is missing, the view says which one, in words.
+
+When all three are true, the workspace sends each cleaned point to TypeSafe. It sends only the cleaned sentence and the titles, intents and open questions of the initiatives in the session. It does not send the speaker's name. It does not send a withheld point. It does not send a point from a private session. The key goes only in the request header.
+
+If Jev cannot be reached, or its answer cannot be read, the card still gets the local guess. The card says that Jev was not reached. If the service rejects the key twice, or cannot be reached three times in a row, Jev pauses for that session and the view shows the reason. The local word match continues.
+
+## Close the session
+
+Press **End and file the note**. The workspace writes a section in the day's requirements note, with your decisions. A rejected point is left out and counted. The raw transcript is deleted. The view shows the path of the note. A closed session is read-only.
+
+## Limits
+
+- The local word match compares words only. It does not understand meaning.
+- How well speech recognition and Jev work on a real meeting has not been measured. The share of guesses you change is the measure.
+- The view does not read meetings from Wispr Flow. The `live-notes` command does that in an agent session.

package/workspace/guide/validate-with-typesafe.md

@@ -76,13 +76,27 @@ The first check after you turn this switch on records the documents that exist a
 
 The answers appear in the initiative detail under **What the documents say**, as lines that start with **Documents suggest**. Each line says that it is a suggestion and names the model. A suggestion never changes a phase, a status or a count, and the workspace writes nothing to the document.
 
+## Route prompts with Jev
+
+A third switch, **route prompts with Jev**, is below the consent switch. It is off until you turn it on. When it is off, no prompt is sent.
+
+When the switch is on, a TypeSafe key is saved, and validation is on for the repository, the workspace asks Jev about each prompt that you type in a workspace terminal. Jev answers with a tier: fast, balanced or deep. If the answer names a model that is different from the model of the session, the PMOS cockpit mod changes the model with `/model` and then sends your prompt. A line in the terminal names the new model and the tier.
+
+These prompts are not sent: a slash command, a prompt with an attachment, a prompt that names a file with `@`, and a prompt shorter than 40 characters. A prompt that matches a credential pattern, or that names an excluded path, is not sent. In these cases the model does not change.
+
+If one of the three conditions is missing, the model does not change. The terminal tells you once which condition is missing. A guess from keywords never changes the model.
+
+To stop routing in one terminal, type `/pmos-route off`. To start it again, type `/pmos-route on`.
+
+A change of model starts a new prompt cache, so the next answer can cost more. The workspace does not yet measure if routing saves money.
+
 ## Check with TypeSafe
 
 ## What leaves your machine
 
 Validation is off until you turn it on. Until then, the workspace sends nothing.
 
-When you turn it on, the workspace sends document text to `api.typesafe.ai`. It sends nothing else. It does not send binary files. It does not send a document that you excluded. It does not send a document that matches a credential pattern, such as a private key or a token. It lists that document as withheld.
+When you turn it on, the workspace sends document text to `api.typesafe.ai`. If **route prompts with Jev** is also on, it sends the text of the prompts that you type in a workspace terminal. It sends nothing else. It does not send binary files. It does not send a document that you excluded. It does not send a document that matches a credential pattern, such as a private key or a token. It lists that document as withheld.
 
 The workspace reads the TypeSafe key only on this machine. After you save the key, the screen does not show it again. The workspace does not give the key to a terminal or to an agent.
 

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

@@ -109,8 +109,9 @@ function history(root, L) {
 const norm = (p) => String(p || '').trim().replace(/^\.\//, '').replace(/^\/+/, '');
 
 // ── since_approval ──────────────────────────────────────────────────────────────────────────────
-function sinceApproval({ root, L, fm, runs, accepted }) {
-  const files = ['prd_path', 'rubric_path', 'brief_path'].map((k) => norm(fm[k])).filter((p) => p && !/^[<(…]/.test(p));
+const SPEC_KEYS = ['prd_path', 'rubric_path', 'brief_path'];
+function sinceApproval({ root, L, fm, runs, accepted, keys = SPEC_KEYS }) {
+  const files = [...new Set(keys.map((k) => norm(fm[k])).filter((p) => p && !/^[<(…]/.test(p)))];
   if (!files.length) return null;
   const contractRun = [...(runs || [])].reverse().find((r) => r && r.pre_run_contract && r.pre_run_contract.PM_approved === true);
   const acceptRow = [...(accepted || [])].reverse().find((a) => a && a.accepted === true);
@@ -201,4 +202,13 @@ function compute(c) {
   return { since_approval: since, coverage: cov, record_says: says };
 }
 
-module.exports = { compute, sinceApproval, coverage, recordSays, history };
+// The pm-artifacts profile (D68): the brief and the deliverable after the PM's acceptance. A document repository has
+// no contract runs and no requirement ids, and its stages are not the product-code stage words, so only this one applies.
+function computeArtifacts({ root, L, fm, accepted }) {
+  let since = null;
+  try { since = sinceApproval({ root, L, fm, runs: [], accepted, keys: ['brief_path', 'prd_path', 'doc_path'] }); }
+  catch (e) { since = { status: 'unknown', reason: `since-approval check failed: ${e.message}` }; }
+  return { since_approval: since, coverage: null, record_says: null };
+}
+
+module.exports = { compute, computeArtifacts, sinceApproval, coverage, recordSays, history };

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

@@ -798,7 +798,7 @@ function computeWorkflowDerived(id, opts) {
 
   // ── D68: the pm-artifacts ladder replaces everything after the anchor ─────────────────────────
   if (pmProfile) {
-    return pmLadder({ id, fm, lane, effLane, knownLane, legacy, steps, root, L, recRel, range, inChange, lastActivity });
+    return pmLadder({ id, fm, lane, effLane, knownLane, legacy, steps, root, L, recRel, range, inChange, lastActivity, opts });
   }
 
   const prd = String(fm.prd_path || '').trim();
@@ -1274,7 +1274,7 @@ function computeWorkflowDerived(id, opts) {
  * existence and their order fail CI for a non-legacy record). Review, approval and handoff are never
  * CI-blocking in either track: none can be true before the PR exists.
  */
-function pmLadder({ id, fm, lane, effLane, knownLane, legacy, steps, root, L, recRel, range, inChange, lastActivity }) {
+function pmLadder({ id, fm, lane, effLane, knownLane, legacy, steps, root, L, recRel, range, inChange, lastActivity, opts }) {
   const declared = String(fm.track || '').trim().toLowerCase();
   const track = declared === 'light' || declared === 'governed' ? declared
     : (laneDefs.laneDef('pm-artifacts', effLane) || laneDefs.laneDef('pm-artifacts', 'prd')).track;
@@ -1348,10 +1348,15 @@ function pmLadder({ id, fm, lane, effLane, knownLane, legacy, steps, root, L, re
   const blockers = steps.filter((x) => x.status === 'blocked');
   const gateFailures = blockers.filter((x) => x.blocking);
   const next = steps.find((x) => x.status === 'blocked') || steps.find((x) => x.status === 'pending' && x.next) || null;
+  // status-from-artifacts: a document repository gets the one fact that applies to it — the brief or the deliverable
+  // changed after the PM accepted it. Coverage and the status-line check are product-code facts and stay null here.
+  const facts = (opts && opts.facts === false) ? {}
+    : statusFacts.computeArtifacts({ root, L, fm, accepted });
   return {
     ok: true, id, lane, laneKnown: knownLane, legacy, in_change: inChange,
     last_activity: lastActivity, accepted: accepted.length > 0, stage, record: recRel,
     title: fm.title || id, anchor: fm.parent_kr || null, profile: 'pm-artifacts', track,
+    ...facts,
     steps, blockers: blockers.map((x) => x.key), gate_failures: gateFailures.map((x) => x.rule || x.key),
     next: next ? { step: next.key, why: next.evidence, action: next.next || next.evidence } : null,
     range: range.ok ? { base: range.base, commits: range.shas.length, whole_history: !!range.wholeHistory } : { error: range.reason },