create-pmos 0.132.0 → 0.133.0

package/workspace/lib/vendor/scripts/onboarding/structure.js

@@ -0,0 +1,217 @@
+'use strict';
+/* structure.js: the proposed portfolio (slice 2). structure(scan, { brief }) -> { scan_id, boards, unboarded, unsorted_total, questions }.
+ *   Board    { key, name, domain, template: product|project|simple, initiatives: [Row], unsorted: [Doc] }
+ *   Row      { proposal_id, title, id, lane, anchor, anchor_source: record|proposed|none, stage: discover|plan|do|learn,
+ *              confidence, checked, open, docs: [Doc] (at most 50), docs_total, evidence, merged: [proposal ids folded in] }
+ *   Doc      { file, title }
+ * Pure over the scan result (no model, no network, no write). The only read is of the files the scan already named, from scan.root
+ * (or opts.reader), to see a document's frontmatter and links; a file that cannot be read is still listed, just not placed by them.
+ * The scan lists a document only when it would gain frontmatter or when a finding cites it; that is the universe placed here.
+ * Everything is sorted, so the same scan gives the same structure. */
+const fs = require('fs');
+const path = require('path');
+const S = require('./scan.js');
+const briefLib = require('./brief.js');
+
+const LANES = ['feature', 'discovery', 'chore', 'incident', 'content', 'prototype'];
+const CONF_RANK = { high: 0, medium: 1, low: 2 };
+const MAX_DOCS = 50;
+const MAX_QUESTIONS = 3;
+const MAX_READ = 1024 * 1024;
+
+const norm = (s) => String(s || '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+const slug = (s) => norm(s).replace(/ /g, '-');
+const cmp = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+const stem = (f) => path.posix.basename(f).replace(/\.[^.]+$/, '');
+const mdFile = (f) => /\.(md|markdown)$/i.test(f);
+const productOf = (file) => { const m = /^products\/([^/]+)\//.exec(file || ''); return m ? m[1] : null; };
+const has = (hay, needle) => needle.length >= 4 && (' ' + hay + ' ').includes(' ' + needle + ' ');
+
+function readText(scan, opts, rel) {
+  try {
+    if (opts.reader) return opts.reader(rel);
+    if (!scan.root) return null;
+    const f = path.join(scan.root, rel);
+    if (fs.statSync(f).size > MAX_READ) return null;
+    const t = fs.readFileSync(f, 'utf8');
+    return t.includes('\0') ? null : t;
+  } catch { return null; }
+}
+
+const SKIP_DIR = /^(\.git|node_modules)$/;
+const MAX_WALK = 5000;
+/** The markdown files under scan.root, honouring the brief's doNotRead. The scan lists a document only when it would gain frontmatter,
+ * so the full list comes from a read-only walk. Sorted; capped. */
+function walkDocs(scan, brief) {
+  const out = []; if (!scan.root) return out;
+  const doNot = (brief && brief.doNotRead) || (scan.brief && scan.brief.doNotRead) || [];
+  (function rec(dir, rel) {
+    let ents; try { ents = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    ents.sort((a, b) => cmp(a.name, b.name));
+    for (const e of ents) {
+      if (out.length >= MAX_WALK) return;
+      const r = rel ? rel + '/' + e.name : e.name;
+      if (e.isDirectory()) { if (!SKIP_DIR.test(e.name) && !briefLib.matchesAny(doNot, r)) rec(path.join(dir, e.name), r); }
+      else if (e.isFile() && mdFile(e.name) && !/^(index|log)\.md$/i.test(e.name) && !/(^|\/)state\/(reports|live-notes)\//.test(r) && !briefLib.matchesAny(doNot, r)) out.push(r);
+    }
+  })(scan.root, '');
+  return out;
+}
+
+function structure(scan, opts = {}) {
+  const brief = opts.brief || null;
+  const cands = scan.candidates || [];
+  const recFiles = new Set(cands.filter((c) => c.kind === 'INITIATIVE' && c.detail && c.detail.record).map((c) => c.detail.record));
+
+  // — the documents that can be placed —
+  const docs = new Map();
+  const addDoc = (file, title, attachment) => { if (file && file !== '(brief)' && !recFiles.has(file) && !docs.has(file)) docs.set(file, { file, title: title || stem(file), attachment: !!attachment }); };
+  if (!opts.reader) for (const f of walkDocs(scan, brief)) addDoc(f);
+  for (const c of cands) if (c.kind === 'DOCUMENT') addDoc(c.evidence[0].file, c.title, c.detail && c.detail.attachment);
+  for (const c of cands) if (c.kind !== 'DOCUMENT') for (const e of c.evidence) if (mdFile(e.file)) addDoc(e.file);
+  const D = [...docs.values()].sort((a, b) => cmp(a.file, b.file));
+  let quarterMention = false;
+  for (const d of D) {
+    d.text = d.attachment ? null : readText(scan, opts, d.file);
+    d.info = d.text ? S.fmInfo(d.text) : null;
+    d.fm = (d.info && d.info.fm) || {};
+    const h = d.text ? S.docTitle(d.text) : null;
+    d.heading = h ? h.title : '';
+    if (d.text) d.title = d.fm.title || d.heading || d.title;
+    if (d.text && /\bQ[1-4]\b/.test(d.text)) quarterMention = true;
+    d.names = norm(stem(d.file)) ; d.headNorm = norm(d.heading || d.fm.title || '');
+  }
+  if (!quarterMention) quarterMention = cands.some((c) => c.evidence.some((e) => /\bQ[1-4]\b/.test(e.quote || '')));
+
+  // — rows: one per distinct initiative —
+  const raw = [];
+  for (const c of cands) {
+    if (c.kind !== 'INITIATIVE') continue;
+    const d = c.detail || {}; const f = (c.proposed && c.proposed.fields) || {};
+    const isRec = !!d.record && d.id; const isKnown = !!d.known;
+    const closed = isRec ? !d.open : false;
+    const id = isRec ? d.id : (f.id || (d.via === 'initiative_id' ? c.title : null));
+    const title = isRec ? c.title.replace(/ \(archived\)$/, '') : (d.name || c.title);
+    const lane = LANES.includes(d.lane) ? d.lane : LANES.includes(f.lane) ? f.lane : LANES.includes(d.lane_guess) ? d.lane_guess : 'feature';
+    raw.push({ c, id, title, lane, record: isRec ? d.record : (isKnown && d.record) || null, isRec, parent_kr: isRec ? d.parent_kr : (f.parent_kr || null), status: isRec ? d.status : null, closed, open: !closed });
+  }
+  raw.sort((a, b) => CONF_RANK[a.c.confidence] - CONF_RANK[b.c.confidence] || (b.isRec - a.isRec) || cmp(norm(a.title), norm(b.title)) || cmp(a.c.id, b.c.id));
+  const rows = [];
+  for (const r of raw) {
+    const nt = norm(r.title);
+    const hit = rows.find((x) => (r.id && x.id && x.id.toLowerCase() === r.id.toLowerCase()) || x._nt === nt || (x._ni && x._ni === nt) || (r.id && norm(r.id) === x._nt));
+    if (hit) { hit.merged.push(r.c.id); if (!hit.id && r.id) hit.id = r.id; if (!hit.parent_kr && r.parent_kr) hit.parent_kr = r.parent_kr; if (hit._record === null && r.record) hit._record = r.record; continue; }
+    const files = new Set(); const dirs = [];
+    if (!r.isRec) {
+      for (const e of r.c.evidence) if (e.file !== '(brief)') files.add(e.file);
+      if (r.c.detail && r.c.detail.via === 'folder' && r.c.evidence[0]) dirs.push(path.posix.dirname(r.c.evidence[0].file));
+    }
+    rows.push({ proposal_id: r.c.id, title: r.title, id: r.id, lane: r.lane, parent_kr: r.parent_kr, status: r.status, confidence: r.c.confidence, open: r.open, evidence: r.c.evidence, merged: [], _nt: nt, _ni: r.id ? norm(r.id) : '', _record: r.record, _files: files, _dirs: dirs, _docs: [] });
+  }
+  rows.sort((a, b) => cmp(a._nt, b._nt) || cmp(a.id || '', b.id || '') || cmp(a.proposal_id, b.proposal_id));
+
+  // — place documents, in order: (a) record links, (b) frontmatter names it, (c) its folder, (d) file name or heading —
+  const byId = new Map(); const byTitle = new Map();
+  for (const r of rows) { if (r.id && !byId.has(r.id.toLowerCase())) byId.set(r.id.toLowerCase(), r); if (!byTitle.has(r._nt)) byTitle.set(r._nt, r); }
+  const fileSet = new Set(D.map((d) => d.file));
+  const linked = new Map();
+  for (const r of rows) {
+    if (!r._record) continue;
+    const t = readText(scan, opts, r._record); if (!t) continue;
+    for (const p of S.recordRefs(t, r._record, fileSet)) if (!linked.has(p)) linked.set(p, r);
+  }
+  const placedBy = new Map();
+  for (const d of D) {
+    let row = linked.get(d.file) || null;
+    if (!row && d.text) {
+      const names = [d.fm.initiative, d.fm.initiative_id, (S.extractDeclaredInitiativeId(d.text) || {}).id].filter(Boolean);
+      for (const n of names) { row = byId.get(String(n).toLowerCase()) || byTitle.get(norm(n)) || null; if (row) break; }
+    }
+    if (!row) row = rows.find((r) => r._files.has(d.file) || r._dirs.some((x) => d.file.startsWith(x + '/'))) || null;
+    if (!row) {
+      const hay = d.names + ' ' + d.headNorm; let best = null; let bl = 0;
+      for (const r of rows) {
+        const l = Math.max(has(hay, r._ni) ? r._ni.length : 0, has(hay, r._nt) ? r._nt.length : 0);
+        if (l > bl) { best = r; bl = l; }
+      }
+      row = best;
+    }
+    if (row) { row._docs.push(d); placedBy.set(d.file, row); }
+  }
+
+  // — boards —
+  const prods = new Set();
+  for (const f of [...D.map((d) => d.file), ...cands.flatMap((c) => c.evidence.map((e) => e.file))]) { const p = productOf(f); if (p) prods.add(p); }
+  const rootDomain = scan.domain || slug(scan.tenant_name) || 'root';
+  const boards = new Map();
+  const board = (key) => {
+    if (!boards.has(key)) boards.set(key, key === 'root' ? { key, name: scan.tenant_name, domain: rootDomain, template: 'product', initiatives: [], unsorted: [] } : { key, name: key, domain: key, template: 'product', initiatives: [], unsorted: [] });
+    return boards.get(key);
+  };
+  if (!prods.size) board('root'); else for (const p of [...prods].sort()) board(p);
+  const unboarded = [];
+  const rowBoard = (r) => {
+    if (!prods.size) return 'root';
+    const own = productOf(r.evidence[0] && r.evidence[0].file) || productOf(r._record);
+    if (own) return own;
+    const votes = {}; for (const d of r._docs) { const p = productOf(d.file); if (p) votes[p] = (votes[p] || 0) + 1; }
+    const top = Object.keys(votes).sort((a, b) => votes[b] - votes[a] || cmp(a, b))[0];
+    return top || 'root';
+  };
+  const CLOSED_STAGE = (r) => !r.open;
+  const planDoc = (d) => /(^|\s)(prd|spec|specification|plan)(\s|$)/.test(d.names) || /\b(prd|spec|specification)\b/i.test(d.fm.type || '') || /(^|\s)(prd|spec|specification)(\s|$)/.test(d.headNorm);
+  const ACTIVE = /active|in.?progress|build|doing|started|wip|develop/i;
+  for (const r of rows) {
+    const bk = rowBoard(r); const b = board(bk); r._board = bk;
+    const stage = CLOSED_STAGE(r) ? 'learn' : r._docs.some(planDoc) ? 'plan' : ACTIVE.test(r.status || '') ? 'do' : 'discover';
+    const anchor = r.parent_kr ? { anchor: r.parent_kr, source: 'record' } : r.open ? { anchor: 'domain:' + b.domain, source: 'proposed' } : { anchor: null, source: 'none' };
+    const list = r._docs.map((d) => ({ file: d.file, title: d.title })).sort((a, b2) => cmp(a.file, b2.file));
+    b.initiatives.push({
+      proposal_id: r.proposal_id, title: r.title, id: r.id, lane: r.lane, anchor: anchor.anchor, anchor_source: anchor.source, stage,
+      confidence: r.confidence, checked: r.confidence === 'high' || r.confidence === 'medium', open: r.open,
+      docs: list.slice(0, MAX_DOCS), docs_total: list.length, evidence: r.evidence, merged: r.merged.slice().sort(),
+    });
+  }
+  let unsortedTotal = 0;
+  for (const d of D) {
+    if (placedBy.has(d.file)) continue;
+    unsortedTotal++;
+    const p = productOf(d.file); const dd = { file: d.file, title: d.title };
+    if (!prods.size) boards.get('root').unsorted.push(dd);
+    else if (p) boards.get(p).unsorted.push(dd);
+    else if (boards.has('root')) boards.get('root').unsorted.push(dd);
+    else unboarded.push(dd);
+  }
+
+  // — template guess —
+  const PROJ = /project|client|engagement|migration|rollout/i;
+  for (const b of boards.values()) {
+    const n = b.initiatives.length; const recs = b.initiatives.filter((r) => r.id && r.evidence.some((e) => recFiles.has(e.file))).length;
+    const projy = b.initiatives.filter((r) => PROJ.test(r.title)).length;
+    if (PROJ.test(b.key) || PROJ.test(b.name) || (n > 0 && projy * 2 > n)) b.template = 'project';
+    else if (!recs && n < 3) b.template = 'simple';
+    b.initiatives.sort((x, y) => cmp(norm(x.title), norm(y.title)) || cmp(x.id || '', y.id || '') || cmp(x.proposal_id, y.proposal_id));
+    b.unsorted.sort((x, y) => cmp(x.file, y.file));
+  }
+  const out = [...boards.values()].filter((b) => b.initiatives.length || b.unsorted.length || prods.size === 0 || boards.size === 1).sort((a, b) => cmp(a.key, b.key));
+  unboarded.sort((x, y) => cmp(x.file, y.file));
+
+  // — questions: only what the scan could not decide, at most three —
+  const questions = [];
+  const proposed = out.flatMap((b) => b.initiatives.filter((r) => r.open && r.anchor_source === 'proposed'));
+  if (proposed.length) {
+    const one = out.length === 1 ? out[0].domain : null;
+    const def = one ? 'domain:' + one : 'per-board';
+    questions.push({ id: 'anchor', text: `${proposed.length} open initiative${proposed.length === 1 ? ' has' : 's have'} no anchor yet. PMOS needs one for each, and never invents a KR.`, default: def, count: proposed.length,
+      options: [{ value: def, label: one ? `Use domain:${one} (recommended)` : 'Use each board\'s domain anchor (recommended)' }], free: 'Or name one KR or health budget for all of them' });
+  }
+  const fy = (brief && brief.vocabulary && brief.vocabulary.fiscalYearStartMonth) || (scan.brief && scan.brief.vocabulary && scan.brief.vocabulary.fiscalYearStartMonth);
+  if (quarterMention && !fy) {
+    questions.push({ id: 'fiscal', text: 'Your documents mention quarters (Q1 to Q4). Which month does your fiscal year start?', default: 'January', options: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'] });
+  }
+  const odd = out.find((b) => b.template !== 'product');
+  if (odd) questions.push({ id: 'template', board: odd.key, text: `Board "${odd.name}" does not look like a product. Which template fits it?`, default: odd.template, options: ['product', 'project', 'simple'] });
+  return { scan_id: scan.scan_id, boards: out, unboarded, unsorted_total: unsortedTotal, questions: questions.slice(0, MAX_QUESTIONS) };
+}
+
+module.exports = { structure };

package/workspace/lib/vendor/scripts/plan-items-stage.js

@@ -0,0 +1,271 @@
+'use strict';
+/* plan-items-stage.js — the stage of each plan item, and the Build rule, for the workflow engine (pm-os-absorb Run 4,
+ * PRD R6, map-spec X29).
+ *
+ *   foldStages(text)               → { items: { [id]: { initiative, stage } }, withdrawn: [id…] }
+ *   readFactory(text)              → { items: { [workItemId]: { initiative, plan_item, integrated, withdrawn } } }
+ *   mainTree(root)                 → the main working tree of root's repository (root itself when it is not linked)
+ *   buildRule({ planText, workText, initiative })
+ *                                  → { applies, materialized: [id…], integrated: [id…], pending: [id…] }
+ *   buildRuleFor(root, id)         → the same, read from the repository's two ledgers; { applies: false } when neither
+ *                                    file is there
+ *   planItemsPath(root) · workItemsPath(root)
+ *
+ * THE BUILD RULE (R6). Items never complete a stage, with one exception: a code initiative's Build stage is done when
+ * every MATERIALIZED item under it is integrated. A materialized item is a work item whose `declared` line names a
+ * plan item (`plan_item`, D86 point 1) that sits in the Build stage of the same initiative and is not withdrawn. A
+ * work item that is withdrawn in the factory ledger is not counted. When an initiative has no materialized item under
+ * Build, the rule does not apply and the engine decides the Build step from the commits, as before.
+ *
+ * WHY THIS FILE EXISTS (X29). The engine (scripts/workflow-state.js) is vendored into the workspace bundle and into
+ * the kit, so it cannot require workspace/lib/plan-items.js. This module reads the same ledger with a small pure fold
+ * of its own. workspace/plan-items-stage-parity.test.js holds it to plan-items.js's fold (stage, withdrawn) and to
+ * scripts/work-item.js's fold (integrated, withdrawn) on every fixture, so a rule added to one fold and not the
+ * other fails a test instead of making CI and the workspace disagree.
+ *
+ * DELIBERATELY FLAT in scripts/, not scripts/lib/ (read-jsonl.js has the same note): the kit and the workspace bundle
+ * vendor the engine's require closure by BASENAME into one directory, so a `./lib/` require from the engine would
+ * load in this checkout and break in every vendored copy.
+ *
+ * The factory half is D65's ORDER, restated small: lines sorted by instant (ledger order breaks a tie), the type's
+ * chain (scripts/work-item.js CHAIN, chainFor), and a two-outcome node satisfied by its LATEST outcome (failed revokes
+ * verified, released revokes claimed). A line that skips its predecessor is not counted, the same as deriveItems
+ * discards it, so a hand-appended `integrated` with no `verified` before it never makes the Build step done. It does
+ * not restate the per-field schema: scripts/check-work-items.js fails CI on a schema-invalid line. Restated, not
+ * required, because work-item.js cannot be vendored (its sink guard requires ./lib/sink.js); the parity test holds the
+ * two folds to one answer, on valid and on invalid ledgers.
+ *
+ * BOTH LEDGERS ARE READ FROM THE MAIN WORKING TREE, as lib/plan-items.js, lib/plan-ledgers.js and lib/factory-join.js
+ * read them. From a linked worktree (where every factory agent works) the engine, check-work-items and the workspace
+ * then read the same two files. mainTree is the filesystem-only walk of lib/plan-tree.js mainTree, restated here.
+ *
+ * Pure apart from the two file reads in buildRuleFor. No network, no git, no clock. Zero dependencies, stock Node.
+ */
+const fs = require('fs');
+const path = require('path');
+
+// ── the plan-items schema, as workspace/lib/plan-items.js lineErr states it ──────────────────────────────────────
+// Every line that lib/plan-items.js ignores must be ignored here too, or the two folds disagree about which line of
+// a repeated event id wins. So the whole stored-line schema is restated, not only the stage fields.
+const EVENTS = ['planned', 'set', 'moved', 'flagged', 'withdrawn', 'kept'];
+const STATES = ['todo', 'doing', 'review', 'done'];
+const SET_FIELDS = ['title', 'stage', 'order', 'owner', 'after', 'start', 'due', 'milestone', 'note'];
+const EVIDENCE_KINDS = ['commit', 'pr', 'file', 'session', 'note'];
+const ID_RE = /^(.+)\.([0-9a-z]{10})$/;
+const INIT_RE = /^[A-Za-z0-9][\w.-]{0,119}$/;
+const EID_RE = /^[0-9a-z]{12}$/;
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const AT_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
+const BY_RE = /^(?:pm:[a-z0-9_-]{1,40}|agent:unknown|agent:sess-\d+\.[0-9a-f]{8})$/;
+
+const isStr = (v) => typeof v === 'string';
+const oneLine = (v, max) => isStr(v) && v.trim().length >= 1 && v.length <= max && !/[\r\n]/.test(v);
+const initiativeOf = (id) => { const m = ID_RE.exec(String(id || '')); return m ? m[1] : null; };
+function ownerOk(v) {
+  if (v === 'you' || v === 'agent') return true;
+  const m = /^(person|tracker):(.+)$/s.exec(String(v));
+  return !!m && m[2].length >= 1 && m[2].length <= 60 && !/[\r\n]/.test(m[2]);
+}
+const dateOk = (v) => v === null || (isStr(v) && DATE_RE.test(v) && (() => {
+  const t = Date.parse(v + 'T00:00:00Z');
+  return Number.isFinite(t) && new Date(t).toISOString().slice(0, 10) === v;
+})());
+function evidenceBad(e) {
+  if (!e || typeof e !== 'object' || Array.isArray(e) || !EVIDENCE_KINDS.includes(e.kind) || !isStr(e.ref)) return true;
+  const ref = e.ref;
+  if (e.kind === 'commit') return !/^[0-9a-f]{7,40}$/i.test(ref);
+  if (e.kind === 'pr') return !/^#?\d+$/.test(ref);
+  if (e.kind === 'file') return !ref || ref.length > 300 || path.isAbsolute(ref) || ref.split(/[\\/]/).includes('..') || /[\r\n]/.test(ref);
+  if (e.kind === 'session') return !/^sess-\d+$/.test(ref);
+  return !oneLine(ref, 200);
+}
+function fieldBad(k, v) {
+  switch (k) {
+    case 'title': return !oneLine(v, 200);
+    case 'stage': return !(isStr(v) && v.trim());
+    case 'order': return !(typeof v === 'number' && Number.isFinite(v));
+    case 'owner': return !ownerOk(v);
+    case 'after': return !(Array.isArray(v) && v.every((x) => isStr(x) && ID_RE.test(x)));
+    case 'start': case 'due': return !dateOk(v);
+    case 'milestone': return typeof v !== 'boolean';
+    case 'note': return !(v === null || (isStr(v) && v.length <= 1000));
+    default: return true;
+  }
+}
+/** true when lib/plan-items.js would ignore this stored line as schema-invalid. */
+function lineBad(r) {
+  if (!r || typeof r !== 'object' || Array.isArray(r)) return true;
+  if (r.v !== 1 || !isStr(r.eid) || !EID_RE.test(r.eid) || !EVENTS.includes(r.ev)) return true;
+  if (!isStr(r.by) || !BY_RE.test(r.by) || (r.via !== 'ui' && r.via !== 'cli')) return true;
+  if (!isStr(r.at) || !AT_RE.test(r.at) || Number.isNaN(Date.parse(r.at))) return true;
+  if (!isStr(r.initiative) || !INIT_RE.test(r.initiative)) return true;
+  if (r.ev !== 'kept' && (!isStr(r.item) || !ID_RE.test(r.item) || initiativeOf(r.item) !== r.initiative)) return true;
+  switch (r.ev) {
+    case 'planned': return SET_FIELDS.some((k) => fieldBad(k, r[k]));
+    case 'set': {
+      const f = r.fields;
+      if (!f || typeof f !== 'object' || Array.isArray(f) || !Object.keys(f).length) return true;
+      return Object.keys(f).some((k) => !SET_FIELDS.includes(k)
+        || (!((k === 'start' || k === 'due' || k === 'note') && f[k] === null) && fieldBad(k, f[k])));
+    }
+    case 'moved':
+      if (!STATES.includes(r.to)) return true;
+      if (r.evidence !== undefined && evidenceBad(r.evidence)) return true;
+      if (r.override !== undefined && (r.override !== true || !String(r.by).startsWith('pm:'))) return true;
+      return false;
+    case 'flagged': return r.blocked === true ? !oneLine(r.reason, 200) : r.blocked !== false;
+    case 'withdrawn': return false;
+    case 'kept':
+      return r.item !== undefined || !isStr(r.batch) || !/^agent:/.test(r.batch)
+        || !Array.isArray(r.items) || !r.items.length || !r.items.every((x) => isStr(x) && ID_RE.test(x));
+    default: return true;
+  }
+}
+
+/**
+ * The plan-items ledger text → each live item's initiative and stage, and the withdrawn ids. The same order-free
+ * fold as lib/plan-items.js: drop byte-identical duplicates, sort by (at, eid, line), keep the first line of an event
+ * id, ignore a second `planned` of one id and every line after a withdraw.
+ */
+function foldStages(text) {
+  const seenRaw = new Set();
+  const lines = [];
+  for (const raw0 of String(text == null ? '' : text).split('\n')) {
+    const raw = raw0.replace(/\r$/, '').trim();
+    if (!raw || seenRaw.has(raw)) continue;
+    let rec;
+    try { rec = JSON.parse(raw); } catch { continue; }
+    if (lineBad(rec)) continue;
+    seenRaw.add(raw);
+    lines.push({ raw, rec });
+  }
+  lines.sort((a, b) => (Date.parse(a.rec.at) - Date.parse(b.rec.at))
+    || (a.rec.eid < b.rec.eid ? -1 : a.rec.eid > b.rec.eid ? 1 : 0)
+    || (a.raw < b.raw ? -1 : a.raw > b.raw ? 1 : 0));
+  const seenEid = new Set();
+  const items = {};
+  const withdrawn = new Set();
+  for (const { rec } of lines) {
+    if (seenEid.has(rec.eid)) continue;
+    seenEid.add(rec.eid);
+    if (rec.ev === 'kept') continue;
+    if (rec.ev === 'planned') {
+      if (items[rec.item] || withdrawn.has(rec.item)) continue;
+      items[rec.item] = { initiative: rec.initiative, stage: rec.stage };
+      continue;
+    }
+    const it = items[rec.item];
+    if (!it || withdrawn.has(rec.item)) continue;
+    if (rec.ev === 'set' && Object.prototype.hasOwnProperty.call(rec.fields, 'stage')) it.stage = rec.fields.stage;
+    if (rec.ev === 'withdrawn') { delete items[rec.item]; withdrawn.add(rec.item); }
+  }
+  return { items, withdrawn: [...withdrawn].sort() };
+}
+
+/* D65(d)'s chain per type (scripts/work-item.js CHAIN, chainFor, NEGATED_BY, standsSatisfied), restated. */
+const FACTORY_EVENTS = ['declared', 'claimed', 'released', 'verified', 'failed', 'integrated', 'shipped', 'withdrawn'];
+const CHAIN_DEFAULT = ['claimed', 'verified', 'integrated', 'shipped'];
+const CHAIN_HOTFIX = ['claimed', 'verified', 'shipped', 'integrated'];
+const chainFor = (type) => (type === 'spike-item' ? CHAIN_DEFAULT.filter((e) => e !== 'verified') : type === 'hotfix' ? CHAIN_HOTFIX : CHAIN_DEFAULT);
+const NEGATED_BY = { verified: 'failed', claimed: 'released' };
+function standsSatisfied(history, need) {
+  const negator = NEGATED_BY[need];
+  if (!negator) return history.includes(need);
+  for (let i = history.length - 1; i >= 0; i -= 1) {
+    if (history[i] === need) return true;
+    if (history[i] === negator) return false;
+  }
+  return false;
+}
+
+/** The factory ledger text → per work item: its initiative, its plan item, and whether it is integrated or withdrawn. */
+function readFactory(text) {
+  const lines = [];
+  String(text == null ? '' : text).split('\n').forEach((raw, idx) => {
+    if (!raw.trim()) return;
+    let rec;
+    try { rec = JSON.parse(raw); } catch { return; }
+    if (!rec || typeof rec !== 'object' || !isStr(rec.item_id) || !isStr(rec.initiative_id) || !FACTORY_EVENTS.includes(rec.event)) return;
+    const t = typeof rec.at === 'string' ? Date.parse(rec.at) : NaN;
+    if (Number.isNaN(t)) return;
+    lines.push({ rec, idx, t });
+  });
+  lines.sort((a, b) => a.t - b.t || a.idx - b.idx);
+  const items = {}; const fold = {};
+  for (const { rec } of lines) {
+    const id = rec.item_id;
+    if (rec.event === 'declared') {
+      if (items[id]) continue;   // declared twice: the fold keeps the first
+      items[id] = { initiative: rec.initiative_id, plan_item: isStr(rec.plan_item) ? rec.plan_item : null, integrated: false, withdrawn: false };
+      fold[id] = { type: rec.type, history: ['declared'] };
+      continue;
+    }
+    const it = items[id];
+    if (!it || it.withdrawn) continue;
+    const chain = chainFor(fold[id].type);
+    const pos = chain.indexOf(rec.event === 'failed' ? 'verified' : rec.event);
+    if (pos > 0 && !standsSatisfied(fold[id].history, chain[pos - 1])) continue;   // out of order: deriveItems discards it
+    fold[id].history.push(rec.event);
+    if (rec.event === 'integrated') it.integrated = true;
+    if (rec.event === 'withdrawn') it.withdrawn = true;
+  }
+  return { items };
+}
+
+/** The Build rule over the two ledgers' text, for one initiative. */
+function buildRule({ planText, workText, initiative }) {
+  const plan = foldStages(planText);
+  const work = readFactory(workText);
+  const materialized = []; const integrated = []; const pending = [];
+  for (const [wid, w] of Object.entries(work.items)) {
+    if (w.initiative !== initiative || w.withdrawn || !w.plan_item) continue;
+    const p = plan.items[w.plan_item];
+    if (!p || p.initiative !== initiative || p.stage !== 'build') continue;
+    materialized.push(wid);
+    (w.integrated ? integrated : pending).push(wid);
+  }
+  const sort = (a) => a.sort();
+  return { applies: materialized.length > 0, materialized: sort(materialized), integrated: sort(integrated), pending: sort(pending) };
+}
+
+/** The main working tree of root's repository: root itself, unless root is a linked worktree. Filesystem only. */
+function mainTree(root) {
+  try {
+    const dotgit = path.join(root, '.git');
+    if (fs.statSync(dotgit).isDirectory()) return root;
+    const m = /^gitdir:\s*(.+)$/m.exec(fs.readFileSync(dotgit, 'utf8'));
+    if (!m) return root;
+    const gitdir = path.resolve(root, m[1].trim());
+    const common = path.resolve(gitdir, fs.readFileSync(path.join(gitdir, 'commondir'), 'utf8').trim());
+    if (path.basename(common) !== '.git') return root;
+    const main = path.dirname(common);
+    return fs.statSync(path.join(main, '.git')).isDirectory() ? main : root;
+  } catch { return root; }
+}
+
+/** The plan-items ledger of a repository: planning/runs/ for PMOS-self, pmos/state/ in a kit (workflow-state layout). */
+function planItemsPath(root) {
+  const main = mainTree(path.resolve(String(root)));
+  const self = path.join(main, 'planning', 'initiatives');
+  const kit = path.join(main, 'pmos', 'state', 'initiatives');
+  const isKit = !fs.existsSync(self) && fs.existsSync(kit);
+  return isKit ? path.join(main, 'pmos', 'state', 'plan-items.jsonl') : path.join(main, 'planning', 'runs', 'plan-items.jsonl');
+}
+/** The D65 factory ledger of a repository (the one scripts/check-work-items.js reads), in the main working tree. */
+const workItemsPath = (root) => path.join(mainTree(path.resolve(String(root))), 'planning', 'work-items.jsonl');
+
+function readText(file) {
+  try { return { ok: true, text: fs.readFileSync(file, 'utf8') }; }
+  catch (e) { return { ok: e && e.code === 'ENOENT', text: '', missing: true, error: e && e.code !== 'ENOENT' ? String(e.message || e) : null }; }
+}
+
+function buildRuleFor(root, initiative) {
+  const work = readText(workItemsPath(root));
+  if (work.missing && work.ok) return { applies: false, materialized: [], integrated: [], pending: [] };
+  if (!work.ok) return { applies: false, unknown: true, reason: `the factory ledger could not be read: ${work.error}`, materialized: [], integrated: [], pending: [] };
+  const plan = readText(planItemsPath(root));
+  if (!plan.ok) return { applies: false, unknown: true, reason: `the plan-items ledger could not be read: ${plan.error}`, materialized: [], integrated: [], pending: [] };
+  return buildRule({ planText: plan.text, workText: work.text, initiative });
+}
+
+module.exports = { foldStages, readFactory, buildRule, buildRuleFor, mainTree, planItemsPath, workItemsPath, lineBad };

package/workspace/lib/vendor/scripts/read-jsonl.js

@@ -0,0 +1,53 @@
+'use strict';
+/*
+ * scripts/read-jsonl.js — THE JSONL reader for the scripts/ checkers and the workflow engine.
+ *
+ * Six near-identical readers grew here, with three different torn-line contracts, and the repo's
+ * own comments record the cost twice: a silently-dropped torn line re-opened a verified entry
+ * (check-verify-queue.js) and made an accepted initiative read as never accepted (workflow-state.js).
+ * Each new checker re-decided the torn-line question from scratch and got it wrong at least twice.
+ * One reader, one contract — the strictest one found:
+ *
+ *   - a torn line is DROPPED, never guessed at — a truncated row parsed "as far as it goes" would
+ *     fabricate a record nobody wrote;
+ *   - and it is REPORTED, never swallowed: every defect comes back with its file, 1-based line,
+ *     parse reason and a bounded slice of the text, so the caller can say out loud what it could
+ *     not read. "Assuming someone else counts is how nobody counts."
+ *   - a MISSING (or unreadable) file is its own state, distinguishable from an empty one — the
+ *     cadence checker needs the difference and a gate must not confuse "no ledger" with "no rows".
+ *
+ * Returns { rows, defects, torn, missing }: rows are the parsed objects in file order; defects is
+ * [{ file, line, reason, text }]; torn === defects.length, kept as a count because most callers
+ * only need the number; missing is true when the file could not be read at all (rows/defects empty).
+ *
+ * DELIBERATELY FLAT in scripts/, not scripts/lib/: the kit and the workspace bundle both vendor the
+ * engine's require closure by BASENAME into a flat directory (kit/build-kit.sh, scripts/
+ * vendor-workspace-engine.js), so a `./lib/` require would resolve in the checkout and break in
+ * every vendored copy — the exact incident class the scripts/lib/sink.js re-export note records.
+ * workspace/lib/file-mode-parse.js does NOT delegate here for the mirrored reason: the workspace
+ * bundle ships alone, cannot require across the bundle boundary, and its silent-drop reader is the
+ * locked mirror of kit/scripts/metrics.py (kit/fixtures/test_parsers.py holds that agreement).
+ *
+ * Zero dependencies, stock Node.
+ */
+const fs = require('fs');
+
+function readJsonl(file) {
+  let text;
+  try { text = fs.readFileSync(file, 'utf8'); }
+  catch { return { rows: [], defects: [], torn: 0, missing: true }; }
+  const rows = [];
+  const defects = [];
+  const lines = text.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const t = lines[i].trim();
+    if (!t) continue;
+    try { rows.push(JSON.parse(t)); }
+    catch (e) {
+      defects.push({ file, line: i + 1, reason: String((e && e.message) || 'not valid JSON').slice(0, 120), text: t.slice(0, 120) });
+    }
+  }
+  return { rows, defects, torn: defects.length, missing: false };
+}
+
+module.exports = { readJsonl };

package/workspace/lib/vendor/scripts/signals/layout-paths.js

@@ -0,0 +1,43 @@
+'use strict';
+// layout-paths.js: where a repo keeps the files the console reads, for BOTH layouts (the PMOS repo itself and a kit tenant).
+// The workflow engine already decides which layout a repo has (scripts/workflow-state.js layout()): the PMOS repo keeps its
+// ledgers under planning/runs, a kit tenant keeps them under pmos/state. Readers must ask here and never hard-code planning/.
+const path = require('path');
+
+function pathsFor(root) {
+  const base = path.resolve(root || process.cwd());
+  const L = require('../workflow-state.js').layout(base);
+  const kit = !!L.kit;
+  return {
+    root: base,
+    kit,
+    initiativesDir: L.initiatives,
+    ledgerDir: L.runsDir,
+    // The factory's work-item ledger exists only in the PMOS repo; a tenant's work items are its plan items.
+    workItemsFile: kit ? path.join(L.runsDir, 'work-items.jsonl') : path.join(base, 'planning', 'work-items.jsonl'),
+    planItemsFile: path.join(L.runsDir, 'plan-items.jsonl'),
+    recordsDir: kit ? path.join(L.runsDir, 'records') : path.join(base, 'planning', 'records'),
+  };
+}
+
+// A folded plan item (workspace/lib/plan-items.js fold) as the console's work-item fact. Proposed items are not the PM's yet.
+function planItemToFact(it) {
+  if (!it || it.proposed) return null;
+  const st = String(it.state || 'todo');
+  return {
+    key: it.id, initiative: it.initiative || null, title: it.title || it.id,
+    status: st === 'done' ? 'done' : (st === 'doing' || st === 'review') ? 'doing' : 'todo',
+    owner: it.owner || null, start: it.start || null, due: it.due || null, after: Array.isArray(it.after) ? it.after : [],
+    source: 'plan-items',
+  };
+}
+
+function planItemFacts(text) {
+  const P = require('../../workspace/lib/plan-items.js');
+  const parsed = P.parseText(text);
+  const folded = P.fold(parsed.lines || parsed);
+  const list = Array.isArray(folded.items) ? folded.items : Object.values(folded.items || {});
+  return list.map(planItemToFact).filter(Boolean);
+}
+
+module.exports = { pathsFor, planItemToFact, planItemFacts };