create-pmos 0.193.0 → 0.194.0

package/workspace/lib/coredoc-cli.js

@@ -0,0 +1,90 @@
+'use strict';
+/* coredoc-cli.js — `pmos coredoc …`: the core documents of each level from a terminal (initiative core-documents, PRD sections 3 and 4).
+ *
+ *   pmos coredoc write --scope <portfolio|board:<id>|initiative:<id>> --key <key> --file <path|->  [--json] [--root <dir>]
+ *        writes ONE draft of a core document under <state>/core-docs/<scope>/<key>/<slot>.md and one `draft` line. Agent-callable: it is the
+ *        only write of a core-doc run (lib/headless.js kind core-doc) and the driver's way to draft a due document. It writes a draft and
+ *        nothing else: only the PM issues or drops it, on the page. Nothing is sent.
+ *
+ * REFUSALS (exit 1): an unknown scope form, a key that is not a document of that level, an entry PMOS does not keep as a document (a derived,
+ * live or report entry), an entry the PM writes (`by: you`) from an agent session, and a scope or key other than the one the server pinned for
+ * this run (PMOS_CORE_DOC_SCOPE, PMOS_CORE_DOC_KEY). Who wrote the draft is the call path (lib/actor.js), never an argument.
+ * Exit codes: 0 done, 1 refused, 2 usage.
+ */
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const actorLib = require('./actor.js');
+const CD = require('./core-docs.js');
+
+const COMMANDS = { coredoc: ['write'] };
+const USAGE = [
+  'usage: pmos coredoc write — the core documents of a portfolio, a board or an initiative',
+  '  pmos coredoc write --scope <portfolio|board:<id>|initiative:<id>> --key <key> --file <path|->',
+  '      Write ONE draft of a core document (the markdown from the file, or standard input with -). It waits for the PM, who issues it.',
+  '      Keys: ' + CD.LEVELS.map((l) => `${l}: ${CD.SETS[l].filter((x) => x.kind === 'doc').map((x) => x.key).join(', ')}`).join(' · '),
+  '  every command: [--json] [--root <dir>]. Nothing is sent.',
+];
+const BOOL = new Set(['json', 'help']);
+const VALUE = new Set(['scope', 'key', 'file', 'root']);
+
+function parse(argv) {
+  const pos = []; const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '-h') { flags.help = true; continue; }
+    if (!a.startsWith('--')) { pos.push(a); continue; }
+    const eq = a.indexOf('=');
+    const key = eq > 0 ? a.slice(2, eq) : a.slice(2);
+    if (BOOL.has(key)) { flags[key] = true; continue; }
+    let val;
+    if (eq > 0) val = a.slice(eq + 1);
+    else { const next = argv[i + 1]; if (next === undefined || (next.startsWith('--') && next.length > 2)) val = ''; else { val = next; i++; } }
+    flags[key] = val;
+  }
+  return { pos, flags };
+}
+function repoRoot(cwd) {
+  try { return execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || cwd; }
+  catch { return cwd; }
+}
+function readStdin(stdin) {
+  if (typeof stdin === 'string') return stdin;
+  try { return fs.readFileSync(0, 'utf8'); } catch { return ''; }
+}
+
+async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isTTY, env, now, stdin } = {}) {
+  const args = argv[0] === 'coredoc' ? argv.slice(1) : argv.slice();
+  const verb = args[0];
+  const { flags } = parse(args.slice(1));
+  const json = !!flags.json;
+  if (!verb || verb === 'help' || verb === '--help' || verb === '-h' || flags.help) { for (const l of USAGE) say(l); return verb ? 0 : 1; }
+  if (!COMMANDS.coredoc.includes(verb)) { say(`unknown coredoc command "${verb}" — one of ${COMMANDS.coredoc.join(', ')}`); return 2; }
+  if ('by' in flags || 'via' in flags) { say(`attribution is set from the call path; --${'by' in flags ? 'by' : 'via'} is not accepted`); return 2; }
+  for (const k of Object.keys(flags)) {
+    if (!BOOL.has(k) && !VALUE.has(k)) { say(`unknown option --${k}`); return 2; }
+    if (VALUE.has(k) && flags[k] === '') { say(`--${k} needs a value`); return 2; }
+  }
+  const fail = (error, code = 1) => { if (json) say(JSON.stringify({ ok: false, error })); else say(`✗ ${error}`); return code; };
+  if (!flags.scope || !flags.key || !flags.file) { say('usage: pmos coredoc write --scope <portfolio|board:<id>|initiative:<id>> --key <key> --file <path|->'); return 2; }
+  const e = env === undefined ? process.env : env;
+  const c = CD.checkEntry(flags.scope, flags.key);
+  if (!c.ok) return fail(c.error);
+  const pinScope = typeof e.PMOS_CORE_DOC_SCOPE === 'string' && e.PMOS_CORE_DOC_SCOPE ? e.PMOS_CORE_DOC_SCOPE : null;
+  const pinKey = typeof e.PMOS_CORE_DOC_KEY === 'string' && e.PMOS_CORE_DOC_KEY ? e.PMOS_CORE_DOC_KEY : null;
+  if ((pinScope && pinScope !== flags.scope) || (pinKey && pinKey !== flags.key)) return fail(`this run drafts ${pinKey || flags.key} for ${pinScope || flags.scope} only`);
+  const actor = actorLib.fromCli({ isTTY: isTTY === undefined ? !!(process.stdin.isTTY && process.stdout.isTTY) : isTTY, env: e });
+  if (c.entry.by === 'you' && actorLib.isAgent(actor)) return fail(`the PM writes the ${c.entry.title.toLowerCase()}; an agent only checks it`);
+  let markdown;
+  if (flags.file === '-') markdown = readStdin(stdin);
+  else { try { markdown = fs.readFileSync(path.resolve(cwd, flags.file), 'utf8'); } catch (err) { return fail(`cannot read ${flags.file}: ${String(err.code || err.message)}`, 2); } }
+  const root = flags.root ? path.resolve(cwd, flags.root) : repoRoot(cwd);
+  let r;
+  try { r = CD.writeDraft(root, { scope: flags.scope, key: flags.key, markdown, by: actor.by, now }); } catch (err) { return fail(`the draft was not written: ${String((err && err.message) || err).slice(0, 160)}`); }
+  if (!r.ok) return fail(r.error);
+  if (json) say(JSON.stringify({ ok: true, scope: flags.scope, key: flags.key, slot: r.slot, path: r.path }));
+  else say(`✓ drafted ${r.path}. It waits for the PM, who issues it. Nothing was sent.`);
+  return 0;
+}
+
+module.exports = { run, COMMANDS, USAGE };

