@event4u/agent-config 16.3.0 → 16.4.0

package/dist/cli-delegate/{chunk-NXEILF2K.js → chunk-F3QDG2GT.js}

@@ -4,6 +4,15 @@ import {
   entryCommands,
   isManagedEntry
 } from "./chunk-DEIV7XP7.js";
+import {
+  manifest_path,
+  readRecordedHashes
+} from "./chunk-OKJUIAPS.js";
+import {
+  COUNCIL_CONFIG_ENV,
+  load_council_config,
+  resolve_config_path
+} from "./chunk-WQWXGIWB.js";
 import {
   scanText
 } from "./chunk-KB5FZ655.js";
@@ -21,32 +30,32 @@ import {
   report_child_scanned,
   scan_file
 } from "./chunk-JQOM7TTM.js";
-import {
-  manifest_path,
-  readRecordedHashes
-} from "./chunk-OKJUIAPS.js";
 import {
   DeadScopeError,
   assertScanned
 } from "./chunk-I3EIN2YG.js";
+import {
+  readHookStdin
+} from "./chunk-F7DQWYR5.js";
 import {
   require_dist
 } from "./chunk-OY53J6II.js";
-import {
-  resolvePackageRoot
-} from "./chunk-MCJYCQPF.js";
 import {
   SRC_SKILLS
 } from "./chunk-YCU3TIXH.js";
+import {
+  resolvePackageRoot
+} from "./chunk-MCJYCQPF.js";
 import {
   __toESM
 } from "./chunk-J55WI3RR.js";
 
 // src/scripts/_cli/cmd_doctor_neighbours.ts
 var YAML = __toESM(require_dist(), 1);
-import * as fs9 from "node:fs";
-import * as path9 from "node:path";
-import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL5 } from "node:url";
+import { spawnSync } from "node:child_process";
+import * as fs11 from "node:fs";
+import * as path10 from "node:path";
+import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL6 } from "node:url";
 
 // src/scripts/_lib/neighbour_census.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -1235,20 +1244,335 @@ function writeScanCache(file, entries) {
   }
 }
 
-// src/scripts/audit_skill_overlap.ts
-var import_yaml2 = __toESM(require_dist(), 1);
-import { createHash as createHash3 } from "node:crypto";
+// src/scripts/_lib/neighbour_contradictions.ts
 import * as fs8 from "node:fs";
