@event4u/agent-config 16.1.0 → 16.3.0

package/dist/cli-delegate/chunk-NXEILF2K.js

@@ -0,0 +1,2160 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  HOOK_SIGNATURES,
+  entryCommands,
+  isManagedEntry
+} from "./chunk-DEIV7XP7.js";
+import {
+  scanText
+} from "./chunk-KB5FZ655.js";
+import {
+  DEFAULT_SCAN_ROOTS,
+  Finding,
+  ROOT,
+  TOKEN_RE,
+  _scan,
+  classifyToken,
+  iter_corpus,
+  legacy_pragma_finding,
+  py_json_dumps_indent2,
+  report,
+  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 {
+  require_dist
+} from "./chunk-OY53J6II.js";
+import {
+  resolvePackageRoot
+} from "./chunk-MCJYCQPF.js";
+import {
+  SRC_SKILLS
+} from "./chunk-YCU3TIXH.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";
+
+// src/scripts/_lib/neighbour_census.ts
+import { createHash as createHash2 } from "node:crypto";
+import * as fs3 from "node:fs";
+import * as os2 from "node:os";
+import * as path3 from "node:path";
+
+// src/scripts/_lib/neighbour_tool_use.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+var MCP_TOOL_PREFIX = "mcp__";
+var FOREIGN_TOOL_USE_REL = "agents/runtime/neighbour-tool-use.json";
+var TOOL_USE_WINDOW_DAYS = 30;
+var SETTINGS_FILENAME = ".agent-settings.yml";
+function usageDay(now) {
+  return now.toISOString().slice(0, 10);
+}
+var DAY_RE = /^\d{4}-\d{2}-\d{2}$/u;
+function isUsageDay(value) {
+  return typeof value === "string" && DAY_RE.test(value);
+}
+function serverSegment(key) {
+  return key.replace(/[^A-Za-z0-9_-]/gu, "_");
+}
+function toolBelongsTo(tool, segment) {
+  if (!tool.startsWith(MCP_TOOL_PREFIX)) return false;
+  const rest = tool.slice(MCP_TOOL_PREFIX.length);
+  return rest === segment || rest.startsWith(`${segment}__`);
+}
+function resolveStoreRoot(start) {
+  let dir = path.resolve(start);
+  for (; ; ) {
+    try {
+      if (fs.statSync(path.join(dir, SETTINGS_FILENAME)).isFile()) return dir;
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return path.resolve(start);
+    dir = parent;
+  }
+}
+function toolsUsedByServer(projectRoot, now, segments) {
+  const known = [...new Set(segments)].sort((a, b) => b.length - a.length);
+  const counts = new Map(known.map((s) => [s, 0]));
+  if (known.length === 0) return counts;
+  let decoded;
+  try {
+    const root = resolveStoreRoot(projectRoot);
+    decoded = JSON.parse(fs.readFileSync(path.join(root, FOREIGN_TOOL_USE_REL), "utf-8"));
+  } catch {
+    return counts;
+  }
+  if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) return counts;
+  const today = usageDay(now);
+  const floor = usageDay(new Date(now.getTime() - (TOOL_USE_WINDOW_DAYS - 1) * 864e5));
+  for (const [tool, seen] of Object.entries(decoded)) {
+    if (!isUsageDay(seen) || seen < floor || seen > today) continue;
+    for (const segment of known) {
+      if (toolBelongsTo(tool, segment)) {
+        counts.set(segment, (counts.get(segment) ?? 0) + 1);
+        break;
+      }
+    }
+  }
+  return counts;
+}
+
+// src/scripts/_lib/skill_origin.ts
+var import_yaml = __toESM(require_dist(), 1);
+import { createHash } from "node:crypto";
+import * as fs2 from "node:fs";
+import * as os from "node:os";
+import * as path2 from "node:path";
+var AUTHORED_SKILL_ROOT = path2.join("src", "skills");
+var SCAN_CACHE_RELATIVE = path2.join("agents", "reports", "neighbour-scan.json");
+function scanCachePath(projectRoot) {
+  return path2.join(projectRoot, SCAN_CACHE_RELATIVE);
+}
+function qualifiedSkillName(name, origin) {
+  return origin === "package" ? name : `${origin}:${name}`;
+}
+function packageClaimedPaths(projectRoot) {
+  const manifest = manifest_path(projectRoot);
+  let doc;
+  try {
+    doc = (0, import_yaml.parse)(fs2.readFileSync(manifest, "utf-8"), { version: "1.1" });
+  } catch {
+    return null;
+  }
+  if (doc === null || typeof doc !== "object" || Array.isArray(doc)) return null;
+  const tools = doc["tools"];
+  const out = /* @__PURE__ */ new Set();
+  if (!Array.isArray(tools)) return out;
+  for (const tool of tools) {
+    if (tool === null || typeof tool !== "object" || Array.isArray(tool)) continue;
+    const files = tool["files"];
+    if (!Array.isArray(files)) continue;
+    for (const entry of files) {
+      if (entry === null || typeof entry !== "object" || Array.isArray(entry)) continue;
+      const raw = entry["path"];
+      if (typeof raw !== "string" || raw === "") continue;
+      out.add(path2.resolve(projectRoot, _expanduser(raw)));
+    }
+  }
+  return out;
+}
+function _expanduser(p) {
+  if (p === "~") return os.homedir();
+  if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
+    return path2.join(os.homedir(), p.slice(2));
+  }
+  return p;
+}
+function makeSkillOriginResolver(projectRoot, opts = {}) {
+  const claims = opts.claims !== void 0 ? opts.claims : packageClaimedPaths(projectRoot);
+  const root = path2.resolve(projectRoot);
+  const authored = path2.join(path2.resolve(opts.packageRoot ?? projectRoot), AUTHORED_SKILL_ROOT);
+  const under = (abs, dir) => abs === dir || abs.startsWith(dir + path2.sep);
+  return (skillMdPath) => {
+    const abs = path2.resolve(skillMdPath);
+    if (under(abs, authored)) return "package";
+    if (claims === null) return "package";
+    if (claims.has(abs)) return "package";
+    return under(abs, root) ? "project" : "home";
+  };
+}
+function classifyCompat(args) {
+  if (args.unscanned !== null) return "unscanned";
+  if (args.shadows.length > 0) return "shadowed";
+  if (args.overlaps.length > 0) return "overlapping";
+  return "unclassified";
+}
+function fileDigest(file) {
+  try {
+    return createHash("sha256").update(fs2.readFileSync(file)).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function scanVerdict(cache, qualified, digest) {
+  if (cache === null) return { ok: false, kind: "no-scan-record" };
+  const rec = cache.entries.find((e) => e.qualified === qualified);
+  if (rec === void 0) return { ok: false, kind: "no-scan-record" };
+  if (digest === null || rec.digest !== digest) return { ok: false, kind: "digest-changed" };
+  if (rec.unscanned !== null) return { ok: false, kind: rec.unscanned };
+  return { ok: true };
+}
+
+// src/scripts/_lib/neighbour_census.ts
+var OUR_MCP_KEY = "agent-config";
+function sha256(text) {
+  return createHash2("sha256").update(text, "utf-8").digest("hex");
+}
+function readJson(p) {
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(p, "utf-8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function commandHead(command) {
+  const trimmed = command.trim();
+  if (trimmed === "") return "";
+  const lastStatement = trimmed.split(";").pop() ?? trimmed;
+  const tokens = lastStatement.trim().split(/\s+/).filter((t) => t !== "");
+  let i = 0;
+  while (i < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[i] ?? "")) i += 1;
+  const head = tokens[i] ?? "";
+  if (head === "") return "(redacted)";
+  if (!/^[A-Za-z0-9_./\\:-]+$/.test(head) || head.includes("@")) return "(redacted)";
+  return scanText(head).length === 0 ? head : "(redacted)";
+}
+function hostNameFor(label) {
+  const user = label.startsWith("~/");
+  const dir = label.replace(/^~\//, "").replace(/\/[^/]+$/, "");
+  const name = dir.split("/").map((seg) => seg.replace(/^\./, "")).join("/");
+  return user ? `user:${name}` : `project:${name}`;
+}
+function hookFiles(projectRoot, homeRoot) {
+  const home = homeRoot ?? os2.homedir();
+  const expand = (label) => label.startsWith("~/") ? path3.join(home, label.slice(2)) : path3.join(projectRoot, label);
+  const out = Object.entries(HOOK_SIGNATURES).map(([label, signature]) => ({
+    host: hostNameFor(label),
+    file: expand(label),
+    signature
+  }));
+  out.push({
+    host: "project:claude",
+    file: path3.join(projectRoot, ".claude", "settings.json"),
+    signature: "dispatch:hook --platform claude"
+  });
+  return out;
+}
+function censusHookFile(host, file, signature) {
+  const doc = readJson(file);
+  if (doc === null) return { entries: [], oursBound: false, present: false };
+  const hooks = doc["hooks"];
+  if (hooks === null || typeof hooks !== "object" || Array.isArray(hooks)) {
+    return { entries: [], oursBound: false, present: true };
+  }
+  const entries = [];
+  let oursBound = false;
+  for (const [event, list] of Object.entries(hooks)) {
+    if (!Array.isArray(list)) continue;
+    for (const raw of list) {
+      if (isManagedEntry(raw, signature)) {
+        oursBound = true;
+        continue;
+      }
+      const commands = entryCommands(raw);
+      const head = commandHead(commands[0] ?? "");
+      const obj = raw ?? {};
+      const matcher = typeof obj["matcher"] === "string" ? obj["matcher"] : null;
+      const timeout = typeof obj["timeout"] === "number" ? obj["timeout"] : null;
+      entries.push({
+        id: `${host}:${event}/${head === "" ? "unreadable" : head}`,
+        shape: "hook_group",
+        digest: sha256(JSON.stringify(raw)),
+        source: file,
+        event,
+        matcher,
+        command_head: head,
+        timeout,
+        // No host exposes another package's hook execution to a hook,
+        // so a neighbour's effect is not readable from its
+        // registration. `unknown` is the honest answer, and 2.3 treats
+        // it as capable of denying rather than assuming it is not.
+        effect: "unknown"
+      });
+    }
+  }
+  entries.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  return { entries, oursBound, present: true };
+}
+function unclaimedUnder(dir, origin, shape, owned, opts = {}) {
+  let names;
+  try {
+    names = fs3.readdirSync(dir).sort();
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (name.startsWith(".")) continue;
+    const full = path3.join(dir, name);
+    const probe = opts.nested === true ? path3.join(full, "SKILL.md") : full;
+    let body;
+    try {
+      const st = fs3.statSync(probe);
+      if (!st.isFile()) continue;
+      body = fs3.readFileSync(probe, "utf-8");
+    } catch {
+      continue;
+    }
+    if (owned.has(path3.resolve(probe))) continue;
+    out.push({
+      id: `${origin}:${opts.nested === true ? name : name.replace(/\.[^.]+$/, "")}`,
+      shape,
+      digest: sha256(body),
+      source: probe
+    });
+  }
+  return out;
+}
+function foreignSections(file, templateFile, origin) {
+  let body;
+  try {
+    body = fs3.readFileSync(file, "utf-8");
+  } catch {
+    return [];
+  }
+  let ours = /* @__PURE__ */ new Set();
+  try {
+    ours = new Set(
+      fs3.readFileSync(templateFile, "utf-8").split("\n").filter((l) => /^#{1,2} /.test(l)).map((l) => l.replace(/^#{1,2} /, "").trim())
+    );
+  } catch {
+  }
+  const out = [];
+  const lines = body.split("\n");
+  const isHeading = (n) => /^#{1,2} /.test(lines[n] ?? "");
+  for (let i = 0; i < lines.length; i += 1) {
+    if (!isHeading(i)) continue;
+    const heading = (lines[i] ?? "").replace(/^#{1,2} /, "").trim();
+    if (ours.has(heading)) continue;
+    let j = i + 1;
+    while (j < lines.length && !isHeading(j)) j += 1;
+    out.push({
+      id: `${origin}:${heading}`,
+      shape: "instruction_section",
+      digest: sha256(lines.slice(i, j).join("\n")),
+      source: file
+    });
+  }
+  return out;
+}
+function foreignMcpServers(projectRoot, now) {
+  const file = path3.join(projectRoot, ".mcp.json");
+  const doc = readJson(file);
+  const servers = doc?.["mcpServers"];
+  if (servers === null || servers === void 0 || typeof servers !== "object" || Array.isArray(servers)) {
+    return [];
+  }
+  const foreign = Object.entries(servers).filter(
+    ([name]) => name !== OUR_MCP_KEY
+  );
+  const used = toolsUsedByServer(projectRoot, now, foreign.map(([name]) => serverSegment(name)));
+  return foreign.map(([name, spec]) => ({
+    id: `project:${name}`,
+    shape: "mcp_server",
+    digest: sha256(JSON.stringify(spec)),
+    source: file,
+    tools_used_30d: used.get(serverSegment(name)) ?? 0,
+    tools_advertised: "unknown",
+    tools_window_days: TOOL_USE_WINDOW_DAYS
+  })).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+function labelFor(entries, oursBound, gatedEvents2) {
+  if (!oursBound) {
+    return {
+      label: "uncontrolled",
+      reason: "this package has no hook group registered in this file"
+    };
+  }
+  if (entries.length === 0) {
+    return { label: "controlled", reason: "no foreign hook entry in this file" };
+  }
+  const onGated = entries.filter((e) => gatedEvents2.has(e.event));
+  const stopEntries = entries.filter((e) => /stop/i.test(e.event));
+  if (onGated.length > 0 || stopEntries.length > 0) {
+    const named = [...new Set([...onGated, ...stopEntries].map((e) => e.id))].sort();
+    return {
+      label: "degraded",
+      reason: `foreign entr(ies) of unread effect on a slot this package gates: ${named.join(", ")}`
+    };
+  }
+  return {
+    label: "coordinated",
+    reason: `${entries.length} foreign entr(ies), none on a slot this package gates`
+  };
+}
+function census(projectRoot, opts = {}) {
+  const gated = opts.gatedEvents ?? /* @__PURE__ */ new Set();
+  const owned = new Set(readRecordedHashes(manifest_path(projectRoot), projectRoot).keys());
+  const home = opts.homeRoot ?? os2.homedir();
+  const hosts = [];
+  const hookGroups = [];
+  for (const { host, file, signature } of hookFiles(projectRoot, home)) {
+    const { entries, oursBound, present } = censusHookFile(host, file, signature);
+    if (!present) continue;
+    const { label, reason } = labelFor(entries, oursBound, gated);
+    hosts.push({
+      host,
+      file,
+      present,
+      hook_groups: entries,
+      ours_bound: oursBound,
+      label,
+      label_reason: reason
+    });
+    hookGroups.push(...entries);
+  }
+  const ourSkillsForCompat = opts.ourSkillNames ?? /* @__PURE__ */ new Set();
+  const originOf = makeSkillOriginResolver(projectRoot, {
+    ...opts.packageRoot === void 0 ? {} : { packageRoot: opts.packageRoot }
+  });
+  const scanCache = opts.scanCache !== void 0 ? opts.scanCache : null;
+  const overlaps = opts.overlaps ?? /* @__PURE__ */ new Map();
+  const skills = [
+    ...unclaimedUnder(path3.join(projectRoot, ".claude", "skills"), "project", "skill", owned, {
+      nested: true
+    }),
+    ...unclaimedUnder(path3.join(home, ".claude", "skills"), "user", "skill", owned, {
+      nested: true
+    })
+  ].map((entry) => {
+    const name = entry.id.split(":").slice(1).join(":");
+    const origin = originOf(entry.source);
+    const qualified = qualifiedSkillName(name, origin);
+    const unscanned = opts.scan !== void 0 ? opts.scan(entry.source) : (() => {
+      const v = scanVerdict(scanCache, qualified, fileDigest(entry.source));
+      return v.ok ? null : v.kind;
+    })();
+    const shadows = ourSkillsForCompat.has(name) ? [name] : [];
+    const hit = overlaps.get(path3.resolve(entry.source));
+    const overlapNames = unscanned === null && hit !== void 0 ? [...hit.names] : [];
+    return {
+      ...entry,
+      shape: "skill",
+      qualified,
+      compat: classifyCompat({ unscanned, shadows, overlaps: overlapNames }),
+      also: [.../* @__PURE__ */ new Set([...shadows, ...overlapNames])].sort(),
+      unscanned,
+      similarity: overlapNames.length > 0 && hit !== void 0 ? hit.similarity : null
+    };
+  });
+  const commands = unclaimedUnder(
+    path3.join(projectRoot, ".claude", "commands"),
+    "project",
+    "command",
+    owned
+  );
+  const agents = unclaimedUnder(
+    path3.join(projectRoot, ".claude", "agents"),
+    "project",
+    "agent",
+    owned
+  );
+  const ruleFiles = [
+    ...unclaimedUnder(path3.join(projectRoot, ".cursor", "rules"), "cursor", "rule_file", owned),
+    ...unclaimedUnder(path3.join(projectRoot, ".windsurf", "rules"), "windsurf", "rule_file", owned),
+    ...unclaimedUnder(path3.join(projectRoot, ".claude", "rules"), "claude", "rule_file", owned)
+  ];
+  const templates = opts.templatesRoot ?? "";
+  const instructionSections = [
+    ...foreignSections(
+      path3.join(projectRoot, "AGENTS.md"),
+      path3.join(templates, "AGENTS.md"),
+      "AGENTS.md"
+    ),
+    ...foreignSections(
+      path3.join(projectRoot, ".github", "copilot-instructions.md"),
+      path3.join(templates, "copilot-instructions.md"),
+      "copilot-instructions.md"
+    )
+  ];
+  const warnings = [];
+  const ourSkills = opts.ourSkillNames ?? /* @__PURE__ */ new Set();
+  for (const s of skills) {
+    const name = s.id.split(":").slice(1).join(":");
+    if (ourSkills.has(name)) {
+      warnings.push({
+        kind: "shadowed",
+        detail: `a skill named \`${name}\` sits at ${s.source} and this package ships one under the same name; which one the host resolves is the host's choice, not ours`
+      });
+    }
+  }
+  warnings.push(...doubleGateWarnings(hookGroups, gated));
+  warnings.push(...settingsTakeover(path3.join(projectRoot, ".claude", "settings.json")));
+  warnings.push(...settingsTakeover(path3.join(home, ".claude", "settings.json")));
+  for (const h of hosts) {
+    if (!h.ours_bound) {
+      warnings.push({
+        kind: "removed-after-install",
+        detail: `${h.file} carries hook entries but none of ours \u2014 this package's group is absent after its own install`
+      });
+    }
+  }
+  return {
+    project_root: projectRoot,
+    hosts,
+    hook_groups: hookGroups,
+    skills,
+    commands,
+    agents,
+    mcp_servers: foreignMcpServers(projectRoot, opts.now ?? /* @__PURE__ */ new Date()),
+    rule_files: ruleFiles,
+    instruction_sections: instructionSections,
+    warnings
+  };
+}
+function doubleGateWarnings(entries, gatedEvents2) {
+  const byEvent = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    if (!gatedEvents2.has(e.event)) continue;
+    const arr = byEvent.get(e.event);
+    if (arr) arr.push(e);
+    else byEvent.set(e.event, [e]);
+  }
+  return [...byEvent.entries()].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0).map(([event, list]) => ({
+    kind: "double-gate",
+    detail: `${event}: ${list.length} foreign entr(ies) (${list.map((e) => e.id).join(", ")}) share this event with a gate of ours. The host runs both; either deny applies.`
+  }));
+}
+function settingsTakeover(settingsFile) {
+  const doc = readJson(settingsFile);
+  if (doc === null) return [];
+  const out = [];
+  if (doc["model"] !== void 0) {
+    out.push({
+      kind: "settings-takeover",
+      detail: `${settingsFile} sets \`model\` \u2014 the host resolves every turn against it, including the ones this package's rules are loaded into`
+    });
+  }
+  const env = doc["env"];
+  if (env !== null && typeof env === "object" && !Array.isArray(env)) {
+    const keys = Object.keys(env).filter((k) => k.startsWith("CLAUDE_CODE_")).sort();
+    if (keys.length > 0) {
+      out.push({
+        kind: "settings-takeover",
+        detail: `${settingsFile} sets host environment key(s) ${keys.join(", ")} \u2014 these change the harness the hooks this package bound run inside`
+      });
+    }
+  }
+  return out;
+}
+function gatedEventsFrom(manifest, nativeAliases = {}) {
+  const concerns = manifest.concerns ?? {};
+  const permission = new Set(
+    Object.keys(concerns).filter((n) => concerns[n]?.effect === "permission")
+  );
+  const out = /* @__PURE__ */ new Set();
+  for (const [host, events] of Object.entries(manifest.platforms ?? {})) {
+    if (events === null || typeof events !== "object") continue;
+    for (const [event, chain] of Object.entries(events)) {
+      if (!Array.isArray(chain)) continue;
+      if (!chain.some((c) => permission.has(String(c)))) continue;
+      out.add(event);
+      const native = nativeAliases[host]?.[event];
+      if (typeof native === "string") out.add(native);
+      for (const [nativeName, acEvent] of Object.entries(nativeAliases[host] ?? {})) {
+        if (acEvent === event) out.add(nativeName);
+      }
+    }
+  }
+  return out;
+}
+
+// src/scripts/_lib/neighbour_scan.ts
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
+
+// src/scripts/lint_instruction_smuggling.ts
+import * as path4 from "node:path";
+import * as fs4 from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var CHECK = "instruction-smuggling";
+var _INLINE_CODE = /`[^`]*`/g;
+var _SUPPRESS = new RegExp(
+  "\\b(do not|don'?t|never)\\s+(mention|tell|inform|disclose|reveal|notify)\\b[^.]{0,40}\\b(the )?(user|human|reviewer|operator|owner)\\b|without (telling|informing|notifying|explaining to) (the )?(user|them|anyone)",
+  "i"
+);
+var _INJECT = new RegExp(
+  "<\\s*(important|system|admin|secret|critical)\\s*>|ignore (all |the )?(previous|prior|above) (instructions|prompts|rules)|disregard (all |the )?(previous|prior|above)|you are now (a|an|the)\\b|new system prompt",
+  "i"
+);
+var _MED = [
+  [/\bcurl\b[^\n|]*\|\s*(ba|z|fi)?sh\b/i, "pipe-to-shell (curl|sh)"],
+  [/\bwget\b[^\n|]*\|\s*(ba|z|fi)?sh\b/i, "pipe-to-shell (wget|sh)"],
+  [/\b(socat|nc)\b[^\n]*\b(exec|-e)\b|\/dev\/tcp\//i, "reverse-shell signature"],
+  [/(~\/\.ssh\/id_[rd]sa|\/etc\/shadow|\.aws\/credentials)/, "secret-path read"]
+];
+function _strip_inline_code(text) {
+  return text.replace(_INLINE_CODE, (m) => " ".repeat(m.length));
+}
+function _scan2(sf) {
+  const pragmaForm = sf.pragma_form(CHECK);
+  if (pragmaForm === "legacy") {
+    return [legacy_pragma_finding(sf, CHECK)];
+  }
+  const finish = (hits) => pragmaForm === "bound" ? sf.filter_bound_pragma(CHECK, hits) : hits;
+  const out = [];
+  for (const [lineno, text] of sf.iter_lines({ skip_example_fence: true, skip_any_fence: true })) {
+    const prose = _strip_inline_code(text);
+    if (_SUPPRESS.test(prose)) {
+      out.push(
+        new Finding(
+          sf.rel,
+          lineno,
+          CHECK,
+          "HIGH",
+          "disclosure-suppression imperative in prose",
+          sf.weight
+        )
+      );
+    }
+    if (_INJECT.test(prose)) {
+      out.push(
+        new Finding(
+          sf.rel,
+          lineno,
+          CHECK,
+          "HIGH",
+          "injection / role-takeover phrase in prose",
+          sf.weight
+        )
+      );
+    }
+    for (const [rx, label] of _MED) {
+      if (rx.test(prose)) {
+        out.push(
+          new Finding(
+            sf.rel,
+            lineno,
+            CHECK,
+            "MED",
+            `${label} in prose (verify intent)`,
+            sf.weight
+          )
+        );
+      }
+    }
+  }
+  return finish(out);
+}
+function _argError(msg) {
+  process.stderr.write("usage: lint_instruction_smuggling [-h] [--json] [--root DIR]\n");
+  process.stderr.write(`lint_instruction_smuggling: error: ${msg}
+`);
+  process.exit(2);
+}
+function parse_args(argv) {
+  const out = { json: false };
+  const extra = [];
+  let rootPending = false;
+  for (const a of argv) {
+    if (rootPending) {
+      out.root = a;
+      rootPending = false;
+      continue;
+    }
+    if (a === "-h" || a === "--help") {
+      process.stdout.write("usage: lint_instruction_smuggling [-h] [--json] [--root DIR]\n");
+      process.exit(0);
+    } else if (a === "--json") {
+      out.json = true;
+    } else if (a === "--root" || a.startsWith("--root=")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1) {
+        out.root = a.slice(eq + 1);
+      } else {
+        rootPending = true;
+      }
+    } else {
+      extra.push(a);
+    }
+  }
+  if (extra.length > 0) {
+    _argError(`unrecognized arguments: ${extra.join(" ")}`);
+  }
+  return out;
+}
+function main(argv = null) {
+  const args = parse_args(argv ?? process.argv.slice(2));
+  const scanBase = args.root === void 0 ? ROOT : path4.resolve(args.root);
+  const findings = [];
+  let corpusFiles = 0;
+  for (const sf of iter_corpus(DEFAULT_SCAN_ROOTS, [".md"], scanBase)) {
+    corpusFiles += 1;
+    for (const h of _scan2(sf)) {
+      findings.push(h);
+    }
+  }
+  try {
+    assertScanned({
+      gate: "lint_instruction_smuggling",
+      scanned: corpusFiles,
+      units: "corpus file(s)",
+      roots: DEFAULT_SCAN_ROOTS
+    });
+  } catch (exc) {
+    if (exc instanceof DeadScopeError) {
+      process.stderr.write(`\u274C  ${exc.message}
+`);
+      return 1;
+    }
+    throw exc;
+  }
+  if (args.json) {
+    report_child_scanned(corpusFiles);
+  }
+  if (args.json) {
+    const payload = py_json_dumps_indent2(findings.map((f) => f.toDict()));
+    process.stdout.write(payload + "\n");
+    return findings.some((f) => f.is_fail) ? 1 : 0;
+  }
+  return report(findings, { check_label: "instruction-smuggling" });
+}
+function _isCliEntry() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path4.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs4.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs4.realpathSync(path4.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry()) {
+  process.exitCode = main();
+}
+
+// src/scripts/lint_confusables.ts
+import * as path5 from "node:path";
+import * as fs5 from "node:fs";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
+var CHECK2 = "mixed-script-confusable";
+var _TOKEN = TOKEN_RE;
+var _classify_token = classifyToken;
+function _scan3(sf) {
+  const pragmaForm = sf.pragma_form(CHECK2);
+  if (pragmaForm === "legacy") {
+    return [legacy_pragma_finding(sf, CHECK2)];
+  }
+  const finish = (hits) => pragmaForm === "bound" ? sf.filter_bound_pragma(CHECK2, hits) : hits;
+  const out = [];
+  for (const [lineno, text] of sf.iter_lines({ skip_example_fence: true })) {
+    const tokens = text.match(_TOKEN);
+    if (tokens === null) continue;
+    for (const tok of tokens) {
+      const desc = _classify_token(tok);
+      if (desc !== null) {
+        out.push(
+          new Finding(
+            sf.rel,
+            lineno,
+            CHECK2,
+            "HIGH",
+            `mixed-script confusable token "${tok}" \u2014 ${desc}`,
+            sf.weight
+          )
+        );
+      }
+    }
+  }
+  return finish(out);
+}
+function _argError2(msg) {
+  process.stderr.write("usage: lint_confusables [-h] [--json] [--root DIR]\n");
+  process.stderr.write(`lint_confusables: error: ${msg}
+`);
+  process.exit(2);
+}
+function parse_args2(argv) {
+  const out = { json: false };
+  const extra = [];
+  let rootPending = false;
+  for (const a of argv) {
+    if (rootPending) {
+      out.root = a;
+      rootPending = false;
+      continue;
+    }
+    if (a === "-h" || a === "--help") {
+      process.stdout.write("usage: lint_confusables [-h] [--json] [--root DIR]\n");
+      process.exit(0);
+    } else if (a === "--json") {
+      out.json = true;
+    } else if (a === "--root" || a.startsWith("--root=")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1) {
+        out.root = a.slice(eq + 1);
+      } else {
+        rootPending = true;
+      }
+    } else {
+      extra.push(a);
+    }
+  }
+  if (extra.length > 0) {
+    _argError2(`unrecognized arguments: ${extra.join(" ")}`);
+  }
+  return out;
+}
+function main2(argv = null) {
+  const args = parse_args2(argv ?? process.argv.slice(2));
+  const scanBase = args.root === void 0 ? ROOT : path5.resolve(args.root);
+  const findings = [];
+  let scanned = 0;
+  for (const sf of iter_corpus(DEFAULT_SCAN_ROOTS, [".md"], scanBase)) {
+    scanned += 1;
+    for (const h of _scan3(sf)) {
+      findings.push(h);
+    }
+  }
+  try {
+    assertScanned({
+      gate: "lint_confusables",
+      scanned,
+      units: "file(s)",
+      roots: DEFAULT_SCAN_ROOTS
+    });
+  } catch (exc) {
+    if (exc instanceof DeadScopeError) {
+      process.stderr.write(`\u274C  ${exc.message}
+`);
+      return 2;
+    }
+    throw exc;
+  }
+  if (args.json) {
+    report_child_scanned(scanned);
+  }
+  if (args.json) {
+    const payload = py_json_dumps_indent2(findings.map((f) => f.toDict()));
+    process.stdout.write(payload + "\n");
+    return findings.some((f) => f.is_fail) ? 1 : 0;
+  }
+  return report(findings, { check_label: "mixed-script-confusable" });
+}
+function _isCliEntry2() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL2(path5.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs5.realpathSync(fileURLToPath2(import.meta.url));
+    const argv = fs5.realpathSync(path5.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry2()) {
+  process.exitCode = main2();
+}
+
+// src/scripts/lint_skill_frontmatter_safety.ts
+import * as path6 from "node:path";
+import * as fs6 from "node:fs";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "node:url";
+var CHECK3 = "dangerous-frontmatter";
+var _WILDCARD_TOOL = /(^|[\s,[\"'])(\*|Bash\(\*\))(\s|,|\]|"|'|$)/;
+var _BARE_BASH = /(^|[\s,[\"'])Bash(\s|,|\]|"|'|$)/;
+var _RE_EXECUTION = /^execution:\s*$/;
+var _RE_EXEC_KEY = /^\s+([A-Za-z0-9_-]+):\s*(.*)$/;
+var _RE_PERMISSION_MODE = /^\s*permissionMode:\s*['"]?bypassPermissions/;
+var _RE_ALLOWED_TOOLS = /^\s*allowed-tools:\s*(.+)$/;
+var _RE_TOOLS_KEY = /^tools:\s*(.*)$/;
+var _RE_SEQ_ITEM = /^\s+-\s*(.+)$/;
+function _stripQuotes(s) {
+  let lo = 0;
+  let hi = s.length;
+  while (lo < hi && (s[lo] === "'" || s[lo] === '"')) lo++;
+  while (hi > lo && (s[hi - 1] === "'" || s[hi - 1] === '"')) hi--;
+  return s.slice(lo, hi);
+}
+function _indent(text) {
+  return text.length - text.replace(/^\s+/, "").length;
+}
+function _frontmatter(sf) {
+  if (sf.lines.length === 0 || sf.lines[0].trim() !== "---") {
+    return null;
+  }
+  const body = [];
+  for (let i = 1; i < sf.lines.length; i++) {
+    if (sf.lines[i].trim() === "---") {
+      return [body, i + 1];
+    }
+    body.push([i + 1, sf.lines[i]]);
+  }
+  return null;
+}
+function _exec_block(body) {
+  const out = {};
+  let in_exec = false;
+  let base_indent = 0;
+  for (const [lineno, text] of body) {
+    if (_RE_EXECUTION.test(text)) {
+      in_exec = true;
+      base_indent = _indent(text);
+      continue;
+    }
+    if (in_exec) {
+      const indent = _indent(text);
+      if (text.trim() && indent <= base_indent) {
+        in_exec = false;
+        continue;
+      }
+      const m = _RE_EXEC_KEY.exec(text);
+      if (m) {
+        out[m[1]] = [lineno, m[2].trim()];
+      }
+    }
+  }
+  return out;
+}
+function grantSurface(rel) {
+  return rel.replace(/\\/g, "/").includes("src/subagents/") ? "subagent" : "skill-like";
+}
+function _scan4(sf) {
+  const pragmaForm = sf.pragma_form(CHECK3);
+  if (pragmaForm === "legacy") {
+    return [legacy_pragma_finding(sf, CHECK3)];
+  }
+  const finish = (hits) => pragmaForm === "bound" ? sf.filter_bound_pragma(CHECK3, hits) : hits;
+  const fm = _frontmatter(sf);
+  if (!fm) {
+    return [];
+  }
+  const [body] = fm;
+  const out = [];
+  const ex = _exec_block(body);
+  const handler = _stripQuotes((ex["handler"] ?? [0, ""])[1]);
+  const is_execution_skill = Object.keys(ex).length > 0 && handler !== "" && handler !== "none";
+  const surface = grantSurface(sf.rel);
+  for (const [lineno, text] of body) {
+    if (surface === "skill-like" && _RE_TOOLS_KEY.test(text)) {
+      out.push(
+        new Finding(
+          sf.rel,
+          lineno,
+          CHECK3,
+          "HIGH",
+          "top-level `tools:` on a non-subagent surface \u2014 subagent-v1 only; the loader ignores it here, so this artefact is NOT restricted (use execution.allowed_tools)",
+          sf.weight
+        )
+      );
+    }
+    if (surface === "subagent" && _RE_EXECUTION.test(text)) {
+      out.push(
+        new Finding(
+          sf.rel,
+          lineno,
+          CHECK3,
+          "HIGH",
+          "`execution:` block on a subagent definition \u2014 subagent-v1 has no such key, so any allowed_tools under it restricts nothing (use top-level `tools:`)",
+          sf.weight
+        )
+      );
+    }
+  }
+  for (const [lineno, text] of body) {
+    if (_RE_PERMISSION_MODE.test(text)) {
+      out.push(
+        new Finding(
+          sf.rel,
+          lineno,
+          CHECK3,
+          "HIGH",
+          "permissionMode: bypassPermissions (consent bypass)",
+          sf.weight
+        )
+      );
+    }
+    const m = _RE_ALLOWED_TOOLS.exec(text);
+    if (m && (_WILDCARD_TOOL.test(m[1]) || _BARE_BASH.test(m[1]) && !is_execution_skill)) {
+      out.push(
+        new Finding(
+          sf.rel,
+          lineno,
+          CHECK3,
+          "HIGH",
+          "wildcard / bare-Bash tool grant (over-broad)",
+          sf.weight
+        )
+      );
+    }
+  }
+  for (let i = 0; i < body.length; i += 1) {
+    const [lineno, text] = body[i];
+    const key = _RE_TOOLS_KEY.exec(text);
+    if (!key) {
+      continue;
+    }
+    const grants = [];
+    const inline = (key[1] ?? "").trim();
+    if (inline !== "") {
+      grants.push(inline);
+    }
+    for (let j = i + 1; j < body.length; j += 1) {
+      const [, next] = body[j];
+      const item = _RE_SEQ_ITEM.exec(next);
+      if (!item) {
+        break;
+      }
+      grants.push(_stripQuotes(item[1].trim()));
+    }
+    const joined = grants.join(", ");
+    if (joined !== "" && (_WILDCARD_TOOL.test(joined) || _BARE_BASH.test(joined))) {
+      out.push(
+        new Finding(
+          sf.rel,
+          lineno,
+          CHECK3,
+          "HIGH",
+          "wildcard / bare-Bash tool grant (over-broad)",
+          sf.weight
+        )
+      );
+    }
+  }
+  if (Object.keys(ex).length === 0) {
+    return finish(out);
+  }
+  const etype = _stripQuotes((ex["type"] ?? [0, ""])[1]);
+  const safety = _stripQuotes((ex["safety_mode"] ?? [0, ""])[1]);
+  const exec_line = (ex["type"] ?? ex["handler"] ?? [0, ""])[0];
+  if (etype === "automated") {
+    if (handler === "" || handler === "none") {
+      out.push(
+        new Finding(
+          sf.rel,
+          exec_line,
+          CHECK3,
+          "HIGH",
+          "automated execution with handler none/missing (runtime-safety)",
+          sf.weight
+        )
+      );
+    }
+    if (safety !== "strict") {
+      out.push(
+        new Finding(
+          sf.rel,
+          exec_line,
+          CHECK3,
+          "HIGH",
+          "automated execution without safety_mode: strict (runtime-safety)",
+          sf.weight
+        )
+      );
+    }
+    if (!("allowed_tools" in ex)) {
+      out.push(
+        new Finding(
+          sf.rel,
+          exec_line,
+          CHECK3,
+          "HIGH",
+          "automated execution without an explicit allowed_tools declaration",
+          sf.weight
+        )
+      );
+    }
+  }
+  const [at_line, at_val] = ex["allowed_tools"] ?? [0, ""];
+  if (at_val && _WILDCARD_TOOL.test(at_val)) {
+    out.push(
+      new Finding(
+        sf.rel,
+        at_line,
+        CHECK3,
+        "HIGH",
+        "execution.allowed_tools wildcard (* / Bash(*)) grant",
+        sf.weight
+      )
+    );
+  } else if (at_val && _BARE_BASH.test(at_val) && !is_execution_skill) {
+    out.push(
+      new Finding(
+        sf.rel,
+        at_line,
+        CHECK3,
+        "HIGH",
+        "bare Bash grant on a non-execution skill (handler none/missing)",
+        sf.weight
+      )
+    );
+  }
+  return finish(out);
+}
+function _argError3(msg) {
+  process.stderr.write("usage: lint_skill_frontmatter_safety [-h] [--json] [--root DIR]\n");
+  process.stderr.write(`lint_skill_frontmatter_safety: error: ${msg}
+`);
+  process.exit(2);
+}
+function parse_args3(argv) {
+  const out = { json: false };
+  const extra = [];
+  let rootPending = false;
+  for (const a of argv) {
+    if (rootPending) {
+      out.root = a;
+      rootPending = false;
+      continue;
+    }
+    if (a === "-h" || a === "--help") {
+      process.stdout.write("usage: lint_skill_frontmatter_safety [-h] [--json] [--root DIR]\n");
+      process.exit(0);
+    } else if (a === "--json") {
+      out.json = true;
+    } else if (a === "--root" || a.startsWith("--root=")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1) {
+        out.root = a.slice(eq + 1);
+      } else {
+        rootPending = true;
+      }
+    } else {
+      extra.push(a);
+    }
+  }
+  if (extra.length > 0) {
+    _argError3(`unrecognized arguments: ${extra.join(" ")}`);
+  }
+  return out;
+}
+function main3(argv = null) {
+  const args = parse_args3(argv ?? process.argv.slice(2));
+  const scanBase = args.root === void 0 ? ROOT : path6.resolve(args.root);
+  const findings = [];
+  const roots = ["src/skills", "src/agent-src", "src/domains", "src/subagents"];
+  let scanned = 0;
+  for (const sf of iter_corpus(roots, [".md"], scanBase)) {
+    scanned += 1;
+    for (const h of _scan4(sf)) {
+      findings.push(h);
+    }
+  }
+  try {
+    assertScanned({
+      gate: "lint_skill_frontmatter_safety",
+      scanned,
+      units: "markdown file(s)",
+      roots
+    });
+  } catch (exc) {
+    if (exc instanceof DeadScopeError) {
+      process.stderr.write(`\u274C  ${exc.message}
+`);
+      return 1;
+    }
+    throw exc;
+  }
+  if (args.json) {
+    report_child_scanned(scanned);
+  }
+  if (args.json) {
+    const payload = py_json_dumps_indent2(findings.map((f) => f.toDict()));
+    process.stdout.write(payload + "\n");
+    return findings.some((f) => f.is_fail) ? 1 : 0;
+  }
+  return report(findings, { check_label: "dangerous-frontmatter", scanned_roots: roots });
+}
+function _isCliEntry3() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL3(path6.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs6.realpathSync(fileURLToPath3(import.meta.url));
+    const argv = fs6.realpathSync(path6.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry3()) {
+  process.exitCode = main3();
+}
+
+// src/scripts/_lib/neighbour_scan.ts
+var SHAPES = [
+  ["instruction-smuggling", _scan2],
+  ["dangerous-frontmatter", _scan4],
+  ["hidden-unicode", _scan],
+  ["mixed-script-confusable", _scan3]
+];
+function scanNeighbourBody(skillMdPath) {
+  let sf;
+  try {
+    sf = scan_file(skillMdPath);
+  } catch {
+    return { kind: "unreadable", findings: [] };
+  }
+  const findings = [];
+  for (const [id, scan] of SHAPES) {
+    try {
+      findings.push(...scan(sf));
+    } catch {
+      findings.push(
+        new Finding(sf.rel, 0, id, "HIGH", "shape check threw on this body", 1)
+      );
+    }
+  }
+  return { kind: findings.length === 0 ? null : findings[0].check, findings };
+}
+function writeScanCache(file, entries) {
+  const payload = {
+    schema_version: 1,
+    entries: [...entries].sort((a, b) => a.qualified < b.qualified ? -1 : 1)
+  };
+  try {
+    fs7.mkdirSync(path7.dirname(file), { recursive: true });
+    fs7.writeFileSync(file, `${JSON.stringify(payload, null, 2)}
+`, "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/scripts/audit_skill_overlap.ts
+var import_yaml2 = __toESM(require_dist(), 1);
+import { createHash as createHash3 } from "node:crypto";
+import * as fs8 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 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 CROSS_CACHE_NAME = "neighbour-overlap.json";
+var ALLOWLIST_CAP = 20;
+var FM_RE = /^---\n([\s\S]*?)\n---/m;
+var OVERLAP_THRESHOLD = 0.7;
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "when",
+  "use",
+  "or",
+  "of",
+  "to",
+  "a",
+  "an",
+  "is",
+  "in",
+  "on",
+  "by",
+  "be",
+  "at",
+  "as",
+  "it",
+  "if",
+  "are",
+  "this",
+  "that",
+  "from",
+  "but",
+  "not",
+  "can",
+  "any",
+  "all",
+  "no",
+  "after",
+  "before",
+  "during",
+  "user",
+  "agent",
+  "code",
+  "project",
+  "via",
+  "into",
+  "onto",
+  "even",
+  "without",
+  "naming",
+  "run",
+  "runs",
+  "running",
+  "each",
+  "every",
+  "one",
+  "two",
+  "now",
+  "then",
+  "also",
+  "based",
+  "default",
+  "skill",
+  "you",
+  "your",
+  "should",
+  "must",
+  "see",
+  "do",
+  "not"
+]);
+function _isDir(p) {
+  try {
+    return fs8.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _isFile(p) {
+  try {
+    return fs8.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function _default_skill_root() {
+  return SRC_SKILLS();
+}
+function _keyword_vector(text) {
+  const counter = /* @__PURE__ */ new Map();
+  const re = /[a-z][a-z0-9_-]{2,}/g;
+  const lowered = text.toLowerCase();
+  let m;
+  while ((m = re.exec(lowered)) !== null) {
+    const t = m[0];
+    if (!STOPWORDS.has(t)) {
+      counter.set(t, (counter.get(t) ?? 0) + 1);
+    }
+  }
+  return counter;
+}
+function _cosine(a, b) {
+  const shared = [];
+  for (const k of a.keys()) {
+    if (b.has(k)) {
+      shared.push(k);
+    }
+  }
+  if (shared.length === 0) {
+    return 0;
+  }
+  let num = 0;
+  for (const t of shared) {
+    num += a.get(t) * b.get(t);
+  }
+  let da = 0;
+  for (const v of a.values()) {
+    da += v * v;
+  }
+  let db = 0;
+  for (const v of b.values()) {
+    db += v * v;
+  }
+  da = Math.sqrt(da);
+  db = Math.sqrt(db);
+  return da && db ? num / (da * db) : 0;
+}
+function _parse(md, field = "body") {
+  const text = fs8.readFileSync(md, "utf-8");
+  let fm = {};
+  let body = text;
+  const m = FM_RE.exec(text);
+  if (m && m.index === 0) {
+    try {
+      fm = (0, import_yaml2.parse)(m[1], { version: "1.1" }) ?? {};
+    } catch {
+      fm = {};
+    }
+    body = text.slice(m.index + m[0].length);
+  }
+  const isObj = fm !== null && typeof fm === "object" && !Array.isArray(fm);
+  const name = isObj ? fm["name"] : null;
+  const packsVal = isObj ? fm["packs"] : null;
+  const descVal = isObj ? fm["description"] : null;
+  const source = field === "description" ? descVal ? String(descVal) : "" : body;
+  return {
+    name: name ? String(name) : path8.basename(path8.dirname(md)),
+    relpath: _relPosix(md, ROOT2),
+    abspath: path8.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("/");
+}
+function _rglobSkillMd(root) {
+  const out = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs8.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = path8.join(dir, ent.name);
+      if (ent.name === "SKILL.md") {
+        out.push(full);
+      }
+      if (ent.isDirectory() || ent.isSymbolicLink() && _isDir(full)) {
+        walk(full);
+      }
+    }
+  };
+  walk(root);
+  out.sort(_pathlibCompare);
+  return out;
+}
+function _pathlibCompare(a, b) {
+  const pa = a.split(path8.sep);
+  const pb = b.split(path8.sep);
+  const n = Math.min(pa.length, pb.length);
+  for (let i = 0; i < n; i++) {
+    const x = pa[i];
+    const y = pb[i];
+    if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return pa.length - pb.length;
+}
+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")) {
+      continue;
+    }
+    const key = path8.basename(path8.dirname(md));
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    skills.push(_parse(md, field));
+  }
+  return skills;
+}
+function pyRound(x, ndigits) {
+  const factor = 10 ** ndigits;
+  const scaled = x * factor;
+  const floor = Math.floor(scaled);
+  const diff = scaled - floor;
+  let r;
+  if (diff > 0.5) {
+    r = floor + 1;
+  } else if (diff < 0.5) {
+    r = floor;
+  } else {
+    r = floor % 2 === 0 ? floor : floor + 1;
+  }
+  return r / factor;
+}
+function find_pairs(skills, threshold) {
+  const pairs = [];
+  for (let i = 0; i < skills.length; i++) {
+    for (let j = i + 1; j < skills.length; j++) {
+      const a = skills[i];
+      const b = skills[j];
+      const sim = _cosine(a.vector, b.vector);
+      if (sim >= threshold) {
+        const shared = [];
+        for (const p of a.packs) {
+          if (b.packs.has(p)) {
+            shared.push(p);
+          }
+        }
+        shared.sort();
+        pairs.push({
+          a: a.name,
+          b: b.name,
+          a_path: a.relpath,
+          b_path: b.relpath,
+          similarity: pyRound(sim, 3),
+          same_domain: shared.length > 0,
+          shared_packs: shared
+        });
+      }
+    }
+  }
+  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"));
+}
+function crossPairsForFiles(neighbourFiles, ourRoot, threshold = OVERLAP_THRESHOLD, field = "body") {
+  const theirs = [];
+  for (const md of neighbourFiles) {
+    try {
+      theirs.push(_parse(md, field));
+    } catch {
+    }
+  }
+  const ours = collect(ourRoot, field);
+  const out = [];
+  for (const n of theirs) {
+    for (const o of ours) {
+      const sim = _cosine(n.vector, o.vector);
+      if (sim < threshold) continue;
+      out.push({
+        neighbour: n.name,
+        neighbour_path: n.abspath,
+        ours: o.name,
+        similarity: pyRound(sim, 3)
+      });
+    }
+  }
+  return stableSort(out, (p) => [-p.similarity]);
+}
+function crossRootOverlapMap(pairs) {
+  const out = /* @__PURE__ */ new Map();
+  for (const p of pairs) {
+    const hit = out.get(p.neighbour_path);
+    if (hit === void 0) {
+      out.set(p.neighbour_path, { names: [p.ours], similarity: p.similarity });
+      continue;
+    }
+    if (!hit.names.includes(p.ours)) hit.names.push(p.ours);
+    if (p.similarity > hit.similarity) hit.similarity = p.similarity;
+  }
+  for (const hit of out.values()) hit.names.sort();
+  return out;
+}
+function censusDigest(neighbourFiles, ourRoot, threshold, field = "body") {
+  const h = createHash3("sha256");
+  h.update(`${String(threshold)}
+${field}
+`);
+  const sides = [
+    [...neighbourFiles].sort(),
+    skillMdsUnder(ourRoot)
+  ];
+  for (const side of sides) {
+    h.update("side\n");
+    for (const md of side) {
+      let bytes;
+      try {
+        bytes = fs8.readFileSync(md);
+      } catch {
+        continue;
+      }
+      h.update(path8.resolve(md));
+      h.update("\0");
+      h.update(createHash3("sha256").update(bytes).digest("hex"));
+      h.update("\n");
+    }
+  }
+  return h.digest("hex");
+}
+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"));
+    if (parsed.digest === digest && Array.isArray(parsed.pairs)) {
+      return { pairs: parsed.pairs, digest, cached: true };
+    }
+  } catch {
+  }
+  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)}
+`, "utf-8");
+  } catch {
+  }
+  return { pairs, digest, cached: false };
+}
+function stableSort(arr, key) {
+  return arr.map((v, i) => [v, i]).sort((x, y) => {
+    const kx = key(x[0]);
+    const ky = key(y[0]);
+    for (let i = 0; i < Math.max(kx.length, ky.length); i++) {
+      const d = (kx[i] ?? 0) - (ky[i] ?? 0);
+      if (d !== 0) {
+        return d;
+      }
+    }
+    return x[1] - y[1];
+  }).map(([v]) => v);
+}
+function _pct(x) {
+  const pct = pyRound(x * 100, 0);
+  return `${pct}%`;
+}
+function render_md(skills, pairs, threshold, field = "body") {
+  const merge = pairs.filter((p) => p.same_domain);
+  const cross = pairs.filter((p) => !p.same_domain);
+  const L = [
+    "# Skill-family overlap report (6.0.0-C Phase 4 Step 8)\n",
+    field === "description" ? `> **NON-CANONICAL measurement.** Cosine over the \`description:\` frontmatter only, across ${skills.length} skills, at \u2265 ${_pct(threshold)}. Routing happens on descriptions, so this answers a question the canonical body metric does not \u2014 but its scores are NOT comparable to the canonical 0.70 merge threshold and must never be mixed into a merge decision. The canonical run is the one without \`--descriptions\`.
+` : `> Content cosine-similarity over ${skills.length} skills; pairs at \u2265 ${_pct(threshold)}. **Same-domain pairs (shared \`packs:\`) are the merge candidates** consumed by [\`evidence-based-pruning.md\`](../../docs/contracts/evidence-based-pruning.md). This report merges NOTHING \u2014 it is input to a future, human-driven consolidation roadmap.
+`,
+    `
+- Skills scanned: **${skills.length}**`,
+    `
+- Overlap pairs \u2265 ${_pct(threshold)}: **${pairs.length}** (${merge.length} same-domain merge candidates, ${cross.length} cross-domain)
+`,
+    "\n## Merge candidates \u2014 same-domain, \u2265 threshold\n"
+  ];
+  if (merge.length === 0) {
+    L.push("None \u2014 no same-domain pair exceeds the overlap threshold.\n");
+  } else {
+    L.push("| Skill A | Skill B | similarity | shared packs |");
+    L.push("|---|---|--:|---|");
+    for (const p of merge) {
+      L.push(
+        `| \`${p.a}\` | \`${p.b}\` | ${_pct(p.similarity)} | ${p.shared_packs.join(", ")} |`
+      );
+    }
+  }
+  L.push("\n## Cross-domain overlaps (informational, not merge candidates)\n");
+  if (cross.length === 0) {
+    L.push("None.\n");
+  } else {
+    L.push("| Skill A | Skill B | similarity |");
+    L.push("|---|---|--:|");
+    for (const p of cross) {
+      L.push(`| \`${p.a}\` | \`${p.b}\` | ${_pct(p.similarity)} |`);
+    }
+  }
+  return L.join("\n") + "\n";
+}
+function _pyJsonStr(s) {
+  let out = '"';
+  for (const ch of s) {
+    const code = ch.codePointAt(0);
+    if (ch === '"') {
+      out += '\\"';
+    } else if (ch === "\\") {
+      out += "\\\\";
+    } else if (ch === "\n") {
+      out += "\\n";
+    } else if (ch === "\r") {
+      out += "\\r";
+    } else if (ch === "	") {
+      out += "\\t";
+    } else if (ch === "\b") {
+      out += "\\b";
+    } else if (ch === "\f") {
+      out += "\\f";
+    } else if (code < 32) {
+      out += `\\u${code.toString(16).padStart(4, "0")}`;
+    } else if (code < 127) {
+      out += ch;
+    } else if (code <= 65535) {
+      out += `\\u${code.toString(16).padStart(4, "0")}`;
+    } else {
+      const c = code - 65536;
+      const hi = 55296 + (c >> 10);
+      const lo = 56320 + (c & 1023);
+      out += `\\u${hi.toString(16).padStart(4, "0")}\\u${lo.toString(16).padStart(4, "0")}`;
+    }
+  }
+  return out + '"';
+}
+function _pyNumber(n) {
+  if (Number.isInteger(n)) {
+    return String(n);
+  }
+  return String(n);
+}
+function _floatStr(n) {
+  if (Number.isInteger(n)) {
+    return `${n}.0`;
+  }
+  return String(n);
+}
+function _pairToJson(p) {
+  return {
+    a: p.a,
+    b: p.b,
+    a_path: p.a_path,
+    b_path: p.b_path,
+    // similarity is a float (round(x,3)); force float repr.
+    similarity: new FloatTag(p.similarity),
+    same_domain: p.same_domain,
+    shared_packs: p.shared_packs
+  };
+}
+var FloatTag = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+};
+function main4(argv = null) {
+  const args = parse_args4(argv ?? process.argv.slice(2));
+  const root = args.root ?? _default_skill_root();
+  if (args.neighbourRoot !== void 0) {
+    return _mainCrossRoot(args, root);
+  }
+  const skills = collect(root, args.field);
+  try {
+    assertScanned({
+      gate: "audit_skill_overlap",
+      scanned: skills.length,
+      units: "skill(s)",
+      roots: [_relPosix(root, ROOT2)]
+    });
+  } catch (exc) {
+    if (!(exc instanceof DeadScopeError)) {
+      throw exc;
+    }
+    process.stderr.write(`\u274C  ${exc.message}
+`);
+    return 3;
+  }
+  process.stderr.write(`scanned: ${String(skills.length)}
+`);
+  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 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");
+  const merge = pairs.filter((p) => p.same_domain);
+  if (!args.quiet) {
+    process.stdout.write(
+      `\u2705  Skill overlap: ${skills.length} skills, ${pairs.length} pair(s) \u2265 ${_pct(args.threshold)} (${merge.length} same-domain merge candidate(s)).
+`
+    );
+    process.stdout.write(`   JSON: ${_relPosix(outJson, ROOT2)}
+`);
+    process.stdout.write(`   MD:   ${_relPosix(outMd, ROOT2)}
+`);
+  }
+  if (args.printTable) {
+    process.stdout.write(
+      `\u2139\uFE0F  skill overlap${args.strict ? "" : " (advisory)"}: ${skills.length} skills scanned, ${merge.length} same-domain pair(s) \u2265 ${_pct(args.threshold)}
+`
+    );
+    for (const p of merge) {
+      process.stdout.write(
+        `   ${p.similarity.toFixed(3)}  ${p.a} \u2194 ${p.b}  [${p.shared_packs.join(", ")}]
+`
+      );
+    }
+  }
+  if (!args.strict) {
+    return 0;
+  }
+  let allow;
+  try {
+    allow = _loadAllowlist(args.allowlist ?? ALLOWLIST);
+  } catch (exc) {
+    process.stderr.write(`\u274C  ${exc instanceof Error ? exc.message : String(exc)}
+`);
+    return 2;
+  }
+  const blocking = merge.filter((p) => !allow.has(_pairKey(p.a, p.b)));
+  if (blocking.length === 0) {
+    return 0;
+  }
+  process.stderr.write(
+    `\u274C  audit_skill_overlap: ${blocking.length} same-pack pair(s) at or above ${_pct(args.threshold)} with no reviewed justification:
+`
+  );
+  for (const p of blocking) {
+    process.stderr.write(
+      `   ${p.similarity.toFixed(3)}  ${p.a} \u2194 ${p.b}  [${p.shared_packs.join(", ")}]
+`
+    );
+  }
+  process.stderr.write(
+    `   Merge the pair, or add {"pair": "${_pairKey(blocking[0].a, blocking[0].b)}", "reason": "\u2026"} to ${_relPosix(args.allowlist ?? ALLOWLIST, ROOT2)} (cap ${ALLOWLIST_CAP}).
+`
+  );
+  return 1;
+}
+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 { pairs, digest, cached } = cachedCrossRootPairs(
+    skillMdsUnder(neighbourRoot),
+    ourRoot,
+    cacheFile,
+    args.threshold,
+    args.field
+  );
+  const theirs = collect(neighbourRoot, args.field);
+  process.stderr.write(`scanned: ${String(theirs.length)}
+`);
+  if (!args.quiet) {
+    process.stdout.write(
+      `\u2705  Neighbour overlap: ${theirs.length} neighbour skill(s) \xD7 ${collect(ourRoot, args.field).length} of ours, ${pairs.length} pair(s) \u2265 ${_pct(args.threshold)} (${cached ? "from cache" : "recomputed"}).
+`
+    );
+    process.stdout.write(`   census digest: ${digest.slice(0, 12)}
+`);
+    process.stdout.write(`   cache: ${_relPosix(cacheFile, ROOT2)}
+`);
+  }
+  const byPath = crossRootOverlapMap(pairs);
+  for (const skill of theirs) {
+    const hit = byPath.get(skill.abspath);
+    if (hit === void 0) continue;
+    process.stdout.write(
+      `   ${hit.similarity.toFixed(3)}  ${skill.name}  also: ${hit.names.join(", ")}
+`
+    );
+  }
+  return 0;
+}
+function _pairKey(a, b) {
+  return a < b ? `${a}::${b}` : `${b}::${a}`;
+}
+function _loadAllowlist(file) {
+  if (!_isFile(file)) {
+    return /* @__PURE__ */ new Set();
+  }
+  const data = JSON.parse(fs8.readFileSync(file, "utf-8"));
+  const entries = Array.isArray(data.entries) ? data.entries : [];
+  if (entries.length > ALLOWLIST_CAP) {
+    throw new Error(
+      `audit_skill_overlap: allowlist has ${entries.length} entries (> ${ALLOWLIST_CAP}). Per the autonomous-execution allowlist-growth antipattern, the threshold is wrong, not the corpus \u2014 re-litigate the bar, do not grow the list.`
+    );
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    const [a, b] = String(e.pair).split("::");
+    if (a === void 0 || b === void 0 || (e.reason ?? "").trim() === "") {
+      throw new Error(
+        `audit_skill_overlap: allowlist entry ${JSON.stringify(e)} needs "pair": "a::b" and a non-empty "reason".`
+      );
+    }
+    out.add(_pairKey(a, b));
+  }
+  return out;
+}
+function _dumpsWithFloats(obj, level = 0) {
+  if (obj instanceof FloatTag) {
+    return _floatStr(obj.value);
+  }
+  if (obj === null || obj === void 0) {
+    return "null";
+  }
+  if (typeof obj === "number") {
+    return _pyNumber(obj);
+  }
+  if (typeof obj === "string") {
+    return _pyJsonStr(obj);
+  }
+  if (obj === true) {
+    return "true";
+  }
+  if (obj === false) {
+    return "false";
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) {
+      return "[]";
+    }
+    const pad2 = " ".repeat(2 * (level + 1));
+    const closePad2 = " ".repeat(2 * level);
+    return `[
+${obj.map((v) => pad2 + _dumpsWithFloats(v, level + 1)).join(",\n")}
+${closePad2}]`;
+  }
+  const keys = Object.keys(obj);
+  if (keys.length === 0) {
+    return "{}";
+  }
+  const pad = " ".repeat(2 * (level + 1));
+  const closePad = " ".repeat(2 * level);
+  const parts = keys.map(
+    (k) => `${pad}${_pyJsonStr(k)}: ${_dumpsWithFloats(obj[k], level + 1)}`
+  );
+  return `{
+${parts.join(",\n")}
+${closePad}}`;
+}
+function parse_args4(argv) {
+  const args = {
+    threshold: OVERLAP_THRESHOLD,
+    quiet: false,
+    printTable: false,
+    strict: false,
+    field: "body"
+  };
+  const takeValue = (flag, inline, next) => {
+    const v = inline ?? next();
+    if (v === void 0) {
+      process.stderr.write(`argument ${flag}: expected one argument
+`);
+      process.exit(2);
+    }
+    return v;
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--quiet") {
+      args.quiet = true;
+    } else if (a === "--strict") {
+      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]));
+    } else if (a === "--descriptions") {
+      args.field = "description";
+    } else if (a === "--print-table") {
+      args.printTable = true;
+    } else if (a === "--threshold" || a.startsWith("--threshold=")) {
+      const inline = a.startsWith("--threshold=") ? a.slice("--threshold=".length) : void 0;
+      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(
+        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]));
+    } 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]));
+    } 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]));
+    } else {
+      process.stderr.write(`unrecognized arguments: ${a}
+`);
+      process.exit(2);
+    }
+  }
+  return args;
+}
+function _isCliEntry4() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL4(path8.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]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+var _isMain = _isCliEntry4();
+if (_isMain) {
+  process.exitCode = main4();
+}
+
+// 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"));
+    return gatedEventsFrom(doc, doc.native_event_aliases ?? {});
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function ourSkillNames(packageRoot) {
+  try {
+    return new Set(
+      fs9.readdirSync(path9.join(packageRoot, "src", "skills"), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name)
+    );
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function runCensus(projectRoot, packageRoot, homeRoot) {
+  const scanned = /* @__PURE__ */ new Map();
+  const scan = (p) => {
+    const hit = scanned.get(p);
+    if (hit !== void 0) return hit;
+    const kind = scanNeighbourBody(p).kind;
+    scanned.set(p, kind);
+    return kind;
+  };
+  const base = {
+    gatedEvents: gatedEvents(packageRoot),
+    templatesRoot: path9.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");
+  let overlaps = /* @__PURE__ */ new Map();
+  if (first.skills.length > 0 && fs9.existsSync(ourRoot)) {
+    try {
+      const { pairs } = cachedCrossRootPairs(
+        first.skills.map((s) => s.source),
+        ourRoot,
+        path9.join(projectRoot, "agents", "reports", CROSS_CACHE_NAME),
+        OVERLAP_THRESHOLD
+      );
+      overlaps = crossRootOverlapMap(pairs);
+    } catch {
+    }
+  }
+  const full = census(projectRoot, { ...base, overlaps });
+  writeScanCache(
+    scanCachePath(projectRoot),
+    // `fileDigest`, not the census's own `digest`: the ranker re-digests the
+    // file bytes it is about to index, and a cache written under a different
+    // digest function would read as `digest-changed` on every prompt.
+    full.skills.map((s) => ({
+      qualified: s.qualified,
+      digest: fileDigest(s.source) ?? "",
+      unscanned: s.unscanned
+    }))
+  );
+  return full;
+}
+function summaryLine(c) {
+  const counts = [
+    `${c.hook_groups.length} hook group(s)`,
+    `${c.skills.length} skill(s)`,
+    `${c.commands.length} command(s)`,
+    `${c.agents.length} agent(s)`,
+    `${c.mcp_servers.length} mcp server(s)`,
+    `${c.rule_files.length} rule file(s)`,
+    `${c.instruction_sections.length} instruction section(s)`
+  ].join(", ");
+  const labels = c.hosts.map((h) => `${h.host}=${h.label}`).join(" ");
+  return `  \u{1F3D8}\uFE0F   neighbours: ${counts}${labels === "" ? "" : ` \xB7 ${labels}`} (run \`doctor neighbours\` for the census)`;
+}
+function renderText(c) {
+  const out = [];
+  out.push(`  \u{1F4CD}  project_root: ${c.project_root}`);
+  out.push("");
+  for (const h of c.hosts) {
+    out.push(`  ${h.host}: ${h.label} \u2014 ${h.label_reason}`);
+    for (const e of h.hook_groups) {
+      const matcher = e.matcher === null ? "" : ` matcher=${e.matcher}`;
+      const timeout = e.timeout === null ? "" : ` timeout=${e.timeout}`;
+      out.push(`      ${e.event}: ${e.command_head}${matcher}${timeout} effect=${e.effect}`);
+    }
+  }
+  const section = (title, rows) => {
+    if (rows.length === 0) return;
+    out.push("");
+    out.push(`  ${title} (${rows.length})`);
+    for (const r of rows) out.push(`      ${r.id}`);
+  };
+  if (c.skills.length > 0) {
+    out.push("");
+    out.push(`  skills (${c.skills.length})`);
+    for (const s of c.skills) {
+      const also = s.also.length === 0 ? "" : ` also: ${s.also.join(", ")}`;
+      const why = s.unscanned === null ? "" : ` unscanned: ${s.unscanned}`;
+      out.push(`      ${s.qualified}  compat: ${s.compat}${also}${why}`);
+    }
+  }
+  section("commands", c.commands);
+  section("agents", c.agents);
+  if (c.mcp_servers.length > 0) {
+    out.push("");
+    out.push(`  mcp servers (${c.mcp_servers.length})`);
+    for (const m of c.mcp_servers) {
+      out.push(
+        `      ${m.id}  tools used (${m.tools_window_days}d): ${m.tools_used_30d}  advertised: ${m.tools_advertised}`
+      );
+    }
+  }
+  section("rule files", c.rule_files);
+  section("instruction sections", c.instruction_sections);
+  if (c.warnings.length > 0) {
+    out.push("");
+    for (const w of c.warnings) out.push(`  \u26A0\uFE0F   ${w.kind}: ${w.detail}`);
+  }
+  out.push("");
+  out.push(
+    "  The host owns load order. This census says what is there and what each entry would do;"
+  );
+  out.push("  it cannot say what ran first, and no label here refuses anything.");
+  return out;
+}
+function main5(argv = process.argv.slice(2)) {
+  let json = 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] === "--project") {
+      root = argv[i + 1] ?? root;
+      i += 1;
+    } else if (argv[i] === "--home") {
+      home = argv[i + 1];
+      i += 1;
+    } else if (argv[i] === "neighbours") {
+      continue;
+    } else {
+      process.stderr.write(`doctor neighbours: unknown argument: ${argv[i]}
+`);
+      return 2;
+    }
+  }
+  const c = runCensus(path9.resolve(root), resolvePackageRoot(import.meta.url), home);
+  if (json) {
+    process.stdout.write(`${JSON.stringify(c)}
+`);
+  } else {
+    for (const line of renderText(c)) process.stdout.write(`${line}
+`);
+  }
+  return 0;
+}
+function _isCliEntry5() {
+  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") {
+    return true;
+  }
+  const argvUrl = pathToFileURL5(path9.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]));
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry5()) {
+  process.exit(main5());
+}
+
+export {
+  runCensus,
+  summaryLine,
+  renderText,
+  main5 as main
+};