@nurix/etna 0.19.65 → 0.19.67

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

@@ -1,405 +0,0 @@
-// 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,
-  formatNeedsSessionRow,
-  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)));
-
-  // A queued dead-glob row covered by an unexpired waiver is resolved history — drop it,
-  // so waiving a finding class actually empties the rows it supersedes.
-  resolveRows(projectDir, (row) => {
-    if (row.kind !== "auto" || !row.body.includes("dead-glob")) return false;
-    const m = /`([^`]+)`/.exec(row.body);
-    return !!m && waivers.some((w) => w.body.includes(`\`${m[1]}\``));
-  });
-
-  // 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), meta.sessionId);
-
-  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));
-
-    // A plan's Doc Obligations ledger names docs whose stated behavior the plan falsifies. Whether
-    // one is discharged is a judgment, never a mechanical fix — so it becomes a `needs-session:`
-    // row, the one kind the bookkeeper leaves untouched, rather than an `auto:` row a sub-agent
-    // would tick without reading the code. Raising it here rather than walling it at Stop is what
-    // gives it the queue's three existing walls (Stop, commit, CI) instead of a fourth special case.
-    // Resolve-then-append keeps exactly one row per plan, so re-editing never stacks duplicates.
-    if (rel.startsWith("docs/history/plans/")) {
-      const planText = readSafe(path.join(projectDir, rel));
-      resolveRows(projectDir, (row) => row.kind === "needs-session" && row.body.includes(rel));
-      if (
-        /^\*\*Status:\*\*\s*Complete\b/m.test(planText) &&
-        /^##\s+Doc Obligations\b/m.test(planText) &&
-        /^\s*-\s*\[ \]\s*Every Doc Obligations row discharged/m.test(planText)
-      ) {
-        rows.push(
-          formatNeedsSessionRow({
-            date: meta.date,
-            description: `${rel} reached Status: Complete with its Doc Obligations rows undischarged`,
-            refs: 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;
-  const waivers = unexpiredWaivers(readQueue(projectDir), "dead-glob", today());
-  for (const { glob, doc } of deadGlobs(projectDir)) {
-    if (waivers.some((w) => w.body.includes(`\`${glob}\``))) continue;
-    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/apollo/hooks/check-bookkeeping-clean.mjs

@@ -1,19 +0,0 @@
-// 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/apollo/hooks/check-changelog-presence.mjs

@@ -1,57 +0,0 @@
-// 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 HARNESS_PREFIXES = [".claude/", ".agents/", ".codex/"];
-const HARNESS_FILES = [
-  "AGENTS.md",
-  "CLAUDE.md",
-  ".mcp.json",
-  ".vscode/settings.json",
-  ".prettierignore",
-  ".prettierrc.json",
-];
-
-const exemptFile = (f) =>
-  LOCKFILES.test(path.basename(f)) ||
-  HARNESS_PREFIXES.some((p) => f.startsWith(p)) ||
-  HARNESS_FILES.includes(f) ||
-  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, harness installs and bumps, lockfile-only, pure renames, changelog housekeeping)."
-);
-process.exit(1);

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

@@ -1,71 +0,0 @@
-// 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)`);
-
-    // EVERY Spec line, not the first. A plan may implement against several feature docs, and a
-    // single-match parse silently exempts all but one — the same singular assumption the Doc
-    // Obligations ledger exists to break, reintroduced here where nothing would surface it.
-    const specs = [...text.matchAll(/^\*\*Spec:\*\*\s*\[[^\]]*\]\(([^)]+)\)/gm)].map((m) => m[1]);
-    for (const spec of specs) {
-      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 ${spec} 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/apollo/hooks/check-ownership.mjs

@@ -1,22 +0,0 @@
-// 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);