create-pmos 0.36.0 → 0.38.0

package/workspace/lib/engine/pmos-skills.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+'use strict';
+/* pmos-skills — the directory of discovered and generated skills (D76).
+ *
+ *   node pmos-skills.js add --id my-skill --file ./downloaded.skill --url https://… --license MIT --author someone --why "…" [--origin discovered|generated]
+ *   node pmos-skills.js list | show <id> [--sha <12>] | reject <id> --sha <12> --reason "…" | retire <id> --sha <12> [--root <repo>] [--json]
+ *
+ * THE POINT OF THIS MODULE IS WHAT IT WILL NOT DO. A skill here is a prompt that runs with the PM's tools and
+ * accounts, and the loader re-reads skill files on every call, so a downloaded file is runnable the moment it lands.
+ * Therefore:
+ *   · `add` puts a text file in QUARANTINE and records provenance. It cannot approve anything. There is no approve
+ *     command in this file at all: approval is a PM press in the workspace, recorded in the workspace's own runtime
+ *     state on that machine (outside the repository, so a commit or a hand-edited registry cannot approve for the PM).
+ *   · the registry in the repository is SUBTRACTIVE-SAFE: anyone may append `add`, `reject` and `retire`, and none of
+ *     them can make a skill run.
+ *   · a file is accepted only as ONE text file of at most 40 KB; archives, binaries, NUL bytes and non-UTF-8 are refused.
+ *   · a critical finding refuses the file outright (nothing is stored); soft findings are stored and shown.
+ *   · the scanner is evadable (the repo's own SECURITY note says so). It is a filter, not a verdict: the PM reading
+ *     the full text, and the loader re-hashing it, are the controls.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const memory = require('./pmos-memory.js');
+
+const MAX_BYTES = 40 * 1024;
+const ID_RE = /^[a-z0-9][a-z0-9-]{0,48}$/;
+const ORIGINS = ['discovered', 'generated'];
+const PERMISSIVE = new Set(['mit', 'apache-2.0', 'bsd-2-clause', 'bsd-3-clause', 'isc', 'cc0-1.0', 'unlicense', '0bsd']);
+const FORCED_KEYS = ['agent', 'run', 'surface'];       // a discovered skill's own values for these are never honoured
+
+// ── paths ────────────────────────────────────────────────────────────────────────────────────
+function stateDir(root, create) {
+  const kit = path.join(root, 'pmos', 'state'); const self = path.join(root, 'planning');
+  if (fs.existsSync(kit)) return kit;
+  if (fs.existsSync(self)) return self;
+  if (create) { fs.mkdirSync(kit, { recursive: true }); return kit; }
+  return null;
+}
+function skillsDir(root, create) {
+  const s = stateDir(root, create); if (!s) return null;
+  const d = path.join(s, 'skills'); if (create) fs.mkdirSync(d, { recursive: true });
+  return d;
+}
+const sha256 = (text) => crypto.createHash('sha256').update(text, 'utf8').digest('hex');
+
+// ── the scan ─────────────────────────────────────────────────────────────────────────────────
+// Critical = refuse. These are the memory scanner's rules (injection phrasing, credentials, exfiltration, a
+// planted key, invisible and bidirectional characters) — in a skill body they have no legitimate use.
+const SOFT = [
+  ['shell command', /\b(rm\s+-rf|sudo\s|chmod\s+[0-7]{3,4}|mkfs|dd\s+if=|:\(\)\s*\{|\beval\s*\(|bash\s+-c|sh\s+-c)\b/],
+  ['downloads and runs', /\b(curl|wget)\b[^\n]{0,120}\b(sh|bash|zsh|python|node)\b/i],
+  ['network fetch', /\b(curl|wget|fetch|http\.get|requests\.(get|post)|urllib)\b/i],
+  ['hidden comment', /<!--[\s\S]{0,2000}?-->/],
+  ['long encoded blob', /[A-Za-z0-9+\/=]{120,}/],
+  ['mentions credential files', /(~\/\.ssh|\bid_rsa\b|\.aws\/credentials|\.env\b|\.netrc|keychain|ANTHROPIC_API_KEY|OPENAI_API_KEY|GITHUB_TOKEN)/i],
+  ['asks to hide or skip the user', /\b(do not tell the user|don't tell the user|without (asking|telling|confirm)|silently|secretly|no need to inform)\b/i],
+  ['sends data out', /\b(send|email|post|upload|forward)\b[^\n]{0,60}\b(to|at)\b[^\n]{0,40}(@|https?:\/\/)/i],
+];
+function lineOf(text, index) { return text.slice(0, index).split('\n').length; }
+function scanSkill(text) {
+  const critical = []; const soft = [];
+  const lines = text.split('\n');
+  for (const [name, re] of memory.SCAN) {
+    const g = new RegExp(re.source, re.flags.replace('g', '') + 'g'); let m;
+    while ((m = g.exec(text)) && critical.length < 20) { critical.push({ rule: name, line: lineOf(text, m.index) }); if (m.index === g.lastIndex) g.lastIndex++; }
+  }
+  for (const [name, re] of SOFT) {
+    const g = new RegExp(re.source, re.flags.replace('g', '') + 'g'); let m; let n = 0;
+    while ((m = g.exec(text)) && n < 5) { soft.push({ rule: name, line: lineOf(text, m.index) }); n++; if (m.index === g.lastIndex) g.lastIndex++; }
+  }
+  const external = [...new Set((text.match(/https?:\/\/[^\s)>"']+/g) || []))];
+  if (external.length) soft.push({ rule: `external links (${external.length})`, line: lineOf(text, text.indexOf(external[0])) });
+  void lines;
+  return { critical, soft };
+}
+// The frontmatter keys a discovered skill sets that this directory will IGNORE (the harness is forced).
+function ignoredKeys(text) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text); if (!m) return [];
+  const out = [];
+  for (const k of FORCED_KEYS) { const kv = new RegExp(`^${k}:\\s*(.+)$`, 'm').exec(m[1]); if (kv && !(k === 'agent' && /^["']?claude["']?$/.test(kv[1].trim())) && !(k === 'run' && /^["']?agent["']?$/.test(kv[1].trim()))) out.push(`${k}: ${kv[1].trim().slice(0, 40)}`); }
+  return out;
+}
+
+// ── validation of an incoming file ───────────────────────────────────────────────────────────
+function validateIncoming(buf) {
+  if (!Buffer.isBuffer(buf)) return 'no file content';
+  if (buf.length === 0) return 'the file is empty';
+  if (buf.length > MAX_BYTES) return `the file is ${buf.length} bytes; the limit is ${MAX_BYTES} — a skill is one short text file`;
+  if (buf.includes(0)) return 'the file contains NUL bytes — it is binary, not a text skill';
+  if (buf[0] === 0x50 && buf[1] === 0x4b) return 'the file looks like an archive — only a single text file is accepted';
+  let text; try { text = new TextDecoder('utf-8', { fatal: true }).decode(buf); } catch { return 'the file is not valid UTF-8 text'; }
+  return { text };
+}
+
+// ── the registry (append-only, in the repository) ────────────────────────────────────────────
+function readEvents(dir) {
+  let text = ''; try { text = fs.readFileSync(path.join(dir, 'registry.jsonl'), 'utf8'); } catch { return { events: [], torn: 0 }; }
+  const events = []; let torn = 0;
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    try { const e = JSON.parse(line); if (e && e.eid && e.op) events.push(e); else torn++; } catch { torn++; }
+  }
+  return { events, torn };
+}
+function appendEvent(dir, ev) {
+  const file = path.join(dir, 'registry.jsonl');
+  const dst = fs.lstatSync(dir);
+  if (!dst.isDirectory() || dst.isSymbolicLink()) throw new Error('the skills directory is not a plain directory — nothing was written');
+  const fd = fs.openSync(file, fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_CREAT | (fs.constants.O_NOFOLLOW || 0), 0o644);
+  try {
+    const st = fs.fstatSync(fd);
+    if (!st.isFile() || st.nlink !== 1) throw new Error('registry.jsonl is not a plain single-link file — nothing was written');
+    const before = st.size; const buf = Buffer.from(JSON.stringify(ev) + '\n');
+    if (fs.writeSync(fd, buf) !== buf.length) { try { fs.ftruncateSync(fd, before); } catch { /* best effort */ } throw new Error('short write — rolled back'); }
+  } finally { fs.closeSync(fd); }
+}
+let _seq = 0;
+const newEid = () => 's-' + Date.now().toString(36).padStart(9, '0') + '-' + String(_seq++ % 1000).padStart(3, '0') + '-' + crypto.randomBytes(3).toString('hex');
+const byTime = (a, b) => String(a.at).localeCompare(String(b.at)) || String(a.eid).localeCompare(String(b.eid));
+
+/* Fold to one row per (id, sha). State here is only quarantined | rejected | retired: whether a candidate is APPROVED
+ * is not in this file — it is the PM's local approval, joined at load time by `resolve`. Adds first, in any order. */
+function fold(events) {
+  const seen = new Map(); for (const e of events) if (!seen.has(e.eid)) seen.set(e.eid, e);
+  const all = [...seen.values()].sort(byTime);
+  const rows = new Map();
+  for (const e of all) if (e.op === 'add' && ID_RE.test(String(e.id || '')) && /^[0-9a-f]{64}$/.test(String(e.sha || ''))) {
+    const key = `${e.id}@${e.sha}`;
+    if (!rows.has(key)) rows.set(key, { id: e.id, sha: e.sha, sha12: e.sha.slice(0, 12), origin: ORIGINS.includes(e.origin) ? e.origin : 'discovered',
+      source_url: e.source_url || null, author: e.author || null, license: e.license || 'unknown', why: e.why || '', found_by: e.by || 'unknown',
+      found_at: e.at, bytes: e.bytes || null, scan: e.scan || { critical: [], soft: [] }, ignored_keys: e.ignored_keys || [], file: e.file || null, state: 'quarantined' });
+  }
+  for (const e of all) {
+    if (e.op !== 'reject' && e.op !== 'retire') continue;
+    const targets = e.sha ? [rows.get(`${e.id}@${e.sha}`)] : [...rows.values()].filter((r) => r.id === e.id);
+    for (const r of targets) if (r) { r.state = e.op === 'reject' ? 'rejected' : 'retired'; r.decided_by = e.by; r.decided_at = e.at; r.reason = e.reason || ''; }
+  }
+  return [...rows.values()];
+}
+
+const relFile = (root, id, sha) => path.posix.join(path.relative(root, skillsDir(root, false) || '').split(path.sep).join('/'), 'candidates', id, `${sha.slice(0, 12)}.skill`);
+
+/* add — agent CLI and the workspace both use it. Returns { ok, id, sha, scan } or { ok:false, error }. */
+function add(root, req) {
+  const id = String(req.id || '').trim();
+  if (!ID_RE.test(id)) return { ok: false, error: `id must be a plain slug (a-z, 0-9, hyphen; at most 49 characters), got '${id.slice(0, 40)}'` };
+  const origin = req.origin || 'discovered';
+  if (!ORIGINS.includes(origin)) return { ok: false, error: `origin must be one of ${ORIGINS.join(', ')}` };
+  const url = String(req.source_url || '').trim();
+  if (origin === 'discovered' && !/^https?:\/\/\S+$/.test(url)) return { ok: false, error: 'a discovered skill needs the http(s) URL it came from' };
+  if (!String(req.why || '').trim()) return { ok: false, error: 'say why this skill is worth the PM reading (one sentence)' };
+  const v = validateIncoming(req.content);
+  if (typeof v === 'string') return { ok: false, error: v };
+  const text = v.text; const sha = sha256(text);
+  const scan = scanSkill(text);
+  if (scan.critical.length) return { ok: false, error: `refused — ${scan.critical.slice(0, 3).map((c) => `${c.rule} (line ${c.line})`).join('; ')}. Nothing was stored.`, scan };
+  const dir = skillsDir(root, true);
+  const existing = fold(readEvents(dir).events).find((r) => r.id === id && r.sha === sha);
+  if (existing) return { ok: true, id, sha, sha12: sha.slice(0, 12), duplicate: true, state: existing.state, scan };
+  const cdir = path.join(dir, 'candidates', id); fs.mkdirSync(cdir, { recursive: true });
+  const file = path.join(cdir, `${sha.slice(0, 12)}.skill`);
+  try { const fd = fs.openSync(file, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | (fs.constants.O_NOFOLLOW || 0), 0o644); fs.writeSync(fd, text); fs.closeSync(fd); }
+  catch (e) { return { ok: false, error: `could not store the candidate — ${String((e && e.message) || e).slice(0, 100)}` }; }
+  const ev = { eid: newEid(), at: new Date().toISOString(), by: req.by || 'agent:cli', op: 'add', id, sha, origin, source_url: url || null,
+    author: req.author ? String(req.author).slice(0, 80) : null, license: String(req.license || 'unknown').slice(0, 40), why: String(req.why).trim().slice(0, 400),
+    bytes: Buffer.byteLength(text), scan, ignored_keys: ignoredKeys(text), file: relFile(root, id, sha) };
+  try { appendEvent(dir, ev); } catch (e) { return { ok: false, error: String((e && e.message) || e) }; }
+  render(root);
+  return { ok: true, id, sha, sha12: sha.slice(0, 12), state: 'quarantined', scan, file: ev.file };
+}
+
+function decide(root, op, req) {
+  const dir = skillsDir(root, false); if (!dir) return { ok: false, error: 'no skills directory yet' };
+  const rows = fold(readEvents(dir).events);
+  const target = rows.find((r) => r.id === req.id && (!req.sha || r.sha.startsWith(req.sha)));
+  if (!target) return { ok: false, error: `no candidate '${req.id}'${req.sha ? ` at ${req.sha}` : ''}` };
+  try { appendEvent(dir, { eid: newEid(), at: new Date().toISOString(), by: req.by || 'agent:cli', op, id: target.id, sha: target.sha, reason: String(req.reason || '').slice(0, 300) }); }
+  catch (e) { return { ok: false, error: String((e && e.message) || e) }; }
+  render(root);
+  return { ok: true, id: target.id, sha12: target.sha12, state: op === 'reject' ? 'rejected' : 'retired' };
+}
+
+function candidates(root) {
+  const dir = skillsDir(root, false); if (!dir) return { rows: [], torn: 0 };
+  const { events, torn } = readEvents(dir);
+  return { rows: fold(events), torn };
+}
+function textOf(root, row) {
+  const dir = skillsDir(root, false); if (!dir) return { ok: false, error: 'no skills directory' };
+  const file = path.join(dir, 'candidates', row.id, `${row.sha12}.skill`);
+  let st; try { st = fs.lstatSync(file); } catch { return { ok: false, error: 'the candidate file is missing' }; }
+  if (!st.isFile() || st.isSymbolicLink()) return { ok: false, error: 'the candidate file is not a plain file' };
+  const text = fs.readFileSync(file, 'utf8');
+  if (sha256(text) !== row.sha) return { ok: false, error: 'the candidate file no longer matches its recorded hash — it was changed after it was filed', changed: true };
+  return { ok: true, text, file };
+}
+
+/* resolve — what may RUN. `approvals` is the PM's LOCAL list: [{id, sha, ack_license}]. A candidate runs only if it
+ * is approved there, not rejected or retired in the registry, and its file still hashes to the approved value. */
+function resolve(root, approvals) {
+  const { rows } = candidates(root);
+  const approved = new Map(); for (const a of approvals || []) if (a && a.id && a.sha) approved.set(`${a.id}@${a.sha}`, a);
+  const skills = []; const blocked = [];
+  for (const r of rows) {
+    const key = `${r.id}@${r.sha}`; const a = approved.get(key);
+    if (!a) continue;                                                       // quarantined: simply not offered
+    if (r.state !== 'quarantined') { blocked.push({ id: r.id, sha12: r.sha12, why: `${r.state} in the registry` }); continue; }
+    const t = textOf(root, r);
+    if (!t.ok) { blocked.push({ id: r.id, sha12: r.sha12, why: t.error }); continue; }
+    skills.push({ id: r.id, sha: r.sha, sha12: r.sha12, text: t.text, file: t.file, row: r });
+  }
+  // an approved id with two approved hashes: the newest approval wins
+  const best = new Map();
+  for (const s of skills) { const prev = best.get(s.id); const ts = (approved.get(`${s.id}@${s.sha}`) || {}).at || ''; if (!prev || ts > prev.ts) best.set(s.id, { s, ts }); }
+  return { skills: [...best.values()].map((x) => x.s), blocked };
+}
+
+const licenseNeedsAck = (license) => !PERMISSIVE.has(String(license || '').toLowerCase().trim());
+
+// ── the generated directory page (OKF v0.2) ─────────────────────────────────────────────────
+function render(root) {
+  const dir = skillsDir(root, false); if (!dir) return;
+  const { rows } = candidates(root);
+  const lines = ['---', 'type: Reference', 'title: "Discovered and generated skills"',
+    'description: "Every candidate skill found or generated for this repository, with where it came from. Nothing here runs until the PM approves its exact text in the workspace."',
+    `generated: {by: process:pmos-skills, at: "${new Date().toISOString()}"}`, 'status: stable', '---', '',
+    '# Discovered and generated skills', '',
+    'A candidate is quarantined until the PM opens its text and approves it in the workspace. Approval is local to the machine that gave it. The registry is `registry.jsonl`; the text of each candidate is under `candidates/`.', '',
+    '| id | origin | state | licence | source | found | hash | findings |', '|---|---|---|---|---|---|---|---|'];
+  for (const r of rows.sort((a, b) => a.id.localeCompare(b.id) || String(b.found_at).localeCompare(String(a.found_at)))) {
+    const src = r.source_url ? `[${(r.author || 'source')}](${r.source_url})` : (r.origin === 'generated' ? 'generated here' : '—');
+    lines.push(`| ${r.id} | ${r.origin} | ${r.state} | ${r.license} | ${src} | ${String(r.found_at).slice(0, 10)} | \`${r.sha12}\` | ${(r.scan.soft || []).length ? (r.scan.soft || []).map((f) => f.rule).join(', ') : 'none'} |`);
+  }
+  if (!rows.length) lines.push('| _none yet_ | | | | | | | |');
+  lines.push('');
+  try { fs.writeFileSync(path.join(dir, 'index.md'), lines.join('\n')); } catch { /* the index is a convenience, never a reason to fail */ }
+}
+
+// ── CLI ──────────────────────────────────────────────────────────────────────────────────────
+function main(argv) {
+  const a = argv.slice(2); const cmd = a[0]; const opt = {}; const rest = [];
+  for (let i = 1; i < a.length; i++) { if (a[i].startsWith('--')) { const k = a[i].slice(2); if (k === 'json') opt.json = true; else opt[k] = a[++i]; } else rest.push(a[i]); }
+  const root = path.resolve(opt.root || process.cwd());
+  const out = (o, human) => process.stdout.write(opt.json ? JSON.stringify(o, null, 2) + '\n' : human + '\n');
+  if (!cmd || cmd === 'help' || cmd === '--help') { process.stdout.write('usage: pmos-skills.js add --id <slug> --file <path> --url <https url> --license <spdx> --author <name> --why "<reason>" [--origin discovered|generated] | list | show <id> | reject <id> --sha <12> --reason "…" | retire <id> --sha <12>   [--root <repo>] [--json]\n(there is no approve command: the PM approves in the workspace)\n'); return cmd ? 0 : 1; }
+  if (cmd === 'add') {
+    let content; try { content = fs.readFileSync(path.resolve(opt.file || '')); } catch { process.stderr.write('--file must name a readable file\n'); return 2; }
+    const r = add(root, { id: opt.id, content, source_url: opt.url, license: opt.license, author: opt.author, why: opt.why, origin: opt.origin, by: opt.by });
+    if (!r.ok) { process.stderr.write(`not filed: ${r.error}\n`); return 2; }
+    out(r, `${r.duplicate ? 'already filed' : 'filed in quarantine'}: ${r.id} @ ${r.sha12} — ${(r.scan.soft || []).length} soft finding(s). It does not run until the PM approves it in the workspace.`);
+    return 0;
+  }
+  if (cmd === 'list') {
+    const { rows } = candidates(root);
+    out(rows, rows.length ? rows.map((r) => `${r.id}@${r.sha12}  ${r.origin}  ${r.state}  ${r.license}  ${(r.scan.soft || []).length} soft finding(s)`).join('\n') : 'no candidates');
+    return 0;
+  }
+  if (cmd === 'show') {
+    const { rows } = candidates(root); const r = rows.find((x) => x.id === rest[0] && (!opt.sha || x.sha.startsWith(opt.sha)));
+    if (!r) { process.stderr.write('no such candidate\n'); return 2; }
+    const t = textOf(root, r); out({ ...r, text: t.ok ? t.text : null, text_error: t.ok ? null : t.error }, `${r.id}@${r.sha12} ${r.state}\nsource: ${r.source_url}\nlicense: ${r.license}\nwhy: ${r.why}\n${t.ok ? '\n' + t.text : '\n(' + t.error + ')'}`);
+    return 0;
+  }
+  if (cmd === 'reject' || cmd === 'retire') {
+    const r = decide(root, cmd, { id: rest[0], sha: opt.sha, reason: opt.reason, by: opt.by });
+    if (!r.ok) { process.stderr.write(r.error + '\n'); return 2; }
+    out(r, `${cmd}ed ${r.id}@${r.sha12}`); return 0;
+  }
+  process.stderr.write(`unknown command '${cmd}'\n`); return 2;
+}
+
+module.exports = { MAX_BYTES, ID_RE, PERMISSIVE, FORCED_KEYS, scanSkill, ignoredKeys, validateIncoming, fold, add, decide, candidates, textOf, resolve, licenseNeedsAck, render, skillsDir, stateDir, readEvents, appendEvent, sha256 };
+if (require.main === module) process.exit(main(process.argv));

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

