create-pmos 0.36.0 → 0.38.0

package/payload/scripts/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/payload/scripts/workflow-sweep.js

@@ -467,7 +467,8 @@ function budgetsFor(root, L) {
     catch { value = { ok: false, text: '', path: path.relative(root, L.budgets) }; }
     _bud.set(root, { stamp, value });
   }
-  return _bud.get(root).value;
+  // D67: the domain registry rides on the budgets object, read fresh (a small, PM-edited file)
+  return anchors.withDomains(_bud.get(root).value, path.dirname(L.budgets), root);
 }
 
 /*

package/payload/state/discoveries.md

@@ -1,2 +1,10 @@
+---
+type: Reference
+title: "Discoveries and friction log"
+description: "Append-only record of what runs discovered and where the process rubbed."
+generated: {by: process:create-pmos, at: "2026-10-02T01:05:10Z"}
+status: stable
+---
+
 # Discoveries & friction log (append-only; ISO dates; tag friction with #friction)
 

package/payload/state/index.md

@@ -0,0 +1,7 @@
+---
+okf_version: "0.2"
+---
+
+# Knowledge bundle
+
+Documents PMOS and its agents write in this repository (OKF v0.2, D73).

package/payload/state/log.md

@@ -0,0 +1,7 @@
+# Log
+
+Newest first, ISO dates.
+
+## 2026-10-02
+
+- Adopted OKF v0.2 (D73).