@nurix/etna 0.19.65 → 0.19.67

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

@@ -1,457 +0,0 @@
-// harness/code/hooks/compliance.mjs — the gate-always-waivable hook module.
-// PreToolUse (Edit|Write|MultiEdit|Bash): deny what is never legitimate (frozen records, protected
-// files, plan-gate skips, changelog-less commits, off-catalog packages), ask where intent matters
-// (branches, live commands). Stop: block an arc that tries
-// to end with unresolved bookkeeping or an unrecorded plan completion. Every gate fails open — a
-// crash or unreadable repo allows the action; enforcement is never allowed to become an outage.
-
-import fs from "node:fs";
-import path from "node:path";
-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";
-
-function readSafe(file) {
-  try {
-    return fs.readFileSync(file, "utf8");
-  } catch (e) {
-    return "";
-  }
-}
-
-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("/");
-}
-
-function git(projectDir, args) {
-  const res = spawnSync("git", args, { cwd: projectDir, encoding: "utf8", timeout: 5000 });
-  return res.status === 0 ? (res.stdout || "").trim() : null;
-}
-
-function decision(permissionDecision, reason) {
-  return {
-    hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision, permissionDecisionReason: reason },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// PreToolUse — file gates
-// ---------------------------------------------------------------------------
-
-function protectedPaths(projectDir) {
-  const listFile = path.join(projectDir, "docs", "operations", "protected-files.md");
-  const paths = ["AGENTS.md", "docs/operations/protected-files.md"];
-  const text = readSafe(listFile);
-  for (const m of text.matchAll(/`([^`\n]+)`/g)) {
-    const candidate = m[1].trim();
-    if (candidate && !candidate.includes(" ")) paths.push(candidate.replace(/^\.\//, ""));
-  }
-  return paths;
-}
-
-// Open plans in the new format only (a `Gates:` line present). Plans without one are
-// legacy and pass every plan gate — otherwise every open plan bricks on harness upgrade.
-function openGatedPlans(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 plans = [];
-  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();
-    if (!gates) continue; // legacy tolerance
-    plans.push({
-      file,
-      status,
-      gates,
-      hasLedger: /^##\s+Test Obligations\b/m.test(text),
-      hasDocLedger: /^##\s+Doc Obligations\b/m.test(text),
-    });
-  }
-  return plans;
-}
-
-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) {
-  const frozen = frozenStatus(projectDir, rel);
-  if (frozen.frozen) {
-    return decision(
-      "deny",
-      `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.`);
-  }
-
-  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",
-          `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",
-          `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",
-          `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.`
-        );
-      }
-    }
-  }
-
-  // Writing a test file is never an interruption. Deferring tests to the verification gate stays
-  // doctrine (`testing.md` § During the loop), but it needs no gate here: what the ledger
-  // actually guarantees is enforced at both ends already — a plan may not take implementation
-  // edits until its `## Test Obligations` section exists (above), and it may not reach
-  // `Status: Complete` until the gate discharges every row (the Stop gate). Policing the *moment*
-  // a file appears adds no guarantee those two do not, and it fires hardest at the gate itself,
-  // where the ledger's tests are precisely what should be getting written.
-
-  // Doc placement is never an interruption: an off-map docs/ folder is detected silently by
-  // the awareness module (a `doc-placement` auto: row) and resolved by the bookkeeper.
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// PreToolUse — Bash gates
-// ---------------------------------------------------------------------------
-
-const LOCKFILES = /^(pnpm-lock\.yaml|package-lock\.json|yarn\.lock|bun\.lockb?|Cargo\.lock)$/;
-
-// Exempt per the changelog rule's closed list, judged mechanically: lockfile-only,
-// harness-file-only (.claude/, AGENTS.md, CLAUDE.md), or changelog housekeeping.
-const HARNESS_PREFIXES = [".claude/", ".agents/", ".codex/"];
-const HARNESS_FILES = [
-  "AGENTS.md",
-  "CLAUDE.md",
-  ".mcp.json",
-  ".vscode/settings.json",
-  ".prettierignore",
-  ".prettierrc.json",
-];
-
-function stagedExempt(files) {
-  return files.every(
-    (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"
-  );
-}
-
-function commitGate(projectDir) {
-  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",
-        "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 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.`
-    );
-  }
-  return null;
-}
-
-// Package names approved in .claude/hooks/approved-packages.md (plus testing.md frameworks and general.md).
-function approvedPackages(projectDir) {
-  const names = new Set();
-  const sources = [
-    path.join(projectDir, ".claude", "hooks", "approved-packages.md"),
-    path.join(projectDir, ".claude", "rules", "general.md"),
-    path.join(projectDir, ".claude", "rules", "testing.md"),
-  ];
-  for (const src of sources) {
-    const text = readSafe(src);
-    for (const m of text.matchAll(/`(@?[a-z0-9][\w./-]*)`/g)) names.add(m[1]);
-  }
-  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);
-  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("-"));
-  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",
-        `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.`
-      );
-    }
-  }
-  return null;
-}
-
-// The repo a Bash command acts on: an explicit `cd <dir>` in the command wins, then the
-// payload's cwd, then the session's home project — a session may operate across repos
-// (forge + consumer), and gating a commit against the wrong repo blocks or passes falsely.
-function commandRoot(projectDir, payload, command) {
-  const cdMatch = /(?:^|&&|;)\s*cd\s+"?([^"\s;&]+)"?/.exec(command || "");
-  for (const candidate of [cdMatch && cdMatch[1], payload.cwd]) {
-    if (!candidate || !path.isAbsolute(candidate)) continue;
-    try {
-      if (fs.statSync(candidate).isDirectory()) return candidate;
-    } catch (e) {
-      /* fall through */
-    }
-  }
-  return projectDir;
-}
-
-// An ask class fires once per session: the first occurrence asks, later ones pass silently —
-// the user has already exercised judgment on this class this session.
-function askOnce(projectDir, sessionId, key, message) {
-  if (askedThisSession(projectDir, sessionId, key)) return null;
-  recordAsked(projectDir, sessionId, key);
-  return decision("ask", message);
-}
-
-// Command matchers anchor at statement boundaries (start, &&, ;, |) so quoted text — an
-// echoed payload, a commit message naming a command — can never trigger a gate.
-const AT_STATEMENT = String.raw`(?:^|&&|;|\|)\s*(?:sudo\s+)?(?:npx\s+(?:--yes\s+)?)?`;
-const statement = (body) => new RegExp(AT_STATEMENT + body);
-
-function bashGate(projectDir, command, sessionId) {
-  if (!command) return null;
-
-  if (statement(String.raw`git\s+commit\b`).test(command)) {
-    return commitGate(projectDir);
-  }
-
-  // `git branch <name>` creates; flag-led forms (--show-current, --list, -d, -vv) query or manage
-  if (statement(String.raw`git\s+(checkout\s+-b|switch\s+-c|branch\s+(?!-)\S+|worktree\s+add)`).test(command)) {
-    return askOnce(
-      projectDir,
-      sessionId,
-      "branch-worktree",
-      "Create a branch/worktree? Policy allows this only when you asked for a PR or branch."
-    );
-  }
-
-  if (
-    statement(String.raw`wrangler(?:@\S+)?\b.*(\bd1\s+execute\b.*--remote|\bsecret\s+(put|bulk)\b|\bdeploy\b)`).test(command) &&
-    !/--dry-run\b|--local\b/.test(command)
-  ) {
-    return askOnce(
-      projectDir,
-      sessionId,
-      "live-command",
-      "Run this live-system command (deploy / remote DB / secrets)? If it's a one-shot migration, its runbook should exist in docs/history/migrations/ first. Asked once per session."
-    );
-  }
-
-  return packageGate(projectDir, command);
-}
-
-// ---------------------------------------------------------------------------
-// Stop
-// ---------------------------------------------------------------------------
-
-// True when the transcript's recent tail shows a bookkeeper dispatch this turn — best-effort:
-// absent or unreadable transcript reads as "not dispatched".
-function bookkeeperDispatched(transcriptPath) {
-  const text = readSafe(transcriptPath || "");
-  if (!text) return false;
-  const tail = text.slice(-200000);
-  return /bookkeeper/i.test(tail) && /"(Task|Agent)"/.test(tail);
-}
-
-// Plans this session flipped to Complete: Status is Complete AND the file appears in this
-// machine's touched.tsv (written by the awareness detector as edits happen).
-function plansCompletedThisSession(projectDir, sessionId) {
-  const touched = readSafe(path.join(projectDir, ".claude", "state", "touched.tsv"));
-  const touchedPlans = new Set(
-    touched
-      .split("\n")
-      .map((line) => line.split("\t"))
-      // THIS session's rows only. touched.tsv is shared by every session in the checkout, so an
-      // unfiltered read blocks one session's Stop for a plan another session completed — whose Ask
-      // quotes and iterations it does not have and cannot invent. Rows written before the id column
-      // existed carry no session and belong to none, so they are skipped rather than assumed.
-      .filter((cols) => sessionId && cols[3] === sessionId)
-      .map((cols) => cols[1])
-      .filter((p) => p && p.startsWith("docs/history/plans/"))
-  );
-  const out = [];
-  for (const rel of touchedPlans) {
-    const text = readSafe(path.join(projectDir, rel));
-    if (/^\*\*Status:\*\*\s*Complete\b/m.test(text)) out.push(rel);
-  }
-  return out;
-}
-
-// Whether some changelog entry already accounts for this plan.
-//
-// COMMITTED COUNTS. The test used to be `git status --porcelain docs/history/changelog/` — i.e. "is
-// there a DIRTY file there" — which a properly committed entry can never satisfy: committing cleans
-// the tree, so the gate re-fired immediately after the one action that discharged it, and the only
-// way to silence it was to leave an uncommitted file lying in the changelog directory.
-//
-// An entry names its plan by slug (the template links `../plans/<slug>.md`), so the slug is what is
-// searched for. A dirty file still counts too: a draft being written this moment has not necessarily
-// named its plan yet, and that was the original check's one real job.
-function planHasChangelogEntry(projectDir, planRel) {
-  if ((git(projectDir, ["status", "--porcelain", "--", "docs/history/changelog/"]) || "").trim()) return true;
-
-  const slug = path.basename(planRel, ".md");
-  const dir = path.join(projectDir, "docs", "history", "changelog");
-  let names = [];
-  try {
-    names = fs.readdirSync(dir);
-  } catch {
-    return false;
-  }
-  return names.some((name) => name.endsWith(".md") && readSafe(path.join(dir, name)).includes(slug));
-}
-
-// Approximate the context the next turn will re-read, from the transcript's last recorded usage.
-// Best-effort: an absent or unparseable transcript reports nothing.
-function sessionContextTokens(transcriptPath) {
-  const text = readSafe(transcriptPath || "");
-  if (!text) return 0;
-  const lines = text.slice(-400000).split("\n");
-  for (let i = lines.length - 1; i >= 0; i--) {
-    if (!lines[i].includes('"usage"')) continue;
-    try {
-      const u = JSON.parse(lines[i]).message.usage;
-      return (
-        (u.input_tokens || 0) + (u.cache_read_input_tokens || 0) + (u.cache_creation_input_tokens || 0)
-      );
-    } catch (e) {
-      // the slice cut this line in half — keep scanning upward
-    }
-  }
-  return 0;
-}
-
-// Context re-reads in full on every turn, so its size IS the standing per-turn floor — the one
-// number that argues for ending a session rather than carrying it into unrelated work. The agent
-// cannot act on this (it can neither end a session nor start one), so it is addressed to the user
-// as a systemMessage and never blocks. Kept out of the model's context deliberately: a running
-// token count in-context produces context anxiety, not shorter sessions.
-const CONTEXT_ADVISORY_TOKENS = 250000;
-
-function sessionSizeNote(payload) {
-  const tokens = sessionContextTokens(payload.transcript_path);
-  if (tokens < CONTEXT_ADVISORY_TOKENS) return null;
-  return (
-    `Session context is roughly ${Math.round(tokens / 1000)}K tokens, and every turn re-reads all of it — ` +
-    "that is the per-turn floor before anything new is produced. A fresh session starts near zero; " +
-    "worth ending this one if the next task is unrelated."
-  );
-}
-
-function stopGate(projectDir, payload) {
-  if (payload.stop_hook_active) return null; // the runtime's infinite-loop guard — never re-block
-
-  // The Stop wall is scoped to this session's own rows (plus sid-less ones) — a concurrent
-  // session's open work must not block this one's stop. The commit wall stays global.
-  const mine = readQueue(projectDir).filter(
-    (row) => !/\bsid=/.test(row.body) || row.body.includes(`sid=${payload.session_id}`)
-  );
-  const counts = countRows(mine);
-  if (counts.unresolved > 0 && !bookkeeperDispatched(payload.transcript_path)) {
-    return {
-      decision: "block",
-      reason:
-        `${counts.unresolved} unresolved bookkeeping rows from this session (${counts.auto} auto, ${counts.note} note, ${counts.needsSession} needs-session) in docs/operations/bookkeeping.md. ` +
-        "Dispatch the `bookkeeper` agent to drain them, resolve them now, or convert to `waived:` rows with reason + expiry. " +
-        "If implementation of the open plan is complete, also report it and offer the verification gate — never run it unbidden.",
-    };
-  }
-
-  // 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)
-  );
-  if (undocumented.length > 0) {
-    return {
-      decision: "block",
-      reason: `Plan \`${undocumented[0]}\` reached Status: Complete this session with no changelog entry drafted. Write the draft now (documentation skill → templates/changelog-entry.md) — the Ask quotes, rejected iterations, and skill verdicts that fill it exist only in this session and die with it.`,
-    };
-  }
-
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-
-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;
-
-  let out = null;
-  if (event === "PreToolUse") {
-    const input = payload.tool_input || {};
-    if (payload.tool_name === "Bash") {
-      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);
-    }
-  } else if (event === "Stop") {
-    out = stopGate(projectDir, payload);
-    // Advisory rides alongside a block rather than replacing it — both are true at once.
-    if (!payload.stop_hook_active) {
-      const note = sessionSizeNote(payload);
-      if (note) out = { ...(out || {}), systemMessage: note };
-    }
-  }
-
-  if (out) process.stdout.write(JSON.stringify(out));
-}
-
-try {
-  main();
-} catch (e) {
-  // Fail open: a broken gate must never become an outage.
-} finally {
-  process.exit(0);
-}