+var RANK_PROJECT = 3;
+var RANK_SUITE = 4;
+var RANK_NEIGHBOUR_ALWAYS_ON = 6;
+var RANK_NEIGHBOUR_SKILL = 7;
+var RANK_LABEL = {
+  [RANK_PROJECT]: "project instruction file",
+  [RANK_SUITE]: "this suite's routed guidance",
+  [RANK_NEIGHBOUR_ALWAYS_ON]: "neighbour's always-on text",
+  [RANK_NEIGHBOUR_SKILL]: "neighbour skill body (discoverable)"
+};
+var NEGATION = /\b(never|don't|do not|must not|mustn't|should not|shouldn't|avoid|stop)\b/iu;
+var DIRECTIVE_WORD = /\b(always|must|should|never|don't|do not|avoid)\b/iu;
+var NON_IMPERATIVE_START = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "we",
+  "you",
+  "i",
+  "our",
+  "they",
+  "there",
+  "when",
+  "if",
+  "see",
+  "for",
+  "in",
+  "on",
+  "as",
+  "by",
+  "with",
+  "from"
+]);
+var STOP = /* @__PURE__ */ new Set([
+  "always",
+  "never",
+  "must",
+  "should",
+  "avoid",
+  "stop",
+  "don",
+  "with",
+  "without",
+  "that",
+  "this",
+  "they",
+  "them",
+  "then",
+  "than",
+  "into",
+  "from",
+  "your",
+  "when",
+  "what",
+  "will",
+  "each",
+  "every",
+  "only",
+  "also",
+  "here",
+  "there",
+  "have",
+  "been",
+  "more",
+  "some",
+  "such",
+  "like",
+  "just"
+]);
+function stem(word) {
+  let w = word.toLowerCase().replace(/[^a-z]/gu, "");
+  for (const suffix of ["ing", "ed", "es", "s"]) {
+    if (w.length > suffix.length + 3 && w.endsWith(suffix)) {
+      w = w.slice(0, -suffix.length);
+      break;
+    }
+  }
+  return w;
+}
+function isDirective(text) {
+  if (DIRECTIVE_WORD.test(text)) return true;
+  const first = (text.split(/\s+/u)[0] ?? "").toLowerCase().replace(/[^a-z']/gu, "");
+  return first.length > 0 && !NON_IMPERATIVE_START.has(first);
+}
+function extractInstructions(source, body) {
+  let text;
+  try {
+    text = body ?? fs8.readFileSync(source.file, "utf-8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  let fenced = false;
+  let frontmatter = false;
+  text.split("\n").forEach((raw, i) => {
+    const line = raw.trim();
+    if (i === 0 && line === "---") {
+      frontmatter = true;
+      return;
+    }
+    if (frontmatter) {
+      if (line === "---") frontmatter = false;
+      return;
+    }
+    if (line.startsWith("```") || line.startsWith("~~~")) {
+      fenced = !fenced;
+      return;
+    }
+    if (fenced || line === "" || line.startsWith("#") || line.startsWith("|") || line.startsWith(">")) return;
+    const clean = line.replace(/^([-*+]|\d+\.)\s+/u, "").replace(/[*_`]/gu, "");
+    if (clean.split(/\s+/u).length < 3 || !isDirective(clean)) return;
+    const stems = new Set(
+      clean.split(/\s+/u).map(stem).filter((s) => s.length >= 4 && !STOP.has(s))
+    );
+    out.push({ source, line: i + 1, text: clean, negative: NEGATION.test(clean), stems });
+  });
+  return out;
+}
+function where(l) {
+  return `${l.source.label}:${l.line}`;
+}
+function modalityPairs(lines, cap = 20) {
+  const out = [];
+  for (let i = 0; i < lines.length && out.length < cap; i += 1) {
+    for (let j = i + 1; j < lines.length && out.length < cap; j += 1) {
+      const x = lines[i];
+      const y = lines[j];
+      if (x.source.rank === y.source.rank || x.negative === y.negative) continue;
+      const shared = [...x.stems].filter((s) => y.stems.has(s)).sort();
+      if (shared.length === 0) continue;
+      const [hi, lo] = x.source.rank <= y.source.rank ? [x, y] : [y, x];
+      out.push({
+        kind: "opposite-modality",
+        a: { label: where(hi), rank: hi.source.rank, text: hi.text },
+        b: { label: where(lo), rank: lo.source.rank, text: lo.text },
+        subject: shared[0]
+      });
+    }
+  }
+  return out;
+}
+function collisionPair(neighbourQualified, ourName) {
+  return {
+    kind: "name-collision",
+    a: { label: `suite:${ourName}`, rank: RANK_SUITE, text: `this suite's skill \`${ourName}\`` },
+    b: {
+      label: neighbourQualified,
+      rank: RANK_NEIGHBOUR_SKILL,
+      text: `neighbour skill \`${neighbourQualified}\``
+    },
+    subject: ourName
+  };
+}
+function winnerBy21(p) {
+  const w = p.a.rank <= p.b.rank ? p.a : p.b;
+  return `${w.label} (rank ${w.rank}, ${RANK_LABEL[w.rank] ?? "unranked"})`;
+}
+function seatPrompt(pairs, rubric) {
+  const rows = pairs.map(
+    (p, i) => `PAIR ${i + 1} (${p.kind}, subject "${p.subject}")
+  A [${p.a.label}]: ${p.a.text}
+  B [${p.b.label}]: ${p.b.text}`
+  );
+  return [
+    "# Neighbour contradiction review",
+    "",
+    "For each pair, decide whether A and B give an agent instructions that cannot both be followed.",
+    "Answer one line per pair, exactly `PAIR <n>: contradiction`, `PAIR <n>: compatible` or `PAIR <n>: unclear`,",
+    "then at most one sentence of reason on the same line. The rubric for which source wins is below; you do not",
+    "need to restate it.",
+    "",
+    "## Rubric \u2014 neighbour-precedence",
+    "",
+    rubric.trim(),
+    "",
+    "## Pairs",
+    "",
+    ...rows,
+    ""
+  ].join("\n");
+}
+function parseVerdicts(text, count) {
+  const out = Array.from({ length: count }, () => "unclear");
+  for (const m of text.matchAll(/PAIR\s+(\d+)\s*:\s*(contradiction|compatible|unclear)/giu)) {
+    const n = Number(m[1]) - 1;
+    if (n >= 0 && n < count) out[n] = (m[2] ?? "unclear").toLowerCase();
+  }
+  return out;
+}
+function reviewRows(pairs, verdicts) {
+  return pairs.map((p, i) => ({
+    pair: `${p.a.label} "${p.a.text}" \xD7 ${p.b.label} "${p.b.text}"`,
+    verdict: verdicts[i] ?? "unclear",
+    wins: winnerBy21(p)
+  }));
+}
+function renderReview(rows) {
+  if (rows.length === 0) return ["  no candidate pairs \u2014 nothing to review"];
+  return ["  pair | verdict | which wins by 2.1", ...rows.map((r) => `  ${r.pair} | ${r.verdict} | ${r.wins}`)];
+}
+
+// src/scripts/council_availability_hook.ts
+import * as fs9 from "node:fs";
 import * as path8 from "node:path";
 import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL4 } from "node:url";
-var _HERE = fileURLToPath4(import.meta.url);
-var ROOT2 = path8.resolve(path8.dirname(_HERE), "..", "..");
-var REPORT_DIR = path8.join(ROOT2, "agents", "reports");
+var EXIT_ALLOW = 0;
+function resolveAvailability(cwd, env) {
+  let p;
+  try {
+    p = String(resolve_config_path(cwd, { env }));
+  } catch {
+    return null;
+  }
+  const exists = fs9.existsSync(p);
+  const provenance = env[COUNCIL_CONFIG_ENV] ? "env-override" : "user-global";
+  if (!exists) {
+    return { configured: false, path: p, exists: false, provenance, membersEnabled: 0, memberNames: [] };
+  }
+  try {
+    const cfg = load_council_config(p);
+    const enabled = [...cfg.members.entries()].filter(([, m]) => m.enabled).map(([n]) => n);
+    return {
+      configured: cfg.enabled && enabled.length > 0,
+      path: p,
+      exists: true,
+      provenance,
+      membersEnabled: enabled.length,
+      memberNames: enabled
+    };
+  } catch {
+    return { configured: false, path: p, exists: true, provenance, membersEnabled: 0, memberNames: [] };
+  }
+}
+function buildFact(a) {
+  const head = a.configured ? `An AI council IS configured: ${String(a.membersEnabled)} enabled member(s) \u2014 ${a.memberNames.join(", ")}.` : a.exists ? "An AI council config exists but is NOT usable (unreadable, disabled, or no enabled member)." : "No AI council is configured on this machine.";
+  return [
+    "<council-availability>",
+    head,
+    `Resolved from ${a.provenance}: ${a.path}`,
+    "The project tree is NEVER searched for council config (ADR-104), and the",
+    "config has not lived in `.agent-settings.yml` since the Phase-0 migration.",
+    "So do NOT infer council availability from any project file, in either",
+    "direction \u2014 this line is the answer, and `agent-config council:status`",
+    "re-checks it on demand without spending anything.",
+    a.configured ? "Never announce that no council is configured, and never substitute a weaker path on that basis." : "A substitute is legitimate here \u2014 say which one you are using and why.",
+    "</council-availability>"
+  ].join("\n");
+}
+function _workspaceRoot(env) {
+  for (const key of ["project_dir", "projectDir", "cwd", "workspace_root"]) {
+    const v = env[key];
+    if (typeof v === "string" && v.trim() !== "") {
+      return v;
+    }
+  }
+  return process.cwd();
+}
+function run(stdin, options = {}) {
+  let envelope = {};
+  if (stdin.trim() !== "") {
+    try {
+      const parsed = JSON.parse(stdin);
+      if (parsed !== null && typeof parsed === "object") {
+        envelope = parsed;
+      }
+    } catch {
+      return EXIT_ALLOW;
+    }
+  }
+  const event = envelope["event"];
+  const slot = typeof event === "string" && event !== "" ? event : "session_start";
+  if (slot !== "session_start") {
+    return EXIT_ALLOW;
+  }
+  const a = resolveAvailability(_workspaceRoot(envelope), options.env ?? process.env);
+  if (a === null) {
+    return EXIT_ALLOW;
+  }
+  process.stdout.write(
+    `${JSON.stringify({
+      decision: "allow",
+      reason: `council-availability: ${a.configured ? "configured" : "not configured"}`,
+      context: buildFact(a)
+    })}
+`
+  );
+  return EXIT_ALLOW;
+}
+function main4(argv) {
+  const args = argv ?? process.argv.slice(2);
+  let env = process.env;
+  void args;
+  return run(readHookStdin(), { env });
+}
+function _isCliEntry4() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  return import.meta.url === pathToFileURL4(path8.resolve(process.argv[1])).href;
+}
+if (_isCliEntry4()) {
+  process.exit(main4());
+}
+
+// src/scripts/audit_skill_overlap.ts
+var import_yaml2 = __toESM(require_dist(), 1);
+import { createHash as createHash3 } from "node:crypto";
+import * as fs10 from "node:fs";
+import * as path9 from "node:path";
+import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL5 } from "node:url";
+var _HERE = fileURLToPath5(import.meta.url);
+var ROOT2 = path9.resolve(path9.dirname(_HERE), "..", "..");
+var REPORT_DIR = path9.join(ROOT2, "agents", "reports");
 var OUT_JSON_NAME = "skill-overlap.json";
 var OUT_MD_NAME = "skill-overlap.md";
-var OUT_JSON = path8.join(REPORT_DIR, OUT_JSON_NAME);
-var OUT_MD = path8.join(REPORT_DIR, OUT_MD_NAME);
-var ALLOWLIST = path8.join(ROOT2, "src", "scripts", "audit_skill_overlap_allowlist.json");
+var OUT_JSON = path9.join(REPORT_DIR, OUT_JSON_NAME);
+var OUT_MD = path9.join(REPORT_DIR, OUT_MD_NAME);
+var ALLOWLIST = path9.join(ROOT2, "src", "scripts", "audit_skill_overlap_allowlist.json");
 var CROSS_CACHE_NAME = "neighbour-overlap.json";
 var ALLOWLIST_CAP = 20;
 var FM_RE = /^---\n([\s\S]*?)\n---/m;
@@ -1320,14 +1644,14 @@ var STOPWORDS = /* @__PURE__ */ new Set([
 ]);
 function _isDir(p) {
   try {
-    return fs8.statSync(p).isDirectory();
+    return fs10.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _isFile(p) {
   try {
-    return fs8.statSync(p).isFile();
+    return fs10.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -1375,7 +1699,7 @@ function _cosine(a, b) {
   return da && db ? num / (da * db) : 0;
 }
 function _parse(md, field = "body") {
-  const text = fs8.readFileSync(md, "utf-8");
+  const text = fs10.readFileSync(md, "utf-8");
   let fm = {};
   let body = text;
   const m = FM_RE.exec(text);
@@ -1393,27 +1717,27 @@ function _parse(md, field = "body") {
   const descVal = isObj ? fm["description"] : null;
   const source = field === "description" ? descVal ? String(descVal) : "" : body;
   return {
-    name: name ? String(name) : path8.basename(path8.dirname(md)),
+    name: name ? String(name) : path9.basename(path9.dirname(md)),
     relpath: _relPosix(md, ROOT2),
-    abspath: path8.resolve(md),
+    abspath: path9.resolve(md),
     packs: Array.isArray(packsVal) ? new Set(packsVal.map((x) => String(x))) : /* @__PURE__ */ new Set(),
     vector: _keyword_vector(source)
   };
 }
 function _relPosix(child, root) {
-  return path8.relative(root, child).split(path8.sep).join("/");
+  return path9.relative(root, child).split(path9.sep).join("/");
 }
 function _rglobSkillMd(root) {
   const out = [];
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs8.readdirSync(dir, { withFileTypes: true });
+      entries = fs10.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const ent of entries) {
-      const full = path8.join(dir, ent.name);
+      const full = path9.join(dir, ent.name);
       if (ent.name === "SKILL.md") {
         out.push(full);
       }
@@ -1427,8 +1751,8 @@ function _rglobSkillMd(root) {
   return out;
 }
 function _pathlibCompare(a, b) {
-  const pa = a.split(path8.sep);
-  const pb = b.split(path8.sep);
+  const pa = a.split(path9.sep);
+  const pb = b.split(path9.sep);
   const n = Math.min(pa.length, pb.length);
   for (let i = 0; i < n; i++) {
     const x = pa[i];
@@ -1443,10 +1767,10 @@ function collect(root = _default_skill_root(), field = "body") {
   const skills = [];
   const seen = /* @__PURE__ */ new Set();
   for (const md of _rglobSkillMd(root)) {
-    if (md.split(path8.sep).includes("_archive")) {
+    if (md.split(path9.sep).includes("_archive")) {
       continue;
     }
-    const key = path8.basename(path8.dirname(md));
+    const key = path9.basename(path9.dirname(md));
     if (seen.has(key)) {
       continue;
     }
@@ -1500,7 +1824,7 @@ function find_pairs(skills, threshold) {
   return stableSort(pairs, (p) => [p.same_domain ? 0 : 1, -p.similarity]);
 }
 function skillMdsUnder(root) {
-  return _rglobSkillMd(root).filter((md) => !md.split(path8.sep).includes("_archive"));
+  return _rglobSkillMd(root).filter((md) => !md.split(path9.sep).includes("_archive"));
 }
 function crossPairsForFiles(neighbourFiles, ourRoot, threshold = OVERLAP_THRESHOLD, field = "body") {
   const theirs = [];
@@ -1554,11 +1878,11 @@ ${field}
     for (const md of side) {
       let bytes;
       try {
-        bytes = fs8.readFileSync(md);
+        bytes = fs10.readFileSync(md);
       } catch {
         continue;
       }
-      h.update(path8.resolve(md));
+      h.update(path9.resolve(md));
       h.update("\0");
       h.update(createHash3("sha256").update(bytes).digest("hex"));
       h.update("\n");
@@ -1569,7 +1893,7 @@ ${field}
 function cachedCrossRootPairs(neighbourFiles, ourRoot, cacheFile, threshold = OVERLAP_THRESHOLD, field = "body") {
   const digest = censusDigest(neighbourFiles, ourRoot, threshold, field);
   try {
-    const parsed = JSON.parse(fs8.readFileSync(cacheFile, "utf-8"));
+    const parsed = JSON.parse(fs10.readFileSync(cacheFile, "utf-8"));
     if (parsed.digest === digest && Array.isArray(parsed.pairs)) {
       return { pairs: parsed.pairs, digest, cached: true };
     }
@@ -1578,8 +1902,8 @@ function cachedCrossRootPairs(neighbourFiles, ourRoot, cacheFile, threshold = OV
   const pairs = crossPairsForFiles(neighbourFiles, ourRoot, threshold, field);
   const payload = { schema_version: 1, digest, threshold, pairs };
   try {
-    fs8.mkdirSync(path8.dirname(cacheFile), { recursive: true });
-    fs8.writeFileSync(cacheFile, `${JSON.stringify(payload, null, 2)}
+    fs10.mkdirSync(path9.dirname(cacheFile), { recursive: true });
+    fs10.writeFileSync(cacheFile, `${JSON.stringify(payload, null, 2)}
 `, "utf-8");
   } catch {
   }
@@ -1703,7 +2027,7 @@ var FloatTag = class {
   }
   value;
 };
-function main4(argv = null) {
+function main5(argv = null) {
   const args = parse_args4(argv ?? process.argv.slice(2));
   const root = args.root ?? _default_skill_root();
   if (args.neighbourRoot !== void 0) {
@@ -1729,16 +2053,16 @@ function main4(argv = null) {
 `);
   const pairs = find_pairs(skills, args.threshold);
   const outDir = args.outDir ?? REPORT_DIR;
-  const outJson = path8.join(outDir, OUT_JSON_NAME);
-  const outMd = path8.join(outDir, OUT_MD_NAME);
-  fs8.mkdirSync(outDir, { recursive: true });
+  const outJson = path9.join(outDir, OUT_JSON_NAME);
+  const outMd = path9.join(outDir, OUT_MD_NAME);
+  fs10.mkdirSync(outDir, { recursive: true });
   const jsonObj = {
     threshold: new FloatTag(args.threshold),
     skills_scanned: skills.length,
     pairs: pairs.map(_pairToJson)
   };
-  fs8.writeFileSync(outJson, _dumpsWithFloats(jsonObj), "utf-8");
-  fs8.writeFileSync(outMd, render_md(skills, pairs, args.threshold, args.field), "utf-8");
+  fs10.writeFileSync(outJson, _dumpsWithFloats(jsonObj), "utf-8");
+  fs10.writeFileSync(outMd, render_md(skills, pairs, args.threshold, args.field), "utf-8");
   const merge = pairs.filter((p) => p.same_domain);
   if (!args.quiet) {
     process.stdout.write(
@@ -1796,7 +2120,7 @@ function main4(argv = null) {
 function _mainCrossRoot(args, ourRoot) {
   const neighbourRoot = args.neighbourRoot;
   const outDir = args.outDir ?? REPORT_DIR;
-  const cacheFile = args.crossCache ?? path8.join(outDir, CROSS_CACHE_NAME);
+  const cacheFile = args.crossCache ?? path9.join(outDir, CROSS_CACHE_NAME);
   const { pairs, digest, cached } = cachedCrossRootPairs(
     skillMdsUnder(neighbourRoot),
     ourRoot,
@@ -1835,7 +2159,7 @@ function _loadAllowlist(file) {
   if (!_isFile(file)) {
     return /* @__PURE__ */ new Set();
   }
-  const data = JSON.parse(fs8.readFileSync(file, "utf-8"));
+  const data = JSON.parse(fs10.readFileSync(file, "utf-8"));
   const entries = Array.isArray(data.entries) ? data.entries : [];
   if (entries.length > ALLOWLIST_CAP) {
     throw new Error(
@@ -1921,7 +2245,7 @@ function parse_args4(argv) {
       args.strict = true;
     } else if (a === "--allowlist" || a.startsWith("--allowlist=")) {
       const inline = a.startsWith("--allowlist=") ? a.slice("--allowlist=".length) : void 0;
-      args.allowlist = path8.resolve(ROOT2, takeValue("--allowlist", inline, () => argv[++i]));
+      args.allowlist = path9.resolve(ROOT2, takeValue("--allowlist", inline, () => argv[++i]));
     } else if (a === "--descriptions") {
       args.field = "description";
     } else if (a === "--print-table") {
@@ -1931,19 +2255,19 @@ function parse_args4(argv) {
       args.threshold = Number(takeValue("--threshold", inline, () => argv[++i]));
     } else if (a === "--neighbour-root" || a.startsWith("--neighbour-root=")) {
       const inline = a.startsWith("--neighbour-root=") ? a.slice("--neighbour-root=".length) : void 0;
-      args.neighbourRoot = path8.resolve(
+      args.neighbourRoot = path9.resolve(
         ROOT2,
         takeValue("--neighbour-root", inline, () => argv[++i])
       );
     } else if (a === "--cross-cache" || a.startsWith("--cross-cache=")) {
       const inline = a.startsWith("--cross-cache=") ? a.slice("--cross-cache=".length) : void 0;
-      args.crossCache = path8.resolve(ROOT2, takeValue("--cross-cache", inline, () => argv[++i]));
+      args.crossCache = path9.resolve(ROOT2, takeValue("--cross-cache", inline, () => argv[++i]));
     } else if (a === "--root" || a.startsWith("--root=")) {
       const inline = a.startsWith("--root=") ? a.slice("--root=".length) : void 0;
-      args.root = path8.resolve(ROOT2, takeValue("--root", inline, () => argv[++i]));
+      args.root = path9.resolve(ROOT2, takeValue("--root", inline, () => argv[++i]));
     } else if (a === "--out-dir" || a.startsWith("--out-dir=")) {
       const inline = a.startsWith("--out-dir=") ? a.slice("--out-dir=".length) : void 0;
-      args.outDir = path8.resolve(ROOT2, takeValue("--out-dir", inline, () => argv[++i]));
+      args.outDir = path9.resolve(ROOT2, takeValue("--out-dir", inline, () => argv[++i]));
     } else {
       process.stderr.write(`unrecognized arguments: ${a}
 `);
@@ -1952,32 +2276,32 @@ function parse_args4(argv) {
   }
   return args;
 }
-function _isCliEntry4() {
+function _isCliEntry5() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL4(path8.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL5(path9.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs8.realpathSync(fileURLToPath4(import.meta.url));
-    const argv = fs8.realpathSync(path8.resolve(process.argv[1]));
+    const here = fs10.realpathSync(fileURLToPath5(import.meta.url));
+    const argv = fs10.realpathSync(path9.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var _isMain = _isCliEntry4();
+var _isMain = _isCliEntry5();
 if (_isMain) {
-  process.exitCode = main4();
+  process.exitCode = main5();
 }
 
 // src/scripts/_cli/cmd_doctor_neighbours.ts
 function gatedEvents(packageRoot) {
   try {
-    const file = path9.join(packageRoot, "src", "scripts", "hook_manifest.yaml");
-    const doc = YAML.parse(fs9.readFileSync(file, "utf-8"));
+    const file = path10.join(packageRoot, "src", "scripts", "hook_manifest.yaml");
+    const doc = YAML.parse(fs11.readFileSync(file, "utf-8"));
     return gatedEventsFrom(doc, doc.native_event_aliases ?? {});
   } catch {
     return /* @__PURE__ */ new Set();
@@ -1986,7 +2310,7 @@ function gatedEvents(packageRoot) {
 function ourSkillNames(packageRoot) {
   try {
     return new Set(
-      fs9.readdirSync(path9.join(packageRoot, "src", "skills"), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name)
+      fs11.readdirSync(path10.join(packageRoot, "src", "skills"), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name)
     );
   } catch {
     return /* @__PURE__ */ new Set();
@@ -2003,21 +2327,21 @@ function runCensus(projectRoot, packageRoot, homeRoot) {
   };
   const base = {
     gatedEvents: gatedEvents(packageRoot),
-    templatesRoot: path9.join(packageRoot, "src", "agent-src", "templates"),
+    templatesRoot: path10.join(packageRoot, "src", "agent-src", "templates"),
     ourSkillNames: ourSkillNames(packageRoot),
     packageRoot,
     scan,
     ...homeRoot === void 0 ? {} : { homeRoot }
   };
   const first = census(projectRoot, base);
-  const ourRoot = path9.join(packageRoot, "src", "skills");
+  const ourRoot = path10.join(packageRoot, "src", "skills");
   let overlaps = /* @__PURE__ */ new Map();
-  if (first.skills.length > 0 && fs9.existsSync(ourRoot)) {
+  if (first.skills.length > 0 && fs11.existsSync(ourRoot)) {
     try {
       const { pairs } = cachedCrossRootPairs(
         first.skills.map((s) => s.source),
         ourRoot,
-        path9.join(projectRoot, "agents", "reports", CROSS_CACHE_NAME),
+        path10.join(projectRoot, "agents", "reports", CROSS_CACHE_NAME),
         OVERLAP_THRESHOLD
       );
       overlaps = crossRootOverlapMap(pairs);
@@ -2038,6 +2362,79 @@ function runCensus(projectRoot, packageRoot, homeRoot) {
   );
   return full;
 }
+function contradictionCandidates(projectRoot, packageRoot, homeRoot) {
+  const ours = ourSkillNames(packageRoot);
+  const c = census(projectRoot, {
+    gatedEvents: gatedEvents(packageRoot),
+    templatesRoot: path10.join(packageRoot, "src", "agent-src", "templates"),
+    ourSkillNames: ours,
+    packageRoot,
+    scan: (p) => scanNeighbourBody(p).kind,
+    ...homeRoot === void 0 ? {} : { homeRoot }
+  });
+  const sources = [];
+  for (const name of ["CLAUDE.md", "AGENTS.md"]) {
+    const file = path10.join(projectRoot, name);
+    if (fs11.existsSync(file)) sources.push({ label: name, file, rank: RANK_PROJECT });
+  }
+  for (const r of c.rule_files) {
+    if (scanNeighbourBody(r.source).kind === null) {
+      sources.push({ label: r.id, file: r.source, rank: RANK_NEIGHBOUR_ALWAYS_ON });
+    }
+  }
+  for (const s of c.skills) {
+    if (s.unscanned === null) sources.push({ label: s.qualified, file: s.source, rank: RANK_NEIGHBOUR_SKILL });
+  }
+  const pairs = modalityPairs(sources.flatMap((src) => extractInstructions(src)));
+  for (const s of c.skills) {
+    const name = s.qualified.split(":").slice(1).join(":") || s.qualified;
+    if (ours.has(name)) pairs.push(collisionPair(s.qualified, name));
+  }
+  return pairs;
+}
+function councilSeat(projectRoot) {
+  return (prompt) => {
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/gu, "-");
+    const q = path10.join(projectRoot, "agents", "runtime", "council", "questions", `neighbour-contradictions-${stamp}.md`);
+    const out = path10.join(projectRoot, "agents", "runtime", "council", "responses", `neighbour-contradictions-${stamp}.md`);
+    try {
+      fs11.mkdirSync(path10.dirname(q), { recursive: true });
+      fs11.writeFileSync(q, prompt, "utf-8");
+      const args = ["council", "run", q, "--single", "--prompt-mode", "analysis", "--output", out, "--confirm", "--invocation", "user_explicit"];
+      const res = spawnSync("agent-config", args, { cwd: projectRoot, encoding: "utf-8" });
+      if (res.status !== 0) return null;
+      const doc = JSON.parse(fs11.readFileSync(out, "utf-8"));
+      return doc.responses?.map((r) => r.text ?? "").join("\n") ?? null;
+    } catch {
+      return null;
+    }
+  };
+}
+function runContradictions(projectRoot, packageRoot, opts = {}) {
+  const configured = opts.configured ?? resolveAvailability(projectRoot, process.env)?.configured ?? false;
+  const pairs = contradictionCandidates(projectRoot, packageRoot, opts.homeRoot);
+  if (!configured) {
+    return {
+      lines: [`  contradictions: n/a \u2014 no council configured (${pairs.length} candidate pair(s) formed, none reviewed)`],
+      rows: null
+    };
+  }
+  if (pairs.length === 0) return { lines: renderReview([]), rows: [] };
+  let rubric = "";
+  for (const rel of [["dist", "agent-src", "rules"], ["src", "rules"]]) {
+    try {
+      rubric = fs11.readFileSync(path10.join(packageRoot, ...rel, "neighbour-precedence.md"), "utf-8");
+      break;
+    } catch {
+    }
+  }
+  const answer = (opts.seat ?? councilSeat(projectRoot))(seatPrompt(pairs, rubric));
+  if (answer === null) {
+    return { lines: [`  contradictions: n/a \u2014 the council seat did not answer (${pairs.length} candidate pair(s) formed)`], rows: null };
+  }
+  const rows = reviewRows(pairs, parseVerdicts(answer, pairs.length));
+  return { lines: renderReview(rows), rows };
+}
 function summaryLine(c) {
   const counts = [
     `${c.hook_groups.length} hook group(s)`,
@@ -2102,12 +2499,14 @@ function renderText(c) {
   out.push("  it cannot say what ran first, and no label here refuses anything.");
   return out;
 }
-function main5(argv = process.argv.slice(2)) {
+function main6(argv = process.argv.slice(2)) {
   let json = false;
+  let contradictions = false;
   let root = process.cwd();
   let home;
   for (let i = 0; i < argv.length; i += 1) {
     if (argv[i] === "--json") json = true;
+    else if (argv[i] === "--contradictions") contradictions = true;
     else if (argv[i] === "--project") {
       root = argv[i + 1] ?? root;
       i += 1;
@@ -2122,7 +2521,15 @@ function main5(argv = process.argv.slice(2)) {
       return 2;
     }
   }
-  const c = runCensus(path9.resolve(root), resolvePackageRoot(import.meta.url), home);
+  if (contradictions) {
+    const r = runContradictions(path10.resolve(root), resolvePackageRoot(import.meta.url), home === void 0 ? {} : { homeRoot: home });
+    if (json) process.stdout.write(`${JSON.stringify({ contradictions: r.rows })}
+`);
+    else for (const line of r.lines) process.stdout.write(`${line}
+`);
+    return 0;
+  }
+  const c = runCensus(path10.resolve(root), resolvePackageRoot(import.meta.url), home);
   if (json) {
     process.stdout.write(`${JSON.stringify(c)}
 `);
@@ -2132,29 +2539,31 @@ function main5(argv = process.argv.slice(2)) {
   }
   return 0;
 }
-function _isCliEntry5() {
+function _isCliEntry6() {
   const bundled = true;
   const cliDelegate = true;
   if (bundled && !cliDelegate) return false;
   if (process.argv[1] === void 0) return false;
-  if (cliDelegate && path9.basename(process.argv[1], ".js") === "cmd_doctor_neighbours") {
+  if (cliDelegate && path10.basename(process.argv[1], ".js") === "cmd_doctor_neighbours") {
     return true;
   }
-  const argvUrl = pathToFileURL5(path9.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL6(path10.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs9.realpathSync(fileURLToPath5(import.meta.url)) === fs9.realpathSync(path9.resolve(process.argv[1]));
+    return fs11.realpathSync(fileURLToPath6(import.meta.url)) === fs11.realpathSync(path10.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry5()) {
-  process.exit(main5());
+if (_isCliEntry6()) {
+  process.exit(main6());
 }
 
 export {
   runCensus,
+  contradictionCandidates,
+  runContradictions,
   summaryLine,
   renderText,
-  main5 as main
+  main6 as main
 };