create-pmos 0.40.0 → 0.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.40.0",
+  "version": "0.42.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@cd7bc4a
-assembled: 2026-10-03
+kernel-source: pmos@e99d9d4
+assembled: 2026-10-04
 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-03T10:44:27Z"}
+generated: {by: process:create-pmos, at: "2026-10-04T01:33:06Z"}
 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-03T10:44:27Z"}
+generated: {by: process:create-pmos, at: "2026-10-04T01:33:06Z"}
 status: stable
 ---
 

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-03T10:44:27Z"}
+generated: {by: process:create-pmos, at: "2026-10-04T01:33:06Z"}
 status: stable
 ---
 

package/payload/state/log.md

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

package/workspace/README.md

@@ -82,6 +82,10 @@ After the session ends, `GET /api/next-step/summary` returns the files the branc
 
 The top of Today is a brief: a greeting, the day's calendar, ranked priorities and a worth-asking list. The server does not build it. The built-in skill `skills/morning-brief.skill` runs in an agent session, reads the sources the settings allow (calendar, wispr, mail, jira, confluence; mail is off by default) and the derived list (`pmos proactive today`), and submits one brief with `pmos proactive brief submit --file`. `POST /api/proactive/brief` checks it with `lib/brief.js` and stores `briefs/<date>.json` in the runtime state folder, replacing any earlier brief for the same day; `GET` returns the newest one with a `stale` flag when its date is not today. The check refuses, with the reason and without storing, a wrong shape, an unknown source, a confidence outside 0 to 1, more than 12 items or 20 events, an over-long field, an item that rests on a source not reported as read, a source reported as read that the settings switched off, and a claim of typed scoring when that setting is off. The bucket is derived: under 0.5 confidence is "worth asking". The order is fixed: confidence, then PM-owned, then title. `POST /api/schedules/seed` with `set: "brief"` (one press in Today, or `pmos proactive brief schedule`) makes the daily 06:45 schedule once; as with every schedule, one made after its time of day runs once within a minute. The routes make no model or network call and write only the brief file. Typed scoring is a standing opt-in setting that is off by default. Tests: `proactive.test.js` G, H, I and `pm-r22-test.js` B1-B11. The guide page is `guide/proactive-engine.md`.
 
+## Find knowledge without reading whole files (`knowledge-graph`, slice K1)
+
+`pmos kg find|card|neighbors|section|why|stats` builds a map of the repository's tracked Markdown files from relations they already write down (links, frontmatter paths, `D<nn>` citations, `initiative_id`, `parent_kr`) and answers from it, so an agent reads one card or one section and not a 130 KB file. `lib/kg.js` is pure; `lib/kg-cli.js` reads the files, keeps the map in the runtime state directory (rebuilt when HEAD or an uncommitted `.md` changes) and writes nothing in the repository. A link to a missing file is listed as dangling and is never an edge; `lib/kg-dangling-rules.json` says which dangling links are history by design. It does not guess, use embeddings, or call a model or the network. `node scripts/kg-bench.js` replays two written strategies over the fixed questions in `planning/evals/knowledge-graph-questions.md`; it is a simulation, and says "NOT REPORTABLE" until three of the questions are the PM's. Guide page: `guide/knowledge-graph.md`. Tests: `kg.test.js`.
+
 ## Scheduled tasks from the terminal (`schedule-cli`)
 
 `pmos schedule` and `pmos skill` talk to the running workspace server, so the terminal and the workspace share one schedule store and one validator. Every change is saved the moment the command succeeds. A refused value names what is allowed and changes nothing. With no server running the command says so and exits 1.
@@ -135,7 +139,7 @@ The three-column layout is retired. The surface is now **four collapsible panels
 **Fixture mode.** `?fixture=proto` renders the whole surface from a bundled seed file, with the server unable to read any repository — that is how the design comparison is run (`npm run test:parity`), and it is never the default.
 
 ## Artifact links are declarations, not integrations
