@nurix/etna 0.19.70 → 0.19.71

package/data/harness-index.json

@@ -1,5 +1,5 @@
 {
-    "fingerprint": "c39e1157ed11",
+    "fingerprint": "6492994f8d44",
     "harnesses": {
         "code": {
             "plugin": "code",

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

@@ -59,7 +59,7 @@ The ownership source of truth is the **union of every feature doc's `owns:` fron
 For each `owns:` glob across the feature docs:
 
 - Verify the glob matches existing files. Report globs matching nothing, deleted paths, and orphaned docs.
-- Flag **equal-specificity overlaps** — two feature docs whose `owns:` globs claim the same paths at the same specificity (an ambiguous owner). Surface as a question.
+- Flag **equal-specificity overlaps** — two feature docs whose `owns:` globs claim the same paths at the same specificity (an ambiguous owner). `node .claude/hooks/check-ownership.mjs` reports these mechanically alongside dead globs (`overlaps()` in `lib/ownership.mjs`); a glob at strictly higher specificity carving out of a broader `**` is the designed layering and is never flagged. Surface a real overlap as a question — narrowing someone's glob is an author's call, not remediation.
 - **Stamp `type:` where missing.** Every doc carries a `type:` genre key (enum = the `documentation` skill's template names); docs predating the key are stamped mechanically — the genre is readable from placement and shape (a `docs/features/` doc is `type: feature`, an AD is `type: architecture-decision`). Stamping is remediation, not a question; an ambiguous genre is backlogged instead.
 
 For each code symbol or path a doc explicitly **names** (function/export/route/type):

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

@@ -57,7 +57,7 @@ The ownership source of truth is the **union of every feature doc's `owns:` fron
 For each `owns:` glob across the feature docs:
 
 - Verify the glob matches existing files. Report globs matching nothing, deleted paths, and orphaned docs.
-- Flag **equal-specificity overlaps** — two feature docs whose `owns:` globs claim the same paths at the same specificity (an ambiguous owner). Surface as a question.
+- Flag **equal-specificity overlaps** — two feature docs whose `owns:` globs claim the same paths at the same specificity (an ambiguous owner). `node .claude/hooks/check-ownership.mjs` reports these mechanically alongside dead globs (`overlaps()` in `lib/ownership.mjs`); a glob at strictly higher specificity carving out of a broader `**` is the designed layering and is never flagged. Surface a real overlap as a question — narrowing someone's glob is an author's call, not remediation.
 - **Stamp `type:` where missing.** Every doc carries a `type:` genre key (enum = the `documentation` skill's template names); docs predating the key are stamped mechanically — the genre is readable from placement and shape (a `docs/features/` doc is `type: feature`, an AD is `type: architecture-decision`). Stamping is remediation, not a question; an ambiguous genre is backlogged instead.
 
 For each code symbol or path a doc explicitly **names** (function/export/route/type):

package/data/harnesses/code/harness.json

@@ -1,7 +1,7 @@
 {
   "harness": "code",
   "name": "code",
-  "version": "3.8.4",
+  "version": "3.9.1",
   "files": [
     ".prettierignore",
     ".prettierrc.json",
@@ -15,5 +15,5 @@
     "docs/memory/main.md",
     ".mcp.json"
   ],
-  "digest": "cfd0df4274c4"
+  "digest": "bc889c51aa02"
 }

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

@@ -1,22 +1,57 @@
-// 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.
+// harness/code/hooks/check-ownership.mjs — CI backstop for docs/features/ ownership. Two checks,
+// one walk of the tree:
+//
+//   1. dead-glob         — every owns: glob matches at least one file
+//   2. ownership-overlap — no two feature docs claim a common file at EQUAL specificity, which
+//                          leaves "most specific wins" unable to pick an owner
+//
+// Either is silenced by an unexpired `waived:` row in docs/operations/bookkeeping.md naming its
+// kind plus the offending glob (dead-glob) or the shared path (ownership-overlap) verbatim.
+// Exit 1 on anything unwaived.
+//
+// A glob at strictly HIGHER specificity carving a sub-path out of a broader `**` is the designed
+// layering, not a conflict — only an exact tie is reported.
 
-import { deadGlobs } from "./lib/ownership.mjs";
+import { deadGlobs, listRepoFiles, overlaps } 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)));
+const files = listRepoFiles(projectDir);
+const queue = readQueue(projectDir);
 
-if (unwaived.length === 0) {
-  console.log(`check-ownership: OK (${dead.length} dead glob(s), all waived or none)`);
+const dead = deadGlobs(projectDir, files);
+const deadWaivers = unexpiredWaivers(queue, "dead-glob", today);
+const unwaivedDead = dead.filter((d) => !deadWaivers.some((w) => w.body.includes(d.glob)));
+
+const conflicts = overlaps(projectDir, files);
+const overlapWaivers = unexpiredWaivers(queue, "ownership-overlap", today);
+const unwaivedOverlaps = conflicts.filter((c) => !overlapWaivers.some((w) => w.body.includes(c.example)));
+
+if (unwaivedDead.length === 0 && unwaivedOverlaps.length === 0) {
+  console.log(
+    `check-ownership: OK (${dead.length} dead glob(s), ${conflicts.length} equal-specificity overlap(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=.");
+
+if (unwaivedDead.length > 0) {
+  console.error(`check-ownership: ${unwaivedDead.length} unwaived dead owns: glob(s):`);
+  for (const d of unwaivedDead) 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=.");
+}
+
+if (unwaivedOverlaps.length > 0) {
+  console.error(`check-ownership: ${unwaivedOverlaps.length} unwaived equal-specificity overlap(s):`);
+  for (const c of unwaivedOverlaps) {
+    console.error(`  ${c.example}`);
+    console.error(`    ${c.a.glob} → ${c.a.doc}`);
+    console.error(`    ${c.b.glob} → ${c.b.doc}`);
+  }
+  console.error(
+    "Narrow one doc's glob so a single owner wins, or add a `waived:` ownership-overlap row naming the shared path with reason + expires=.",
+  );
+}
+
 process.exit(1);

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

@@ -242,3 +242,60 @@ export function deadGlobs(projectDir, repoFiles) {
   }
   return dead;
 }
+
+// Specificity of an owns: glob as a (literal, wildcard) segment tuple. The ownership rule is
+// "most specific wins", so a glob at strictly higher specificity legitimately carves a sub-path
+// out of a broader `**` — that is the designed layering, never a conflict. Only an exact tie
+// leaves the owner ambiguous, which is what `overlaps()` reports.
+export function specificity(glob) {
+  let literal = 0;
+  let wildcard = 0;
+  for (const segment of String(glob).split("/")) {
+    if (segment === "") continue;
+    if (segment.includes("*") || segment.includes("?")) wildcard++;
+    else literal++;
+  }
+  return { literal, wildcard };
+}
+
+// Two globs are equally specific when both tuple components match.
+export function sameSpecificity(a, b) {
+  return a.literal === b.literal && a.wildcard === b.wildcard;
+}
+
+// Cross-doc equal-specificity ownership conflicts: two globs from DIFFERENT feature docs that
+// match a common file at the same specificity, so "most specific wins" cannot pick an owner and
+// the path is doubly owned. Returns [{ a: {doc, glob}, b: {doc, glob}, example }].
+//
+// This is the mechanical half of a rule the harness has always stated and never checked — the
+// `documentation` skill's frontmatter reference calls an equal-specificity overlap "an ownership
+// conflict to resolve", and the `maintenance` agent is told to flag one. Without this, both had
+// to be enforced by eye.
+export function overlaps(projectDir, repoFiles) {
+  const files = repoFiles || listRepoFiles(projectDir);
+  const owners = [];
+  for (const entry of scanFeatureDocs(projectDir)) {
+    if (entry.status === "deprecated") continue;
+    for (const glob of entry.owns) {
+      const re = globToRegExp(glob);
+      owners.push({ doc: entry.doc, glob, spec: specificity(glob), files: files.filter((f) => re.test(f)) });
+    }
+  }
+  return pairOverlaps(owners);
+}
+
+// The pure core of `overlaps()`, split out so tests can feed synthetic owners without a repo tree.
+export function pairOverlaps(owners) {
+  const found = [];
+  for (let i = 0; i < owners.length; i++) {
+    for (let j = i + 1; j < owners.length; j++) {
+      const a = owners[i];
+      const b = owners[j];
+      if (a.doc === b.doc) continue;
+      if (!sameSpecificity(a.spec, b.spec)) continue;
+      const example = a.files.find((f) => b.files.includes(f));
+      if (example) found.push({ a: { doc: a.doc, glob: a.glob }, b: { doc: b.doc, glob: b.glob }, example });
+    }
+  }
+  return found;
+}

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

@@ -59,7 +59,7 @@ The ownership source of truth is the **union of every feature doc's `owns:` fron
 For each `owns:` glob across the feature docs:
 
 - Verify the glob matches existing files. Report globs matching nothing, deleted paths, and orphaned docs.
-- Flag **equal-specificity overlaps** — two feature docs whose `owns:` globs claim the same paths at the same specificity (an ambiguous owner). Surface as a question.
+- Flag **equal-specificity overlaps** — two feature docs whose `owns:` globs claim the same paths at the same specificity (an ambiguous owner). `node .claude/hooks/check-ownership.mjs` reports these mechanically alongside dead globs (`overlaps()` in `lib/ownership.mjs`); a glob at strictly higher specificity carving out of a broader `**` is the designed layering and is never flagged. Surface a real overlap as a question — narrowing someone's glob is an author's call, not remediation.
 - **Stamp `type:` where missing.** Every doc carries a `type:` genre key (enum = the `documentation` skill's template names); docs predating the key are stamped mechanically — the genre is readable from placement and shape (a `docs/features/` doc is `type: feature`, an AD is `type: architecture-decision`). Stamping is remediation, not a question; an ambiguous genre is backlogged instead.
 
 For each code symbol or path a doc explicitly **names** (function/export/route/type):

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

@@ -57,7 +57,7 @@ The ownership source of truth is the **union of every feature doc's `owns:` fron
 For each `owns:` glob across the feature docs:
 
 - Verify the glob matches existing files. Report globs matching nothing, deleted paths, and orphaned docs.
-- Flag **equal-specificity overlaps** — two feature docs whose `owns:` globs claim the same paths at the same specificity (an ambiguous owner). Surface as a question.
+- Flag **equal-specificity overlaps** — two feature docs whose `owns:` globs claim the same paths at the same specificity (an ambiguous owner). `node .claude/hooks/check-ownership.mjs` reports these mechanically alongside dead globs (`overlaps()` in `lib/ownership.mjs`); a glob at strictly higher specificity carving out of a broader `**` is the designed layering and is never flagged. Surface a real overlap as a question — narrowing someone's glob is an author's call, not remediation.
 - **Stamp `type:` where missing.** Every doc carries a `type:` genre key (enum = the `documentation` skill's template names); docs predating the key are stamped mechanically — the genre is readable from placement and shape (a `docs/features/` doc is `type: feature`, an AD is `type: architecture-decision`). Stamping is remediation, not a question; an ambiguous genre is backlogged instead.
 
 For each code symbol or path a doc explicitly **names** (function/export/route/type):

package/data/harnesses/delivery/harness.json

@@ -1,12 +1,12 @@
 {
   "harness": "delivery",
   "name": "delivery",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "files": [
     ".prettierignore",
     ".prettierrc.json",
     ".vscode/settings.json"
   ],
   "seeds": [],
-  "digest": "bfd105b1ff3c"
+  "digest": "cebc16bda479"
 }

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

@@ -59,7 +59,7 @@ The ownership source of truth is the **union of every feature doc's `owns:` fron
 For each `owns:` glob across the feature docs:
 
 - Verify the glob matches existing files. Report globs matching nothing, deleted paths, and orphaned docs.
-- Flag **equal-specificity overlaps** — two feature docs whose `owns:` globs claim the same paths at the same specificity (an ambiguous owner). Surface as a question.
+- Flag **equal-specificity overlaps** — two feature docs whose `owns:` globs claim the same paths at the same specificity (an ambiguous owner). `node .claude/hooks/check-ownership.mjs` reports these mechanically alongside dead globs (`overlaps()` in `lib/ownership.mjs`); a glob at strictly higher specificity carving out of a broader `**` is the designed layering and is never flagged. Surface a real overlap as a question — narrowing someone's glob is an author's call, not remediation.
 - **Stamp `type:` where missing.** Every doc carries a `type:` genre key (enum = the `documentation` skill's template names); docs predating the key are stamped mechanically — the genre is readable from placement and shape (a `docs/features/` doc is `type: feature`, an AD is `type: architecture-decision`). Stamping is remediation, not a question; an ambiguous genre is backlogged instead.
 
 For each code symbol or path a doc explicitly **names** (function/export/route/type):

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

@@ -57,7 +57,7 @@ The ownership source of truth is the **union of every feature doc's `owns:` fron
 For each `owns:` glob across the feature docs:
 
 - Verify the glob matches existing files. Report globs matching nothing, deleted paths, and orphaned docs.
-- Flag **equal-specificity overlaps** — two feature docs whose `owns:` globs claim the same paths at the same specificity (an ambiguous owner). Surface as a question.
+- Flag **equal-specificity overlaps** — two feature docs whose `owns:` globs claim the same paths at the same specificity (an ambiguous owner). `node .claude/hooks/check-ownership.mjs` reports these mechanically alongside dead globs (`overlaps()` in `lib/ownership.mjs`); a glob at strictly higher specificity carving out of a broader `**` is the designed layering and is never flagged. Surface a real overlap as a question — narrowing someone's glob is an author's call, not remediation.
 - **Stamp `type:` where missing.** Every doc carries a `type:` genre key (enum = the `documentation` skill's template names); docs predating the key are stamped mechanically — the genre is readable from placement and shape (a `docs/features/` doc is `type: feature`, an AD is `type: architecture-decision`). Stamping is remediation, not a question; an ambiguous genre is backlogged instead.
 
 For each code symbol or path a doc explicitly **names** (function/export/route/type):

package/data/harnesses/etna/harness.json

@@ -1,12 +1,12 @@
 {
   "harness": "etna",
   "name": "etna",
-  "version": "1.4.7",
+  "version": "1.4.8",
   "files": [
     ".prettierignore",
     ".prettierrc.json",
     ".vscode/settings.json"
   ],
   "seeds": [],
-  "digest": "593183c2c83c"
+  "digest": "e69567759f7b"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nurix/etna",
-    "version": "0.19.70",
+    "version": "0.19.71",
     "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": "c39e1157ed11"
+    "etnaFingerprint": "6492994f8d44"
 }