@nurix/etna 0.19.42 → 0.19.44

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

@@ -27,7 +27,7 @@ Decide the mode once, up front, from the version marker — then run.
 2. Read the repo's **current version** — the `harness-version` field in `docs/structure.md` frontmatter (a semver).
    - **Absent** ⇒ the repo is unharnessed ⇒ **baseline mode** (reconcile from nothing), then audit.
    - **Behind on major** ⇒ **baseline mode** (reconcile across the gap), then audit.
-   - **Behind on minor/patch** ⇒ **probe before deciding.** Run the Step B2 detection pass read-only: if any old-shape artifact in the fold table is present, **or** any **scaffolded file** in the target tree is missing (`docs/README.md`, `docs/structure.md`, `docs/history/CHANGELOG.md`, `docs/history/backlog.md`, `docs/memory/index.md`), the shape *did* change ⇒ **baseline mode**. Only when the probe finds nothing ⇒ re-stamp the version (no reshape), then audit.
+   - **Behind on minor/patch** ⇒ **probe before deciding.** Run the Step B2 detection pass read-only: if any old-shape artifact in the fold table is present, **or** any **scaffolded file** in the target tree is missing (`docs/README.md`, `docs/structure.md`, `docs/history/CHANGELOG.md`, `docs/history/backlog.md`, `docs/memory/main.md`), the shape *did* change ⇒ **baseline mode**. Only when the probe finds nothing ⇒ re-stamp the version (no reshape), then audit.
 
    > **Never probe on a missing folder.** Git does not track empty directories, so an unused folder is absent on every clone — reading that as drift puts the repo in baseline mode *forever* and contradicts this agent's own idempotency guarantee. Only the five scaffolded files above are shape signals; every folder in the target tree is created on first use.
    - **Equal to installed** ⇒ **audit only** (the default spine).
@@ -115,7 +115,7 @@ For unowned code paths:
 
 ### Step 6: Report & update tracking
 
-1. Update `docs/structure.md` Health Log with today's date and summary — **append to the end**, never date-sorted into the middle. Rows are positional: one may say "the row above is…", and an inserted row silently breaks that reference.
+1. Update `docs/structure.md` Health Log with today's date and summary — **append to the end**, never date-sorted into the middle. Rows are positional: one may say "the row above is…", and an inserted row silently breaks that reference. A Health Log entry is a **generated row, not a narrative essay**: one line — date · counts (stale docs fixed, dead globs, unowned paths, backlog items created) · links to anything that needs a human.
 2. Update `docs/memory/maintenance.md` with last review date, stale docs fixed, unowned paths, backlog items created.
 3. Report findings: stale docs, broken ownership, unowned code, architecture drift, backlog health.
 
@@ -137,6 +137,7 @@ docs/
 ├── features/              # Feature specs — the only first-class doc unit (flat; ownership in each doc's `owns:` frontmatter)
 │   └── {group}/           #   browse-only subfolder for grouping; NEVER a module; may carry a Readme.md
 ├── operations/            # Setup, development, deployment, CI/CD
+│   └── bookkeeping.md     #   the shared doc-sync work queue (hook-appended, bookkeeper-drained, walled at commit) — author-created, never scaffolded; treat rows as live work, never as drift
 ├── research/              # In-progress brainstorm sessions ({topic}-brainstorm/; legacy -brainstorming/) + standing research; Readme.md is the index
 │   └── {topic}-brainstorm/     #   created by the `brainstorm` skill; moves to history/brainstorms/ on a passed harvest
 ├── history/
@@ -144,11 +145,12 @@ docs/
 │   ├── changelog/         # Individual entries (YYYY-MM-DD-{three-words}.md; written at commit time)
 │   ├── plans/             # Implementation plans (Status field required)
 │   ├── migrations/        # One-shot migration/upgrade runbooks (YYYY-MM-DD-{slug}.md; outcome-stamped then frozen)
+│   ├── journal.md         # Append-only mid-execution knowledge capture (one line per fact; resolves by landing in its owning doc) — author-created, never scaffolded
 │   ├── brainstorms/       # Harvested brainstorm sessions ({topic}/) — user decides kept (committed) or deleted; Readme.md is the index
 │   ├── research/          # Deep-research records ({topic}/ — README.md synthesis + findings.md + sources.md); frozen, cited, owns no code
 │   └── backlog.md       ✱ # Tracked work items by priority (P0-P3)
 ├── memory/