-The PMOS server makes no outbound request and holds no credential, with one named exception ([D79](/okf/products/pmos/adr/d79-typesafe-validation-egress.md)): when you save a TypeSafe key and turn validation on for a repository, the **validate** page sends that repository's document text to `api.typesafe.ai`, from one module, only after you confirm the plan. With no key, nothing is sent. The key stays on this machine, is never shown again, and is never given to a terminal. The consistency checks at the top of the **validate** page are local: they read files and git and send nothing. Automatic checking is off until you switch it on for a repository, and then the workspace appends problems to that repository's `claims.jsonl`. The workspace makes no request you did not ask for. Its git network verbs are named and press-only: `Sync` runs `fetch`, a fast-forward or an own-commit rebase, a commit of record paths, and `push` — only when you press it, never on a timer or on load, never forced ([D70](/okf/products/pmos/adr/d70-stopped-initiatives-and-sync.md)). A web page opens in a tab only when you type or click its address, and a restored web tab loads only when you press "load this page" ([D69](/okf/products/pmos/adr/d69-web-tab.md)). Linking an artifact to an external destination therefore records a **declaration** — `{artifact_path, kind, target}` appended to `pmos/state/artifact-links.jsonl`. The sync panel renders as designed, and with no connector configured its summary line says exactly that: *no connector configured — nothing was read, and nothing will be written*, with the approval buttons disabled. A difference summary it never read would be the watermelon this repo has a word for.
+The PMOS server makes no outbound request and holds no credential, with one named exception ([D79](/okf/products/pmos/adr/d79-typesafe-validation-egress.md)): when you save a TypeSafe key and turn validation on for a repository, the **validate** page sends that repository's document text to `api.typesafe.ai`, from one module, only after you confirm the plan. With no key, nothing is sent. The key stays on this machine, is never shown again, and is never given to a terminal. The consistency checks at the top of the **validate** page are local: they read files and git and send nothing. Automatic checking is off until you switch it on for a repository, and then the workspace appends problems to that repository's `claims.jsonl`. A second switch, **check with Jev automatically** ([D80](/okf/products/pmos/adr/d80-jev-claim-pairs.md)), is also off; only when a key, validation, automatic checking and that switch all hold does the workspace send pairs of short claim texts that changed, after a first pass that records what exists and sends nothing. The workspace makes no request you did not ask for. Its git network verbs are named and press-only: `Sync` runs `fetch`, a fast-forward or an own-commit rebase, a commit of record paths, and `push` — only when you press it, never on a timer or on load, never forced ([D70](/okf/products/pmos/adr/d70-stopped-initiatives-and-sync.md)). A web page opens in a tab only when you type or click its address, and a restored web tab loads only when you press "load this page" ([D69](/okf/products/pmos/adr/d69-web-tab.md)). Linking an artifact to an external destination therefore records a **declaration** — `{artifact_path, kind, target}` appended to `pmos/state/artifact-links.jsonl`. The sync panel renders as designed, and with no connector configured its summary line says exactly that: *no connector configured — nothing was read, and nothing will be written*, with the approval buttons disabled. A difference summary it never read would be the watermelon this repo has a word for.
 
 ## The gates are real, never automatic (R5)
 `approve` / `return` / `accept` write the PMOS file-mode vocabulary to `acceptances.jsonl` and clear the matching needs entry — only ever on your click.

package/workspace/bin/pmos.js

@@ -402,6 +402,10 @@ function doctor() {
     code = await require('../lib/proactive-cli').run(process.argv.slice(2), {
       say, call: async (m, p, b) => (port ? api(port, m, p, b) : null) });
   }