package/workspace/lib/doc-category.js

@@ -47,7 +47,7 @@ const TYPE_TO_CATEGORY = {
   Concept: 'knowledge', ADR: 'spec-artifact', Template: 'other', Playbook: 'knowledge', Reference: null,
   Initiative: 'spec-artifact', PRD: 'prd', Story: 'spec-artifact', Rubric: 'spec-artifact', OKR: 'spec-artifact',
   Radar: 'report', Checklist: 'other', Calibration: 'report', Research: null, Design: 'spec-artifact',
-  Prototype: 'other', Handover: 'report',
+  Prototype: 'other', Handover: 'report', Review: 'report',
   Decision: 'spec-artifact', Principle: 'knowledge', Debt: 'report', Discovery: 'report', Guide: 'knowledge',
 };
 

package/workspace/lib/driver-cli.js

@@ -31,7 +31,7 @@ const COMMANDS = { driver: ['propose', 'status', 'keep', 'return', 'drop', 'paus
 const USAGE = [
   'usage: pmos driver propose|status|keep|return|drop|pause|resume|mode — the Initiative Driver',
   '  pmos driver propose <initiative|work> <id> --what <what> (--file <json|md> | --data "<text>") --why "<one line>" [--source label=ref …]',
-  '      what: problem, evidence, sizing, assumption, stakeholders, move, note (initiative) · next-step, follow-up, note (Work task)',
+  '      what: problem, evidence, sizing, assumption, stakeholders, move, note, doc (initiative) · next-step, follow-up, note (Work task)',
   '  pmos driver status <initiative|work> <id>',
   '  pmos driver keep <proposal>                                  PM only',
   '  pmos driver return <proposal> --note "<what to change>"      PM only',
@@ -132,6 +132,20 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
     const actor = actorLib.fromCli(who);
     const state = D.fold(D.readLines(file));
     const same = JSON.stringify(c.proposal.data);
+    // core-documents: a stage move waits until the current stage's documents are kept; a doc proposal names a draft that is there.
+    if (c.proposal.what === 'move' || c.proposal.what === 'doc') {
+      const CD = require('./core-docs.js');
+      const store = CD.storeOf(root);
+      const scope = `initiative:${c.proposal.target.id}`;
+      if (c.proposal.what === 'move') {
+        const latestIssue = (key) => { const x = store.get(`${scope}|${key}`); return x && x.issued ? Date.parse(x.issued.at) : null; };
+        const held = D.moveHeld(state, c.proposal.target, { now, issuedAt: latestIssue });
+        if (held) return fail(`a stage move waits until the current stage's documents are kept (${(held.docs || []).join(', ') || held.text}). Draft them with pmos coredoc write and file a doc proposal first`);
+      } else {
+        const x = store.get(`${scope}|${c.proposal.data.key}`);
+        if (!x || !x.draft || x.draft.slot !== c.proposal.data.slot) return fail(`no open draft ${c.proposal.data.slot} of ${c.proposal.data.key} for initiative ${c.proposal.target.id}: write it first with pmos coredoc write --scope ${scope} --key ${c.proposal.data.key}`);
+      }
+    }
     const dup = [...state.proposals.values()].find((p) => D.targetKey(p.target) === D.targetKey(c.proposal.target) && p.what === c.proposal.what && JSON.stringify(p.data) === same);
     if (dup) return done({ filed: false, duplicate: dup.id, state: dup.state }, `${dup.id} holds this already (${dup.state}); nothing new was filed`);
     const token = actorLib.isAgent(actor) && actor.by !== 'agent:unknown' ? actor.by.slice('agent:'.length) : null;
@@ -175,7 +189,7 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
     if (!file) return noState();
     const p = D.fold(D.readLines(file)).proposals.get(pid);
     if (p && verb === 'keep' && p.what === 'move') return fail('keep a move on the workspace page: the board move route checks the stage and its warnings');
-    const ctx = { stageFile: path.join(stateDir, stageTools.LEDGER), itemsDir: path.join(stateRoot.defaultRoot(), 'pm-items'),
+    const ctx = { stageFile: path.join(stateDir, stageTools.LEDGER), itemsDir: path.join(stateRoot.defaultRoot(), 'pm-items'), root,
       correctionsFile: path.join(stateRoot.defaultRoot(), 'corrections.jsonl') };
     const r = await decideLib.decide(verb, { file, proposal: pid, note: flags.note, actor, ctx, now });
     if (!r.ok) return fail(r.error);

package/workspace/lib/driver-decide.js

@@ -4,7 +4,7 @@
  * a page press cannot differ.
  *
  *   decide(verb, { file, proposal, note, actor, ctx, now }) → Promise of { ok, proposal, wrote } | { ok: false, status, error }
- *        verb: keep | return | drop. ctx: { stageFile, itemsDir, move(proposal) → { status, body }, correctionsFile? }
+ *        verb: keep | return | drop. ctx: { stageFile, itemsDir, move(proposal) → { status, body }, correctionsFile?, root? }
  *   setPause(file, verb, target, actor, { now })        verb: pause | resume
  *   setMode(file, board, mode, actor, { now })          mode: off | shadow | approve; board '*' is every board
  *
@@ -15,6 +15,7 @@
  *   problem    → lib/stage-tools.js appendTool, tool `problem`, `by` the PM
  *   move       → the board move route's own function (lib/routes-boards.js move): its validation and warnings apply
  *   next-step  → lib/pm-items.js appendEvent: a step (lib/item-steps.js) and, when the proposal names a date, an `edited` due
+ *   doc        → lib/core-docs.js issue: the draft the run wrote is issued (one `issue` line, `state: issued` in its file), as the PM
  * Every other kind (evidence, sizing, assumption, stakeholders, follow-up, note) is kept as a decision only: the PM's choice to
  * rely on it. A follow-up is never sent: the PM sends it from their own session. The driver never moves a stage by itself (D3).
  * RETURN needs a note and DROP may carry one; each logs one correction (the north star counts it) and a return wakes a run.
@@ -46,6 +47,12 @@ async function writeRecord(p, actor, ctx, now) {
     if (!r || !r.body || r.body.ok !== true) return refuse((r && r.status) || 500, (r && r.body && r.body.error) || 'the move was refused');
     return { ok: true, wrote: 'move', warnings: r.body.warnings || [] };
   }
+  if (p.what === 'doc') {
+    if (!ctx.root) return refuse(409, 'this repository has no folder for the core documents');
+    const r = require('./core-docs.js').issue(ctx.root, { scope: `initiative:${p.target.id}`, key: p.data && p.data.key, slot: p.data && p.data.slot }, actor, { now });
+    if (!r.ok) return refuse(r.status || 409, r.error);
+    return { ok: true, wrote: 'doc' };
+  }
   if (p.what === 'next-step') {
     if (!ctx.itemsDir) return refuse(409, 'no folder for the Work items');
     const paths = itemsPaths(ctx.itemsDir);

package/workspace/lib/driver-facts.js

@@ -13,6 +13,7 @@
  * LIMITS, NAMED. The Jira readings keep no status-change time, so `last_ticket_move` is the latest resolved date of the
  * initiative's tickets (null when none: the Do rule then stays quiet instead of guessing). `has_evidence` counts kept driver
  * evidence only. `has_done_criteria` is a PRD that names done-criteria, acceptance criteria or a rubric, or a rubric file.
+ * `docs_due` and `docs_stale` (core-documents) are the current stage's core documents that are due or stale (lib/core-docs.js driverLists).
  */
 const fs = require('fs');
 const path = require('path');
@@ -43,7 +44,7 @@ function outcomeChecked(stateDir, id) {
   } catch { return false; }
 }
 
-function initiativeFacts(w, ctx, { driverState, stateDir }) {
+function initiativeFacts(w, ctx, { driverState, stateDir, now = Date.now() }) {
   const boards = require('./routes-boards.js');
   const got = boards.baseRows(w);
   if (got.pending) return { pending: true };
@@ -57,6 +58,10 @@ function initiativeFacts(w, ctx, { driverState, stateDir }) {
   const keptEvidence = new Set();
   for (const p of driverState.proposals.values()) if (p.state === 'kept' && p.what === 'evidence' && p.target.kind === 'initiative') keptEvidence.add(p.target.id);
   const out = [];
+  // core-documents: each active initiative's core set with its state, read once for the sweep (lib/core-docs.js). A set that cannot be
+  // read gives empty lists: the doc rules then stay quiet instead of guessing.
+  let docSets = new Map();
+  try { docSets = require('./core-docs.js').initiativeDocs(ctx, w, { now, fr, rows: got.rows.filter((b) => !(b.status === 'done' || b.lifecycle || b.dormant)) }); } catch { docSets = new Map(); }
   for (const base of got.rows) {
     if (base.status === 'done' || base.lifecycle || base.dormant) continue;
     const boardId = boards.boardIdOf(base, fr.boards, fr.folded, w);
@@ -78,6 +83,7 @@ function initiativeFacts(w, ctx, { driverState, stateDir }) {
       check_by: placed && placed.ok && placed.byInit[base.id] ? placed.byInit[base.id].check_by || null : null,
       outcome_checked: outcomeChecked(stateDir, base.id),
       kill_tripped: !!(rec.kill && rec.kill.data && (rec.kill.data.items || []).some((i) => i.status === 'tripped')),
+      ...(() => { const set = docSets.get(base.id); if (!set) return { docs_due: [], docs_stale: [] }; const l = require('./core-docs.js').driverLists(set); return { docs_due: l.due, docs_stale: l.stale }; })(),
     });
   }
   return { ok: true, list: out };
@@ -100,7 +106,7 @@ function gather(w, ctx, { now = Date.now(), includeWork = false, runtimeDir, dri
   const stateDir = ctx.stateDirFor ? ctx.stateDirFor(w) : null;
   if (!stateDir) return { ok: false, error: 'no state folder' };
   const facts = { day: D.localDay(now), now, initiatives: [], work: [] };
-  const ini = initiativeFacts(w, ctx, { driverState: driverState || D.fold([]), stateDir });
+  const ini = initiativeFacts(w, ctx, { driverState: driverState || D.fold([]), stateDir, now });
   if (ini.pending) return { pending: true };
   if (ini.ok === false) return ini;
   facts.initiatives = ini.list;

package/workspace/lib/driver-run.js

@@ -64,6 +64,12 @@ function create(deps) {
     if (facts1 && target.kind === 'initiative') {
       stage = facts1.cat;
       lines.push(`Stage category: ${stage || 'unknown'}. Kept problem statement: ${facts1.has_problem ? 'yes' : 'no'}. Kept evidence: ${facts1.has_evidence ? 'yes' : 'no'}. PRD: ${facts1.has_prd ? 'yes' : 'no'}. Anchor: ${facts1.has_anchor ? 'yes' : 'no'}.`);
+      // core-documents: the current stage's documents. A move waits for them (pmos driver propose refuses it).
+      const due = facts1.docs_due || []; const stale = facts1.docs_stale || [];
+      if (due.length || stale.length) {
+        lines.push(`Core documents of this stage: due ${due.join(', ') || 'none'}; stale ${stale.join(', ') || 'none'}. Draft each one with \`pmos coredoc write --scope initiative:${target.id} --key <key> --file -\` (the document on standard input), then file \`--what doc\` with data {"key": "<key>", "slot": "<the slot it printed>"}. The PM's Keep issues it.`);
+        if (due.length) lines.push('Do not propose a stage move while a document of this stage is due: `pmos driver propose` refuses it until the PM keeps the documents.');
+      }
     }
     if (facts1 && target.kind === 'work') {
       lines.push(`Placement: ${facts1.placement}. Due: ${facts1.due || 'none'}. Waiting on: ${facts1.waiting_on || 'nobody'}${facts1.waiting_since ? ` since ${String(facts1.waiting_since).slice(0, 10)}` : ''}. Steps: ${facts1.steps}.`);

package/workspace/lib/driver.js

@@ -24,6 +24,7 @@
  *
  * THE LINES. Every line is { v: 1, ev, …, at }. Who wrote a decision is the call path (lib/actor.js), never a field:
  *   proposal   { id, target: { kind, ws, id }, what, data, why, sources: [{ label, ref }], run, by }   by an agent session
+ *              what `doc` (core-documents): data { key, slot } names a core document draft the run wrote; Keep issues it
  *   keep|return|drop  { proposal, note?, by }           PM only: the fold ignores one whose `by` is not pm:*
  *   correction { proposal, run, kind: 'return'|'drop', by }   one per return or drop; the north star counts it
  *   pause|resume { target, by } · mode { board, mode, by }     PM only, as above. `board` '*' is every board.
@@ -48,7 +49,7 @@ const crypto = require('crypto');
 const LEDGER = 'driver.jsonl';
 const KINDS = Object.freeze(['initiative', 'work']);
 const WHATS = Object.freeze({
-  initiative: Object.freeze(['problem', 'evidence', 'sizing', 'assumption', 'stakeholders', 'move', 'note']),
+  initiative: Object.freeze(['problem', 'evidence', 'sizing', 'assumption', 'stakeholders', 'move', 'note', 'doc']),
   work: Object.freeze(['next-step', 'follow-up', 'note']),
 });
 // A claim without a pointer is not a proposal (PRD section 2: "Nothing without a pointer").
@@ -69,6 +70,7 @@ const WS_RE = /^[A-Za-z0-9._-]{1,80}$/;
 const PROPOSAL_RE = /^p-[0-9a-f]{10}$/;
 const RUN_RE = /^run-[0-9a-f]{10}$/;
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const SLOT_RE = /^\d{4}-\d{2}-\d{2}(-[2-9]|-[1-9]\d)?$/;   // a core document's slot (lib/core-docs.js)
 const MAX_DATA = 8000;
 const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 const oneLine = (v, max) => typeof v === 'string' && v.trim().length >= 1 && v.trim().length <= max && !/[\r\n\x00-\x08\x0b-\x1f]/.test(v);
@@ -163,6 +165,13 @@ function checkProposal(input) {
   } else if (i.what === 'move') {
     if (!oneLine(data.to, 120)) return { ok: false, error: 'a move needs data.to: the name of the stage' };
     data = { to: data.to.trim(), ...(oneLine(data.board, 120) ? { board: data.board.trim() } : {}) };
+  } else if (i.what === 'doc') {
+    // core-documents: a draft the run wrote with `pmos coredoc write`. Keep issues it (lib/driver-decide.js).
+    const CD = require('./core-docs.js');
+    const e = CD.entryOf('initiative', data.key);
+    if (!e || !CD.draftable(e)) return { ok: false, error: `a doc proposal needs data.key: one of ${CD.SETS.initiative.filter(CD.draftable).map((x) => x.key).join(', ')}` };
+    if (typeof data.slot !== 'string' || !SLOT_RE.test(data.slot)) return { ok: false, error: 'a doc proposal needs data.slot: the slot `pmos coredoc write` printed (YYYY-MM-DD, or YYYY-MM-DD-2)' };
+    data = { key: data.key, slot: data.slot };
   } else if (i.what === 'next-step') {
     if (!oneLine(data.text, 500)) return { ok: false, error: 'a next step needs data.text: one line of up to 500 characters' };
     if (data.due != null && !(typeof data.due === 'string' && DATE_RE.test(data.due))) return { ok: false, error: 'data.due is YYYY-MM-DD' };
@@ -282,7 +291,9 @@ function plan(state, { now, running = 0, activeTargets = [] } = {}) {
  *   facts.initiatives[]  { ws, board, id, title, cat: Discover|Plan|Do|Learn, active, last_activity (ms|null),
  *                          has_problem, has_evidence, has_prd, has_done_criteria, has_anchor,
  *                          has_tickets, last_ticket_move (ms|null), blocked_tickets: [key], check_by ('YYYY-MM-DD'|null),
- *                          outcome_checked, kill_tripped }
+ *                          outcome_checked, kill_tripped, docs_due: [key], docs_stale: [key] }
+ *                        docs_due / docs_stale (core-documents): the current stage's core documents (lib/core-docs.js driverLists) that are
+ *                        due or not started, and that are stale. They raise doc-due and doc-stale; a run drafts them and files a `doc` proposal.
  *   facts.work[]         { ws, id, title, done, placement: inbox|today|upcoming|waiting|someday, due, waiting_on, waiting_since (ISO|null),
  *                          touched_at (ISO|null), untouched (bool: the Review queue holds it), steps (count) }
  * A blocker is { key, target, board, title, code, owner: 'pm'|'agent', cat, text }. */
@@ -316,6 +327,9 @@ function detect(facts, state, { now, stalledDays } = {}) {
       if (i.check_by && i.check_by < day && !i.outcome_checked) b('check-by-passed', 'agent', 'Learn', `The check-by date ${i.check_by} passed with no outcome check`);
       if (i.kill_tripped) b('kill-tripped', 'agent', 'Learn', 'A kill condition tripped');
     }
+    // core-documents: a current-stage document that is due or stale. While doc-due is raised, a stage move is not filed (lib/driver-cli.js).
+    if (Array.isArray(i.docs_due) && i.docs_due.length) { b('doc-due', 'agent', i.cat || null, `Documents due at this stage: ${i.docs_due.join(', ')}`); out[out.length - 1].docs = i.docs_due.slice(); }
+    if (Array.isArray(i.docs_stale) && i.docs_stale.length) b('doc-stale', 'agent', i.cat || null, `Stale since the stage move: ${i.docs_stale.join(', ')}`);
     if (i.last_activity != null && t - i.last_activity >= stall) b('stalled', 'agent', null, `Nothing changed for ${Math.floor((t - i.last_activity) / DAY)} days`);
   }
   for (const w of facts.work || []) {
@@ -346,7 +360,7 @@ function sweepLines(facts, state, { now, stalledDays } = {}) {
   const lines = [];
   for (const b of blockers) {
     if (state.blockerDays.has(`${b.key}|${day}`)) continue;
-    lines.push({ ev: 'blocker', key: b.key, day, target: b.target, board: b.board, code: b.code, owner: b.owner, text: b.text });
+    lines.push({ ev: 'blocker', key: b.key, day, target: b.target, board: b.board, code: b.code, owner: b.owner, text: b.text, ...(b.docs ? { docs: b.docs } : {}) });
     if (b.owner === 'agent' && !pmBlocked.has(targetKey(b.target))) {
       const key = `stuck:${b.key}:${day}`;
       if (!state.wakeKeys.has(key)) lines.push({ ev: 'wake', key, target: b.target, board: b.board, reason: 'stuck', blocker: b.code });
@@ -387,6 +401,20 @@ function answeredWakes(state, { boardOf = () => null } = {}) {
   return lines;
 }
 
+/** core-documents: is a stage move held? The doc-due blocker of today's sweep for the target while one of the documents it names
+ * has not been issued since. `issuedAt(key)` is the ms of the latest `issue` of that initiative document (lib/core-docs.js), or null. */
+function moveHeld(state, target, { now, issuedAt = () => null } = {}) {
+  const day = localDay(now == null ? Date.now() : now);
+  const key = targetKey(target);
+  const b = state.blockers.filter((x) => x.code === 'doc-due' && x.day === day && x.target && targetKey(x.target) === key).pop();
+  if (!b) return null;
+  const since = Date.parse(b.at);
+  const docs = Array.isArray(b.docs) && b.docs.length ? b.docs : null;
+  if (!docs) return b;
+  const open = docs.filter((k) => { const t = issuedAt(k); return !(t != null && Number.isFinite(since) && t > since); });
+  return open.length ? { ...b, docs: open } : null;
+}
+
 /** The run that was alive for an agent session token (its session id part), or null. */
 function runOfSession(state, token) {
   if (typeof token !== 'string') return null;
@@ -396,5 +424,5 @@ function runOfSession(state, token) {
 module.exports = {
   LEDGER, KINDS, WHATS, NEEDS_SOURCE, MODES, DEFAULT_MODE, WAKES, EVENTS, BUDGET, DAY, PM_WAIT_MS, SWEEP_EVERY_MS, DEFAULT_STALLED_DAYS, ID_RE, WS_RE, PROPOSAL_RE, RUN_RE,
   stateDirOf, ledgerFile, append, readLines, newId, checkTarget, checkProposal, fold, modeOf, isPaused, openProposals, runsOnDay, admit, plan,
-  detect, sweepLines, wakesFromLedgers, answeredWakes, runOfSession, localDay, targetKey, wsIdOf,
+  detect, sweepLines, wakesFromLedgers, answeredWakes, runOfSession, moveHeld, localDay, targetKey, wsIdOf,
 };

package/workspace/lib/headless.js

@@ -3,7 +3,7 @@
  * (initiative workspace-headless-jobs; PM decision 2026-10-11: keep Jev, no direct Claude API, background
  * jobs that need no human run headless).
  *
- *   kindFor({ agent, origin, skill, env })        → 'notes' | 'skill' | 'ask' | 'drive' | 'scan-web' | 'scan-repo' | 'scan-research-web' | 'scan-research-repo' | 'report-setup' | 'report-find' | null   (null: open a pane, as before)
+ *   kindFor({ agent, origin, skill, env })        → 'notes' | 'skill' | 'ask' | 'drive' | 'scan-web' | 'scan-repo' | 'scan-research-web' | 'scan-research-repo' | 'report-setup' | 'report-find' | 'core-doc' | null   (null: open a pane, as before)
  *   argsFor(kind, { modelArgs, addDirs })          → the argv after `claude`
  *   parseResult(stdout)                            → { ok, text, isError, turns, durationMs, costUsd, denied[] }
  *   streamLines(line)                              → { log: [lines], result: object|null }   one stream-json event, for the live log
@@ -40,6 +40,10 @@
  * no Write, no Edit, no web fetch and no tool that sends or posts, and its only write is `pmos report propose`. A connector tool is named in neither
  * list: a connector read runs only where the PM's own Claude Code settings already allow it, and a connector write is denied and reported. A proposal
  * is data; only the PM's press on the Reports page sets a report up. Neither kind ever runs in a pane.
+ *
+ * The `core-doc` kind drafts ONE core document (initiative core-documents): origin `core-doc:<scope>:<key>`. It reads and searches the repository,
+ * and its only write is `pmos coredoc write`, which writes a draft and nothing else (the server pins the scope and key in the run's environment).
+ * No Write, no Edit, no web, nothing that sends. The draft waits for the PM, who issues it. It never runs in a pane.
  */
 
 // The skills whose every start runs headless: they read, file a result for PMOS, and send nothing out.
@@ -68,14 +72,17 @@ const WEB_KINDS = Object.freeze(['scan-web', 'scan-research-web']);   // kinds t
 // report-workspace: the Ask box run (origin `report-setup:<ask>`) and the weekly finder run (origin `report-find:<run>`).
 const REPORT_SETUP_ORIGINS = Object.freeze(['report-setup:']);
 const REPORT_FIND_ORIGINS = Object.freeze(['report-find:']);
+// core-documents: one run drafts one core document of a portfolio, a board or an initiative (origin `core-doc:<scope>:<key>`).
+const CORE_DOC_ORIGINS = Object.freeze(['core-doc:']);
 
 // What each kind may use. Read-only search is always allowed. The notes passes write their JSON (and rename the .tmp
 // file) in their notes folder, which --add-dir opens to them; the skills also run `pmos` verbs and repository scripts.
 const TOOLS = Object.freeze({
   notes: Object.freeze(['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash(mv *)']),
   ask: Object.freeze(['Read', 'Glob', 'Grep']),
+  // core-documents: the driver drafts a current-stage document that is due with `pmos coredoc write` (a draft only; Keep issues it).
   drive: Object.freeze(['Read', 'Glob', 'Grep', 'Bash(pmos driver *)', 'Bash(pmos initiative list *)', 'Bash(pmos initiative export *)',
-    'Bash(git log *)', 'Bash(ls *)', 'Bash(date *)']),
+    'Bash(pmos coredoc write *)', 'Bash(git log *)', 'Bash(ls *)', 'Bash(date *)']),
   // The web run: WebSearch, WebFetch and the one verb that files a finding. No Read, no Glob, no Grep, no repository path in its prompt or its add-dirs.
   // `pmos scan section` writes a section of a report document; the web run gives each web claim a URL it read.
   'scan-web': Object.freeze(['WebSearch', 'WebFetch', 'Bash(pmos scan file *)', 'Bash(pmos scan section *)']),
@@ -92,6 +99,8 @@ const TOOLS = Object.freeze({
   // The finder run: read and search, and the one verb that files a finding. Calendar, Slack, mail subjects and Drive are read through the PM's own
   // connectors where the PM's settings allow it. No web fetch, no git, no Write or Edit, nothing that sends or posts.
   'report-find': Object.freeze(['Read', 'Glob', 'Grep', 'Bash(pmos report propose *)']),
+  // The core-doc run: read and search, and the one verb that writes a draft. No Write, no Edit, no web, nothing that sends.
+  'core-doc': Object.freeze(['Read', 'Glob', 'Grep', 'Bash(pmos coredoc write *)']),
   skill: Object.freeze(['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash(pmos *)', 'Bash(node *)',
     'Bash(git log *)', 'Bash(git status *)', 'Bash(git diff *)', 'Bash(ls *)', 'Bash(date *)']),
 });
@@ -114,6 +123,7 @@ function kindFor({ agent, origin, skill, env } = {}) {
   if (SCAN_RESEARCH_REPO_ORIGINS.some((p) => o.startsWith(p))) return 'scan-research-repo';
   if (REPORT_SETUP_ORIGINS.some((p) => o.startsWith(p))) return 'report-setup';
   if (REPORT_FIND_ORIGINS.some((p) => o.startsWith(p))) return 'report-find';
+  if (CORE_DOC_ORIGINS.some((p) => o.startsWith(p))) return 'core-doc';
   if (skill && HEADLESS_SKILLS.includes(String(skill))) return 'skill';
   return null;
 }
@@ -232,4 +242,4 @@ function logLines(r, exitCode) {
   return out;
 }
 
-module.exports = { HEADLESS_SKILLS, HEADLESS_ORIGINS, ASK_ORIGINS, DRIVE_ORIGINS, SCAN_WEB_ORIGINS, SCAN_REPO_ORIGINS, SCAN_RESEARCH_WEB_ORIGINS, SCAN_RESEARCH_REPO_ORIGINS, WEB_KINDS, REPORT_SETUP_ORIGINS, REPORT_FIND_ORIGINS, TOOLS, DEFAULT_TIMEOUT_MS, kindFor, argsFor, timeoutMs, parseResult, streamLines, outcomeOf, logLines, switchedOff };
+module.exports = { HEADLESS_SKILLS, HEADLESS_ORIGINS, ASK_ORIGINS, DRIVE_ORIGINS, SCAN_WEB_ORIGINS, SCAN_REPO_ORIGINS, SCAN_RESEARCH_WEB_ORIGINS, SCAN_RESEARCH_REPO_ORIGINS, WEB_KINDS, REPORT_SETUP_ORIGINS, REPORT_FIND_ORIGINS, CORE_DOC_ORIGINS, TOOLS, DEFAULT_TIMEOUT_MS, kindFor, argsFor, timeoutMs, parseResult, streamLines, outcomeOf, logLines, switchedOff };

package/workspace/lib/needs-providers.js

@@ -34,6 +34,7 @@ const PROVIDERS = Object.freeze([
   'work-check-needs',   // Run 4 (4D): a person's item in Review, a batched Release (kind 4)
   'report-needs',       // Run 5 (5C): a report to issue (kind 1), cycle rows (kind 7), a schedule left no output (kind 8)
   'driver-needs',       // initiative-driver: drafts the agent filed (kind 7), a target the PM is blocking (kind 7)
+  'core-docs-needs',    // core-documents: one row per scope with core document drafts waiting for the PM (kind 1)
 ]);
 /** Kinds that already mean something in the needs queue. A provider may not reuse one. */
 const RESERVED_KINDS = Object.freeze(['question', 'accept', 'outcome', 'keep', 'evidence', 'plan-flag', 'provider-error']);

package/workspace/lib/pmos-verbs.js

@@ -62,6 +62,9 @@ const VERBS = Object.freeze({
   // Not a pm-os-absorb verb (run: null): initiative horizon-scan added it through the same table; horizon-scan-portfolio added section, propose, setting and --boards.
   scan: Object.freeze({ module: 'scan-cli.js', run: null, guide: 'horizon-scan.md',
     help: 'pmos scan file|section|propose|list [--sections]|match|suggest [--boards]|status|setting|cadence|watch [--boards] … — the Horizon scan: the portfolio watch list, the findings, the report sections and the proposals the PM approves, changes or dismisses (pmos scan help)' }),
+  // Not a pm-os-absorb verb (run: null): initiative core-documents added it through the same table.
+  coredoc: Object.freeze({ module: 'coredoc-cli.js', run: null, guide: 'core-documents.md',
+    help: 'pmos coredoc write --scope <scope> --key <key> --file <path|-> — write one draft of a core document; the PM issues it on the page (pmos coredoc help)' }),
   launcher: Object.freeze({ module: 'launcher-cli.js', run: null, guide: 'launcher.md',
     help: 'pmos launcher on|off|status — a PMOS app and a login item, so the workspace starts without a terminal' }),
 });

package/workspace/lib/route-modules.js

@@ -71,6 +71,7 @@ const MODULES = Object.freeze([
   'routes-driver',        // initiative-driver: the Agent strip's data, Keep, Send back, Drop, Pause and the board mode (driver.jsonl)
   'routes-scan',          // horizon-scan-portfolio: one scan for the workspace: the watch list and setting, Scan now and Stop, report documents and their proposals (approve, change, dismiss, undo), plus the first scan's per-board and Briefing reads (scan.jsonl)
   'routes-report-setups', // report-workspace: recurring reports, the Ask box, the finder, the report documents and their export (report-setups.jsonl)
+  'routes-core-docs',     // core-documents: the core documents of each level, Draft it (a core-doc run), Issue it and Drop (core-docs.jsonl)
 ]);
 const PM_DIR = path.join(__dirname, '..', 'public', 'pm');
 const MODULE_NAME = /^[a-z0-9][a-z0-9-]*\.js$/;

package/workspace/lib/routes-core-docs.js

@@ -0,0 +1,171 @@
+'use strict';
+/* routes-core-docs.js — the core documents of each level (initiative core-documents, PRD sections 3 to 5).
+ *
+ *   GET  /api/core-docs?ws&level=portfolio|board|initiative&board&id
+ *        → { ok, level, scope, question, reader, rhythm, build, wfTpl, stage, cat, summary: { draft, due, missing, stale }, docs: [entry + state] }
+ *          202 { ok: true, pending: true } while the initiatives are still being read (level=initiative only)
+ *   POST /api/core-docs/draft  { ws, scope, key }        → { ok, run }      starts a core-doc run; 409 when one runs for that entry
+ *   POST /api/core-docs/issue  { ws, scope, key, slot }  → { ok }           `state: issued` in the file and one `issue` line
+ *   POST /api/core-docs/drop   { ws, scope, key, slot }  → { ok }           one `drop` line
+ *
+ * WHO WRITES. Every POST refuses a request that carries an agent session header (403), as routes-scan.js does. Draft it passes pm-guard
+ * requirePagePress; Issue it and Drop pass requirePmPress (act `issue`): only the PM issues or drops a core document. A draft is never sent.
+ *
+ * THE RUN. A press on Draft it (and the schedule tick) starts ONE headless run, kind `core-doc` (lib/headless.js), origin
+ * `core-doc:<scope>:<key>`. Its tools are Read, Glob, Grep and `pmos coredoc write`; the server pins the entry it may write with
+ * PMOS_CORE_DOC_SCOPE and PMOS_CORE_DOC_KEY. At most RUN_CAP core-doc runs run at once.
+ *
+ * THE TICK (PRD section 4). tick(ctx, { now }) runs every 30 minutes inside the working hours (lib/driver-run.js dayCheckOpen: the day-check
+ * window and the quiet hours). For each repository (the lead tree) it drafts every `doc` entry of the portfolio and of each board whose cadence
+ * has passed (state `due`) and that has no open draft, at most once per entry per day; never an entry the PM writes (`by: you`). Initiative
+ * documents are the Initiative Driver's (lib/driver.js doc-due). ctx adds to the route ctx: { proSettings(), inQuiet(now, quiet), isLead(w) }.
+ */
+const guard = require('./pm-guard.js');
+const CD = require('./core-docs.js');
+const headless = require('./headless.js');
+
+const text = (v) => (typeof v === 'string' ? v : '');
+const bad = (status, error) => ({ status, body: { ok: false, error } });
+const POSTS = ['draft', 'issue', 'drop'];
+const RUN_CAP = 3;
+const TICK_EVERY_MS = 30 * 60 * 1000;
+
+const runs = new Map();     // `${ws}|${scope}|${key}` → session id, for the core-doc runs this server started
+const tried = new Map();    // `${ws}|${scope}|${key}` → the local day the tick last started a run for it
+let lastTick = null;
+
+const runKey = (ws, scope, key) => `${ws}|${scope}|${key}`;
+function wsOf(ctx, id) {
+  const w = ctx.getWs(id || null);
+  return w && (!id || w.id === id) ? w : null;
+}
+const isRunning = (ws) => (scope, key) => runs.has(runKey(ws, scope, key));
+
+/** The entry of a scope in this workspace: the level's facts must find the board or the initiative. → { ok, entry, facts } | refusal */
+function resolve(ctx, w, scope, key, now) {
+  const p = CD.parseScope(scope);
+  if (!p) return { ok: false, status: 400, error: 'scope must be portfolio, board:<id> or initiative:<id>' };
+  const entry = CD.entryOf(p.level, key);
+  if (!entry) return { ok: false, status: 400, error: `no core document ${String(key).slice(0, 40)} at the ${p.level} level` };
+  const g = CD.gather(ctx, w, { level: p.level, board: p.level === 'board' ? p.id : null, id: p.level === 'initiative' ? p.id : null, now });
+  if (g.pending) return { ok: false, status: 202, error: 'The initiatives are being read. Ask again in a few seconds.' };
+  if (!g.ok) return g;
+  return { ok: true, entry, facts: g.facts, level: p.level, id: p.id };
+}
+
+/** Start the run that drafts one entry. → { ok, run } | { ok: false, status, error } */
+function startRun(ctx, w, scope, entry, { label, now } = {}) {
+  if (typeof ctx.spawnSession !== 'function') return { ok: false, status: 409, error: 'this workspace cannot start sessions' };
+  const origin = `core-doc:${scope}:${entry.key}`;
+  if (headless.kindFor({ agent: 'claude', origin }) !== 'core-doc') return { ok: false, status: 409, error: 'Background runs are switched off here (PMOS_HEADLESS=off), so PMOS cannot draft this document.' };
+  const k = runKey(w.id, scope, entry.key);
+  if (runs.has(k)) return { ok: false, status: 409, error: `PMOS is drafting the ${entry.title.toLowerCase()} already` };
+  if (runs.size >= RUN_CAP) return { ok: false, status: 409, error: `${RUN_CAP} documents are being drafted already. Try again when one is done.` };
+  const prompt = CD.runPrompt(entry, scope, { today: CD.localDay(now == null ? Date.now() : now), label });
+  const s = ctx.spawnSession({ name: `Core document · ${entry.title}`, agent: 'claude', ws: w.id, origin, initialInput: prompt + '\r',
+    initiative: scope.startsWith('initiative:') ? scope.slice('initiative:'.length) : undefined,
+    extraEnv: { PMOS_CORE_DOC_SCOPE: scope, PMOS_CORE_DOC_KEY: entry.key },
+    onDone: () => { runs.delete(k); try { if (ctx.invalidateNeedsAgg) ctx.invalidateNeedsAgg(w.id); } catch { /* the next poll recounts */ } } });
+  if (!s || s.state === 'exited' || s.headless !== 'core-doc') {
+    if (s && s.headless !== 'core-doc' && s.state !== 'exited' && typeof ctx.stopSession === 'function') { try { ctx.stopSession(s.id); } catch { /* best effort */ } }
+    return { ok: false, status: 409, error: 'The draft could not start: ' + ((s && s.note) || 'no background run') };
+  }
+  runs.set(k, s.id);
+  return { ok: true, run: s.id };
+}
+
+const labelOf = (facts) => (facts.level === 'board' && facts.board ? facts.board.name : facts.level === 'initiative' && facts.row ? `${facts.row.id} ${facts.row.title || ''}`.trim() : null);
+
+// ── the tick ─────────────────────────────────────────────────────────────────────────────────────────
+/** Draft each due doc entry of the portfolio and the boards. → [{ ws, scope, key, ok, error? }] */
+function tick(ctx, { now = Date.now(), force = false } = {}) {
+  if (!ctx || typeof ctx.getWs !== 'function') return [];
+  if (!force && lastTick != null && now - lastTick < TICK_EVERY_MS) return [];
+  const settings = (() => { try { return ctx.proSettings ? ctx.proSettings() : null; } catch { return null; } })();
+  const open = require('./driver-run.js').dayCheckOpen(settings || {}, now, ctx.inQuiet || (() => false));
+  if (!open) return [];
+  lastTick = now;
+  if (headless.switchedOff(process.env)) return [];
+  const day = CD.localDay(now);
+  const out = [];
+  const list = typeof ctx.workspaceList === 'function' ? ctx.workspaceList() : [ctx.getWs(null)].filter(Boolean);
+  for (const w of list) {
+    if (!w || !w.root) continue;
+    if (typeof ctx.isLead === 'function' && !ctx.isLead(w)) continue;
+    const levels = [{ level: 'portfolio' }];
+    try { for (const b of require('./routes-boards.js').frameFor(ctx, w).boards) levels.push({ level: 'board', board: b.id }); } catch { /* the portfolio still drafts */ }
+    for (const lv of levels) {
+      if (runs.size >= RUN_CAP) return out;
+      let g;
+      try { g = CD.gather(ctx, w, { ...lv, now }); } catch { continue; }
+      if (!g.ok) continue;
+      for (const entry of g.facts.entries) {
+        if (runs.size >= RUN_CAP) return out;
+        if (!CD.draftable(entry)) continue;
+        const st = CD.stateOf(entry, g.facts);
+        if (st.st !== 'due' || st.draft) continue;
+        const k = runKey(w.id, g.facts.scope, entry.key);
+        if (runs.has(k) || tried.get(k) === day) continue;
+        const x = g.facts.store.get(`${g.facts.scope}|${entry.key}`);
+        if (x && x.drafts.some((d) => CD.localDay(Date.parse(d.at)) === day)) continue;   // drafted today already (by a press, or before a restart)
+        tried.set(k, day);
+        const r = startRun(ctx, w, g.facts.scope, entry, { label: labelOf(g.facts), now });
+        out.push({ ws: w.id, scope: g.facts.scope, key: entry.key, ok: r.ok, ...(r.ok ? { run: r.run } : { error: r.error }) });
+      }
+    }
+  }
+  return out;
+}
+
+// ── the handler ──────────────────────────────────────────────────────────────────────────────────────
+async function handle(req, res, url, ctx) {
+  const p = url.pathname;
+  const send = (r) => { ctx.json(res, r.body, r.status); return true; };
+  const sub = p.replace(/^\/api\/core-docs\/?/, '');
+
+  if (sub === '') {
+    if (req.method !== 'GET') return send(bad(405, 'GET only'));
+    const w = wsOf(ctx, url.searchParams.get('ws'));
+    if (!w) return send(bad(404, 'no such workspace'));
+    const level = text(url.searchParams.get('level')) || 'portfolio';
+    const g = CD.gather(ctx, w, { level, board: url.searchParams.get('board') || null, id: url.searchParams.get('id') || null, now: Date.now() });
+    if (g.pending) return send({ status: 202, body: { ok: true, pending: true } });
+    if (!g.ok) return send(bad(g.status || 400, g.error));
+    return send({ status: 200, body: CD.answer(g.facts, { running: isRunning(w.id) }) });
+  }
+  if (!POSTS.includes(sub)) return send(bad(404, 'no such core-docs route'));
+  if (req.method !== 'POST') return send(bad(405, 'POST only'));
+  const read = await ctx.readJson(req);
+  if (!read.ok) return send(bad(400, 'the body is not JSON'));
+  const body = read.body || {};
+  if (req.headers && req.headers['x-pmos-session']) return send(bad(403, 'an agent session cannot draft, issue or drop a core document. Only a press on the page does'));
+  const g = sub === 'draft' ? guard.requirePagePress(req, body) : guard.requirePmPress(req, body, { act: 'issue' });
+  if (!g.ok) return send(bad(g.status, g.error));
+  const w = wsOf(ctx, text(body.ws));
+  if (!w) return send(bad(404, 'no such workspace'));
+  const scope = text(body.scope);
+  const key = text(body.key);
+  const now = Date.now();
+  const refresh = () => { try { if (ctx.invalidateNeedsAgg) ctx.invalidateNeedsAgg(w.id); } catch { /* the next poll recounts */ } };
+
+  if (sub === 'draft') {
+    const r = resolve(ctx, w, scope, key, now);
+    if (!r.ok) return send(bad(r.status || 400, r.error));
+    if (r.entry.kind !== 'doc') return send(bad(400, `${r.entry.title} is read from its own source; there is nothing to draft here`));
+    if (r.entry.by === 'you') return send(bad(400, `You write the ${r.entry.title.toLowerCase()}. PMOS only checks it`));
+    if (r.level === 'board' && r.entry.build && !r.facts.board.build) return send(bad(400, `${r.entry.title} is only for a board with Build and deliver`));
+    if (r.level === 'initiative' && !r.facts.list.some((x) => x.entry.key === key)) return send(bad(400, `${r.entry.title} is not in this initiative's set`));
+    const s = startRun(ctx, w, scope, r.entry, { label: labelOf(r.facts), now });
+    if (!s.ok) return send(bad(s.status, s.error));
+    return send({ status: 200, body: { ok: true, run: s.run } });
+  }
+  const c = CD.checkEntry(scope, key);
+  if (!c.ok) return send(bad(c.status, c.error));
+  const fn = sub === 'issue' ? CD.issue : CD.drop;
+  const r = fn(w.root, { scope, key, slot: text(body.slot) }, g.actor, { now });
+  if (!r.ok) return send(bad(r.status, r.error));
+  refresh();
+  return send({ status: 200, body: { ok: true } });
+}
+
+module.exports = { prefixes: ['/api/core-docs'], handle, tick, startRun, RUN_CAP, TICK_EVERY_MS, _runs: runs, _reset: () => { runs.clear(); tried.clear(); lastTick = null; } };

package/workspace/lib/routes-driver.js

@@ -135,6 +135,7 @@ async function handle(req, res, url, ctx) {
       stageFile: path.join(stateDir, stageTools.LEDGER),
       itemsDir: path.join(runtimeOf(ctx), 'pm-items'),
       correctionsFile: path.join(runtimeOf(ctx), 'corrections.jsonl'),
+      root: w.root,   // core-documents: Keep of a doc proposal issues the draft (lib/core-docs.js)
       // The board move route's own function: its validation and its warnings apply, and `by` is the PM.
       move: async (pr) => {
         const routesBoards = require('./routes-boards.js');

package/workspace/lib/vendor/scripts/migrate-layout.js

@@ -67,7 +67,7 @@ function registry() {
   try {
     REGISTRY = new Set(fs.readFileSync(path.join(PMOS_ROOT, 'scripts', 'frontmatter_registry.txt'), 'utf8')
       .split('\n').map((l) => l.trim()).filter((l) => l && !l.startsWith('#')));
-  } catch { REGISTRY = new Set(['Concept', 'ADR', 'Template', 'Playbook', 'Reference', 'Initiative', 'PRD', 'Story', 'Rubric', 'OKR', 'Radar', 'Checklist', 'Calibration', 'Research', 'Design', 'Prototype', 'Handover', 'Decision', 'Principle', 'Debt', 'Discovery', 'Guide']); }
+  } catch { REGISTRY = new Set(['Concept', 'ADR', 'Template', 'Playbook', 'Reference', 'Initiative', 'PRD', 'Story', 'Rubric', 'OKR', 'Radar', 'Checklist', 'Calibration', 'Research', 'Design', 'Prototype', 'Handover', 'Review', 'Decision', 'Principle', 'Debt', 'Discovery', 'Guide']); }
   return REGISTRY;
 }