-│   └── index.md         ✱ #   plus main.md, {agent}.md — project knowledge + per-agent strategy memory
+│   └── main.md          ✱ #   plus {agent}.md — project knowledge + per-agent strategy memory
 └── tests/                 # Behavioral test checklists ({feature}.md, step → **Assert**), derived at plan Completion via the `documentation` skill; author-maintained
 ```
 

package/data/harnesses/code/codex/agents/maintenance.toml

@@ -25,7 +25,7 @@ Decide the mode once, up front, from the version marker — then run.
 2. Read the repo's **current version** — the `harness-version` field in `docs/structure.md` frontmatter (a semver).
    - **Absent** ⇒ the repo is unharnessed ⇒ **baseline mode** (reconcile from nothing), then audit.
    - **Behind on major** ⇒ **baseline mode** (reconcile across the gap), then audit.
-   - **Behind on minor/patch** ⇒ **probe before deciding.** Run the Step B2 detection pass read-only: if any old-shape artifact in the fold table is present, **or** any **scaffolded file** in the target tree is missing (`docs/README.md`, `docs/structure.md`, `docs/history/CHANGELOG.md`, `docs/history/backlog.md`, `docs/memory/index.md`), the shape *did* change ⇒ **baseline mode**. Only when the probe finds nothing ⇒ re-stamp the version (no reshape), then audit.
+   - **Behind on minor/patch** ⇒ **probe before deciding.** Run the Step B2 detection pass read-only: if any old-shape artifact in the fold table is present, **or** any **scaffolded file** in the target tree is missing (`docs/README.md`, `docs/structure.md`, `docs/history/CHANGELOG.md`, `docs/history/backlog.md`, `docs/memory/main.md`), the shape *did* change ⇒ **baseline mode**. Only when the probe finds nothing ⇒ re-stamp the version (no reshape), then audit.
 
    > **Never probe on a missing folder.** Git does not track empty directories, so an unused folder is absent on every clone — reading that as drift puts the repo in baseline mode *forever* and contradicts this agent's own idempotency guarantee. Only the five scaffolded files above are shape signals; every folder in the target tree is created on first use.
    - **Equal to installed** ⇒ **audit only** (the default spine).
@@ -146,7 +146,7 @@ docs/
 │   ├── research/          # Deep-research records ({topic}/ — README.md synthesis + findings.md + sources.md); frozen, cited, owns no code
 │   └── backlog.md       ✱ # Tracked work items by priority (P0-P3)
 ├── memory/
-│   └── index.md         ✱ #   plus main.md, {agent}.md — project knowledge + per-agent strategy memory
+│   └── main.md          ✱ #   plus {agent}.md — project knowledge + per-agent strategy memory
 └── tests/                 # Behavioral test checklists ({feature}.md, step → **Assert**), derived at plan Completion via the `documentation` skill; author-maintained
 ```
 

package/data/harnesses/code/harness.json

@@ -1,11 +1,12 @@
 {
   "harness": "code",
   "name": "code",
-  "version": "3.5.8",
+  "version": "3.5.10",
   "files": [
     ".prettierignore",
     ".prettierrc.json",
     ".vscode/settings.json"
   ],
-  "digest": "5dafd73481fb"
+  "seeds": [],
+  "digest": "552c88cf99bf"
 }

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