+  else if (cmd === 'kg') {
+    // Reads tracked .md files straight from disk (lib/kg-cli.js); needs no running server.
+    code = require('../lib/kg-cli').run(process.argv.slice(2), { say });
+  }
   else if (cmd === 'upgrade') {
     // Escape hatch: pull the latest bundled app and force-reinstall over this global copy. Delegates
     // to the scaffolder (which owns the install path) rather than reinstalling itself in place.
@@ -413,12 +417,13 @@ function doctor() {
     if (r.error) { say('✗ could not run ' + npx + ' — ' + r.error.message); code = 1; }
     else code = r.status === null ? 1 : r.status;
   } else if (cmd === 'help' || cmd === '--help' || cmd === '-h') {
-    say('usage: pmos [<path>|status|ls|stop|doctor|upgrade|schedule|skill|proactive]');
+    say('usage: pmos [<path>|status|ls|stop|doctor|upgrade|schedule|skill|proactive|kg]');
     say('  pmos          open the current repo as a workspace (starts the server if needed)');
     say('  pmos <path>   open another repo as a workspace');
     say('  pmos schedule …  create, edit and run scheduled tasks (pmos schedule --help)');
     say('  pmos skill …     list, read, create and edit skills');
     say('  pmos proactive … what is waiting for you, feedback, settings (pmos proactive --help)');
+    say('  pmos kg …       find a card, a section or a decision\'s citers without reading whole files (pmos kg --help)');
     say('  pmos upgrade  reinstall the workspace app from the latest published create-pmos');
     code = 0;
   } else if (cmd === 'up' || cmd === 'start' || cmd === 'open') {

package/workspace/guide/index.md

@@ -38,3 +38,4 @@ 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.
+- [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/knowledge-graph.md

@@ -0,0 +1,63 @@
+---
+type: Guide
+title: "Guide: find knowledge without reading whole files"
+timestamp: 2026-10-03
+---
+
+# Guide: find knowledge without reading whole files
+
+`pmos kg` reads the Markdown files of a repository and builds a map of how they point at each other. You use the map to find one card, one section or one decision's readers. You do not need to open a long file.
+
+## What it is, and what it is not
+
+A **card** is a short summary of one file: its title, its type, its `description` (or its first paragraph) and its size in tokens. A **section** is the lines under one heading.
+
+The map has an **edge** only where a file states a relation:
+
+| Edge | What states it |
+|---|---|
+| link | A Markdown link to a tracked file. |
+| frontmatter | A path in `prd_path`, `rubric_path`, `explainer_path` or `sources`. |
+| supersedes, amended_by, cites | A document that chooses to carry one of these keys. |
+| initiative | An `initiative_id` that names an initiative record. |
+| anchor | A `parent_kr` of `health:<id>` or a KR id. |
+| cites (mention) | A `D<nn>` in the text, such as `D65`, with two or more digits. |
+
+A link that points at a missing file is **dangling**. It is listed and never becomes an edge. A link, a `D<nn>` or a heading inside a code block or a code span is not read.
+
+It does not guess. A file that talks about a topic without a link, a path or a `D<nn>` is not connected to it. It does not use embeddings or a model, and it does not use the network.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `pmos kg find <term>` | Lists cards whose id, title, headings or card contain the term, with the token size of each file. |
+| `pmos kg card <id>` | Prints one card and the headings of the file with their line ranges. |
+| `pmos kg neighbors <id> [--type T] [--depth 1\|2]` | Lists the files that link to this file or that it links to, with the type and the basis of each edge. |
+| `pmos kg section <path>#<heading>` | Prints only that section. `pmos kg section <path> <from>-<to>` prints a line range. |
+| `pmos kg why <D-id>` | Prints the decision's ADR view, its line in the amendment log of `DECISIONS.md`, and the files that cite it, grouped by kind. |
+| `pmos kg stats` | Prints counts: files, edges by type, written and derived cards, files with no incoming link, and the dangling links. |
+
+Add `--max-tokens N` to stop printing at a result boundary. The command then says how many results it did not show.
+
+An unknown file, heading or decision stops with a message that says what was not found. The exit code is 1.
+
+## What the numbers mean
+
+- A token count is the number of characters divided by four. It is an estimate.
+- `stats` splits dangling links into **history by design** and **needs a decision**. The rules are in `workspace/lib/kg-dangling-rules.json`. Read the file and change it if you disagree. A link in `okf/log.md` or in a decision about a removed document is history.
+- A file with no incoming link is not an error. It means no other file links to it.
+- A **derived** card comes from the first paragraph of a file that has no `description`.
+
+## Where the map is kept
+
+The command reads the tracked `.md` files of the Git repository you run it in. It keeps the map in the runtime state directory of the workspace, never in the repository. It builds the map again when the Git HEAD changes or when you edit a tracked `.md` file that is not yet committed. It does not use the cache for any other change.
+
+The command does not edit a file in the repository.
+
+## Limits
+
+- It finds only relations that are written in the files.
+- It reads Markdown files. It does not read the ledgers in `pmos/state/`, a connector, or a session.
+- `find` matches the words you type. It does not know that two different words mean the same thing.
+- The benchmark in `scripts/kg-bench.js` replays two written strategies over fixed questions. It is a simulation. It does not measure the tokens of a real agent session.

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

@@ -39,6 +39,27 @@ The record of problems is the file `claims.jsonl` in the runs folder of a PMOS r
 
 A verdict of *Consistent* means that no recorded statement contradicts its source. The workspace does not read prose. A sentence that no structure records is not checked.
 
+## Check changed claim pairs with Jev
+
+Some questions need judgement, and the local checks cannot answer them. Does the rubric grade a requirement? Does a story deliver what the requirement asks for? Does a decision support the sentence that cites it? Do two sections of one PRD contradict each other? For these, the workspace can put a **pair of short texts** to Jev. It never sends a whole file.
+
+The switch **check with Jev automatically** is off until you turn it on for a repository. Nothing is sent unless all four of these hold:
+
+1. A TypeSafe key is saved.
+2. Validation is on for this repository.
+3. Automatic checking is on.
+4. **Check with Jev automatically** is on.
+
+The page says which of the four is missing. If a path is excluded, or a text matches a credential pattern, the pair is not sent and the page lists it.
+
+The first check after you turn the switch on records every existing pair as the starting point and sends nothing. After that, the workspace sends a pair only when one of its two texts is new or changed. An answer is kept by the content of both texts. A pair whose texts did not change, or that returns to a text it already asked about, is not asked again. There is no limit on requests, because only changed pairs are sent.
+
+To ask about the pairs that already exist, press **check the backlog with Jev**. The page shows how many requests that takes and how many characters. It sends only after you press **confirm and send** with that same number. If the number changed, the workspace refuses and asks you to look again.
+
+Jev's answers are **suspected**, not proven. They appear in their own group, **suspected by Jev — advisory, not counted as problems**, as plain sentences with words: *very likely*, *likely* or *possible*. The verdict line adds them apart from the problems, for example "3 problems · Jev suspects 2 more". A suspected finding names the two texts and the question. Jev cannot quote the passage.
+
+Two rejected keys, or three failed requests in a row, pause automatic checking for that repository. The page says why and shows **resume**. The workspace appends suspected pairs to `claims.jsonl`. Those lines hold a short snippet of the claim. A pair that Jev found fine is not written.
+
 ## Check with TypeSafe
 
 ## What leaves your machine

package/workspace/lib/claims.js

@@ -271,6 +271,179 @@ function loadDecisions(root, files) {
   return { ids, available, file: dec || null };
 }
 
+/* ── semantic pairs (jev-claim-checks, D80) ──────────────────────────────────────────────────────
+ * A pair is two SHORT texts taken by structure, plus the question a model could answer about them. Nothing here
+ * sends anything; lib/jev-claims.js decides what may leave the machine. A requirement, section or citation the
+ * structure does not find is never turned into a pair, an unclassified file yields none, and a structural gap
+ * (a missing counterpart, a repeated requirement id) yields none, because a model cannot repair a gap. */
+const PAIR_QUESTIONS = {
+  coverage: 'None of the rubric dimensions would grade the requirement.',
+  delivers: 'The story section does not deliver what the requirement it cites asks for.',
+  supports: 'The decision does not support what the document says it decides.',
+  sections: 'These two sections of the same document contradict each other.',
+};
+const PAIR_CAP = { rubric: 2500, req: 1200, story: 1500, reqs: 1500, sentence: 600, decision: 700, section: 1800 };
+// A link keeps its words, not its path.
+const clip = (t, n) => { const s = String(t).replace(/\[([^\]]*)\]\([^)]*\)/g, '$1').replace(/[ \t]+/g, ' ').trim(); return s.length > n ? s.slice(0, n - 1) + '…' : s; };
+
+/** Requirement bullets of a PRD as Map id → text, with ids that appear more than once dropped (a structural gap). */
+function requirementTexts(text) {
+  const lines = text.split('\n');
+  const found = new Map(); const dup = new Set();
+  for (let i = 0; i < lines.length; i++) {
+    const m = REQ_RE.exec(lines[i]);
+    if (!m) continue;
+    let body = lines[i].trim().replace(/^[-*]\s+/, '');
+    for (let j = i + 1; j < lines.length && j <= i + 4; j++) {
+      if (!lines[j].trim() || /^\s*[-*]\s/.test(lines[j]) || /^#{1,6}\s/.test(lines[j]) || !/^\s+\S/.test(lines[j])) break;
+      body += ' ' + lines[j].trim();
+    }
+    if (found.has(m[1])) dup.add(m[1]); else found.set(m[1], clip(body, PAIR_CAP.req));
+  }
+  for (const d of dup) found.delete(d);
+  return found;
+}
+
+/** The weights tables' dimension rows of a rubric, as one short text. Empty when the rubric has no such table. */
+function rubricDimensionText(text) {
+  const lines = text.split('\n'); const rows = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (!/^\s*\|/.test(lines[i])) continue;
+    const cells = lines[i].split('|').slice(1, -1).map((c) => c.trim().toLowerCase());
+    if (!cells.some((c) => /^\**weight\**$/.test(c))) continue;
+    let j = i + 1;
+    if (/^\s*\|[\s:|-]+\|\s*$/.test(lines[j] || '')) j++;
+    for (; j < lines.length && /^\s*\|/.test(lines[j]); j++) {
+      const rc = lines[j].split('|').slice(1, -1);
+      if (rc.some((c) => /^\**total\**$/i.test(c.trim()))) continue;
+      rows.push(rc.map((c) => c.trim()).filter(Boolean).join(' | '));
+    }
+    i = j;
+  }
+  return clip(rows.join('\n'), PAIR_CAP.rubric);
+}
+
+/** Markdown sections, flat, in order: [{level, title, text}] where text is the body up to the next heading. */
+function sectionsOf(text) {
+  const body = text.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '');
+  const out = []; let cur = null; let fence = false;
+  for (const line of body.split('\n')) {
+    if (/^\s*```/.test(line)) fence = !fence;
+    const m = !fence && /^(#{1,6})\s+(.+?)\s*$/.exec(line);
+    if (m) { cur = { level: m[1].length, title: m[2].trim(), lower: m[2].toLowerCase(), text: '' }; out.push(cur); }
+    else if (cur) cur.text += line + '\n';
+  }
+  return out;
+}
+/** A section and the deeper sections under it, except those whose title matches `skip`. */
+function sectionTree(secs, i, skip) {
+  let t = secs[i].text;
+  for (let j = i + 1; j < secs.length && secs[j].level > secs[i].level; j++) if (!(skip && skip.test(secs[j].lower))) t += secs[j].text;
+  return t;
+}
+
+/** The opening of a decision: from its heading in the decisions file, else from its ADR file. */
+function decisionText(root, files, n) {
+  const dec = files.find((f) => f.toLowerCase() === 'decisions.md');
+  if (dec) {
+    let t = ''; try { t = fs.readFileSync(path.join(root, dec), 'utf8'); } catch { /* unreadable */ }
+    const m = new RegExp('^###\\s+D0*' + n + '\\b[^\\n]*\\n([\\s\\S]*?)(?=^###\\s|^## )', 'm').exec(t);
+    if (m) return clip(m[0], PAIR_CAP.decision);
+  }
+  const adr = files.find((f) => new RegExp('(?:^|/)adr/d0*' + n + '-[^/]+\\.md$', 'i').test(f));
+  if (adr) {
+    let t = ''; try { t = fs.readFileSync(path.join(root, adr), 'utf8'); } catch { /* unreadable */ }
+    t = t.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '');
+    const h = /^#\s+(.+)$/m.exec(t);
+    return clip((h ? h[1] + '\n' : '') + t.replace(/^#.*$/m, '').replace(/^\s*\*\*Status[^\n]*\n/m, ''), PAIR_CAP.decision);
+  }
+  return null;
+}
+
+/**
+ * The semantic pairs of a repository, from the per-document index the local check keeps.
+ * @param {object} a
+ * @param {string} a.root, a.cacheDir
+ * @param {Set<string>} [a.only]  limit to pairs whose own document is in this set (a changed file and its dependents)
+ * @returns {{pairs: object[], reads: number}}
+ */
+function pairsFor({ root, cacheDir, only = null }) {
+  const index = readJson(path.join(cacheDir, 'index.json'), null);
+  if (!index) return { pairs: [], reads: 0 };
+  const files = Object.keys(index).filter((r) => index[r] && index[r].cls);
+  const initiatives = new Map();
+  for (const rel of files) { const fm = index[rel].fm || {}; if (fm.type === 'Initiative' && fm.id) initiatives.set(fm.id, { rel, fm }); }
+  const cache = new Map(); let reads = 0;
+  const read = (rel) => { if (!cache.has(rel)) { reads++; let t = null; try { t = fs.readFileSync(path.join(root, rel), 'utf8'); } catch { /* gone */ } cache.set(rel, t); } return cache.get(rel); };
+  const typeOf = (rel) => (index[rel] && index[rel].cls ? index[rel].cls.type : null);
+  const pairs = [];
+  const add = (p) => pairs.push({ ...p, id: sha(p.doc + '|' + p.kind + '|' + p.subject).slice(0, 12), question: PAIR_QUESTIONS[p.kind] });
+  const prdOf = (rel) => {
+    const e = index[rel]; const iid = idOf((e.body || {}).initiative_id || (e.fm || {}).initiative_id);
+    const rec = iid ? initiatives.get(iid) : null;
+    const p = rec && rec.fm.prd_path ? norm(rec.fm.prd_path) : null;
+    return p && typeOf(p) === 'PRD' ? p : null;
+  };
+  for (const rel of files.sort()) {
+    if (only && !only.has(rel)) continue;
+    const e = index[rel]; const type = e.cls.type; const fm = e.fm || {}; const body = e.body || {};
+    if (type === 'PRD') {
+      const text = read(rel); if (text == null) continue;
+      // coverage: each requirement against the rubric's dimension rows
+      const iid = idOf(body.initiative_id || fm.initiative_id); const rec = iid ? initiatives.get(iid) : null;
+      const rubricRel = (body.rubric ? firstLinkPath(rel, body.rubric) : null) || (rec && rec.fm.rubric_path ? norm(rec.fm.rubric_path) : null);
+      if (rubricRel && typeOf(rubricRel) === 'Rubric') {
+        const rt = read(rubricRel); const dims = rt == null ? '' : rubricDimensionText(rt);
+        if (dims) for (const [id, req] of requirementTexts(text)) add({ kind: 'coverage', doc: rel, subject: id, a: req, b: dims, a_label: 'requirement ' + id, partner: rubricRel });
+      }
+      // supports: the sentence around a [Dnn] citation against that decision's opening
+      const files2 = Object.keys(index);
+      const seenCites = new Map(); let n = 0;
+      for (const unit of text.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '').split(/\n(?=\s*[-*]\s)|\n\s*\n/)) {
+        if (n >= 12) break;
+        const cites = Array.from(unit.matchAll(/\[(D\d{1,3})\b[^\]]*\]\([^)]*\)/g)).map((m) => Number(m[1].slice(1)));
+        if (!cites.length) continue;
+        const plain = unit.replace(/^\s*[-*]\s+/, '').replace(/\*\*/g, '').replace(/\[([^\]]*)\]\([^)]*\)/g, '$1').replace(/\s+/g, ' ').trim();
+        for (const d of Array.from(new Set(cites)).slice(0, 2)) {
+          const sentence = clip(plain.split(/(?<=[.!?])\s+/).filter((x) => new RegExp('\\bD0*' + d + '\\b').test(x)).join(' ') || plain, PAIR_CAP.sentence);
+          if (sentence.length < 30) continue;
+          const dt = decisionText(root, files2, d); if (!dt) continue;
+          const ord = (seenCites.get(d) || 0) + 1; seenCites.set(d, ord); n++;
+          add({ kind: 'supports', doc: rel, subject: 'D' + d + '#' + ord, a: sentence, b: dt, a_label: 'D' + d + ' citation', partner: 'D' + d });
+        }
+      }
+      // sections: goal/problem and non-goals against requirements; requirements against success criteria
+      const secs = sectionsOf(text);
+      const find = (re) => secs.findIndex((s) => re.test(s.lower));
+      const ri = find(/\brequirements\b/);
+      if (ri >= 0) {
+        const reqs = clip(sectionTree(secs, ri, /non-?goals/), PAIR_CAP.section);
+        const named = (label, re) => { const i = find(re); return i >= 0 ? { label, text: clip(sectionTree(secs, i), PAIR_CAP.section) } : null; };
+        const goal = named('goal', /^(goal|problem|situating context|intent)\b/);
+        const succ = named('success criteria', /^success (criteria|metrics)/);
+        const non = named('non-goals', /non-?goals/);
+        if (goal && goal.text.length > 40 && reqs.length > 40) add({ kind: 'sections', doc: rel, subject: goal.label + '>requirements', a: goal.text, b: reqs, a_label: goal.label + ' and requirements', partner: rel });
+        if (succ && succ.text.length > 40 && reqs.length > 40) add({ kind: 'sections', doc: rel, subject: 'requirements>success', a: reqs, b: succ.text, a_label: 'requirements and success criteria', partner: rel });
+        if (non && non.text.length > 40 && reqs.length > 40) add({ kind: 'sections', doc: rel, subject: 'non-goals>requirements', a: non.text, b: reqs, a_label: 'non-goals and requirements', partner: rel });
+      }
+    }
+    if (type === 'Story') {
+      const prdRel = prdOf(rel); if (!prdRel) continue;
+      const text = read(rel); const prdText = read(prdRel); if (text == null || prdText == null) continue;
+      const reqs = requirementTexts(prdText);
+      let k = 0;
+      for (const sec of sectionsOf(text)) {
+        if (k >= 30) break;
+        const ids = Array.from(new Set(Array.from((sec.title + '\n' + sec.text).matchAll(/\b([A-RT-Z]{1,3}\d{1,3})\b/g)).map((m) => m[1]))).filter((id) => reqs.has(id));
+        if (!ids.length || (sec.text.trim().length < 30)) continue;
+        k++;
+        add({ kind: 'delivers', doc: rel, subject: clip(sec.title, 60), a: clip(sec.title + '\n' + sec.text, PAIR_CAP.story), b: clip(ids.map((id) => reqs.get(id)).join('\n'), PAIR_CAP.reqs), a_label: sec.title, partner: prdRel, ids });
+      }
+    }
+  }
+  return { pairs, reads };
+}
+
 /* ── verification ──────────────────────────────────────────────────────────────────────────────── */
 const date = (secs) => new Date(secs * 1000).toISOString().slice(0, 16).replace('T', ' ');
 
@@ -400,6 +573,7 @@ function foldLedger(file) {
   }
   return map;
 }
+const isJev = (e) => !!e && String(e.kind || '').startsWith('jev_');
 const claimId = (c) => sha(c.doc + '|' + c.kind + '|' + c.subject).slice(0, 12);
 
 /* ── the cache (per-user runtime directory) ───────────────────────────────────────────────────── */
@@ -542,7 +716,7 @@ async function check({ root, cacheDir, ledgerFile, sweep = false, now = Date.now
   }
   // a claim that is gone from an affected or removed document is withdrawn, not forgotten
   for (const [id, e] of folded) {
-    if (e.status === 'withdrawn' || e.status === 'verified' || seenIds.has(id)) continue;
+    if (e.status === 'withdrawn' || e.status === 'verified' || seenIds.has(id) || isJev(e)) continue;   // a Jev claim is withdrawn by the Jev pass, not here
     if (affected.has(e.doc) || removed.includes(e.doc)) events.push({ ...e, status: 'withdrawn', truth: null, sentence: null, verified_at: stamp, at: stamp });
   }
   let appended = 0;
@@ -564,9 +738,9 @@ function buildView({ ledgerFile, index, scope, now = Date.now() }) {
     if (!byDoc.has(e.doc)) byDoc.set(e.doc, []);
     byDoc.get(e.doc).push(e);
   }
-  const rank = { contradicted: 0, stale: 1, undecided: 2 };
+  const rank = { contradicted: 0, stale: 1, undecided: 2, suspected: 3 };
   const docsOut = [];
-  let problems = 0, stale = 0, undecided = 0, verified = 0, unclassified = 0, internalOnly = 0;
+  let problems = 0, stale = 0, undecided = 0, verified = 0, unclassified = 0, internalOnly = 0, suspected = 0;
   for (const [rel, ent] of Object.entries(index)) {
     if (!ent.cls) continue;
     const claims = (byDoc.get(rel) || []).sort((a, b) => rank[a.status] - rank[b.status]);
@@ -577,20 +751,20 @@ function buildView({ ledgerFile, index, scope, now = Date.now() }) {
       rel, type: cls.type, via: cls.via, classified: !!cls.classified,
       references: REFERENCES[cls.type] || [],
       compared_with: v.compared || [],
-      problems: count('contradicted'), stale: count('stale'), undecided: count('undecided'), verified: v.verified || 0,
-      findings: claims.slice(0, 30).map((c) => ({ kind: c.kind, status: c.status, sentence: c.sentence || c.text, truth: c.truth, source: c.source })),
+      problems: count('contradicted'), stale: count('stale'), undecided: count('undecided'), suspected: count('suspected'), verified: v.verified || 0,
+      findings: claims.slice(0, 30).map((c) => ({ kind: c.kind, status: c.status, sentence: c.sentence || c.text, truth: c.truth, source: c.source, likelihood: c.likelihood || null })),
     };
     docsOut.push(entry);
-    problems += entry.problems; stale += entry.stale; undecided += entry.undecided; verified += entry.verified;
+    problems += entry.problems; stale += entry.stale; undecided += entry.undecided; verified += entry.verified; suspected += entry.suspected;
     if (!cls.classified) unclassified++;
     else if (!REFERENCES[cls.type]) internalOnly++;
   }
-  docsOut.sort((a, b) => (b.problems - a.problems) || (b.stale - a.stale) || (b.undecided - a.undecided) || a.rel.localeCompare(b.rel));
+  docsOut.sort((a, b) => (b.problems - a.problems) || (b.stale - a.stale) || (b.undecided - a.undecided) || (b.suspected - a.suspected) || a.rel.localeCompare(b.rel));
   const checked = docsOut.length;
   const verdict = !checked ? 'not-checked' : problems ? 'problems' : 'consistent';
   return {
     verdict,
-    counts: { documents: checked, problems, stale, undecided, verified, unclassified, internal_only: internalOnly, truncated: !!(scope && scope.truncated) },
+    counts: { documents: checked, problems, stale, undecided, suspected, verified, unclassified, internal_only: internalOnly, truncated: !!(scope && scope.truncated) },
     docs: docsOut, as_of: new Date(now).toISOString(),
   };
 }
@@ -598,8 +772,8 @@ function buildView({ ledgerFile, index, scope, now = Date.now() }) {
 /** The current view without running a check: from the per-user cache and the folded ledger. */
 function readView({ cacheDir, ledgerFile, now = Date.now() }) {
   const index = readJson(path.join(cacheDir, 'index.json'), null);
-  if (!index) return { verdict: 'not-checked', counts: { documents: 0, problems: 0, stale: 0, undecided: 0, verified: 0, unclassified: 0, internal_only: 0, truncated: false }, docs: [], as_of: null };
+  if (!index) return { verdict: 'not-checked', counts: { documents: 0, problems: 0, stale: 0, undecided: 0, suspected: 0, verified: 0, unclassified: 0, internal_only: 0, truncated: false }, docs: [], as_of: null };
   return buildView({ ledgerFile, index, scope: null, now });
 }
 
-module.exports = { readView, idOf, cleanValue, check, buildView, extract, verifyClaim, foldLedger, listScope, frontmatter, bodyKeys, resolveRef, rubricWeights, loadDecisions, STALE_SECS };
+module.exports = { pairsFor, requirementTexts, rubricDimensionText, sectionsOf, PAIR_QUESTIONS, isJev, readView, idOf, cleanValue, check, buildView, extract, verifyClaim, foldLedger, listScope, frontmatter, bodyKeys, resolveRef, rubricWeights, loadDecisions, STALE_SECS };