package/data/harnesses/apollo/hooks/hooks.json

@@ -1,23 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Edit(docs/**)",
-      "Edit(**/tests/**)",
-      "Edit(**/e2e/**)"
-    ]
-  },
-  "hooks": {
-    "SessionStart": [
-      { "matcher": "", "hooks": [ { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/awareness.mjs\"", "timeout": 10 } ] }
-    ],
-    "PostToolUse": [
-      { "matcher": "Edit|Write|MultiEdit|Bash", "hooks": [ { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/awareness.mjs\"", "timeout": 10 } ] }
-    ],
-    "PreToolUse": [
-      { "matcher": "Edit|Write|MultiEdit|Bash", "hooks": [ { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/compliance.mjs\"", "timeout": 10 } ] }
-    ],
-    "Stop": [
-      { "matcher": "", "hooks": [ { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/compliance.mjs\"", "timeout": 15 } ] }
-    ]
-  }
-}

package/data/harnesses/apollo/hooks/lib/frozen.mjs

@@ -1,58 +0,0 @@
-// harness/code/hooks/lib/frozen.mjs — the frozen-record predicate, shared by the compliance gate
-// and CI. Frozen: a committed docs/history/changelog/ entry, a plan whose Status is Complete or
-// Abandoned, an outcome-stamped migration runbook. Immutability begins at commit for changelog
-// entries (a draft in the working tree is meant to be edited), at the status flip for plans, and
-// at the Executed stamp for runbooks. Every check fails open: no git, unreadable file ⇒ not frozen.
-
-import fs from "node:fs";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-
-function relPosix(projectDir, filePath) {
-  return path.relative(projectDir, path.resolve(projectDir, filePath)).split(path.sep).join("/");
-}
-
-// True when git tracks the file at HEAD (i.e. it has been committed at least once).
-export function isCommitted(projectDir, filePath) {
-  const rel = relPosix(projectDir, filePath);
-  const res = spawnSync("git", ["cat-file", "-e", `HEAD:${rel}`], { cwd: projectDir, stdio: "ignore" });
-  return res.status === 0;
-}
-
-function readSafe(projectDir, filePath) {
-  try {
-    return fs.readFileSync(path.resolve(projectDir, filePath), "utf8");
-  } catch (e) {
-    return "";
-  }
-}
-
-// The predicate. Returns { frozen: boolean, reason?: string }.
-export function frozenStatus(projectDir, filePath) {
-  const rel = relPosix(projectDir, filePath);
-  if (rel.startsWith("docs/history/changelog/") && rel.endsWith(".md")) {
-    if (isCommitted(projectDir, rel)) {
-      return { frozen: true, reason: "committed changelog entry — immutability begins at commit" };
-    }
-    return { frozen: false };
-  }
-  if (rel.startsWith("docs/history/plans/") && rel.endsWith(".md")) {
-    const text = readSafe(projectDir, rel);
-    if (/^\*\*Status:\*\*\s*(Complete|Abandoned)\b/m.test(text)) {
-      return { frozen: true, reason: "plan with Status: Complete or Abandoned" };
-    }
-    return { frozen: false };
-  }
-  if (rel.startsWith("docs/history/migrations/") && rel.endsWith(".md")) {
-    const text = readSafe(projectDir, rel);
-    if (/^\*\*Executed:\*\*\s*\d{4}-\d{2}-\d{2}/m.test(text)) {
-      return { frozen: true, reason: "outcome-stamped migration runbook" };
-    }
-    return { frozen: false };
-  }
-  return { frozen: false };
-}
-
-export function isFrozen(projectDir, filePath) {
-  return frozenStatus(projectDir, filePath).frozen;
-}