@@ -0,0 +1,370 @@
+// harness/code/hooks/awareness.mjs — the inform-never-block hook module.
+// SessionStart: inject the session context block, the ownership index, and a budget-capped drift
+// banner (full report → .claude/state/drift-report.md). PostToolUse (Edit|Write|MultiEdit|Bash):
+// the silent detector — record file→doc touches, append machine-recomputable findings as auto:
+// rows to docs/operations/bookkeeping.md. Never narrates into the session, never blocks, exits 0
+// on every path: everything here is a convenience, absent on any failure.
+
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import {
+  readStdin,
+  resolveProjectDir,
+  buildIndex,
+  scanFeatureDocs,
+  owningDocs,
+  listRepoFiles,
+  deadGlobs,
+  globToRegExp,
+  frontmatter,
+} from "./lib/ownership.mjs";
+import {
+  readQueue,
+  countRows,
+  formatAutoRow,
+  appendRows,
+  resolveRows,
+  unexpiredWaivers,
+  stateDir,
+  recordTouched,
+} from "./lib/state.mjs";
+
+const today = () => new Date().toISOString().slice(0, 10);
+
+function readSafe(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch (e) {
+    return "";
+  }
+}
+
+function readJsonSafe(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch (e) {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// SessionStart
+// ---------------------------------------------------------------------------
+
+function detectPackageManager(projectDir) {
+  const lockfiles = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["package-lock.json", "npm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lockb", "bun"],
+    ["bun.lock", "bun"],
+  ];
+  for (const [file, manager] of lockfiles) {
+    if (fs.existsSync(path.join(projectDir, file))) return `${manager} (${file} found)`;
+  }
+  return null;
+}
+
+function harnessLine(projectDir) {
+  const marker = readJsonSafe(path.join(projectDir, ".claude", "harness.json"));
+  if (!marker || !marker.version) return null;
+  const structure = readSafe(path.join(projectDir, "docs", "structure.md"));
+  const stamped = (/harness-version:\s*([\w.-]+)/.exec(frontmatter(structure) || structure) || [])[1];
+  const state =
+    stamped === marker.version
+      ? "reconciled"
+      : stamped
+        ? `stamped ${stamped} — behind: run maintenance`
+        : "unstamped — run maintenance";
+  return `Harness: installed ${marker.version} · docs/structure.md ${state}`;
+}
+
+function memoryLine(projectDir) {
+  const dir = path.join(projectDir, "docs", "memory");
+  let entries;
+  try {
+    entries = fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
+  } catch (e) {
+    return null;
+  }
+  return entries.length ? `Memory: ${entries.map((f) => `docs/memory/${f}`).join(", ")}` : null;
+}
+
+function openPlanLines(projectDir) {
+  const dir = path.join(projectDir, "docs", "history", "plans");
+  let entries;
+  try {
+    entries = fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
+  } catch (e) {
+    return [];
+  }
+  const lines = [];
+  for (const file of entries) {
+    const text = readSafe(path.join(dir, file));
+    const status = (/^\*\*Status:\*\*\s*(.+)$/m.exec(text) || [])[1]?.trim();
+    if (!status || /Complete|Abandoned/.test(status)) continue;
+    const gates = (/^\*\*Gates:\*\*\s*(.+)$/m.exec(text) || [])[1]?.trim();
+    const ledgerRows = (text.match(/^\|\s*\d+\s*\|/gm) || []).length;
+    const parts = [`Open plan: ${file} (${status}`];
+    if (gates) parts.push(` · Gates: ${gates}`);
+    if (ledgerRows) parts.push(` · ledger: ${ledgerRows} rows`);
+    lines.push(parts.join("") + ")");
+  }
+  return lines;
+}
+
+// Compute drift facts once; write the full report, return the one-line banner.
+function driftBanner(projectDir) {
+  const repoFiles = listRepoFiles(projectDir);
+  const dead = deadGlobs(projectDir, repoFiles);
+  const queueRows = readQueue(projectDir);
+  const counts = countRows(queueRows);
+  const waivers = unexpiredWaivers(queueRows, "dead-glob", today());
+  const unwaivedDead = dead.filter((d) => !waivers.some((w) => w.body.includes(d.glob)));
+
+  // Docs older than the code they own (doc mtime < newest owned-file mtime).
+  const staleDocs = [];
+  for (const entry of scanFeatureDocs(projectDir)) {
+    let docTime;
+    try {
+      docTime = fs.statSync(path.join(projectDir, entry.doc)).mtimeMs;
+    } catch (e) {
+      continue;
+    }
+    const res = entry.owns.map((g) => globToRegExp(g));
+    let newest = 0;
+    for (const file of repoFiles) {
+      if (!res.some((re) => re.test(file))) continue;
+      try {
+        newest = Math.max(newest, fs.statSync(path.join(projectDir, file)).mtimeMs);
+      } catch (e) {
+        /* deleted between walk and stat */
+      }
+    }
+    if (newest > docTime) staleDocs.push(entry.doc);
+  }
+
+  const report = [
+    `# Drift report — generated ${new Date().toISOString()}`,
+    "",
+    `## Dead owns: globs (${dead.length}, ${dead.length - unwaivedDead.length} waived)`,
+    ...dead.map((d) => `- ${d.glob} → ${d.doc}${unwaivedDead.includes(d) ? "" : " (waived)"}`),
+    "",
+    `## Docs older than owned code (${staleDocs.length})`,
+    ...staleDocs.map((d) => `- ${d}`),
+    "",
+    `## Bookkeeping queue (${counts.unresolved} unresolved: ${counts.auto} auto · ${counts.note} note · ${counts.needsSession} needs-session · ${counts.waived} waived)`,
+  ].join("\n");
+  try {
+    fs.writeFileSync(path.join(stateDir(projectDir), "drift-report.md"), report + "\n");
+  } catch (e) {
+    /* report is a convenience */
+  }
+
+  if (dead.length === 0 && staleDocs.length === 0 && counts.unresolved === 0) return null;
+  const waivedNote = dead.length
+    ? unwaivedDead.length === 0
+      ? " (all waived)"
+      : ` (${unwaivedDead.length} UNWAIVED)`
+    : "";
+  return (
+    `Drift: ${dead.length} dead owns: glob(s)${waivedNote} · ${staleDocs.length} doc(s) older than owned code · ` +
+    `bookkeeping: ${counts.unresolved} unresolved row(s) — full report: .claude/state/drift-report.md`
+  );
+}
+
+function sessionStart(projectDir) {
+  const lines = [];
+  const pm = detectPackageManager(projectDir);
+  if (pm) lines.push(`Package manager: ${pm}`);
+  const harness = harnessLine(projectDir);
+  if (harness) lines.push(harness);
+  const memory = memoryLine(projectDir);
+  if (memory) lines.push(memory);
+  lines.push(...openPlanLines(projectDir).slice(0, 4));
+  try {
+    const drift = driftBanner(projectDir);
+    if (drift) lines.push(drift);
+  } catch (e) {
+    /* the banner is optional; the index below still injects */
+  }
+  const block = lines.length
+    ? "# Session context (generated — a convenience, never a gate)\n" + lines.slice(0, 10).join("\n")
+    : "";
+  const index = buildIndex(projectDir);
+  const context = [block, index].filter(Boolean).join("\n\n");
+  if (!context) return;
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: context },
+    })
+  );
+}
+
+// ---------------------------------------------------------------------------
+// PostToolUse — the silent detector
+// ---------------------------------------------------------------------------
+
+const SOURCE_EXT = /\.(m?[jt]sx?|py|rs|go|rb|java|kt|swift|c|h|cpp|hpp|cs|sh|sql|css|scss|vue|svelte)$/;
+
+function relIfInside(projectDir, filePath) {
+  if (!filePath) return null;
+  const rel = path.relative(projectDir, path.resolve(projectDir, filePath));
+  if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+  return rel.split(path.sep).join("/");
+}
+
+// Spawn the installed doc-lint over one file; returns finding lines (empty when absent/clean).
+function docLint(projectDir, rel) {
+  const script = path.join(projectDir, ".claude", "skills", "documentation", "scripts", "doc-lint.mjs");
+  if (!fs.existsSync(script)) return [];
+  const res = spawnSync("node", [script, rel], { cwd: projectDir, encoding: "utf8", timeout: 5000 });
+  const out = `${res.stdout || ""}`;
+  return out.split("\n").filter((line) => /:\d+ \[(block|warn)\]/.test(line));
+}
+
+// True when a source file's first lines carry its repo-relative path (the header-comment rule).
+function hasHeaderComment(projectDir, rel) {
+  const head = readSafe(path.join(projectDir, rel)).split("\n").slice(0, 5).join("\n");
+  return head.includes(rel) || head.includes(path.basename(rel));
+}
+
+function detectorForFile(projectDir, rel, meta, rows) {
+  const owners = owningDocs(projectDir, rel);
+  recordTouched(projectDir, rel, owners.map((o) => o.doc));
+
+  if (rel.endsWith(".md")) {
+    // An edited doc resolves any doc-implicated row that pointed at it.
+    resolveRows(projectDir, (row) => row.kind === "auto" && row.body.includes("doc-implicated") && row.body.includes(rel));
+    if (rel.startsWith("docs/")) {
+      const findings = docLint(projectDir, rel);
+      if (findings.length) {
+        rows.push(
+          formatAutoRow({
+            ...meta,
+            kind: "doc-lint",
+            description: `${rel} has ${findings.length} doc-lint finding(s)`,
+            action: `fix or doc-lint-disable with reason`,
+          })
+        );
+      }
+    }
+    const segment = rel.split("/")[1];
+    if (rel.startsWith("docs/") && segment && !segment.endsWith(".md")) {
+      const structure = readSafe(path.join(projectDir, "docs", "structure.md"));
+      if (structure && !structure.includes(`${segment}/`) && !structure.includes(`docs/${segment}`)) {
+        rows.push(
+          formatAutoRow({
+            ...meta,
+            kind: "doc-placement",
+            description: `${rel} sits in a folder absent from docs/structure.md's authority map`,
+            action: "move the doc per the add-a-doc table, or record the new folder in structure.md",
+          })
+        );
+      }
+    }
+    if (rel.startsWith("docs/features/") && !readSafe(path.join(projectDir, "docs", "README.md")).includes(path.basename(rel))) {
+      rows.push(
+        formatAutoRow({
+          ...meta,
+          kind: "index-row-missing",
+          description: `${rel} is not linked from docs/README.md`,
+          action: "add its row to the Features index",
+        })
+      );
+    }
+    return;
+  }
+
+  if (SOURCE_EXT.test(rel)) {
+    if (!hasHeaderComment(projectDir, rel)) {
+      rows.push(
+        formatAutoRow({
+          ...meta,
+          kind: "header-missing",
+          description: `${rel} lacks its file-path header comment`,
+          action: "add the header comment",
+        })
+      );
+    }
+    for (const owner of owners) {
+      rows.push(
+        formatAutoRow({
+          ...meta,
+          kind: "doc-implicated",
+          description: `${rel} changed; owning doc ${owner.doc} may need an update (doc-implicated: ${owner.doc})`,
+          action: "update the doc or delete this row if no documented behavior changed",
+        })
+      );
+    }
+    if (/(schema|init\.sql|migration|auth|webhook|\benv\b|wrangler)/i.test(rel)) {
+      rows.push(
+        formatAutoRow({
+          ...meta,
+          kind: "boundary-scan-suggested",
+          description: `${rel} is contract-heavy`,
+          action: "run the boundary skill scoped to the diff",
+        })
+      );
+    }
+  }
+}
+
+function detectRenames(projectDir, command, meta, rows) {
+  if (!/\bgit mv\b|\bmv\b/.test(command || "")) return;
+  for (const { glob, doc } of deadGlobs(projectDir)) {
+    rows.push(
+      formatAutoRow({
+        ...meta,
+        kind: "dead-glob",
+        description: `owns: glob \`${glob}\` in ${doc} matches no files`,
+        action: `update the doc's owns: frontmatter`,
+      })
+    );
+  }
+}
+
+function postToolUse(projectDir, payload) {
+  const meta = {
+    date: today(),
+    sessionId: payload.session_id,
+    transcriptPath: payload.transcript_path,
+    ts: new Date().toISOString(),
+  };
+  const input = payload.tool_input || {};
+  const rows = [];
+  if (payload.tool_name === "Bash") {
+    detectRenames(projectDir, input.command, meta, rows);
+  } else {
+    const rel = relIfInside(projectDir, input.file_path || input.notebook_path);
+    if (rel) detectorForFile(projectDir, rel, meta, rows);
+    // Editing a feature doc's frontmatter can orphan globs the same way a rename can.
+    if (rel && rel.startsWith("docs/features/")) detectRenames(projectDir, "git mv", meta, rows);
+  }
+  appendRows(projectDir, rows);
+}
+
+// ---------------------------------------------------------------------------
+
+function main() {
+  const raw = readStdin();
+  let payload = {};
+  try {
+    payload = raw ? JSON.parse(raw) : {};
+  } catch (e) {
+    payload = {};
+  }
+  const projectDir = resolveProjectDir(payload);
+  const event = payload.hook_event_name || "SessionStart";
+  if (event === "PostToolUse") postToolUse(projectDir, payload);
+  else sessionStart(projectDir);
+}
+
+try {
+  main();
+} catch (e) {
+  // Inform-only module: on any failure, inject nothing, write nothing, never block.
+} finally {
+  process.exit(0);
+}

