@nurix/etna 0.19.90 → 0.19.92

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

@@ -0,0 +1,68 @@
+// harness/code/hooks/lib/repo.mjs — the shared floor every hook module stands on: safe reads,
+// path normalization, git, session ids, and the one definition of "source file". Each of these
+// existed as 2–5 diverging private copies before being hoisted here.
+
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+export function readSafe(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch (e) {
+    return "";
+  }
+}
+
+// Repo-relative /-separated path, or null when the target lies outside the project.
+export 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("/");
+}
+
+export function git(cwd, args) {
+  const res = spawnSync("git", args, { cwd, encoding: "utf8", timeout: 5000 });
+  return res.status === 0 ? (res.stdout || "").trim() : null;
+}
+
+export const today = () => new Date().toISOString().slice(0, 10);
+
+export function sid8(sessionId) {
+  return String(sessionId || "unknown").replace(/[^a-zA-Z0-9-]/g, "").slice(0, 8) || "unknown";
+}
+
+// One definition of "source file" — the plan gate and the drift detector must agree on it.
+export const SOURCE_EXT = /\.(m?[jt]sx?|py|rs|go|rb|java|kt|swift|c|h|cpp|hpp|cs|sh|sql|css|scss|vue|svelte)$/;
+
+// Space-free backticked tokens in a markdown chunk, `./` prefix stripped — the shared grammar
+// for path-carrying prose (protected lists, plan scopes).
+export function backtickTokens(text) {
+  const out = [];
+  for (const m of String(text || "").matchAll(/`([^`\n]+)`/g)) {
+    const candidate = m[1].trim().replace(/^\.\//, "");
+    if (candidate && !candidate.includes(" ")) out.push(candidate);
+  }
+  return out;
+}
+
+// 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.
+// A candidate is normalized to its git toplevel so a subdirectory cwd still resolves to the
+// repo root. Claim and release both route here — two private copies of this rule once
+// disagreed, and the divergence leaked stale claims.
+export function commandRoot(projectDir, payload, command) {
+  const cdMatch = /(?:^|\n|&&|;)\s*cd\s+"?([^"\s;&]+)"?/.exec(command || "");
+  for (const candidate of [cdMatch && cdMatch[1], payload && payload.cwd]) {
+    if (!candidate || !path.isAbsolute(candidate)) continue;
+    try {
+      if (!fs.statSync(candidate).isDirectory()) continue;
+    } catch (e) {
+      continue;
+    }
+    return git(candidate, ["rev-parse", "--show-toplevel"]) || candidate;
+  }
+  return projectDir;
+}

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

@@ -1,6 +1,6 @@
 // harness/code/hooks/lib/session-log.mjs — the per-session gate log: enforcement state, not a record.
 // It lives in .claude/state/sessions/ (machine-local, self-ignored) because its load-bearing role
-// is synchronous: machinery appends `denied` and `hook-crash` events, the session appends
+// is synchronous: machinery appends `denied` events, the session appends
 // `resolved` lines, and 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.
 // Within a session resolution appends rather than deletes (the retry story is what the walls
@@ -10,10 +10,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { stateDir } from "./state.mjs";
-
-function sid8(sessionId) {
-  return String(sessionId || "unknown").replace(/[^a-zA-Z0-9-]/g, "").slice(0, 8) || "unknown";
-}
+import { sid8 } from "./repo.mjs";
 
 export function sessionLogPath(projectDir, sessionId) {
   const dir = path.join(stateDir(projectDir), "sessions");

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

@@ -9,15 +9,20 @@
 // only while its expires= date is in the future; past it, the deferral is over and the wall returns.
 // Rows are also re-verified against the repo before the walls read them (awareness.mjs's sweep),
 // so a row whose condition died is deleted rather than waiting for its date.
+//
+// The three walls read the queue at three widths: the commit wall takes only the rows implicating
+// the commit's staged set (§ What a row implicates), the Stop wall takes the ending session's own
+// rows, and CI takes every row. Accountability is per session; a commit is per set of files.
 
 import fs from "node:fs";
 import path from "node:path";
+import { globToRegExp } from "./ownership.mjs";
 
 export const QUEUE_PATH = ["docs", "operations", "bookkeeping.md"];
 
 export const QUEUE_HEADER = `# Bookkeeping
 
-The shared work queue keeping documentation and code in sync — a queue, never an archive. Rows are appended mechanically (auto:) and by working sessions (note:), drained by the bookkeeper agent, and walled at commit: a commit is possible only when every row is either **resolved, which deletes it**, or converted to \`waived:\`. A drained row leaves no trace here; what it closed is recorded in the doc it corrected, and git history holds the row itself. Row grammar and lifecycle: the \`documentation\` skill's \`templates/bookkeeping.md\`.\n\n**Every row is a cache of a condition, not a record of an event.** A session-start sweep re-tests each row against the repo and deletes the ones whose condition has died — \`waived:\` rows included, because a waiver defers a finding and never makes one immortal. What the sweep cannot mechanically re-test ages out instead: a \`waived:\` row carries \`expires=\`, is PR-reviewable history until that date, and counts as **unresolved** past it — which returns the wall and re-summons the bookkeeper to re-judge whether the reason still holds.
+The shared work queue keeping documentation and code in sync — a queue, never an archive. Rows are appended mechanically (auto:) and by working sessions (note:), drained by the bookkeeper agent, and walled at commit: a commit goes through only when every row **implicating one of its staged files** is either **resolved, which deletes it**, or converted to \`waived:\`. A row about files the commit does not touch belongs to whoever raised it; a row naming no file, and a commit staging none, block everything. A drained row leaves no trace here; what it closed is recorded in the doc it corrected, and git history holds the row itself. Row grammar and lifecycle: the \`documentation\` skill's \`templates/bookkeeping.md\`.\n\n**Every row is a cache of a condition, not a record of an event.** A session-start sweep re-tests each row against the repo and deletes the ones whose condition has died — \`waived:\` rows included, because a waiver defers a finding and never makes one immortal. What the sweep cannot mechanically re-test ages out instead: a \`waived:\` row carries \`expires=\`, is PR-reviewable history until that date, and counts as **unresolved** past it — which returns the wall and re-summons the bookkeeper to re-judge whether the reason still holds.
 `;
 
 export function queueFile(projectDir) {
@@ -143,6 +148,85 @@ export function countRows(rows, today = new Date().toISOString().slice(0, 10)) {
   return c;
 }
 
+// The unresolved rows themselves — the same set countRows() tallies, as rows rather than a number.
+export function unresolvedRows(rows, today = new Date().toISOString().slice(0, 10)) {
+  return rows.filter((row) => {
+    if (row.kind !== "waived") return true;
+    const expires = waiverExpiry(row);
+    return !expires || expires < today;
+  });
+}
+
+// --- What a row implicates -------------------------------------------------------------------
+//
+// THE COMMIT WALL IS SCOPED BY PATH. Every mechanical finding names the file it is about, so a
+// commit can be walled by the rows implicating ITS staged set rather than by the whole queue.
+// A global wall is unattributable the moment agents share a checkout: sibling agents also share a
+// session id, so an agent ready to commit was held behind rows a concurrent sibling raised — rows
+// the ownership etiquette (drain only what your own edits raised) forbids it from draining, which
+// makes the wall a wait with no action that clears it. Measured on the fleet: a 15-minute stall
+// behind a sibling's ten rows, and two agents in 5–6-minute mutual politeness loops.
+//
+// The shapes below mirror the ones awareness.mjs's ROW_VERIFIERS re-test — one grammar, two
+// readers. Each rule captures every path the row names: the file the finding is about AND the doc
+// that owns or records it, since staging either one is a commit answering for that row.
+//
+// A ROW THIS CANNOT PARSE IMPLICATES EVERYTHING. Scoping may narrow a wall on evidence, never on
+// ignorance — so an unrecognized row, a judgment row, and a commit with nothing staged to compare
+// against all keep the old repo-wide block.
+const ROW_PATH_RULES = [
+  /·\s*doc-implicated\s*·\s*(\S+)\s+changed;\s+owning doc\s+(\S+?)\s+may need/,
+  /·\s*doc-lint\s*·\s*(\S+)\s+has\s/,
+  /·\s*header-missing\s*·\s*(\S+)\s+lacks\s/,
+  /·\s*index-row-missing\s*·\s*(\S+)\s+is not linked from\s+(\S+)/,
+  /·\s*package-rejected\s*·\s*(\S+)\s+declares\s/,
+  /·\s*frozen-record-edited\s*·\s*(\S+)\s+is a frozen record/,
+  /·\s*dead-glob\s*·\s*owns: glob\s+`([^`]+)`\s+in\s+(\S+)\s+matches/,
+  /→\s*lands-in:\s*(\S+\/\S+)/, // a note: row names the doc its context lands in
+];
+
+// The paths a row implicates, or null when its grammar yields none.
+export function rowPaths(row) {
+  for (const re of ROW_PATH_RULES) {
+    const m = re.exec(row.body);
+    if (!m) continue;
+    const paths = m.slice(1).filter(Boolean);
+    if (paths.length > 0) return paths;
+  }
+  return null;
+}
+
+// True when one of a row's tokens names a staged file. A token carrying `*` — the glob a dead-glob
+// row quotes — compiles through the ownership index's engine; a plain token matches a staged file
+// exactly, or as the directory it sits in.
+function tokenHitsStaged(token, staged) {
+  if (token.includes("*")) {
+    const re = globToRegExp(token);
+    return staged.some((f) => re.test(f));
+  }
+  return staged.some((f) => f === token || f.startsWith(token + "/"));
+}
+
+// The unresolved rows a commit staging `staged` must answer for, each with the staged paths it
+// implicates. `needs-session:` rows and expired waivers are judgments rather than mechanical
+// findings — they carry no reliable path and stay global by kind, which is the semantics they had
+// before scoping. Returns { blocking, unrelated }: `unrelated` counts the rows this commit is
+// walked past, which the block message reports so scoping is visible rather than silent.
+export function rowsBlockingCommit(rows, staged, today = new Date().toISOString().slice(0, 10)) {
+  const blocking = [];
+  let unrelated = 0;
+  for (const row of unresolvedRows(rows, today)) {
+    const paths = row.kind === "auto" || row.kind === "note" ? rowPaths(row) : null;
+    const hits = paths && staged.length > 0 ? paths.filter((p) => tokenHitsStaged(p, staged)) : null;
+    if (hits && hits.length === 0) {
+      unrelated += 1;
+      continue;
+    }
+    blocking.push({ row, hits: hits || [] });
+  }
+  return { blocking, unrelated };
+}
+
 // Format one auto: row per the grammar; the sid tail is the only provenance kept —
 // a transcript path or timestamp is machine noise in a PR-reviewed queue.
 export function formatAutoRow({ date, kind, description, action, sessionId }) {
@@ -219,18 +303,26 @@ export function resolveRows(projectDir, predicate) {
   return res.result;
 }
 
+export function waiverExpiry(row) {
+  return (/expires=(\d{4}-\d{2}-\d{2})/.exec(row.body) || [])[1] || null;
+}
+
 // Unexpired waived rows for a finding kind (the dead-glob allowlist CI honors).
-// A waived row covers a glob when its body names it verbatim.
 export function unexpiredWaivers(rows, kind, today) {
   return rows.filter((row) => {
     if (row.kind !== "waived") return false;
     if (kind && !row.body.includes(kind)) return false;
-    const expires = (/expires=(\d{4}-\d{2}-\d{2})/.exec(row.body) || [])[1];
-    if (!expires) return false;
-    return expires >= today;
+    const expires = waiverExpiry(row);
+    return !!expires && expires >= today;
   });
 }
 
+// True when an unexpired waiver of `kind` names the finding's subject. The subject is matched
+// BACKTICKED — a bare substring match let a waiver for `src/dead1.ts` silently cover `src/dead`.
+export function waiverCovers(rows, kind, subject, today) {
+  return unexpiredWaivers(rows, kind, today).some((w) => w.body.includes(`\`${subject}\``));
+}
+
 // Ensure .claude/state/ exists and is self-ignoring (a `*` .gitignore inside it),
 // so consumers never see machine-local state as untracked noise. Returns the dir.
 export function stateDir(projectDir) {

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

@@ -1,13 +1,15 @@
 # Bookkeeping ledger (docs/operations/bookkeeping.md)
 
-Truth document with an unusual lifecycle: a **work queue**, not an archive. Rows are appended mechanically by the awareness hook (`auto:`) and deliberately by working sessions (`note:`), drained by the `bookkeeper` agent, and walled at Stop and commit — a commit is possible only when every row is resolved (deleted) or converted to `waived:`. What survives in git — `waived:` and `needs-session:` rows — is exactly what a PR reviewer should see.
+Truth document with an unusual lifecycle: a **work queue**, not an archive. Rows are appended mechanically by the awareness hook (`auto:`) and deliberately by working sessions (`note:`), drained by the `bookkeeper` agent, and walled at Stop, at commit, and in CI. What survives in git — `waived:` and `needs-session:` rows — is exactly what a PR reviewer should see.
+
+**Each wall reads the queue at its own width.** Stop takes the ending session's own rows, because accountability for an arc is per session. The commit gate takes only the rows **implicating that commit's staged files** — a row names the file its finding is about, and holding a commit behind rows raised by somebody else's edits is a wait nothing the committer may do can clear. CI takes every row on the branch, where there is no staged set to scope by. Fail-closed cases stay repo-wide at the commit gate: a row whose grammar names no path, a `needs-session:` row, an expired waiver, and a commit staging nothing at all.
 
 The row grammar is machine-read by the hooks and CI; keep it exact. A `waived:` row's `expires=` date is enforced: CI honors the waiver until the date, then fails. `waived:` rows whose finding kind is `dead-glob` double as the dead-glob allowlist.
 
 ```
 # Bookkeeping
 
-The shared work queue keeping documentation and code in sync — a queue, never an archive. Rows are appended mechanically (auto:) and by working sessions (note:), drained by the bookkeeper agent, and walled at commit: a commit is possible only when every row is either **resolved, which deletes it**, or converted to `waived:`. A drained row leaves no trace here; what it closed is recorded in the doc it corrected, and git history holds the row itself. Row grammar and lifecycle: the `documentation` skill's `templates/bookkeeping.md`. A `waived:` row carries `expires=` and is PR-reviewable history.
+The shared work queue keeping documentation and code in sync — a queue, never an archive. Rows are appended mechanically (auto:) and by working sessions (note:), drained by the bookkeeper agent, and walled at commit: a commit goes through only when every row **implicating one of its staged files** is either **resolved, which deletes it**, or converted to `waived:`. A row about files the commit does not touch belongs to whoever raised it; a row naming no file, and a commit staging none, block everything. A drained row leaves no trace here; what it closed is recorded in the doc it corrected, and git history holds the row itself. Row grammar and lifecycle: the `documentation` skill's `templates/bookkeeping.md`. A `waived:` row carries `expires=` and is PR-reviewable history.
 
 - auto: YYYY-MM-DD · {finding-kind} · {description} → {action} | sid={session_id} tp={transcript_path} ts={ISO}
 - note: YYYY-MM-DD · {area} · {one-line context only the session holds} → lands-in: {owning doc | backlog | memory} | sid=… tp=… ts=…
@@ -15,4 +17,4 @@ The shared work queue keeping documentation and code in sync — a queue, never
 - waived: YYYY-MM-DD · {what is deferred} · reason: {why} → expires=YYYY-MM-DD
 ```
 
-Finding kinds for `auto:`: `dead-glob` · `doc-implicated` · `doc-lint` · `header-missing` · `index-row-missing` · `boundary-scan-suggested` · `doc-placement`.
+Finding kinds for `auto:`: `dead-glob` · `doc-implicated` · `doc-lint` · `header-missing` · `index-row-missing` · `package-rejected` · `frozen-record-edited`.

package/data/harnesses/delivery/harness.json

@@ -1,12 +1,12 @@
 {
   "harness": "delivery",
   "name": "delivery",
-  "version": "0.2.18",
+  "version": "0.2.20",
   "files": [
     ".prettierignore",
     ".prettierrc.json",
     ".vscode/settings.json"
   ],
   "seeds": [],
-  "digest": "a11ca1e20bd4"
+  "digest": "3bb0c6640019"
 }

package/data/harnesses/delivery/skills/documentation/templates/bookkeeping.md

@@ -1,13 +1,15 @@
 # Bookkeeping ledger (docs/operations/bookkeeping.md)
 
-Truth document with an unusual lifecycle: a **work queue**, not an archive. Rows are appended mechanically by the awareness hook (`auto:`) and deliberately by working sessions (`note:`), drained by the `bookkeeper` agent, and walled at Stop and commit — a commit is possible only when every row is resolved (deleted) or converted to `waived:`. What survives in git — `waived:` and `needs-session:` rows — is exactly what a PR reviewer should see.
+Truth document with an unusual lifecycle: a **work queue**, not an archive. Rows are appended mechanically by the awareness hook (`auto:`) and deliberately by working sessions (`note:`), drained by the `bookkeeper` agent, and walled at Stop, at commit, and in CI. What survives in git — `waived:` and `needs-session:` rows — is exactly what a PR reviewer should see.
+
+**Each wall reads the queue at its own width.** Stop takes the ending session's own rows, because accountability for an arc is per session. The commit gate takes only the rows **implicating that commit's staged files** — a row names the file its finding is about, and holding a commit behind rows raised by somebody else's edits is a wait nothing the committer may do can clear. CI takes every row on the branch, where there is no staged set to scope by. Fail-closed cases stay repo-wide at the commit gate: a row whose grammar names no path, a `needs-session:` row, an expired waiver, and a commit staging nothing at all.
 
 The row grammar is machine-read by the hooks and CI; keep it exact. A `waived:` row's `expires=` date is enforced: CI honors the waiver until the date, then fails. `waived:` rows whose finding kind is `dead-glob` double as the dead-glob allowlist.
 
 ```
 # Bookkeeping
 
-The shared work queue keeping documentation and code in sync — a queue, never an archive. Rows are appended mechanically (auto:) and by working sessions (note:), drained by the bookkeeper agent, and walled at commit: a commit is possible only when every row is either **resolved, which deletes it**, or converted to `waived:`. A drained row leaves no trace here; what it closed is recorded in the doc it corrected, and git history holds the row itself. Row grammar and lifecycle: the `documentation` skill's `templates/bookkeeping.md`. A `waived:` row carries `expires=` and is PR-reviewable history.
+The shared work queue keeping documentation and code in sync — a queue, never an archive. Rows are appended mechanically (auto:) and by working sessions (note:), drained by the bookkeeper agent, and walled at commit: a commit goes through only when every row **implicating one of its staged files** is either **resolved, which deletes it**, or converted to `waived:`. A row about files the commit does not touch belongs to whoever raised it; a row naming no file, and a commit staging none, block everything. A drained row leaves no trace here; what it closed is recorded in the doc it corrected, and git history holds the row itself. Row grammar and lifecycle: the `documentation` skill's `templates/bookkeeping.md`. A `waived:` row carries `expires=` and is PR-reviewable history.
 
 - auto: YYYY-MM-DD · {finding-kind} · {description} → {action} | sid={session_id} tp={transcript_path} ts={ISO}
 - note: YYYY-MM-DD · {area} · {one-line context only the session holds} → lands-in: {owning doc | backlog | memory} | sid=… tp=… ts=…
@@ -15,4 +17,4 @@ The shared work queue keeping documentation and code in sync — a queue, never
 - waived: YYYY-MM-DD · {what is deferred} · reason: {why} → expires=YYYY-MM-DD
 ```
 
-Finding kinds for `auto:`: `dead-glob` · `doc-implicated` · `doc-lint` · `header-missing` · `index-row-missing` · `boundary-scan-suggested` · `doc-placement`.
+Finding kinds for `auto:`: `dead-glob` · `doc-implicated` · `doc-lint` · `header-missing` · `index-row-missing` · `package-rejected` · `frozen-record-edited`.

package/data/harnesses/etna/harness.json

@@ -1,12 +1,12 @@
 {
   "harness": "etna",
   "name": "etna",
-  "version": "1.5.7",
+  "version": "1.5.9",
   "files": [
     ".prettierignore",
     ".prettierrc.json",
     ".vscode/settings.json"
   ],
   "seeds": [],
-  "digest": "5843b3511178"
+  "digest": "269767b3abdf"
 }

package/data/harnesses/etna/skills/documentation/templates/bookkeeping.md

@@ -1,13 +1,15 @@
 # Bookkeeping ledger (docs/operations/bookkeeping.md)
 
-Truth document with an unusual lifecycle: a **work queue**, not an archive. Rows are appended mechanically by the awareness hook (`auto:`) and deliberately by working sessions (`note:`), drained by the `bookkeeper` agent, and walled at Stop and commit — a commit is possible only when every row is resolved (deleted) or converted to `waived:`. What survives in git — `waived:` and `needs-session:` rows — is exactly what a PR reviewer should see.
+Truth document with an unusual lifecycle: a **work queue**, not an archive. Rows are appended mechanically by the awareness hook (`auto:`) and deliberately by working sessions (`note:`), drained by the `bookkeeper` agent, and walled at Stop, at commit, and in CI. What survives in git — `waived:` and `needs-session:` rows — is exactly what a PR reviewer should see.
+
+**Each wall reads the queue at its own width.** Stop takes the ending session's own rows, because accountability for an arc is per session. The commit gate takes only the rows **implicating that commit's staged files** — a row names the file its finding is about, and holding a commit behind rows raised by somebody else's edits is a wait nothing the committer may do can clear. CI takes every row on the branch, where there is no staged set to scope by. Fail-closed cases stay repo-wide at the commit gate: a row whose grammar names no path, a `needs-session:` row, an expired waiver, and a commit staging nothing at all.
 
 The row grammar is machine-read by the hooks and CI; keep it exact. A `waived:` row's `expires=` date is enforced: CI honors the waiver until the date, then fails. `waived:` rows whose finding kind is `dead-glob` double as the dead-glob allowlist.
 
 ```
 # Bookkeeping
 
-The shared work queue keeping documentation and code in sync — a queue, never an archive. Rows are appended mechanically (auto:) and by working sessions (note:), drained by the bookkeeper agent, and walled at commit: a commit is possible only when every row is either **resolved, which deletes it**, or converted to `waived:`. A drained row leaves no trace here; what it closed is recorded in the doc it corrected, and git history holds the row itself. Row grammar and lifecycle: the `documentation` skill's `templates/bookkeeping.md`. A `waived:` row carries `expires=` and is PR-reviewable history.
+The shared work queue keeping documentation and code in sync — a queue, never an archive. Rows are appended mechanically (auto:) and by working sessions (note:), drained by the bookkeeper agent, and walled at commit: a commit goes through only when every row **implicating one of its staged files** is either **resolved, which deletes it**, or converted to `waived:`. A row about files the commit does not touch belongs to whoever raised it; a row naming no file, and a commit staging none, block everything. A drained row leaves no trace here; what it closed is recorded in the doc it corrected, and git history holds the row itself. Row grammar and lifecycle: the `documentation` skill's `templates/bookkeeping.md`. A `waived:` row carries `expires=` and is PR-reviewable history.
 
 - auto: YYYY-MM-DD · {finding-kind} · {description} → {action} | sid={session_id} tp={transcript_path} ts={ISO}
 - note: YYYY-MM-DD · {area} · {one-line context only the session holds} → lands-in: {owning doc | backlog | memory} | sid=… tp=… ts=…
@@ -15,4 +17,4 @@ The shared work queue keeping documentation and code in sync — a queue, never
 - waived: YYYY-MM-DD · {what is deferred} · reason: {why} → expires=YYYY-MM-DD
 ```
 
-Finding kinds for `auto:`: `dead-glob` · `doc-implicated` · `doc-lint` · `header-missing` · `index-row-missing` · `boundary-scan-suggested` · `doc-placement`.
+Finding kinds for `auto:`: `dead-glob` · `doc-implicated` · `doc-lint` · `header-missing` · `index-row-missing` · `package-rejected` · `frozen-record-edited`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nurix/etna",
-  "version": "0.19.90",
+  "version": "0.19.92",
   "description": "Bootstrap a project with a Nurix harness — copies the harness's CLAUDE.md, skills, agents, rules, and hooks directly into the project from a bundled payload (no marketplace fetch, no network).",
   "type": "module",
   "bin": {
@@ -42,5 +42,5 @@
     "agent",
     "plugin"
   ],
-  "etnaFingerprint": "8d6f9b80d64d"
+  "etnaFingerprint": "a1cf8eb35f57"
 }