@nurix/etna 0.19.64 → 0.19.66

package/data/harnesses/code/hooks/compliance.mjs

@@ -11,6 +11,8 @@ import { spawnSync } from "node:child_process";
 import { readStdin, resolveProjectDir, frontmatter } from "./lib/ownership.mjs";
 import { readQueue, countRows, askedThisSession, recordAsked } from "./lib/state.mjs";
 import { frozenStatus } from "./lib/frozen.mjs";
+import { undischargedRows } from "./lib/ledger.mjs";
+import { appendEvent, unresolvedDenials, sessionLogPath } from "./lib/session-log.mjs";
 
 function readSafe(file) {
   try {
@@ -38,6 +40,23 @@ function decision(permissionDecision, reason) {
   };
 }
 
+// A deny is also an event in the session gate log — the record that makes going silent after a
+// block impossible. The log is a dated per-session record (never drained; bookkeeping stays a
+// queue); the Stop and commit walls block on `denied` lines with no later `resolved` pair.
+function deny(projectDir, sessionId, gate, target, reason) {
+  appendEvent(projectDir, sessionId, "denied", gate, target);
+  return decision("deny", reason);
+}
+
+// The mechanical half of resolution: when the once-denied operation later succeeds through the
+// gate, machinery writes `retried-ok` itself — the session hand-writes only the judgment claims
+// (`waived → {ref}`, `disclosed → {entry}`).
+function autoResolve(projectDir, sessionId, gate, target) {
+  if (unresolvedDenials(projectDir, sessionId).includes(`${gate} · ${target}`)) {
+    appendEvent(projectDir, sessionId, "resolved", gate, target, "retried-ok");
+  }
+}
+
 // ---------------------------------------------------------------------------
 // PreToolUse — file gates
 // ---------------------------------------------------------------------------
@@ -83,40 +102,54 @@ function openGatedPlans(projectDir) {
 
 const SOURCE_LIKE = /\.(m?[jt]sx?|py|rs|go|rb|java|kt|swift|c|h|cpp|hpp|cs|sh|sql|vue|svelte)$/;
 
-function fileGate(projectDir, rel, toolName) {
+function fileGate(projectDir, rel, toolName, sessionId) {
   const frozen = frozenStatus(projectDir, rel);
   if (frozen.frozen) {
-    return decision(
-      "deny",
+    return deny(
+      projectDir,
+      sessionId,
+      "frozen-record",
+      rel,
       `BLOCKED — frozen record. \`${rel}\` is committed history and is never edited (${frozen.reason}). A correction is a new dated entry that links back.`
     );
   }
 
   if (protectedPaths(projectDir).includes(rel)) {
-    return decision("deny", `BLOCKED — protected file. \`${rel}\` is on the protected list.`);
+    return deny(projectDir, sessionId, "protected-file", rel, `BLOCKED — protected file. \`${rel}\` is on the protected list.`);
   }
 
   const inDocs = rel.startsWith("docs/") || rel.startsWith(".claude/") || rel.endsWith(".md");
   if (!inDocs && SOURCE_LIKE.test(rel)) {
     for (const plan of openGatedPlans(projectDir)) {
       if (/Boundary:\s*pending/i.test(plan.gates)) {
-        return decision(
-          "deny",
+        return deny(
+          projectDir,
+          sessionId,
+          "plan-gate",
+          plan.file,
           `BLOCKED — plan gate. \`${plan.file}\` is open but its Gates line reads 'Boundary: pending'. Run the \`boundary\` skill and record its verdict in the plan before implementation edits.`
         );
       }
       if (!plan.hasLedger) {
-        return decision(
-          "deny",
+        return deny(
+          projectDir,
+          sessionId,
+          "plan-gate",
+          plan.file,
           `BLOCKED — plan gate. \`${plan.file}\` has no \`## Test Obligations\` section. Run the \`testing\` skill (plan-gate mode); its ledger is what the verification gate discharges.`
         );
       }
       if (!plan.hasDocLedger) {
-        return decision(
-          "deny",
+        return deny(
+          projectDir,
+          sessionId,
+          "plan-gate",
+          plan.file,
           `BLOCKED — plan gate. \`${plan.file}\` has no \`## Doc Obligations\` section. Resolve the Proposed Changes paths against the ownership index and fill the table yourself — it is a lookup, not a skill run. "None" is a valid row when the plan touches only unowned paths.`
         );
       }
+      // The gates pass now — a plan-gate denial recorded earlier is a successful retry.
+      autoResolve(projectDir, sessionId, "plan-gate", plan.file);
     }
   }
 
@@ -158,30 +191,51 @@ function stagedExempt(files) {
       HARNESS_PREFIXES.some((p) => f.startsWith(p)) ||
       HARNESS_FILES.includes(f) ||
       f.startsWith("docs/history/changelog/") ||
+      f.startsWith("docs/history/sessions/") ||
       f === "docs/history/CHANGELOG.md"
   );
 }
 
-function commitGate(projectDir) {
+function commitGate(projectDir, sessionId) {
   const staged = (git(projectDir, ["diff", "--cached", "--name-only"]) || "")
     .split("\n")
     .map((s) => s.trim())
     .filter(Boolean);
   if (staged.length > 0 && !stagedExempt(staged)) {
     if (!staged.some((f) => f.startsWith("docs/history/changelog/"))) {
-      return decision(
-        "deny",
+      return deny(
+        projectDir,
+        sessionId,
+        "changelog",
+        "git commit",
         "BLOCKED — changelog. This commit stages no `docs/history/changelog/` entry. Every non-exempt commit carries its entry inside it (exempt: release/bot, harness installs and bumps, lockfile-only, pure renames, changelog housekeeping — state which if claiming one, then stage accordingly or re-run)."
       );
     }
   }
   const counts = countRows(readQueue(projectDir));
   if (counts.unresolved > 0) {
+    return deny(
+      projectDir,
+      sessionId,
+      "bookkeeping",
+      "git commit",
+      `BLOCKED — bookkeeping. ${counts.unresolved} unresolved row(s) in docs/operations/bookkeeping.md. Dispatch the bookkeeper, resolve, or convert to \`waived:\` with a reason and expiry.`
+    );
+  }
+
+  // This session's own open denials wall the commit too — a commit is the arc's end as much as a
+  // stop is, and an undisclosed failure must not ride out inside one.
+  const open = unresolvedDenials(projectDir, sessionId).filter((pair) => !pair.startsWith("changelog ·") && !pair.startsWith("bookkeeping ·"));
+  if (open.length > 0) {
     return decision(
       "deny",
-      `BLOCKED — bookkeeping. ${counts.unresolved} unresolved row(s) in docs/operations/bookkeeping.md. Dispatch the bookkeeper, resolve, or convert to \`waived:\` with a reason and expiry.`
+      `BLOCKED — session gate log. ${open.length} denial(s) this session have no resolved line (${open.join("; ")}). Append \`resolved\` to the session log — retried-ok happens automatically on a successful retry; otherwise \`waived → {ref}\` or \`disclosed → {changelog entry}\`. Never delete log lines.`
     );
   }
+
+  // All commit gates pass — a changelog/bookkeeping denial recorded earlier is a successful retry.
+  autoResolve(projectDir, sessionId, "changelog", "git commit");
+  autoResolve(projectDir, sessionId, "bookkeeping", "git commit");
   return null;
 }
 
@@ -200,22 +254,40 @@ function approvedPackages(projectDir) {
   return names;
 }
 
-function packageGate(projectDir, command) {
-  const m = new RegExp(String.raw`(?:^|&&|;|\|)\s*(?:sudo\s+)?(?:pnpm|npm|yarn|bun)\s+(?:add|install|i)\s+(.+)`).exec(command);
+// A token must parse as an npm package spec — name or @scope/name, optional @range tail —
+// before it may be judged against the table. Everything else on an install line (redirections
+// like 2>&1, chained commands, flags, paths, URLs) is shell, not a package. A non-candidate is
+// skipped, never blocked: a miss is caught downstream by the lockfile, while a false deny
+// teaches the session the gate is noise exactly where the gate matters most.
+const PKG_SPEC = /^(@[a-z0-9~-][\w.-]*\/)?[a-z0-9~-][\w.-]*(@[\w.^~*<>=|x-]+)?$/;
+
+function packageGate(projectDir, command, sessionId) {
+  const m = new RegExp(
+    String.raw`(?:^|&&|;|\|)\s*(?:sudo\s+)?(?:pnpm|npm|yarn|bun)\s+(?:add|install|i)(?=\s|$)([^&;|]*)`
+  ).exec(command);
   if (!m) return null;
   const approved = approvedPackages(projectDir);
   if (approved.size === 0) return null; // no rules file installed — nothing to enforce
-  const args = m[1].split(/\s+/).filter((a) => a && !a.startsWith("-"));
+  const args = (m[1] || "")
+    .split(/\s+/)
+    .filter((a) => a && !a.startsWith("-") && PKG_SPEC.test(a));
   for (const arg of args) {
     const pkg = arg.startsWith("@") ? arg.split("@").slice(0, 2).join("@") : arg.split("@")[0];
-    if (!pkg || pkg === "." || pkg.includes("/") && !pkg.startsWith("@")) continue;
     if (!approved.has(pkg)) {
-      return decision(
-        "deny",
+      return deny(
+        projectDir,
+        sessionId,
+        "package-table",
+        pkg,
         `BLOCKED — package table. \`${pkg}\` is not in the approved table (.claude/hooks/approved-packages.md; test packages: .claude/rules/testing.md). The table changes only by explicit user decision.`
       );
     }
   }
+  // Every named package is approved — a package-table denial for one of them is a successful retry.
+  for (const arg of args) {
+    const pkg = arg.startsWith("@") ? arg.split("@").slice(0, 2).join("@") : arg.split("@")[0];
+    autoResolve(projectDir, sessionId, "package-table", pkg);
+  }
   return null;
 }
 
@@ -252,7 +324,7 @@ function bashGate(projectDir, command, sessionId) {
   if (!command) return null;
 
   if (statement(String.raw`git\s+commit\b`).test(command)) {
-    return commitGate(projectDir);
+    return commitGate(projectDir, sessionId);
   }
 
   // `git branch <name>` creates; flag-led forms (--show-current, --list, -d, -vv) query or manage
@@ -277,7 +349,7 @@ function bashGate(projectDir, command, sessionId) {
     );
   }
 
-  return packageGate(projectDir, command);
+  return packageGate(projectDir, command, sessionId);
 }
 
 // ---------------------------------------------------------------------------
@@ -397,13 +469,44 @@ function stopGate(projectDir, payload) {
     };
   }
 
+  // Open gate denials wall the stop: silence after a block is the one ending the log exists to
+  // make impossible. Resolution appends to the log — retried-ok is machinery-written on a
+  // successful retry; waived/disclosed are the session's hand-written, auditable claims.
+  const openDenials = unresolvedDenials(projectDir, payload.session_id);
+  if (openDenials.length > 0) {
+    const rel = path.relative(projectDir, sessionLogPath(projectDir, payload.session_id));
+    return {
+      decision: "block",
+      reason:
+        `${openDenials.length} gate denial(s) this session have no resolved line in ${rel}: ${openDenials.join("; ")}. ` +
+        "For each, either retry the operation properly (a success appends `retried-ok` automatically), convert it to a waiver and append " +
+        "`resolved · {gate} · {target} · waived → {ref}`, or record the failure honestly in the changelog entry and append " +
+        "`resolved · {gate} · {target} · disclosed → {entry file}`. Never delete log lines — the log is a record, not a queue.",
+    };
+  }
+
   // An undischarged Doc Obligations ledger is not walled here — the detector raises it as a
   // `needs-session:` row, which the queue wall above already blocks on, and which outlives this
   // stop through the commit gate and CI. A second wall keyed to one checkbox would add a special
   // case beside a general rule that already covers it.
-  const undocumented = plansCompletedThisSession(projectDir, payload.session_id).filter(
-    (rel) => !planHasChangelogEntry(projectDir, rel)
-  );
+  const completed = plansCompletedThisSession(projectDir, payload.session_id);
+
+  // The Test Obligations ledger IS walled per row: the Outcome cell lives in the plan file, so the
+  // only way past this block is reading the file — a context-held copy of the ledger is exactly
+  // how rows get missed. (Tables without an Outcome column are legacy and pass; see lib/ledger.)
+  for (const rel of completed) {
+    const rows = undischargedRows(readSafe(path.join(projectDir, rel)));
+    if (rows.length > 0) {
+      return {
+        decision: "block",
+        reason:
+          `Plan \`${rel}\` is Status: Complete with ${rows.length} Test Obligations row(s) missing a discharge outcome (#${rows.join(", #")}). ` +
+          "Re-read the ledger from the plan file and discharge every row at the verification gate — satisfied, owes nothing (reason), or blocked → backlog — before completing.",
+      };
+    }
+  }
+
+  const undocumented = completed.filter((rel) => !planHasChangelogEntry(projectDir, rel));
   if (undocumented.length > 0) {
     return {
       decision: "block",
@@ -434,7 +537,7 @@ function main() {
       out = bashGate(commandRoot(projectDir, payload, input.command), input.command, payload.session_id);
     } else {
       const rel = relIfInside(projectDir, input.file_path || input.notebook_path);
-      if (rel) out = fileGate(projectDir, rel, payload.tool_name);
+      if (rel) out = fileGate(projectDir, rel, payload.tool_name, payload.session_id);
     }
   } else if (event === "Stop") {
     out = stopGate(projectDir, payload);
@@ -451,7 +554,15 @@ function main() {
 try {
   main();
 } catch (e) {
-  // Fail open: a broken gate must never become an outage.
+  // Fail open: a broken gate must never become an outage. But a gate that crashes silently is a
+  // gate nobody knows stopped guarding — leave a trace where the next SessionStart can find it.
+  try {
+    const dir = path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), ".claude", "state");
+    fs.mkdirSync(dir, { recursive: true });
+    fs.appendFileSync(path.join(dir, "hook-failures.log"), `${new Date().toISOString()} compliance.mjs ${e?.message || e}\n`);
+  } catch (e2) {
+    /* truly nowhere to write — fail open stays absolute */
+  }
 } finally {
   process.exit(0);
 }

package/data/harnesses/code/hooks/lib/ledger.mjs

@@ -0,0 +1,31 @@
+// harness/code/hooks/lib/ledger.mjs — the Test Obligations table, read the way the walls read it.
+// A row is discharged when its Outcome cell states one of the gate's three outcomes. The plan file
+// is the checked truth — a discharge held only in conversation memory does not exist, which is what
+// forces the gate to re-read the ledger from disk. Tables without an Outcome column predate the
+// contract and are out of scope: the same legacy tolerance the Gates: line gets, so an upgrade
+// cannot brick a plan already Complete.
+
+const OUTCOME = /^(satisfied|owes nothing|blocked)\b/i;
+
+// Row numbers (the `#` column) of every ledger row whose Outcome cell is empty or off-vocabulary.
+export function undischargedRows(planText) {
+  const start = (planText || "").search(/^##\s+Test Obligations\b/m);
+  if (start === -1) return [];
+  const body = [];
+  for (const line of planText.slice(start).split("\n").slice(1)) {
+    if (/^##\s/.test(line)) break; // next section
+    body.push(line);
+  }
+  const rows = body.filter((line) => /^\s*\|/.test(line));
+  if (rows.length < 3) return []; // header + divider + at least one data row
+  const header = rows[0].split("|").map((cell) => cell.trim().toLowerCase());
+  const col = header.indexOf("outcome");
+  if (col === -1) return []; // legacy table — predates the Outcome contract
+  const out = [];
+  for (const line of rows.slice(2)) {
+    const cells = line.split("|").map((cell) => cell.trim());
+    if (!/^\d+$/.test(cells[1] || "")) continue;
+    if (!OUTCOME.test(cells[col] || "")) out.push(cells[1]);
+  }
+  return out;
+}

package/data/harnesses/code/hooks/lib/session-log.mjs

@@ -0,0 +1,75 @@
+// harness/code/hooks/lib/session-log.mjs — the per-session gate log: a dated record, never drained.
+// Bookkeeping is a queue whose success state is empty; this file is the opposite genre — the
+// session's operational story, kept like memory. Machinery appends `denied` and `hook-crash`
+// events; the session appends `resolved` lines. The walls read PAIRS: a `denied` with no later
+// `resolved` for the same gate·target is an open failure, and silence about it is what the Stop
+// and commit walls refuse. Every line survives forever — the row's afterlife is the failure
+// stream later intelligence reads, so resolution appends rather than deletes.
+
+import fs from "node:fs";
+import path from "node:path";
+
+const DIR = ["docs", "history", "sessions"];
+
+function sid8(sessionId) {
+  return String(sessionId || "unknown").replace(/[^a-zA-Z0-9-]/g, "").slice(0, 8) || "unknown";
+}
+
+export function sessionLogPath(projectDir, sessionId) {
+  const dir = path.join(projectDir, ...DIR);
+  const suffix = `-${sid8(sessionId)}.md`;
+  try {
+    const existing = fs.readdirSync(dir).find((f) => f.endsWith(suffix));
+    if (existing) return path.join(dir, existing);
+  } catch (e) {
+    /* dir absent — first event creates it */
+  }
+  const date = new Date().toISOString().slice(0, 10);
+  return path.join(dir, `${date}${suffix}`);
+}
+
+// Append one event line, creating the file (with its header) on first write. Best-effort by
+// design: a log append must never become an outage, so failures return false and are the
+// caller's cue to fall back to .claude/state/hook-failures.log.
+export function appendEvent(projectDir, sessionId, kind, gate, target, detail = "") {
+  try {
+    const file = sessionLogPath(projectDir, sessionId);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    if (!fs.existsSync(file)) {
+      fs.writeFileSync(
+        file,
+        `# Session gate log · sid=${sessionId || "unknown"}\n\n` +
+          "Machinery-written record (a dated record, never edited down — resolutions append). " +
+          "Every `denied` line needs a later `resolved` line for the same gate · target — " +
+          "`retried-ok`, `waived → {ref}`, or `disclosed → {changelog entry}` — before the " +
+          "session ends or commits.\n\n"
+      );
+    }
+    const ts = new Date().toISOString().slice(11, 19);
+    const tail = detail ? ` · ${detail}` : "";
+    fs.appendFileSync(file, `- ${ts} ${kind} · ${gate} · ${target}${tail}\n`);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// Open failures: gate·target pairs denied with no later `resolved` line. Multiple denials of one
+// pair are one open failure (the retry count stays in the story; the wall asks one question).
+export function unresolvedDenials(projectDir, sessionId) {
+  let text = "";
+  try {
+    text = fs.readFileSync(sessionLogPath(projectDir, sessionId), "utf8");
+  } catch (e) {
+    return [];
+  }
+  const open = new Map();
+  for (const line of text.split("\n")) {
+    const m = /^- \S+ (denied|resolved) · ([^·]+) · ([^·\n]+?)(?: · |$)/.exec(line);
+    if (!m) continue;
+    const key = `${m[2].trim()} · ${m[3].trim()}`;
+    if (m[1] === "denied") open.set(key, true);
+    else open.delete(key);
+  }
+  return [...open.keys()];
+}

package/data/harnesses/code/rules/changelog.md

@@ -12,6 +12,8 @@ Every unit of work leaves one record — `docs/history/changelog/YYYY-MM-DD-{thr
 
 An entry is owed only by work that changes promised behavior or takes a design decision; mechanical and cosmetic commits — a typo, a copy tweak, a config value, a log line — take only their `docs/history/CHANGELOG.md` row, no entry file. The failure fields (`Ask:`, `Skills:`, `Pin:`) are required only when non-none.
 
+Route the lesson by who pays for losing it: product context — what changed and why — belongs in the entry; anything the **next session would re-pay** — a library's API drifted from what the model expects, a validator's quirk, a tooling workaround — goes to `docs/memory/main.md` as well, because a changelog is read by people tracing history and memory is read by every session before it repeats the mistake.
+
 ## Lifecycle
 
 Draft (created before its commit exists) → complete (missing fields filled from the diff and the session) → frozen the moment it rides in a commit. **Immutability begins at commit, not at creation** — a draft is meant to be edited, which is what lets a completed plan record its context before anything is committed; a committed entry is history, and a correction is a new entry linking back, **never** an edit.

package/data/harnesses/code/skills/documentation/SKILL.md

@@ -73,6 +73,7 @@ The two guarantees are complementary and both break on mixing: a reader holding
 | Testing strategy | [`templates/testing-strategy.md`](templates/testing-strategy.md) |
 | Behavioral checklist for one feature (`docs/tests/{feature}.md`) | [`templates/behavioral-checklist.md`](templates/behavioral-checklist.md) — the verification gate's driving script, and the source its suite tests are drawn from |
 | Recurring procedure/setup | [`templates/operations-procedure.md`](templates/operations-procedure.md) |
+| Cold-start build order (implementation map) | [`templates/implementation-map.md`](templates/implementation-map.md) — authored by the executing session at build start, updated in place as waves complete |
 | Capture mid-execution knowledge (`docs/history/journal.md`) | [`templates/journal.md`](templates/journal.md) (record — append-only; a row resolves by landing in its owning doc) |
 | Bookkeeping work queue (`docs/operations/bookkeeping.md`) | [`templates/bookkeeping.md`](templates/bookkeeping.md) — machine-read row grammar; appended by hooks and sessions, drained by the `bookkeeper` agent, walled at Stop and commit |
 | One-shot migration/upgrade | [`templates/migration-runbook.md`](templates/migration-runbook.md) (record) |

package/data/harnesses/code/skills/documentation/references/frontmatter.md

@@ -12,7 +12,7 @@ When creating or updating a feature doc, derive its **`owns:` frontmatter** —
 
 ## How to derive the frontmatter
 
-A feature doc's ownership frontmatter is `owns:` (required), `module:` (optional), `keywords:` (required), and `status:` (required). An optional `last-reviewed:` date (stamped whenever the doc is substantively reviewed or updated) gives the `maintenance` agent a staleness signal to rank its audits by — it is tooling metadata, never narrated in the body.
+A feature doc's ownership frontmatter is `owns:` (required), `module:` (optional), `keywords:` (required), and `status:` (required). An optional `last-reviewed:` date (stamped whenever the doc is substantively reviewed or updated) gives the `maintenance` agent a staleness signal to rank its audits by — it is tooling metadata, never narrated in the body. `type:` (required — the genre, enum = the template names) and `rev:` (generator-written generation stamp) are the same class: external tooling reads them, sessions **preserve them on edits** and never narrate or inject them. The `maintenance` agent stamps `type:` on docs that predate the key.
 
 **1. `owns:`** (the path scope)
 

package/data/harnesses/code/skills/documentation/references/style-guide.md

@@ -154,6 +154,39 @@ For screen layouts (not data flows), use these conventions:
 
 ---
 
+## Mermaid Diagrams
+
+**Structure at rest is ASCII; behaviour over time is mermaid.** A file tree, an on-disk layout, a load-class split, a wireframe — draw with box characters, because the diagram *is* the thing's shape. A sequence of turns, a state machine, a branching flow — write mermaid, because a renderer tracks the arrows better than a reader tracks them across box art, and the source stays diffable when a step is inserted.
+
+**Docs only**, on the same reasoning as ASCII: a diagram never enters an instruction file.
+
+### When to Use
+
+| Diagram | Use for |
+| --- | --- |
+| `sequenceDiagram` | Who calls whom in what order — a session turn, a hand-off between components |
+| `stateDiagram-v2` | Modes with transitions — a workflow, a record's lifecycle |
+| `flowchart` | A process with branches, gates, or fan-out |
+| `timeline` | A dated lineage, in records only — never in a truth document |
+
+### Rules
+
+- **At most 7 participants and 15 interactions** per diagram. Past that, split it — an unreadable diagram is worse than the prose it replaced.
+- **Labels under 8 words**, no trailing punctuation.
+- **Declare a direction** on every flowchart (`flowchart TD` / `LR`) so the render is stable.
+- **The diagram never carries a fact the prose omits.** It restates structure for a reader who scans; a reader who greps must still find everything in the text.
+- **No styling directives** — no `style`, no `classDef`, no theme overrides. Rendering is the reader's; the source stays portable across GitHub, Obsidian, and a plain editor.
+
+```
+flowchart LR
+  A[Plan approved] --> B{boundary}
+  B -->|BLOCK| C[Re-plan]
+  B -->|PASS| D[testing plan-gate]
+  D --> E[Implement]
+```
+
+---
+
 ## Code Examples
 
 ### Rules
@@ -344,7 +377,7 @@ Always end with:
 | Parameters | Type + purpose                  |
 | Returns    | Type + shape                    |
 | State      | Persistence points only         |
-| Diagrams   | ASCII for all flows — docs only, never instruction files |
+| Diagrams   | ASCII for structure at rest, mermaid for behaviour over time — docs only, never instruction files |
 | Code       | Under 15 lines, contracts only  |
 | Voice      | Imperative/active               |
 | Mechanics  | Inline-code identifiers; bold-assertion bullets |

package/data/harnesses/code/skills/documentation/scripts/doc-lint.mjs

@@ -89,7 +89,7 @@ function lintFile(path, findings) {
   const isFolderIndex = /(^|\/)(readme)\.md$/i.test(path);
   if (scope === 'truth' && !isFolderIndex && /(^|\/)docs\/features\/[^/]+\.md$/.test(path)) {
     const fm = text.startsWith('---') ? text.slice(0, text.indexOf('\n---', 3)) : '';
-    for (const key of ['owns:', 'keywords:', 'status:'])
+    for (const key of ['owns:', 'keywords:', 'status:', 'type:'])
       if (!fm.includes(key)) findings.push({ path, n: 1, severity: 'block', id: 'feature-frontmatter', message: `feature doc missing \`${key}\` frontmatter` });
   }
 }

package/data/harnesses/code/skills/documentation/templates/Readme.md

@@ -16,6 +16,7 @@ One file per template. Every template is either a **truth document** (states cur
 | Testing strategy | [testing-strategy.md](testing-strategy.md) | Truth |
 | Behavioral checklist | [behavioral-checklist.md](behavioral-checklist.md) | Truth |
 | Operations procedure | [operations-procedure.md](operations-procedure.md) | Truth |
+| Implementation map | [implementation-map.md](implementation-map.md) | Truth |
 | Bookkeeping ledger | [bookkeeping.md](bookkeeping.md) | Truth (work queue) |
 | Protected files | [protected-files.md](protected-files.md) | Truth |
 | Project root README | [root-readme.md](root-readme.md) | Truth |

package/data/harnesses/code/skills/documentation/templates/behavioral-checklist.md

@@ -16,6 +16,7 @@ Required: **Conventions**, at least one numbered behavior section, **Failure Rep
 - **Prefer exact literals** — the real prompt text, the real button label, the real count. A vague assertion passes a broken product.
 - **Assert persistence separately from display.** "It appeared on screen" and "it was written" are two claims; a surface that streams unsaved content satisfies the first while failing the second.
 - **State each section's trace.** `Pinned:` names the suite test that now guards it, or says `driven only` **with the reason** — an unmarked section is indistinguishable from an unexamined one.
+- **State each section's `AC:` keys.** Where the repo carries a keyed acceptance-criteria source, each section names the keys it proves, so the chain from criterion to checklist to suite test survives the last hop; the gate reports coverage and backlogs uncovered keys. `none — not AC-mapped` is the honest line where no keyed source exists.
 - **A known-failing assertion stays written as the contract.** A checklist states what the feature promises; the *run* records the failure and the backlog carries the defect. Never soften an assertion to make a run go green.
 
 ```
@@ -44,6 +45,7 @@ Each step is an action; each **Assert** is the observable it must produce.
 - [ ] **Assert**: {the persistence claim, where the behavior writes something}
 
 > Pinned: `{tests/path/to/file.test.ts}` — or `driven only — {why no durable test is bought}`
+> AC: {the acceptance-criteria keys this section proves} — or `none — not AC-mapped`
 
 ### 2. {The next behavior}
 

package/data/harnesses/code/skills/documentation/templates/changelog-entry.md

@@ -16,7 +16,7 @@ An entry is not a summary line. Its value concentrates in the fields a diff cann
 - **Iterations:** {N} · rejected: {what was rejected and why} | none
 - **Skills:** {skill}@{version} — survived | partially survived | overridden ({why, briefly}) | none used
 - **Change:** {added/changed X, which does Y, because Z — behavior first, mechanism second. Plan-linked entries also carry the verification gate's results here: rows discharged, suite outcome, anything blocked}
-- **Discovered:** {non-obvious fact learned by running the product — environment quirk, platform ceiling, seam behavior, dependency constraint} | none
+- **Discovered:** {non-obvious fact learned by running the product — environment quirk, platform ceiling, seam behavior, dependency constraint} [source: {tag}] | none
 - **Class:** {one or more keywords — suggestive vocabulary, not a closed enum; see Field rules}
 - **Pin:** {enforced artifact written in this entry's commit: test / token / guardrail / schema} | none — candidate: {what should hold it}
 ```
@@ -39,7 +39,7 @@ An entry is not a summary line. Its value concentrates in the fields a diff cann
 - **`surface`** uses the repo's ownership vocabulary — the owning feature doc's topic or an `owns:` path stem — so entries are queryable per surface.
 - **`Ask` quotes taste verbatim.** The user's preference wording is the one thing no skill can infer and no rebuild recovers; the entry is its durable home.
 - **`Skills` records efficacy honestly** — survived / partially survived / overridden with a reason. These verdicts are the raw data the `retro` agent aggregates into skill-evolution findings; sanitizing them into success stories destroys the mechanism's value.
-- **`Discovered` holds what only running the product teaches.** If it was learned in use, it is recorded the same day — this field feeds the pin candidates.
+- **`Discovered` holds what only running the product teaches.** If it was learned in use, it is recorded the same day — this field feeds the pin candidates. **Each finding carries a `source:` tag from a closed list** — `generator` (a generated doc was wrong) · `generator-conflict` (two generated docs disagreed) · `rules-conflict` (a generated doc contradicted standing rules) · `runtime-discovery` (only running revealed it) · `environment` (tooling or harness). Closed deliberately, unlike `Class:` — the consumer is the doc generator's readback grep, not a human. A finding in a repo with no generated docs is almost always `runtime-discovery` or `environment`.
 - **`Class` is a suggestive vocabulary, not a closed enum.** Tag with one or more keywords, preferring an existing term over a synonym so the `retro` agent can cluster; coin a new one when nothing fits — a recurring coinage is itself retro signal that the vocabulary (or the doc set) is missing a category. Suggested keywords: `ux` · `ui` · `visual` · `taste` · `layout` · `motion` · `interaction` · `copy` · `a11y` · `responsiveness` · `navigation` · `state` · `structure` · `architecture` · `seam` · `contract` · `schema` · `data` · `content` · `seed` · `performance` · `caching` · `resilience` · `error-handling` · `security` · `auth` · `observability` · `logging` · `testing` · `tooling` · `dependency` · `ops` · `deploy` · `env` · `ci` · `i18n` · `docs`.
 - **`Pin` closes the loop:** the enforced artifact written in this commit, or the named candidate for the `retro` agent to flag. A taste-verified behavior with `Pin: none` and no candidate is a template smell.
 - **Out-of-session entries** (the writing session did not do the work): fill what the diff and conversation evidence support; mark the rest `unknown — committed out-of-session`.

package/data/harnesses/code/skills/documentation/templates/feature.md

@@ -13,6 +13,7 @@ module: billing                                  # optional — single bounded-c
 keywords: [invoice, pdf]                         # required — discovery terms
 status: active                                   # required — active | draft | deprecated
 last-reviewed: YYYY-MM-DD                        # optional tooling key — stamped on substantive review/update; the maintenance agent ranks audit priority by it (metadata, never narrated in the body)
+type: feature                                    # required tooling key — genre stamp (generator-written or authored; enum = the template names), read by tooling (UI grouping, protected-file mapping); preserve on edits, never narrate
 ---
 ```
 

package/data/harnesses/code/skills/documentation/templates/implementation-map.md

@@ -0,0 +1,42 @@
+# Implementation Map (docs/operations/implementation-map.md)
+
+Truth document. Use for: **the cold-start execution contract of a project being built from its documented design** — one per repo, at `docs/operations/implementation-map.md`. It is authored by the **executing session at build start**, never generated at design time: build order is derived from the repo's actual feature docs and their stated dependencies, and a design-time prediction of it goes stale the day reality disagrees. It lives in operations because it says *how to proceed*, not *what is true of the design*.
+
+## Writing the map
+
+- **Derive waves from the feature docs** — their stated dependencies plus shared foundations (schema before routes, auth before anything it guards). A wave groups features that can build together; the order reflects foundations, not product importance.
+- **A wave's done criterion is observable** — its plans' verification gates passed, the suite green, a named surface driveable. Never "feels complete".
+- **Authority order names this repo's own docs, most specific wins.** A contradiction between documents is repaired in the owning truth doc *before* code — never reinterpreted while planning.
+- **Plans are records, not an execution queue.** The map points at the active wave's dated plan; historical plans are read only when a truth doc cites them as provenance.
+- **Update in place as waves complete** — the map states the current build position in present tense; the journey lives in the plans and changelog entries.
+
+```
+# {Project} implementation map
+
+## Cold-start contract
+
+{One paragraph: what a fresh session asked to "build this" is expected to do with this
+repository — plan, gate, implement, verify, in what granularity — and the statement that it
+needs nothing outside the repo.}
+
+## Authority order
+
+When documents disagree:
+
+1. {The constitutional docs — guardrails, non-goals, PRD-class documents}
+2. The most specific feature doc under `docs/features/`
+3. {The structural truth docs — domain model, storage schema, API contracts}
+4. The dated plan for the active wave
+5. Owned source files as implementation evidence
+
+## Waves
+
+| Wave | Features | Depends on | Done when |
+| - | - | - | - |
+| 1 | {docs/features/x.md, docs/features/y.md} | — | {observable criterion} |
+| 2 | {…} | 1 | {…} |
+
+## Current position
+
+{One line per wave: complete · in progress ([plan](../history/plans/YYYY-MM-DD-slug.md)) · pending.}
+```

package/data/harnesses/code/skills/testing/SKILL.md

@@ -47,14 +47,14 @@ Assign each behavior the **cheapest layer that can prove it**, then name the ora
    ```
    ## Test Obligations
 
-   | # | Behavior (LLD promise) | Layer | Target file | Oracle | Fixtures / faults |
-   | - | ---------------------- | ----- | ----------- | ------ | ----------------- |
+   | # | Behavior (LLD promise) | Layer | Target file | Oracle | Fixtures / faults | Outcome |
+   | - | ---------------------- | ----- | ----------- | ------ | ----------------- | ------- |
 
    Coverage: {N} behaviors · {N} integration · {N} component · {N} unit · {N} e2e ({N} extend, {N} new)
    Completion checklist: docs/tests/{feature}.md  (derived at the gate, not now)
    ```
 
-   A behavior with no obligation is stated too, with the reason — "none — compiler-guarded" reads as *checked*; an empty cell reads as *not analyzed*. A short manifest is valid — do not pad.
+   A behavior with no obligation is stated too, with the reason — "none — compiler-guarded" reads as *checked*; an empty cell reads as *not analyzed*. A short manifest is valid — do not pad. **`Outcome` is written empty here — it is gate mode's cell**, and the completion walls read it: a plan cannot reach `Status: Complete` while any row's Outcome is empty.
 6. **Record the write in the plan's `Gates:` line**, rewriting only your segment to exactly `Test-plan: written YYYY-MM-DD (N rows)` — the compliance hook greps this exact form. Add the line if the plan predates the format.
 
 ---
@@ -162,5 +162,5 @@ Runs only when the user triggers the verification gate (constraints — precondi
 
    A driven check is evidence, not an artifact — it proves the change works today and leaves nothing behind; that is why this rung exists.
 4. **Run the affected suite**, plus the project's e2e smoke gate where one is wired.
-5. **Discharge every ledger row into exactly one outcome**: **satisfied** (test green, or driven check passed), **owes nothing** (with the reason — compiler-guarded, covered elsewhere), or **blocked** (missing infrastructure named, row converted to a backlog item). A row left unexamined blocks the gate.
-6. **Report results honestly, including failures**; record which test now guards each checklist section (`Pinned:` traces). Completion steps — freezing the plan, the changelog entry — are the root policy file's, not yours.
+5. **Discharge every ledger row into exactly one outcome**: **satisfied** (test green, or driven check passed), **owes nothing** (with the reason — compiler-guarded, covered elsewhere), or **blocked** (missing infrastructure named, row converted to a backlog item). **Open by re-reading the ledger from the plan file on disk, never from conversation memory** — a context-held copy is how rows get missed. **Write each row's outcome into its `Outcome` cell in the plan file** — exactly `satisfied`, `owes nothing — {reason}`, or `blocked → backlog` — because the Stop wall and CI read that cell, and a row left unexamined blocks completion.
+6. **Report results honestly, including failures**; record which test now guards each checklist section (`Pinned:` traces) and each section's `AC:` line where the repo carries a keyed acceptance-criteria source, closing with the coverage count — `AC coverage: {n}/{m}; uncovered: {keys} → backlog`. Completion steps — freezing the plan, the changelog entry — are the root policy file's, not yours.

package/data/harnesses/delivery/agents/maintenance.md

@@ -62,6 +62,7 @@ For each `owns:` glob across the feature docs:
 
 - Verify the glob matches existing files. Report globs matching nothing, deleted paths, and orphaned docs.
 - Flag **equal-specificity overlaps** — two feature docs whose `owns:` globs claim the same paths at the same specificity (an ambiguous owner). Surface as a question.
+- **Stamp `type:` where missing.** Every doc carries a `type:` genre key (enum = the `documentation` skill's template names); docs predating the key are stamped mechanically — the genre is readable from placement and shape (a `docs/features/` doc is `type: feature`, an AD is `type: architecture-decision`, and so on). Stamping is remediation, not a question; an ambiguous genre is backlogged instead.
 
 For each code symbol or path a doc explicitly **names** (function/export/route/type):