@@ -94,7 +94,8 @@ function budgetsFor(root, L) {
     catch { value = { ok: false, text: '', path: path.relative(root, L.budgets) }; }
     _budCache.set(root, { stamp, value });
   }
-  return _budCache.get(root).value;
+  // D67: the domain registry rides on the budgets object, read fresh (a small, PM-edited file)
+  return anchors.withDomains(_budCache.get(root).value, path.dirname(L.budgets), root);
 }
 
 /*
@@ -527,6 +528,21 @@ function surfaceRoute(v) {
   return 'malformed';
 }
 
+// ── Repository profile (D68) ──────────────────────────────────────────────────────────────────
+// A repository declares `pm-artifacts` (a PM's documents, strategy and specifications — no code) or
+// `product-code` (PMOS-self and code repositories) in a one-line `.pmos-profile` file at its root.
+// No file, or anything else in it, is `product-code`: every existing repository behaves as before.
+const PM_LANES = ['strategy', 'prd', 'project-plan', 'discovery', 'decision-record', 'report', 'chore'];
+const PM_LIGHT_BY_DEFAULT = ['decision-record', 'report', 'chore'];
+const PM_NO_HANDOFF = ['decision-record', 'report', 'chore'];
+function profileOf(root) {
+  try {
+    const line = fs.readFileSync(path.join(root, '.pmos-profile'), 'utf8')
+      .split('\n').map((l) => l.replace(/#.*$/, '').trim()).find(Boolean);
+    return line === 'pm-artifacts' ? 'pm-artifacts' : 'product-code';
+  } catch { return 'product-code'; }
+}
+
 // ── Step model ─────────────────────────────────────────────────────────────────────────────────
 // status ∈ done | current | blocked | pending | na | unknown
 // `blocking` marks a step whose failure fails CI. O5/O6/O7 are deliberately NOT blocking: none can
@@ -539,7 +555,12 @@ function step(key, label, status, evidence, next, opts) {
   };
 }
 
-function computeWorkflow(id, opts) {
+// D74 — `generated: {by: x, at: "2026-10-02T01:00:00Z"}` on one line (the only form PMOS writes). Returns the `at`, or ''.
+function generatedAt(v) {
+  const m = /\bat:\s*["']?([^"',}\s]+)/.exec(String(v || ''));
+  return m ? m[1] : '';
+}
+function computeWorkflowDerived(id, opts) {
   const root = path.resolve((opts && opts.root) || process.cwd());
   const L = layout(root);
   const recRel = path.relative(root, path.join(L.initiatives, `${id}.md`));
@@ -548,9 +569,13 @@ function computeWorkflow(id, opts) {
     return { ok: false, id, error: `no initiative record at ${recRel} — an initiative must exist before its work` };
   }
   const fm = readFrontmatter(recAbs) || {};
-  const lane = (fm.lane || 'feature').trim() || 'feature';
-  const knownLane = ['feature', 'discovery', 'chore', 'incident', 'content', 'prototype'].includes(lane);
-  const effLane = knownLane ? lane : 'feature';           // unknown lane = strictest, as the bash gate does
+  const profile = profileOf(root);
+  const pmProfile = profile === 'pm-artifacts';
+  const lane = (fm.lane || (pmProfile ? 'prd' : 'feature')).trim() || (pmProfile ? 'prd' : 'feature');
+  const knownLane = pmProfile ? PM_LANES.includes(lane)
+    : ['feature', 'discovery', 'chore', 'incident', 'content', 'prototype'].includes(lane);
+  // unknown lane = the profile's strictest (feature in product-code, a governed prd in pm-artifacts)
+  const effLane = knownLane ? lane : (pmProfile ? 'prd' : 'feature');
   const range = (opts && opts.range) || commitRange(root);
   // See ENFORCED_FROM: git decides, the frontmatter only breaks a tie git cannot see.
   //
@@ -575,7 +600,7 @@ function computeWorkflow(id, opts) {
   const legacy = recIdx === -1 ? true
     : /^\d{4}-\d{2}-\d{2}$/.test(recon) ? recon < ENFORCED_FROM
       : recAt ? new Date(recAt * 1000).toISOString().slice(0, 10) < ENFORCED_FROM
-        : String(fm.timestamp || '').slice(0, 10) < ENFORCED_FROM;   // fallback — see ENFORCED_FROM
+        : String(fm.timestamp || generatedAt(fm.generated) || '').slice(0, 10) < ENFORCED_FROM;   // fallback — see ENFORCED_FROM; D74: OKF v0.2 `generated.at` stands in for `timestamp`
   /*
    * `legacy` answers the ENFORCEMENT question — should this PR fail? It is NOT the visibility
    * question. Filtering the board by it was a real bug: on `main`, every record is legacy, so the
@@ -673,6 +698,18 @@ function computeWorkflow(id, opts) {
           `only the PM adds a budget — use an existing id from ${budRel} or anchor to a KR`,
           { blocking: !legacy, rule: 'R1' }));
       }
+    } else if (r.kind === 'domain') {
+      // D67 — the domain's standing goal: resolved like a health budget, rejected like one when the
+      // id is not in the PM-edited registry.
+      const domRel = (budgetsFor(root, L).domains || {}).path || 'planning/okrs/domains.md';
+      if (r.status === 'resolved') {
+        steps.push(step('anchor', 'anchor', 'done', `domain:${r.domain} — ${r.domain_goal || 'standing goal not written'} (no OKR, D67)`));
+      } else {
+        steps.push(step('anchor', 'anchor', legacy ? 'unknown' : 'blocked',
+          `domain:${r.domain} is not a declared domain`,
+          `only the PM adds a domain — use an id from ${domRel}, or anchor to a KR or a health budget`,
+          { blocking: !legacy, rule: 'R1' }));
+      }
     } else if (r.status === 'resolved') {
       steps.push(step('anchor', 'anchor', 'done',
         `${anchors.canonical(r, (okrIndexFor(root) || {}).period) || anchor} — ${r.reason}`));
@@ -691,6 +728,11 @@ function computeWorkflow(id, opts) {
     }
   }
 
+  // ── D68: the pm-artifacts ladder replaces everything after the anchor ─────────────────────────
+  if (pmProfile) {
+    return pmLadder({ id, fm, lane, effLane, knownLane, legacy, steps, root, L, recRel, range, inChange, lastActivity });
+  }
+
   const prd = String(fm.prd_path || '').trim();
   const rubric = String(fm.rubric_path || '').trim();
   const prdIdx = prd ? firstAppearance(root, range, prd) : null;
@@ -1133,7 +1175,7 @@ function computeWorkflow(id, opts) {
   return {
     ok: true, id, lane, laneKnown: knownLane, legacy, in_change: inChange,
     last_activity: lastActivity, accepted: accepted.length > 0, stage, record: recRel,
-    title: fm.title || id, anchor: fm.parent_kr || null,
+    title: fm.title || id, anchor: fm.parent_kr || null, profile: 'product-code',
     steps, blockers: blockers.map((s) => s.key), gate_failures: gateFailures.map((s) => s.rule || s.key),
     next: next ? { step: next.key, why: next.evidence, action: next.next || next.evidence } : null,
     range: range.ok ? { base: range.base, commits: range.shas.length, whole_history: !!range.wholeHistory } : { error: range.reason },
@@ -1141,6 +1183,122 @@ function computeWorkflow(id, opts) {
   };
 }
 
+/**
+ * D68 — the pm-artifacts ladder: route → anchor → brief → draft → review → approved → handed off.
+ *
+ * Route and anchor are computed by the shared code above and keep their rules (anchoring holds in
+ * every profile — D59/D67); route is re-stated here because its product-code form asks the
+ * specimen/surface questions, which a PM document does not need. What follows is evidence-derived
+ * like every other rung — nothing is declared done:
+ *   brief    — the brief file (`brief_path`, or `prd_path`) exists
+ *   draft    — the deliverable (`doc_path`) exists, and — governed only — did not appear before the brief
+ *   review   — an evals.jsonl verdict for this id, or a named `reviewed_by:` (a rubric, an agent, a human)
+ *   approved — the PM's acceptance in acceptances.jsonl (D12, never automatic)
+ *   handoff  — `handed_off:` names where it went; n/a for decision records, reports and chores
+ * Track: `light` (guidance — only route and anchor can fail CI) or `governed` (brief and draft
+ * existence and their order fail CI for a non-legacy record). Review, approval and handoff are never
+ * CI-blocking in either track: none can be true before the PR exists.
+ */
+function pmLadder({ id, fm, lane, effLane, knownLane, legacy, steps, root, L, recRel, range, inChange, lastActivity }) {
+  const declared = String(fm.track || '').trim().toLowerCase();
+  const track = declared === 'light' || declared === 'governed' ? declared
+    : (PM_LIGHT_BY_DEFAULT.includes(effLane) ? 'light' : 'governed');
+  const enforce = track === 'governed' && !legacy;
+  const exists = (p) => !!p && fs.existsSync(path.join(root, p));
+
+  // route — the lane is a pm-artifacts lane
+  steps[0] = knownLane
+    ? step('route', 'route', 'done', `${lane} lane · ${track} track (pm-artifacts profile, D68)`)
+    : step('route', 'route', 'done', `unknown lane '${lane}' — treated as a governed prd, the profile's strictest (D68)`,
+      `set lane: to one of ${PM_LANES.join(', ')}`);
+
+  const briefPath = String(fm.brief_path || fm.prd_path || '').trim();
+  const docPath = String(fm.doc_path || '').trim();
+  const briefIdx = briefPath ? firstAppearance(root, range, briefPath) : null;
+  const docIdx = docPath ? firstAppearance(root, range, docPath) : null;
+
+  if (exists(briefPath)) steps.push(step('brief', 'brief', 'done', `${briefPath} present`));
+  else steps.push(step('brief', 'brief', enforce ? 'blocked' : 'pending',
+    briefPath ? `brief_path '${briefPath}' does not exist` : 'no brief yet',
+    `write a short brief (the question, the reader, the decision it informs) and set brief_path in ${recRel}`,
+    { blocking: enforce, rule: 'P1' }));
+
+  if (exists(docPath)) {
+    const inOrder = briefIdx == null || docIdx == null ? null : docIdx >= briefIdx;
+    if (enforce && inOrder === false) {
+      steps.push(step('draft', 'draft', 'blocked', `${docPath} appeared before its brief ${briefPath}`,
+        'a governed document is briefed before it is drafted — the brief must land first', { blocking: true, rule: 'P2' }));
+    } else steps.push(step('draft', 'draft', 'done', `${docPath} present`));
+  } else steps.push(step('draft', 'draft', enforce && docPath ? 'blocked' : 'pending',
+    docPath ? `doc_path '${docPath}' does not exist` : 'no draft yet',
+    `write the document and set doc_path in ${recRel}`, { blocking: enforce && !!docPath, rule: 'P2' }));
+
+  const evals = cachedJsonl(path.join(L.runsDir, 'evals.jsonl')).filter((e) => e && e.initiative_id === id);
+  const reviewer = String(fm.reviewed_by || '').trim();
+  if (evals.length) steps.push(step('review', 'review', 'done', `${evals[evals.length - 1].verdict || 'verdict'} recorded in evals.jsonl`));
+  else if (reviewer) steps.push(step('review', 'review', 'done', `reviewed by ${reviewer}`));
+  else steps.push(step('review', 'review', 'pending', 'not reviewed yet',
+    'name the reviewer in reviewed_by: (a person, an agent, or a rubric verdict in evals.jsonl)'));
+
+  const accepted = cachedJsonl(path.join(L.runsDir, 'acceptances.jsonl'))
+    .filter((a) => a && a.initiative_id === id && a.accepted === true);
+  steps.push(accepted.length
+    ? step('approved', 'approved', 'done', `accepted by the PM${accepted[accepted.length - 1].accepted_at ? ' on ' + String(accepted[accepted.length - 1].accepted_at).slice(0, 10) : ''}`)
+    : step('approved', 'approved', 'pending', 'awaiting the PM\'s acceptance (D12)', 'the PM accepts the document — never automatic'));
+
+  if (PM_NO_HANDOFF.includes(effLane)) steps.push(step('handoff', 'handed off', 'na', `${effLane} — nothing to hand off`));
+  else {
+    const to = String(fm.handed_off || '').trim();
+    steps.push(to ? step('handoff', 'handed off', 'done', `handed off — ${to}`)
+      : step('handoff', 'handed off', 'pending', 'not handed off yet',
+        'record where it went in handed_off: (a tracker link, the team, or "accepted as the deliverable")'));
+  }
+
+  const by = Object.fromEntries(steps.map((x) => [x.key, x]));
+  let stage = 'intake';
+  if (by.brief.status === 'done') stage = 'brief';
+  if (by.draft.status === 'done') stage = 'draft';
+  if (by.review.status === 'done') stage = 'review';
+  if (accepted.length) stage = 'accepted';
+  const blockers = steps.filter((x) => x.status === 'blocked');
+  const gateFailures = blockers.filter((x) => x.blocking);
+  const next = steps.find((x) => x.status === 'blocked') || steps.find((x) => x.status === 'pending' && x.next) || null;
+  return {
+    ok: true, id, lane, laneKnown: knownLane, legacy, in_change: inChange,
+    last_activity: lastActivity, accepted: accepted.length > 0, stage, record: recRel,
+    title: fm.title || id, anchor: fm.parent_kr || null, profile: 'pm-artifacts', track,
+    steps, blockers: blockers.map((x) => x.key), gate_failures: gateFailures.map((x) => x.rule || x.key),
+    next: next ? { step: next.key, why: next.evidence, action: next.next || next.evidence } : null,
+    range: range.ok ? { base: range.base, commits: range.shas.length, whole_history: !!range.wholeHistory } : { error: range.reason },
+    enforced_from: ENFORCED_FROM,
+  };
+}
+
+// ── Lifecycle (D70) — a stopped initiative is a ledger line, never a record field ───────────────
+// `lifecycle.jsonl` beside the other ledgers: {initiative_id, state, reason, pm, at}. The latest line
+// for an id wins. `active` reopens. The same reader exists in workspace/lib/lifecycle.js; a parity
+// fixture keeps the two in step. A lifecycle line is never an acceptance and never writes one.
+const STOPPED_STATES = ['closed', 'on-hold', 'cancelled'];
+function readLifecycle(root) {
+  const L = layout(root);
+  const latest = new Map();
+  for (const r of cachedJsonl(path.join(L.runsDir, 'lifecycle.jsonl'))) {
+    if (!r || typeof r.initiative_id !== 'string') continue;
+    if (r.state !== 'active' && !STOPPED_STATES.includes(r.state)) continue;
+    latest.set(r.initiative_id, { state: r.state, reason: r.reason || '', pm: r.pm || '', at: r.at || '' });
+  }
+  return latest;
+}
+function computeWorkflow(id, opts) {
+  const w = computeWorkflowDerived(id, opts);
+  if (!w.ok) return w;
+  const lc = readLifecycle(path.resolve((opts && opts.root) || process.cwd())).get(id);
+  if (!lc || lc.state === 'active') return w;
+  // Stopped: leaves the board and stops gating. The ladder is kept so a reopen shows where it was.
+  return { ...w, stopped: lc, blockers: [], gate_failures: [], next: null,
+    steps: w.steps.map((x) => (x.status === 'blocked' ? { ...x, status: 'pending', blocking: false } : x)) };
+}
+
 // ── Rendering ──────────────────────────────────────────────────────────────────────────────────
 const COLOR = process.stdout.isTTY && !process.env.NO_COLOR;
 const c = (code, s) => (COLOR ? `\x1b[${code}m${s}\x1b[0m` : s);