package/data/harnesses/code/hooks/check-bookkeeping-clean.mjs

@@ -0,0 +1,19 @@
+// harness/code/hooks/check-bookkeeping-clean.mjs — CI backstop: no unresolved bookkeeping rows
+// (auto:/note:/needs-session:) may reach the remote. waived: rows pass — they are the recorded,
+// PR-reviewable exceptions. Exit 1 when unresolved rows exist.
+
+import { readQueue, countRows } from "./lib/state.mjs";
+
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const counts = countRows(readQueue(projectDir));
+
+if (counts.unresolved === 0) {
+  console.log(`check-bookkeeping-clean: OK (${counts.waived} waived row(s))`);
+  process.exit(0);
+}
+console.error(
+  `check-bookkeeping-clean: ${counts.unresolved} unresolved row(s) in docs/operations/bookkeeping.md ` +
+    `(${counts.auto} auto, ${counts.note} note, ${counts.needsSession} needs-session). ` +
+    "Drain them (bookkeeper agent), resolve them, or convert to waived: with reason + expires=."
+);
+process.exit(1);

package/data/harnesses/code/hooks/check-changelog-presence.mjs

@@ -0,0 +1,48 @@
+// harness/code/hooks/check-changelog-presence.mjs — CI backstop: the commit under test (HEAD)
+// carries a docs/history/changelog/ entry unless it is exempt by the changelog rule's closed list,
+// judged mechanically: lockfile-only, harness-file-only, pure renames, changelog housekeeping,
+// or a bot author. Exit 1 when a non-exempt HEAD stages no entry.
+
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+function git(args) {
+  const res = spawnSync("git", args, { cwd: projectDir, encoding: "utf8" });
+  return res.status === 0 ? (res.stdout || "").trim() : null;
+}
+
+const nameStatus = git(["diff-tree", "--root", "--no-commit-id", "--name-status", "-r", "HEAD"]) || "";
+const entries = nameStatus
+  .split("\n")
+  .filter(Boolean)
+  .map((line) => {
+    const [status, ...files] = line.split("\t");
+    return { status, file: files[files.length - 1] };
+  });
+
+const LOCKFILES = /^(pnpm-lock\.yaml|package-lock\.json|yarn\.lock|bun\.lockb?|Cargo\.lock)$/;
+const exemptFile = (f) =>
+  LOCKFILES.test(path.basename(f)) ||
+  f.startsWith(".claude/") ||
+  f === "AGENTS.md" ||
+  f === "CLAUDE.md" ||
+  f.startsWith("docs/history/changelog/") ||
+  f === "docs/history/CHANGELOG.md";
+
+const author = git(["log", "-1", "--format=%an <%ae>"]) || "";
+const isBot = /\[bot\]|actions@github\.com/i.test(author);
+const allRenames = entries.length > 0 && entries.every((e) => e.status.startsWith("R"));
+const allExempt = entries.length === 0 || entries.every((e) => exemptFile(e.file));
+const hasEntry = entries.some((e) => e.file.startsWith("docs/history/changelog/") && e.file.endsWith(".md"));
+
+if (isBot || allRenames || allExempt || hasEntry) {
+  console.log("check-changelog-presence: OK");
+  process.exit(0);
+}
+console.error(
+  "check-changelog-presence: HEAD is a non-exempt commit carrying no docs/history/changelog/ entry. " +
+    "Every non-exempt commit ships its entry inside it (exempt: release/bot, lockfile-only, pure renames, changelog housekeeping)."
+);
+process.exit(1);

