create-pmos 0.40.0 → 0.42.0

package/workspace/lib/kg.js

@@ -0,0 +1,266 @@
+'use strict';
+/* kg.js — the repository's knowledge graph, derived from what its files already state (knowledge-graph K1).
+ *
+ * Pure: takes [{path, text}] for the tracked Markdown files and returns nodes, edges and the dangling links.
+ * No filesystem, no git, no network, no model. Same input → byte-identical output.
+ *
+ * WHAT IS A NODE. One tracked .md file. It carries a CARD (the frontmatter `description`, else the first paragraph,
+ * cut at 240 characters), a token estimate (characters ÷ 4 — an estimate, not a measurement), and its headings with
+ * line ranges so a caller can read ONE section and not the file.
+ *
+ * WHAT IS AN EDGE. Only a relation a file writes down:
+ *   link         a Markdown link to a tracked file                                  basis stated
+ *   frontmatter  a path in prd_path / rubric_path / explainer_path / sources        basis stated
+ *   supersedes · amended_by · cites   (typed keys a document opts into)             basis stated
+ *   initiative   initiative_id (frontmatter or an identity bullet) → its record     basis stated
+ *   anchor       parent_kr / parent_KR `health:<id>` or a KR id → the file naming it basis stated
+ *   cites        a `D<nn>` mention in prose → that decision's ADR view              basis mention
+ * A link to a file that does not exist is a DANGLING item, never an edge. A link-like string inside a code fence or
+ * an inline code span is not a relation and makes no edge. Nothing is inferred by similarity; workspace/lib/
+ * related-docs.js took the same position for alignment, for the same reason.
+ *
+ * `D<nn>` needs two or more digits on purpose: slice labels such as "D1" and "D3" in the proactive-engine documents
+ * would otherwise cite decisions D01 and D03 that they never mention.
+ */
+(function (root, factory) {
+  const api = factory();
+  if (typeof module !== 'undefined' && module.exports) module.exports = api;
+  else root.Kg = api;
+})(typeof self !== 'undefined' ? self : this, function () {
+
+  const CARD_MAX = 240;
+  const ADR_DIR = 'okf/products/pmos/adr/';
+  const PATH_KEYS = ['prd_path', 'rubric_path', 'explainer_path', 'sources'];
+  const TYPED_KEYS = ['supersedes', 'amended_by', 'cites'];
+  const estTokens = (s) => Math.ceil(String(s || '').length / 4);
+
+  /* Replace fenced code blocks and inline code spans with spaces of the same length, keeping every newline, so line
+   * numbers stay true and nothing inside code is read as a link, a citation or a heading. */
+  function stripCode(text) {
+    const blank = (s) => s.replace(/[^\n]/g, ' ');
+    let out = '';
+    let fence = null;
+    for (const line of String(text || '').split('\n')) {
+      const m = /^\s{0,3}(`{3,}|~{3,})/.exec(line);
+      if (fence) { out += blank(line) + '\n'; if (m && m[1][0] === fence[0] && m[1].length >= fence.length) fence = null; continue; }
+      if (m) { fence = m[1]; out += blank(line) + '\n'; continue; }
+      out += line.replace(/(`+)[^`\n]*?\1/g, (s) => blank(s)) + '\n';
+    }
+    return out.slice(0, -1);
+  }
+
+  /* Frontmatter values come from the reader workspace/lib/related-docs.js already ships (one-line `key: value`);
+   * the body start line is the only thing computed here. */
+  const readFm = (typeof require === 'function') ? require('./related-docs').frontmatter : null;
+  function frontmatter(text) {
+    const m = /^---\n([\s\S]*?)\n---(?:\n|$)/.exec(String(text || ''));
+    if (!m) return { fm: {}, bodyStart: 1 };
+    return { fm: readFm ? readFm(text) : {}, bodyStart: m[0].split('\n').length };
+  }
+
+  function headingsOf(stripped, bodyStart) {
+    const lines = stripped.split('\n');
+    const found = [];
+    for (let i = bodyStart - 1; i < lines.length; i++) {
+      const m = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(lines[i]);
+      if (m) found.push({ level: m[1].length, text: m[2].trim(), start: i + 1 });
+    }
+    for (let k = 0; k < found.length; k++) {
+      let end = lines.length;
+      for (let j = k + 1; j < found.length; j++) if (found[j].level <= found[k].level) { end = found[j].start - 1; break; }
+      found[k].end = end;
+    }
+    return found;
+  }
+
+  function cardOf(fm, stripped, bodyStart) {
+    if (fm.description) return fm.description.slice(0, CARD_MAX);
+    const lines = stripped.split('\n').slice(bodyStart - 1);
+    const para = [];
+    for (const raw of lines) {
+      const l = raw.trim();
+      if (!l) { if (para.length) break; continue; }
+      if (/^(#|\||>|---|[-*]\s|\d+\.\s|<)/.test(l)) { if (para.length) break; continue; }
+      para.push(l);
+    }
+    return para.join(' ').replace(/\[([^\]]+)\]\([^)]*\)/g, '$1').slice(0, CARD_MAX);
+  }
+
+  const norm = (from, target) => {
+    const t = target.replace(/^<|>$/g, '');
+    const parts = (t.startsWith('/') ? t.slice(1) : from.replace(/[^/]*$/, '') + t).split('/');
+    const out = [];
+    for (const p of parts) { if (p === '.' || p === '') continue; if (p === '..') out.pop(); else out.push(p); }
+    return out.join('/');
+  };
+
+  const pathsIn = (value) => [...String(value || '').matchAll(/[\w@./-]+\.md\b/g)].map((m) => m[0].replace(/^\//, ''));
+
+  function build(files) {
+    const list = (files || []).filter((f) => f && typeof f.path === 'string').sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    const have = new Set(list.map((f) => f.path));
+    const adrFor = new Map();
+    for (const p of have) { const m = /^okf\/products\/pmos\/adr\/d(\d{2,3})-/.exec(p); if (m) adrFor.set('D' + m[1], p); }
+    const krFile = new Map();
+    for (const f of list) if (f.path.startsWith('planning/okrs/')) for (const m of f.text.matchAll(/\bO\d+\.KR\d+\b/g)) if (!krFile.has(m[0])) krFile.set(m[0], f.path);
+    const budgets = have.has('planning/okrs/health-budgets.md') ? 'planning/okrs/health-budgets.md' : null;
+
+    const nodes = [];
+    const edges = new Map();
+    const dangling = [];
+    const meta = { decisionLines: {} };
+    const addEdge = (from, to, type, basis) => {
+      if (from === to || !have.has(to)) return;
+      const key = from + '\u0000' + to + '\u0000' + type;
+      const cur = edges.get(key);
+      if (!cur) edges.set(key, { from, to, type, basis });
+      else if (cur.basis === 'mention' && basis === 'stated') cur.basis = 'stated';
+    };
+
+    for (const f of list) {
+      const text = String(f.text || '');
+      const { fm, bodyStart } = frontmatter(text);
+      const stripped = stripCode(text);
+      const body = stripped;
+      const heads = headingsOf(stripped, bodyStart);
+      const title = fm.title || (heads.find((h) => h.level === 1) || {}).text || f.path;
+      nodes.push({
+        id: f.path, title, type: fm.type || null, card: cardOf(fm, stripped, bodyStart),
+        described: !!fm.description, tokens_est: estTokens(text), lines: text.split('\n').length,
+        headings: heads.map((h) => ({ level: h.level, text: h.text, start: h.start, end: h.end })),
+        status: fm.status || null, stale_after: fm.stale_after || null,
+      });
+
+      for (const m of body.matchAll(/\]\(([^)\s]+?)(?:#[^)]*)?\)/g)) {
+        const raw = m[1];
+        if (/^[a-z][a-z0-9+.-]*:/i.test(raw) || raw.startsWith('#')) continue;
+        if (!/\.md$/i.test(raw)) continue;
+        const to = norm(f.path, raw);
+        if (have.has(to)) addEdge(f.path, to, 'link', 'stated');
+        else dangling.push({ from: f.path, to: raw });
+      }
+      for (const m of body.matchAll(/\bD(\d{2,3})\b/g)) {
+        const to = adrFor.get('D' + m[1]);
+        if (to) addEdge(f.path, to, 'cites', 'mention');
+      }
+      for (const k of PATH_KEYS) for (const p of pathsIn(fm[k])) addEdge(f.path, p, 'frontmatter', 'stated');
+      for (const k of TYPED_KEYS) for (const p of pathsIn(fm[k])) addEdge(f.path, p, k, 'stated');
+      const ini = fm.initiative_id || ((/^[-*]?\s*initiative_id:\s*([\w.-]+)/m.exec(body) || [])[1]);
+      if (ini) addEdge(f.path, 'planning/initiatives/' + ini + '.md', 'initiative', 'stated');
+      const anchor = fm.parent_kr || fm.parent_KR || ((/^[-*]?\s*parent_kr:\s*([\w:.-]+)/im.exec(body) || [])[1]);
+      if (anchor) {
+        if (/^health:/.test(anchor) && budgets) addEdge(f.path, budgets, 'anchor', 'stated');
+        else if (krFile.has(anchor)) addEdge(f.path, krFile.get(anchor), 'anchor', 'stated');
+      }
+      if (f.path === 'DECISIONS.md') {
+        const lines = body.split('\n');
+        for (let i = 0; i < lines.length; i++) { const m = /\bAdded \*\*(D\d{2,3})\*\*/.exec(lines[i]); if (m && !(m[1] in meta.decisionLines)) meta.decisionLines[m[1]] = i + 1; }
+      }
+    }
+    const e = [...edges.values()].sort((a, b) => (a.from + a.to + a.type < b.from + b.to + b.type ? -1 : 1));
+    dangling.sort((a, b) => (a.from + a.to < b.from + b.to ? -1 : a.from + a.to > b.from + b.to ? 1 : 0));
+    return { nodes, edges: e, dangling, meta };
+  }
+
+  /* Split dangling links into "history by design" and "needs a decision" by a readable rule list:
+   * [{from?: regex, to?: regex, why: string}] — a rule matches when every field it names matches. */
+  function splitDangling(graph, rules) {
+    const compiled = (rules || []).map((r) => ({ from: r.from ? new RegExp(r.from) : null, to: r.to ? new RegExp(r.to) : null, why: r.why || '' }));
+    const history = []; const needs = [];
+    for (const d of graph.dangling) {
+      const r = compiled.find((x) => (x.from || x.to) && (!x.from || x.from.test(d.from)) && (!x.to || x.to.test(d.to)));
+      if (r) history.push({ ...d, why: r.why }); else needs.push(d);
+    }
+    return { history, needs };
+  }
+
+  function stats(graph, rules) {
+    const byType = {}; const byBasis = { stated: 0, mention: 0 };
+    for (const e of graph.edges) { byType[e.type] = (byType[e.type] || 0) + 1; byBasis[e.basis]++; }
+    const inbound = new Set(graph.edges.map((e) => e.to));
+    const orphans = graph.nodes.filter((n) => !inbound.has(n.id) && !/(^|\/)(index|log)\.md$/.test(n.id)).length;
+    const split = splitDangling(graph, rules);
+    return {
+      nodes: graph.nodes.length, edges: graph.edges.length, byType, byBasis,
+      cardsWritten: graph.nodes.filter((n) => n.described).length,
+      cardsDerived: graph.nodes.filter((n) => !n.described && n.card).length,
+      noCard: graph.nodes.filter((n) => !n.card).length,
+      noType: graph.nodes.filter((n) => !n.type).length,
+      noIncoming: orphans, dangling: graph.dangling.length,
+      danglingHistory: split.history.length, danglingNeedsDecision: split.needs.length, needsDecision: split.needs,
+    };
+  }
+
+  const nodeById = (graph, id) => graph.nodes.find((n) => n.id === id) || null;
+  const cardText = (n) => `${n.id} [${n.type || 'untyped'}] ${n.title}${n.card ? ' — ' + n.card : ''} (file ~${n.tokens_est} tokens)`;
+
+  /* Rank: where the term matches (id 3, title 3, heading 2, card 1), then how many files link to the node. */
+  function find(graph, term, { limit = 20 } = {}) {
+    const t = String(term || '').toLowerCase().trim();
+    if (!t) return [];
+    const indeg = new Map();
+    for (const e of graph.edges) indeg.set(e.to, (indeg.get(e.to) || 0) + 1);
+    const out = [];
+    for (const n of graph.nodes) {
+      let score = 0; const where = [];
+      if (n.id.toLowerCase().includes(t)) { score += 3; where.push('id'); }
+      if (n.title.toLowerCase().includes(t)) { score += 3; where.push('title'); }
+      const h = n.headings.find((x) => x.text.toLowerCase().includes(t));
+      if (h) { score += 2; where.push('heading "' + h.text + '"'); }
+      if ((n.card || '').toLowerCase().includes(t)) { score += 1; where.push('card'); }
+      if (score) out.push({ node: n, score, where, indegree: indeg.get(n.id) || 0 });
+    }
+    return out.sort((a, b) => b.score - a.score || b.indegree - a.indegree || (a.node.id < b.node.id ? -1 : 1)).slice(0, limit);
+  }
+
+  function neighbors(graph, id, { type = null, depth = 1 } = {}) {
+    if (!nodeById(graph, id)) return null;
+    const seen = new Map([[id, 0]]); const rows = [];
+    let frontier = [id];
+    for (let d = 1; d <= depth; d++) {
+      const next = [];
+      for (const e of graph.edges) {
+        if (type && e.type !== type) continue;
+        for (const [a, b, dir] of [[e.from, e.to, 'out'], [e.to, e.from, 'in']]) {
+          if (!frontier.includes(a) || seen.has(b)) continue;
+          seen.set(b, d); next.push(b); rows.push({ id: b, via: e.type, basis: e.basis, direction: dir, depth: d, from: a });
+        }
+      }
+      frontier = next;
+    }
+    return rows;
+  }
+
+  /* why("D65"): the ADR view, the amendment-log line in DECISIONS.md, and every file that cites the ADR, by kind. */
+  function why(graph, dId) {
+    const id = String(dId || '').toUpperCase().replace(/^D(\d)$/, 'D0$1');
+    const adr = graph.nodes.find((n) => n.id.startsWith(ADR_DIR + id.toLowerCase() + '-'));
+    if (!adr) return null;
+    const groups = {};
+    const byFrom = new Map();
+    for (const e of graph.edges) if (e.to === adr.id) {
+      const cur = byFrom.get(e.from) || { id: e.from, via: [], basis: 'mention' };
+      if (!cur.via.includes(e.type)) cur.via.push(e.type);
+      if (e.basis === 'stated') cur.basis = 'stated';
+      byFrom.set(e.from, cur);
+    }
+    for (const r of byFrom.values()) { const n = nodeById(graph, r.id); const k = (n && n.type) || 'untyped'; r.via.sort(); (groups[k] = groups[k] || []).push(r); }
+    for (const k of Object.keys(groups)) groups[k].sort((a, b) => (a.id < b.id ? -1 : 1));
+    const line = graph.meta && graph.meta.decisionLines ? graph.meta.decisionLines[id] || null : null;
+    return { decision: id, adr, amendmentLog: line ? { path: 'DECISIONS.md', line } : null, citedBy: groups };
+  }
+
+  /* section(node, text, spec): spec is "#heading words" or "from-to". Returns {from,to,text} or null. */
+  function section(node, text, spec) {
+    const lines = String(text || '').split('\n');
+    const m = /^(\d+)-(\d+)$/.exec(spec || '');
+    if (m) { const from = Math.max(1, +m[1]); const to = Math.min(lines.length, +m[2]); if (from > to) return null; return { from, to, text: lines.slice(from - 1, to).join('\n') }; }
+    const want = String(spec || '').replace(/^#/, '').trim().toLowerCase();
+    if (!want || !node) return null;
+    const h = node.headings.find((x) => x.text.toLowerCase() === want) || node.headings.find((x) => x.text.toLowerCase().includes(want));
+    if (!h) return null;
+    return { from: h.start, to: h.end, heading: h.text, text: lines.slice(h.start - 1, h.end).join('\n') };
+  }
+
+  return { build, stats, splitDangling, find, neighbors, why, section, nodeById, cardText, stripCode, frontmatter, estTokens, ADR_DIR };
+});

package/workspace/lib/typesafe-settings.js

@@ -94,16 +94,19 @@ function getRepo(stateDir, root) {
     // claims-ledger: keep this repository checked as its files change. Default OFF — switching it on makes the
     // workspace append to the repository's claims.jsonl, so it is the PM's press and never a surprise.
     watch: !!(r && r.watch === true),
+    // jev-claim-checks (D80): also ask Jev about changed claim pairs after each check. Default OFF, separate from
+    // `consent` and `watch`; a request needs all of key, consent, watch and this.
+    jev: !!(r && r.jev === true),
   };
 }
 
-function setRepo(stateDir, root, { consent, exclude, watch }) {
+function setRepo(stateDir, root, { consent, exclude, watch, jev }) {
   const cur = read(stateDir);
   const prev = getRepo(stateDir, root);
   const ex = Array.isArray(exclude)
     ? exclude.map((x) => String(x).trim().replace(/^\/+/, '')).filter((x) => x && !x.includes('..') && x.length <= 200).slice(0, MAX_EXCLUDES)
     : prev.exclude;
-  const repos = { ...cur.repos, [root]: { consent: typeof consent === 'boolean' ? consent : prev.consent, exclude: ex, watch: typeof watch === 'boolean' ? watch : prev.watch } };
+  const repos = { ...cur.repos, [root]: { consent: typeof consent === 'boolean' ? consent : prev.consent, exclude: ex, watch: typeof watch === 'boolean' ? watch : prev.watch, jev: typeof jev === 'boolean' ? jev : prev.jev } };
   return write(stateDir, { key: cur.key, repos });
 }
 

package/workspace/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.40.0",
+  "version": "0.42.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.40.0",
+  "version": "0.42.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",
@@ -10,12 +10,12 @@
   "scripts": {
     "start": "node server.js",
     "test": "node test.js && npm run test:modules",
-    "test:modules": "node proactive.test.js && node focus.test.js && node handoff.test.js && node repo-scan.test.js && node profiles.test.js && node external-linking.test.js && node story-artifacts.test.js && node no-network.test.js && node typesafe-validation.test.js && node claims.test.js && node repo-watch.test.js && node fixture-parity.test.mjs && node markdown.test.mjs && node start-policy.test.js && node state-isolation.test.js && node sync.test.js && node schedule-cli.test.js && node initiative-surface.test.js && node guide.test.js && node next-step-actions.test.js",
+    "test:modules": "node proactive.test.js && node focus.test.js && node handoff.test.js && node repo-scan.test.js && node profiles.test.js && node external-linking.test.js && node story-artifacts.test.js && node no-network.test.js && node typesafe-validation.test.js && node claims.test.js && node jev-claims.test.js && node repo-watch.test.js && node fixture-parity.test.mjs && node markdown.test.mjs && node start-policy.test.js && node state-isolation.test.js && node sync.test.js && node schedule-cli.test.js && node initiative-surface.test.js && node guide.test.js && node next-step-actions.test.js && node kg.test.js",
     "test:ui": "node ui-test.js",
     "test:parity": "node design-parity.js --states",
     "test:all": "npm test && npm run test:panels && npm run test:ui && npm run test:parity && npm run test:offline",
     "doctor": "node doctor.js",
-    "test:panels": "node pm-shell-test.js && node pm-repos-test.js && node pm-initiatives-test.js && node pm-detail-test.js && node pm-tabs-test.js && node pm-term-test.js && node pm-modes-test.js && node pm-r1-test.js && node pm-r2-test.js && node pm-r3-test.js && node pm-r4-test.js && node pm-r5-test.js && node pm-r6-test.js && node pm-r7-test.js && node pm-r8-test.js && node pm-r9-test.js && node pm-r10-test.js && node pm-r11-test.js && node pm-r12-test.js && node pm-r13-test.js && node pm-r14-test.js && node pm-r15-test.js && node pm-r16-test.js && node pm-r17-test.js && node pm-r16-test.js && node pm-r18-test.js && node pm-r19-test.js && node pm-r20-test.js && node pm-r21-test.js && node pm-r22-test.js && node pm-r23-test.js",
+    "test:panels": "node pm-shell-test.js && node pm-repos-test.js && node pm-initiatives-test.js && node pm-detail-test.js && node pm-tabs-test.js && node pm-term-test.js && node pm-modes-test.js && node pm-r1-test.js && node pm-r2-test.js && node pm-r3-test.js && node pm-r4-test.js && node pm-r5-test.js && node pm-r6-test.js && node pm-r7-test.js && node pm-r8-test.js && node pm-r9-test.js && node pm-r10-test.js && node pm-r11-test.js && node pm-r12-test.js && node pm-r13-test.js && node pm-r14-test.js && node pm-r15-test.js && node pm-r16-test.js && node pm-r17-test.js && node pm-r16-test.js && node pm-r18-test.js && node pm-r19-test.js && node pm-r20-test.js && node pm-r21-test.js && node pm-r22-test.js && node pm-r23-test.js && node pm-r24-test.js",
     "test:offline": "node offline-tarball.test.js"
   },
   "engines": {

package/workspace/public/pm/modes-live.js

@@ -605,6 +605,69 @@ async function cWatch(on) {
 const cToggle = (k) => { if (cOpen.has(k)) cOpen.delete(k); else cOpen.add(k); setState({}); };
 const TYPE_CHIP = 'font-family:var(--mono);font-size:9.5px;padding:1px 6px;border:1px solid var(--border);color:var(--muted-foreground)';
 
+let jPlan = null;            // the backlog plan the PM is looking at: { ws, plan }
+let jNote = null;
+const jSay = (text) => { jNote = text; setState({}); };
+async function jSwitch(on) {
+  const ws = vWs(); if (!ws) return;
+  const out = await post('/api/claims/jev', { ws, jev: on });
+  reload('claims'); jPlan = null;
+  jSay(out && out.ok ? (on ? 'checking with Jev automatically is on — the first check records what exists and sends nothing; after that only changed pairs are sent' : 'checking with Jev automatically is off') : ((out && out.error) || 'not saved'));
+}
+async function jResume() {
+  const ws = vWs(); if (!ws) return;
+  const out = await post('/api/claims/jev/resume', { ws });
+  reload('claims');
+  jSay(out && out.ok ? 'automatic checking with Jev resumed' : ((out && out.error) || 'not resumed'));
+}
+async function jBacklogPlan() {
+  const ws = vWs(); if (!ws) return;
+  const out = await post('/api/claims/jev/backlog', { ws });
+  if (!out || out.ok === false) { jPlan = null; return jSay((out && out.error) || 'no plan'); }
+  jPlan = { ws, plan: out.plan }; jSay('review the count, then confirm to send');
+}
+async function jBacklogRun() {
+  if (!jPlan) return;
+  const { ws, plan } = jPlan;
+  jSay('sending ' + plan.requests + ' request(s) to ' + plan.host + ' …');
+  const out = await post('/api/claims/jev/backlog', { ws, confirm: true, expect_requests: plan.requests });
+  jPlan = null; reload('claims');
+  jSay(!out || out.ok === false ? ((out && out.error) || 'the backlog run failed') : 'asked ' + out.sent + ' · ' + out.suspected + ' suspected · ' + out.cached + ' answered from the cache · ' + out.failed + ' failed');
+}
+const lastJevLine = (j) => {
+  const l = j && j.last; if (!l) return null;
+  const when = String(l.at).replace('T', ' ').slice(0, 16);
+  if (l.baseline) return 'Last Jev pass ' + when + ': recorded ' + l.baseline + ' existing pair(s) as the starting point and sent nothing.';
+  const w = l.withheld_count != null ? l.withheld_count : (l.withheld || []).length;
+  return 'Last Jev pass ' + when + (l.backlog ? ' (backlog)' : '') + ': sent ' + l.sent + ' · answered from the cache ' + l.cached + ' · withheld ' + w + ' · excluded ' + l.excluded + ' · failed ' + l.failed + ' · suspected ' + l.suspected + '.';
+};
+function jevBlock(ws, d) {
+  const j = d.jev; if (!j) return [];
+  const kids = [];
+  kids.push(el('div', { style: LABEL }, iv('jev checks on changed claim pairs')));
+  kids.push(el('div', { 'data-r24': 'explain', style: NOTE }, iv('Where the local checks cannot decide, a pair of short texts (a requirement and the rubric’s dimensions, a story section and the requirement it cites, a sentence and the decision it cites, two sections of one PRD) can be put to Jev. Only pairs that changed are sent. Jev’s answers are suspicions: advisory, shown in words, and never counted as problems.')));
+  kids.push(el('div', { style: 'display:flex;gap:6px;align-items:center;flex-wrap:wrap;padding:2px 14px 6px' },
+    el('button', { style: BTN + (j.switch ? ';color:var(--foreground);border-color:var(--foreground)' : ''), hover: 'color:var(--foreground)', 'data-r24': 'switch', onClick: () => jSwitch(!j.switch) },
+      iv(j.switch ? 'check with Jev automatically: ON — turn off' : 'check with Jev automatically: OFF — turn on'))));
+  kids.push(el('div', { 'data-r24': 'gate', 'data-open': j.open ? 'yes' : 'no', style: NOTE + (j.open ? '' : ';color:var(--foreground)') },
+    iv(j.open ? 'Active: a key is saved, validation is on for this repository, automatic checking is on and this switch is on.' : 'Not active: ' + j.sentence + ' All four must hold before anything is sent.')));
+  if (j.paused) kids.push(el('div', { 'data-r24': 'paused', style: 'display:flex;gap:8px;align-items:center;padding:2px 14px 6px;font-size:11.5px;color:var(--destructive)' },
+    el('span', null, iv(j.paused.reason)),
+    el('button', { style: BTN, hover: 'color:var(--foreground)', 'data-r24': 'resume', onClick: jResume }, 'resume')));
+  const line = lastJevLine(j);
+  if (line) kids.push(el('div', { 'data-r24': 'last', style: NOTE }, iv(line)));
+  kids.push(el('div', { style: 'display:flex;gap:6px;align-items:center;flex-wrap:wrap;padding:2px 14px 6px' },
+    el('button', { style: BTN, hover: 'color:var(--foreground)', disabled: j.switch && j.missing.every((m) => m === 'watch') ? null : 'true', 'data-r24': 'backlog',
+      title: 'Shows how many requests the existing pairs would take, and sends only after you confirm that number.', onClick: jBacklogPlan }, 'check the backlog with Jev'),
+    jPlan && jPlan.ws === ws ? el('button', { style: BTN + ';color:var(--foreground);border-color:var(--foreground)', hover: 'background:var(--accent)', 'data-r24': 'backlog-run', onClick: jBacklogRun }, 'confirm and send ' + jPlan.plan.requests + ' request(s)') : null));
+  if (jPlan && jPlan.ws === ws) {
+    const p = jPlan.plan;
+    kids.push(el('div', { 'data-r24': 'backlog-plan', style: NOTE }, iv(p.requests + ' request(s), about ' + p.characters.toLocaleString() + ' characters, to ' + p.host + ' · ' + p.pairs + ' pairs in all · ' + p.cached + ' already answered · ' + p.excluded + ' excluded · ' + p.withheld_count + ' withheld by the credential scan.')));
+  }
+  if (jNote) kids.push(el('div', { 'data-r24': 'note', style: NOTE }, iv(jNote)));
+  return kids;
+}
+
 function claimsBlock(ws) {
   const kids = [];
   kids.push(el('div', { style: LABEL }, iv('consistency of this repository')));
@@ -621,8 +684,11 @@ function claimsBlock(ws) {
       + c.internal_only + ' are checked by their own structure only; ' + c.unclassified + ' are not classified and are never compared with other files.';
   kids.push(el('div', { 'data-r22': 'verdict', 'data-verdict': d.checking ? 'checking' : d.verdict, style: 'padding:6px 14px;border-left:2px solid ' + tone + ';margin:2px 14px 6px' },
     el('span', { 'data-r22': 'verdict-word', style: 'font-size:15px;font-weight:600;color:' + tone }, iv(word)),
+    c.suspected > 0 ? el('span', { 'data-r24': 'suspects', style: 'font-size:13px;color:var(--muted-foreground)' }, iv(' · Jev suspects ' + c.suspected + ' more')) : null,
     el('span', { 'data-r22': 'verdict-why', style: 'display:block;font-size:11.5px;color:var(--muted-foreground);line-height:1.5;margin-top:2px' }, iv(why))));
-  kids.push(el('div', { 'data-r22': 'limits', style: NOTE }, iv('Checked by structure and the claims record. Prose is not read, so “Consistent” means no recorded statement contradicts its source — not that every sentence was checked. Nothing here is sent anywhere.')));
+  const sends = !!(d.jev && d.jev.open);
+  kids.push(el('div', { 'data-r22': 'limits', style: NOTE }, iv('Checked by structure and the claims record. Prose is not read, so “Consistent” means no recorded statement contradicts its source — not that every sentence was checked. '
+    + (sends ? 'Changed claim pairs are sent to TypeSafe (Jev); everything else stays on this computer.' : 'Nothing here is sent anywhere.'))));
   kids.push(el('div', { style: 'display:flex;gap:6px;align-items:center;flex-wrap:wrap;padding:2px 14px 6px' },
     el('button', { style: BTN, hover: 'color:var(--foreground)', 'data-r22': 'check', disabled: d.checking ? 'true' : null, onClick: cCheck }, 'check now'),
     el('button', { style: BTN + (d.watching ? ';color:var(--foreground);border-color:var(--foreground)' : ''), hover: 'color:var(--foreground)', 'data-r22': 'watch', onClick: () => cWatch(!d.watching),
@@ -632,6 +698,7 @@ function claimsBlock(ws) {
   if (cNote) kids.push(el('div', { 'data-r22': 'note', style: NOTE }, iv(cNote)));
   if (d.ledger && d.verdict !== 'not-checked') kids.push(el('div', { style: NOTE }, iv('Record of problems: '), el('button', { style: 'text-decoration:underline;color:var(--foreground)', 'data-r22': 'ledger', onClick: () => openDocIn(ws, d.ledger, state.product) }, iv(d.ledger))));
 
+  kids.push(...jevBlock(ws, d));
   const docs = d.docs || [];
   const finding = (f, rel) => el('div', { 'data-r22': 'finding', 'data-status': f.status, style: 'padding:2px 14px 2px 26px;font-size:11.5px;line-height:1.5;color:' + (f.status === 'contradicted' ? 'var(--foreground)' : 'var(--muted-foreground)') }, iv(f.sentence));
   const docRow = (x, showFindings) => el('div', { 'data-r22': 'doc', 'data-rel': x.rel, style: 'padding:4px 0;border-bottom:1px solid oklch(1 0 0 / 5%)' },
@@ -651,6 +718,7 @@ function claimsBlock(ws) {
   const only = (st) => (x) => ({ ...x, findings: x.findings.filter((f) => f.status === st) });
   kids.push(group('problems', 'problems — a statement is contradicted by its source', withStatus('contradicted').map(only('contradicted')), 'always', true));
   kids.push(group('stale', 'stale — a source changed after the document did, or its date passed', withStatus('stale').map(only('stale')), 'always', true));
+  kids.push(group('suspected', 'suspected by Jev — advisory, not counted as problems', withStatus('suspected').map(only('suspected')), 'always', true));
   kids.push(group('undecided', 'worth a look — structure cannot decide', withStatus('undecided').map(only('undecided')), 'toggle', true));
   kids.push(group('fine', 'checked and fine', docs.filter((x) => x.classified && !x.findings.length), 'toggle', false));
   kids.push(group('unclassified', 'not classified — nothing declares what these are', docs.filter((x) => !x.classified), 'toggle', true));

package/workspace/server.js

@@ -64,6 +64,7 @@ const { checkSurface } = require('./lib/surface-contract');
 const { createSinkGuard } = require('./lib/sink.js');
 const tsSettings = require('./lib/typesafe-settings.js');
 const tsClient = require('./lib/typesafe.js');
+const jevClaims = require('./lib/jev-claims.js');   // D80 — the bridge between the claims ledger and the one TypeSafe module
 const validateLib = require('./lib/validate.js');
 const claimsLib = require('./lib/claims.js');
 const repoWatch = require('./lib/repo-watch.js');
@@ -4476,9 +4477,24 @@ async function runClaims(w, { sweep = false } = {}) {
   try {
     const { cacheDir, ledgerFile, ledgerDir } = claimsPaths(w);
     try { fs.mkdirSync(ledgerDir, { recursive: true }); fs.mkdirSync(cacheDir, { recursive: true }); } catch { /* the writers report it */ }
-    return await claimsLib.check({ root: w.root, cacheDir, ledgerFile, sweep });
+    const out = await claimsLib.check({ root: w.root, cacheDir, ledgerFile, sweep });
+    // D80 — after the local check, and only when all four gates hold (the bridge decides), ask Jev about changed claim pairs.
+    if (out.ok) {
+      const f = tsSettings.getRepo(STATE, w.root);
+      const jev = await jevClaims.run({ root: w.root, cacheDir, ledgerFile, key: tsSettings.getKey(STATE), flags: f, exclude: f.exclude, changed: out.run ? out.run.changed : null });
+      const fresh = claimsLib.readView({ cacheDir, ledgerFile });
+      return { ...out, ...fresh, jev };
+    }
+    return out;
   } finally { claimsRunning.delete(w.root); }
 }
+// D80 — what the page needs to explain the Jev switch: which gates hold, and what the last pass did.
+function jevGateInfo(w) {
+  const f = tsSettings.getRepo(STATE, w.root);
+  const g = jevClaims.gates({ key: tsSettings.status(STATE).present, consent: f.consent, watch: f.watch, jev: f.jev });
+  const { cacheDir } = claimsPaths(w);
+  return { switch: f.jev, open: g.open, missing: g.missing, sentence: g.open ? null : jevClaims.gateSentence(g.missing), ...jevClaims.status(cacheDir) };
+}
 const claimsLast = new Map();      // root → { at, run, error }
 const claimsWatcher = repoWatch.createWatcher({
   repos: () => Array.from(workspaces.values()).map((w) => ({ id: w.id, root: w.root })),
@@ -6077,7 +6093,7 @@ async function handleRequest(req, res) {
     const { cacheDir, ledgerFile } = claimsPaths(w);
     const last = claimsLast.get(w.root) || null;
     return json(res, { ok: true, ws: w.id, name: w.name, ...claimsLib.readView({ cacheDir, ledgerFile }),
-      watching: tsSettings.getRepo(STATE, w.root).watch === true, checking: claimsRunning.has(w.root), last_run: last,
+      watching: tsSettings.getRepo(STATE, w.root).watch === true, checking: claimsRunning.has(w.root), last_run: last, jev: jevGateInfo(w),
       // the record's path, only when it is inside the repository AND something has been written to it
       ledger: (path.relative(w.root, ledgerFile).startsWith('..') || !fs.existsSync(ledgerFile)) ? null : path.relative(w.root, ledgerFile).split(path.sep).join('/') });
   }
@@ -6102,6 +6118,45 @@ async function handleRequest(req, res) {
     if (!out.ok) return json(res, { ok: false, error: out.error }, 500);
     return json(res, { ok: true, ws: w.id, watching: tsSettings.getRepo(STATE, w.root).watch === true });
   }
+  // ── D80 — Jev on changed claim pairs: the switch, a resume after a pause, and the backlog (plan, then confirmed run) ──
+  if (p === '/api/claims/jev' && req.method === 'POST') {
+    let body = {};
+    try { body = JSON.parse((await readBody(req)) || '{}'); }
+    catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const w = getWs(body.ws);
+    if (!w) return json(res, { ok: false, error: 'no workspace' }, 400);
+    if (typeof body.jev !== 'boolean') return json(res, { ok: false, error: 'jev must be true or false' }, 400);
+    const out = tsSettings.setRepo(STATE, w.root, { jev: body.jev });
+    if (!out.ok) return json(res, { ok: false, error: out.error }, 500);
+    return json(res, { ok: true, ws: w.id, jev: jevGateInfo(w) });
+  }
+  if (p === '/api/claims/jev/resume' && req.method === 'POST') {
+    let body = {};
+    try { body = JSON.parse((await readBody(req)) || '{}'); }
+    catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const w = getWs(body.ws);
+    if (!w) return json(res, { ok: false, error: 'no workspace' }, 400);
+    jevClaims.resume(claimsPaths(w).cacheDir);
+    return json(res, { ok: true, ws: w.id, jev: jevGateInfo(w) });
+  }
+  if (p === '/api/claims/jev/backlog' && req.method === 'POST') {
+    let body = {};
+    try { body = JSON.parse((await readBody(req)) || '{}'); }
+    catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const w = getWs(body.ws);
+    if (!w) return json(res, { ok: false, error: 'no workspace' }, 400);
+    const f = tsSettings.getRepo(STATE, w.root);
+    const g = jevClaims.gates({ key: tsSettings.status(STATE).present, consent: f.consent, watch: true, jev: f.jev });
+    if (!g.open) return json(res, { ok: false, error: jevClaims.gateSentence(g.missing) }, 409);
+    const { cacheDir, ledgerFile } = claimsPaths(w);
+    if (body.confirm !== true) return json(res, { ok: true, ws: w.id, plan: jevClaims.backlogPlan({ root: w.root, cacheDir, exclude: f.exclude }) });
+    if (claimsRunning.has(w.root)) return json(res, { ok: false, busy: true, error: 'a check is already running for this repository' }, 409);
+    claimsRunning.add(w.root);
+    try {
+      const out = await jevClaims.runBacklog({ root: w.root, cacheDir, ledgerFile, key: tsSettings.getKey(STATE), flags: f, exclude: f.exclude, expectRequests: body.expect_requests });
+      return json(res, { ws: w.id, ...out, jev: jevGateInfo(w), ...claimsLib.readView({ cacheDir, ledgerFile }) }, out.ok ? 200 : (out.conflict ? 409 : 500));
+    } finally { claimsRunning.delete(w.root); }
+  }
   // ── D79 — repository validation through TypeSafe ──────────────────────────────────────────────────
   // The ONLY routes that lead to an outbound request, and only through lib/typesafe.js. The key is never
   // in a response: `status` says present or absent. Nothing here edits a repository file.