@@ -1192,7 +1350,15 @@ function renderBoard(rows, opts) {
   out.push(`  ${c(1, 'PMOS workflow board')} · ${total} without a recorded acceptance · ${blocked ? c(31, `${blocked} blocked`) : c(32, 'none blocked')}${acceptedN ? c(90, ` · ${acceptedN} accepted`) : ''}`);
   out.push(`  ${c(90, 'most recently worked on first · ✗ blocked · ● in this change')}`);
   out.push(`  ${c(90, '─'.repeat(78))}`);
-  if (!shown.length) { out.push(`  ${c(32, 'every initiative here has a recorded acceptance.')}`); out.push(''); return out.join('\n'); }
+  const stoppedList = () => {
+  const stopped = rows.filter((r) => r.ok && r.stopped);
+  if (stopped.length) {
+    out.push(`  ${c(90, `stopped (${stopped.length}) — off the board, not gating:`)}`);
+    for (const r of stopped) out.push(`  ${c(90, `─ ${r.id}  ${r.stopped.state}${r.stopped.at ? ' ' + String(r.stopped.at).slice(0, 10) : ''}${r.stopped.reason ? ' — ' + brief(r.stopped.reason, 60) : ''}`)}`);
+    out.push('');
+  }
+  };
+  if (!shown.length) { out.push(`  ${c(32, 'every initiative here has a recorded acceptance.')}`); out.push(''); stoppedList(); return out.join('\n'); }
   const w1 = Math.min(34, Math.max(...shown.map((r) => r.id.length), 4));
   for (const r of shown) {
     if (!r.ok) { out.push(`  ${c(31, '✗')} ${r.id.padEnd(w1)}  ${c(31, r.error)}`); continue; }
@@ -1210,6 +1376,7 @@ function renderBoard(rows, opts) {
   // The two ranges, said out loud. The board reads the whole trunk so a delivered initiative does
   // not render as unstarted; the gate reads the PR so "spec before build" stays decidable. A rule
   // can therefore read done here and still be evaluated on the PR — intended, and not a discrepancy.
+  stoppedList();
   out.push(`  ${c(90, 'derived from the whole trunk history; the CI gate evaluates order within the PR only')}`);
   out.push(`  ${c(90, `one initiative in detail:  node ${opts.self} <id>`)}`);
   out.push('');
@@ -1232,7 +1399,7 @@ function renderBoard(rows, opts) {
 const BOARD_CAP = 12;
 function inFlight(rows, opts) {
   const cap = (opts && opts.cap) || BOARD_CAP;
-  const live = rows.filter((r) => !r.ok || !r.accepted);
+  const live = rows.filter((r) => !r.ok || (!r.accepted && !r.stopped));
   const rank = (r) => (!r.ok ? 0 : r.blockers.length ? 1 : r.in_change ? 2 : 3);
   const sorted = [...live].sort((a, b) =>
     rank(a) - rank(b)
@@ -1285,6 +1452,7 @@ function main(argv) {
 
     // ── gate mode ──────────────────────────────────────────────────────────────────────────────
     if (!w.ok) { process.stdout.write(`::error::workflow-gate: ${w.error}\n`); return 1; }
+    if (w.stopped) { process.stdout.write(`ℹ️  '${w.id}' is ${w.stopped.state} — stopped initiatives do not gate (D70).\n✅ workflow gate PASSED — '${w.id}' is ${w.stopped.state}.\n`); return 0; }
     const fails = w.steps.filter((s) => s.status === 'blocked' && s.blocking);
     if (fails.length) {
       for (const f of fails) {
@@ -1325,7 +1493,7 @@ function main(argv) {
 }
 
 module.exports = {
-  computeWorkflow, renderLadder, renderBoard, listInitiatives, layout, inFlight, BOARD_CAP,
+  computeWorkflow, readLifecycle, STOPPED_STATES, renderLadder, renderBoard, listInitiatives, layout, inFlight, BOARD_CAP,
   parseLeadingFrontmatter, specimenRoute, surfaceRoute, priorsCitation, isBuildPath, commitRange,
   // the board's trunk range, exported so the suite can assert the split: the same record is legacy
   // under BOTH ranges, and `in this change` is false under the trunk one.

package/workspace/lib/focus.js

@@ -746,9 +746,8 @@ function delegatedSection(products, skills) {
 /*
  * R10 — upkeep says only what it can read.
  *
- * MEMORY is a stated absence, not a count. `memory` mode is `data: 'absent'` by construction; there
- * is no store, so there are no unpinned entries at compaction risk. The row says the mechanism is
- * not built.
+ * MEMORY is a stated non-reading, not a count (R9, D72). Memory exists now, per repository, but this pure
+ * function is given no memory input, so the row points at the drawer instead of inventing a number.
  *
  * HEALTH BUDGETS carry a caveat instead of a verdict. The caps are shares of A QUARTER's
  * initiatives; no initiative record carries a period and `surfaceSpine` reads none. So the counts
@@ -761,10 +760,10 @@ const BUDGET_CAVEAT = 'The caps are shares of a QUARTER\'s initiatives. No initi
 function upkeepSection(products, registry) {
   const memory = {
     id: 'memory',
-    state: 'absent',
+    state: 'unread',
     heading: 'memory grooming',
-    body: 'not built. There is no memory store in this workspace, so there are no entries to groom and none at compaction risk. '
-      + 'This row states the absence of the mechanism; it is not a count of zero.',
+    body: 'Memory is curated per repository. This row does not read it, so it carries no count and no verdict: '
+      + 'open the Memory drawer to see how full it is, what is unconfirmed or stale, and what waits for your approval.',
     count: null,
   };