package/data/harnesses/code/hooks/check-completion-integrity.mjs

@@ -0,0 +1,68 @@
+// harness/code/hooks/check-completion-integrity.mjs — CI backstop for plan completion. Scope:
+// plans in the Gates: format only (legacy plans predate the contract and are history). A Complete
+// plan must show a fully discharged surface: no unchecked Done Criteria boxes, the Spec'd LLD
+// flipped active, and the behavioral checklist present. An Abandoned plan must reference the
+// backlog (undischarged obligations outlive the frozen file there). Exit 1 on any violation.
+
+import fs from "node:fs";
+import path from "node:path";
+import { frontmatter, field } from "./lib/ownership.mjs";
+
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const plansDir = path.join(projectDir, "docs", "history", "plans");
+
+function readSafe(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch (e) {
+    return "";
+  }
+}
+
+let failures = 0;
+const fail = (msg) => {
+  failures += 1;
+  console.error(`check-completion-integrity: ${msg}`);
+};
+
+let plans = [];
+try {
+  plans = fs.readdirSync(plansDir).filter((f) => f.endsWith(".md"));
+} catch (e) {
+  plans = [];
+}
+
+for (const file of plans) {
+  const text = readSafe(path.join(plansDir, file));
+  if (!/^\*\*Gates:\*\*/m.test(text)) continue; // legacy plan — out of contract
+  const status = (/^\*\*Status:\*\*\s*(\S+)/m.exec(text) || [])[1];
+
+  if (status === "Complete") {
+    const unchecked = (text.match(/^- \[ \]/gm) || []).length;
+    if (unchecked > 0) fail(`${file} is Complete with ${unchecked} unchecked Done Criteria box(es)`);
+
+    const spec = (/^\*\*Spec:\*\*\s*\[[^\]]*\]\(([^)]+)\)/m.exec(text) || [])[1];
+    if (spec) {
+      const specPath = path.resolve(plansDir, spec);
+      const specText = readSafe(specPath);
+      const specStatus = (field(frontmatter(specText), "status") || "").toString();
+      if (specText && specStatus !== "active") {
+        fail(`${file} is Complete but its Spec LLD is status: ${specStatus || "unknown"} (expected active)`);
+      }
+      const feature = path.basename(specPath, ".md");
+      if (!fs.existsSync(path.join(projectDir, "docs", "tests", `${feature}.md`))) {
+        fail(`${file} is Complete but docs/tests/${feature}.md (the behavioral checklist) is missing`);
+      }
+    }
+  }
+
+  if (status === "Abandoned" && !/backlog/i.test(text)) {
+    fail(`${file} is Abandoned without referencing the backlog — undischarged obligations must outlive the frozen plan`);
+  }
+}
+
+if (failures === 0) {
+  console.log("check-completion-integrity: OK");
+  process.exit(0);
+}
+process.exit(1);

package/data/harnesses/code/hooks/check-ownership.mjs

@@ -0,0 +1,22 @@
+// harness/code/hooks/check-ownership.mjs — CI backstop: every owns: glob must match at least one
+// file, unless an unexpired `waived:` dead-glob row in docs/operations/bookkeeping.md covers it
+// (the waiver names the glob verbatim). Exit 1 on any unwaived dead glob.
+
+import { deadGlobs } from "./lib/ownership.mjs";
+import { readQueue, unexpiredWaivers } from "./lib/state.mjs";
+
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const today = new Date().toISOString().slice(0, 10);
+
+const dead = deadGlobs(projectDir);
+const waivers = unexpiredWaivers(readQueue(projectDir), "dead-glob", today);
+const unwaived = dead.filter((d) => !waivers.some((w) => w.body.includes(d.glob)));
+
+if (unwaived.length === 0) {
+  console.log(`check-ownership: OK (${dead.length} dead glob(s), all waived or none)`);
+  process.exit(0);
+}
+console.error(`check-ownership: ${unwaived.length} unwaived dead owns: glob(s):`);
+for (const d of unwaived) console.error(`  ${d.glob} → ${d.doc}`);
+console.error("Fix the owning doc's owns: frontmatter, or add a `waived:` dead-glob row with reason + expires=.");
+process.exit(1);