@dadado/agent-kit-cli 5.16.0 → 5.17.0

package/dist/{chunk-KI6ZHBPV.js → chunk-STGFBAYT.js}

@@ -1,3 +1,11 @@
+import {
+  CLAUDE_COMMANDS_DIR_REL,
+  CLAUDE_SETTINGS_REL,
+  GUARD_SHELL_HOOK_MARKER,
+  RESOLVE_AGENT_KIT_REL,
+  SESSION_START_HOOK_MARKER,
+  discoverInstalledCommands
+} from "./chunk-W24CMQ32.js";
 import {
   createReadinessReport
 } from "./chunk-PNFF6OU3.js";
@@ -19,9 +27,308 @@ import {
   writeJson
 } from "./chunk-77V75A7O.js";
 
-// src/scanner/safe-fixes.ts
-import { readFile, writeFile } from "fs/promises";
+// src/invariants/hooks-health.ts
+import { execFile } from "child_process";
+import { constants, access, readFile, readdir, stat } from "fs/promises";
 import path from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var GIT_HOOK_CANONICAL_NAMES = ["pre-commit", "pre-push", "prepare-commit-msg"];
+var EXPECTED_EVENTS = [
+  "sessionStart",
+  "preCompact",
+  "beforeShellExecution",
+  "afterFileEdit",
+  "beforeSubmitPrompt"
+];
+async function exists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isExecutable(p) {
+  try {
+    await access(p, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveAgentKitCli(rootDir) {
+  const root = path.resolve(rootDir);
+  const candidates = [
+    path.join(root, "node_modules", ".bin", "agent-kit"),
+    path.join(root, "packages", "cli", "dist", "index.js")
+  ];
+  for (const c of candidates) {
+    if (await exists(c)) return c;
+  }
+  try {
+    const { stdout } = await execFileAsync("which", ["agent-kit"], { encoding: "utf8" });
+    const hit = stdout.trim().split("\n")[0]?.trim();
+    if (hit) return hit;
+  } catch {
+  }
+  return null;
+}
+function commandLooksLikeAdapter(command) {
+  const trimmed = command.trim();
+  if (!trimmed) return null;
+  const m = trimmed.match(/(\.cursor\/hooks\/agent\/[A-Za-z0-9._-]+\.sh)\b/);
+  return m?.[1] ?? null;
+}
+async function assessGitHooksInstallDrift(rootDir) {
+  const root = path.resolve(rootDir);
+  const canonicalDir = path.join(root, "git-hooks");
+  if (!await exists(canonicalDir)) return [];
+  let hooksPathCfg = "";
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["-C", root, "config", "--get", "core.hooksPath"],
+      { encoding: "utf8" }
+    );
+    hooksPathCfg = stdout.trim();
+  } catch {
+  }
+  if (hooksPathCfg) {
+    const resolved = path.isAbsolute(hooksPathCfg) ? path.normalize(hooksPathCfg) : path.normalize(path.join(root, hooksPathCfg));
+    if (resolved === path.normalize(canonicalDir)) {
+      return [];
+    }
+  }
+  const gitDir = path.join(root, ".git");
+  if (!await exists(gitDir)) return [];
+  try {
+    const st = await stat(gitDir);
+    if (!st.isDirectory()) return [];
+  } catch {
+    return [];
+  }
+  const installedDir = path.join(gitDir, "hooks");
+  const advisories = [];
+  const installHint = "Install or refresh with: `cp git-hooks/<name> .git/hooks/<name> && chmod +x .git/hooks/<name>` (see git-hooks/README.md)";
+  let names = [...GIT_HOOK_CANONICAL_NAMES];
+  try {
+    const listed = await readdir(canonicalDir);
+    const fromDisk = listed.filter(
+      (n) => GIT_HOOK_CANONICAL_NAMES.includes(n)
+    );
+    if (fromDisk.length > 0) names = fromDisk;
+  } catch {
+  }
+  for (const name of names) {
+    const canonical = path.join(canonicalDir, name);
+    const installed = path.join(installedDir, name);
+    if (!await exists(canonical)) continue;
+    if (!await exists(installed)) {
+      advisories.push(
+        `git-hooks drift: \`.git/hooks/${name}\` missing (canonical \`git-hooks/${name}\` present). ${installHint}`
+      );
+      continue;
+    }
+    try {
+      const [a, b] = await Promise.all([readFile(canonical, "utf8"), readFile(installed, "utf8")]);
+      if (a !== b) {
+        advisories.push(
+          `git-hooks drift: \`.git/hooks/${name}\` differs from \`git-hooks/${name}\`. ${installHint}`
+        );
+      }
+    } catch {
+      advisories.push(
+        `git-hooks drift: could not compare \`git-hooks/${name}\` with \`.git/hooks/${name}\`. ${installHint}`
+      );
+    }
+  }
+  return advisories;
+}
+async function assessSignatureGateHook(rootDir) {
+  const root = path.resolve(rootDir);
+  if (!await exists(path.join(root, "autogit", "gitupdate.md"))) return [];
+  if (await exists(path.join(root, "git-hooks", "prepare-commit-msg"))) return [];
+  return [
+    "signature gate hook missing: `git-hooks/prepare-commit-msg` (/git-staging runs `sh git-hooks/prepare-commit-msg --check -`; a missing file exits 127 and reads as red). Run `agent-kit update` to restore it."
+  ];
+}
+async function assessClaudeCommandAdapters(rootDir) {
+  const root = path.resolve(rootDir);
+  if (!await exists(path.join(root, ".claude"))) return [];
+  const sources = await discoverInstalledCommands(root);
+  if (sources.length === 0) return [];
+  const missing = [];
+  for (const { name } of sources) {
+    if (!await exists(path.join(root, CLAUDE_COMMANDS_DIR_REL, `${name}.md`))) missing.push(name);
+  }
+  if (missing.length === 0) return [];
+  const shown = missing.slice(0, 3).map((n) => `/${n}`);
+  const more = missing.length > shown.length ? `, +${missing.length - shown.length} more` : "";
+  return [
+    `Claude Code command adapters missing: ${missing.length} of ${sources.length} installed kit commands have no \`.claude/commands/<name>.md\` (${shown.join(", ")}${more}), so they are not recognized as slash commands. Run \`agent-kit update --claude\` to generate them (writes only \`.claude/commands/*\`).`
+  ];
+}
+async function resolveGuardProbeArgv(root) {
+  const hookBin = process.env.AGENT_KIT_HOOK_BIN;
+  if (hookBin && await isExecutable(hookBin)) return [hookBin];
+  const local = path.join(root, "node_modules", ".bin", "agent-kit");
+  if (await isExecutable(local)) return [local];
+  const dist = path.join(root, "packages", "cli", "dist", "index.js");
+  if (await exists(dist)) return [process.execPath, dist];
+  try {
+    const { stdout } = await execFileAsync("which", ["agent-kit"], { encoding: "utf8" });
+    const hit = stdout.trim().split("\n")[0]?.trim();
+    if (hit) return [hit];
+  } catch {
+  }
+  return null;
+}
+async function assessClaudeGuardProbe(rootDir) {
+  const root = path.resolve(rootDir);
+  let text;
+  try {
+    text = await readFile(path.join(root, CLAUDE_SETTINGS_REL), "utf8");
+  } catch {
+    return [];
+  }
+  if (!text.includes(GUARD_SHELL_HOOK_MARKER)) {
+    return text.includes(SESSION_START_HOOK_MARKER) ? [
+      "Claude SessionStart hook is installed but the PreToolUse guard hook is absent from `.claude/settings.json`. Run `agent-kit install --claude`."
+    ] : [];
+  }
+  const stale = "Claude guard hook active but resolved CLI is too old or stale dist; update the CLI / rebuild.";
+  const argv = await resolveGuardProbeArgv(root);
+  if (!argv) return [`${stale} (agent-kit CLI not resolvable)`];
+  const [bin, ...lead] = argv;
+  try {
+    const { stdout } = await execFileAsync(
+      bin,
+      [
+        ...lead,
+        "guard",
+        "shell",
+        "--format",
+        "claude",
+        "--command",
+        "git push --force origin main"
+      ],
+      {
+        cwd: root,
+        encoding: "utf8",
+        timeout: 1e4,
+        env: { ...process.env, ALLOW_MAIN_PUSH: "" }
+      }
+    );
+    const decision = JSON.parse(stdout).hookSpecificOutput?.permissionDecision;
+    return decision === "deny" ? [] : [stale];
+  } catch {
+    return [stale];
+  }
+}
+async function assessHooksHealth(rootDir) {
+  const root = path.resolve(rootDir);
+  const hooksJsonPath = ".cursor/hooks.json";
+  const hooksJsonAbs = path.join(root, hooksJsonPath);
+  const reasons = [];
+  const wiredEvents = [];
+  const advisories = [
+    ...await assessGitHooksInstallDrift(root),
+    ...await assessSignatureGateHook(root),
+    ...await assessClaudeGuardProbe(root),
+    ...await assessClaudeCommandAdapters(root)
+  ];
+  if (!await exists(hooksJsonAbs)) {
+    return {
+      status: "missing",
+      reasons: ["`.cursor/hooks.json` not found"],
+      advisories,
+      hooksJsonPath,
+      expectedEvents: [...EXPECTED_EVENTS],
+      wiredEvents
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(hooksJsonAbs, "utf8"));
+  } catch {
+    return {
+      status: "degraded",
+      reasons: ["`.cursor/hooks.json` is not valid JSON"],
+      advisories,
+      hooksJsonPath,
+      expectedEvents: [...EXPECTED_EVENTS],
+      wiredEvents
+    };
+  }
+  const hooks = parsed.hooks ?? {};
+  const adapterRels = /* @__PURE__ */ new Set();
+  for (const event of EXPECTED_EVENTS) {
+    const list = hooks[event];
+    if (Array.isArray(list) && list.length > 0) {
+      wiredEvents.push(event);
+      for (const entry of list) {
+        if (!entry || typeof entry !== "object") continue;
+        const command = String(entry.command ?? "");
+        if (command.endsWith(".py") || command.includes("python")) {
+          reasons.push(`${event} still points at a Python script (${command})`);
+        }
+        const rel = commandLooksLikeAdapter(command);
+        if (rel) adapterRels.add(rel);
+      }
+    } else {
+      reasons.push(`missing hook event: ${event}`);
+    }
+  }
+  const resolveLib = path.join(root, RESOLVE_AGENT_KIT_REL);
+  if (!await exists(resolveLib)) {
+    reasons.push(`missing \`${RESOLVE_AGENT_KIT_REL}\` (thin adapter resolver)`);
+  } else if (!await isExecutable(resolveLib)) {
+    reasons.push(`\`${RESOLVE_AGENT_KIT_REL}\` is not executable (chmod +x)`);
+  }
+  for (const rel of adapterRels) {
+    const abs = path.join(root, rel);
+    if (!await exists(abs)) {
+      reasons.push(`missing adapter script: \`${rel}\``);
+      continue;
+    }
+    try {
+      const st = await stat(abs);
+      if (!st.isFile()) {
+        reasons.push(`adapter path is not a file: \`${rel}\``);
+        continue;
+      }
+    } catch {
+      reasons.push(`unreadable adapter script: \`${rel}\``);
+      continue;
+    }
+    if (!await isExecutable(abs)) {
+      reasons.push(`adapter not executable: \`${rel}\` (chmod +x)`);
+    }
+  }
+  const cli = await resolveAgentKitCli(root);
+  if (!cli) {
+    reasons.push(
+      "agent-kit CLI not resolvable (node_modules/.bin/agent-kit, packages/cli/dist, or PATH)"
+    );
+  }
+  if (Array.isArray(hooks.stop) && hooks.stop.length > 0) {
+    reasons.push("`stop` hook is registered (forbidden; remove it)");
+  }
+  const status = reasons.length === 0 && wiredEvents.length === EXPECTED_EVENTS.length ? "active" : "degraded";
+  return {
+    status,
+    reasons,
+    advisories,
+    hooksJsonPath,
+    expectedEvents: [...EXPECTED_EVENTS],
+    wiredEvents
+  };
+}
+
+// src/scanner/safe-fixes.ts
+import { readFile as readFile2, writeFile } from "fs/promises";
+import path2 from "path";
 var CONTEXT_CONFIG_REL_POSIX = CONTEXT_CONFIG_REL.replace(/\\/g, "/");
 var ESSENTIAL_DIRECTORIES = [
   ".cursor",
@@ -207,7 +514,7 @@ async function refreshRepositoryProfile(rootDir, options) {
     generatedAt
   });
   const desiredProfile = createProfile(scan, report, generatedAt);
-  const profilePath = path.join(scan.rootDir, REPOSITORY_PROFILE_REL);
+  const profilePath = path2.join(scan.rootDir, REPOSITORY_PROFILE_REL);
   const existingProfile = await readJson(profilePath) ?? {};
   const reconciled = reconcileFreshOverExisting(desiredProfile, existingProfile);
   const meaningfulChange = !jsonEqual(
@@ -230,21 +537,21 @@ async function executeSafeReadinessFixes(rootDir, options) {
   });
   const changes = [];
   for (const relativePath of ESSENTIAL_DIRECTORIES) {
-    const absolutePath = path.join(beforeScan.rootDir, relativePath);
-    const exists = await fileExists(absolutePath);
-    if (!exists && !dryRun) await ensureDir(absolutePath);
+    const absolutePath = path2.join(beforeScan.rootDir, relativePath);
+    const exists2 = await fileExists(absolutePath);
+    if (!exists2 && !dryRun) await ensureDir(absolutePath);
     recordChange(
       changes,
       "ensure-agent-kit-directory",
       relativePath,
-      !exists,
+      !exists2,
       dryRun,
-      relativeEvidence(relativePath, exists ? "already exists" : "missing directory")
+      relativeEvidence(relativePath, exists2 ? "already exists" : "missing directory")
     );
   }
   const gitignoreRelativePath = ".gitignore";
-  const gitignorePath = path.join(beforeScan.rootDir, gitignoreRelativePath);
-  const existingGitignore = await fileExists(gitignorePath) ? await readFile(gitignorePath, "utf8") : "";
+  const gitignorePath = path2.join(beforeScan.rootDir, gitignoreRelativePath);
+  const existingGitignore = await fileExists(gitignorePath) ? await readFile2(gitignorePath, "utf8") : "";
   const gitignoreAfterSecrets = mergeSecretIgnores(existingGitignore);
   const secretsChanged = gitignoreAfterSecrets !== existingGitignore;
   const mergedGitignore = mergeKitOwnedIgnores(gitignoreAfterSecrets);
@@ -273,7 +580,7 @@ async function executeSafeReadinessFixes(rootDir, options) {
       kitOwnedChanged ? "kit-owned session/derived paths are missing" : "kit-owned session/derived paths are present"
     )
   );
-  const profilePath = path.join(beforeScan.rootDir, REPOSITORY_PROFILE_REL);
+  const profilePath = path2.join(beforeScan.rootDir, REPOSITORY_PROFILE_REL);
   const existingProfile = await readJson(profilePath) ?? {};
   const desiredProfile = createProfile(beforeScan, before, generatedAt);
   const mergedProfile = mergeMissing(existingProfile, desiredProfile);
@@ -327,6 +634,8 @@ async function executeSafeReadinessFixes(rootDir, options) {
 }
 
 export {
+  assessClaudeCommandAdapters,
+  assessHooksHealth,
   refreshRepositoryProfile,
   executeSafeReadinessFixes
 };

package/dist/{chunk-CGTE7DHN.js → chunk-W24CMQ32.js}

@@ -4,35 +4,146 @@ import {
 import {
   assertRealContained,
   assertRealParentContained,
+  contentHash,
   isRealWriteTargetContained,
-  resolveContained
-} from "./chunk-VS2JD2XC.js";
+  loadManagedHashLedger,
+  resolveContained,
+  saveManagedHashLedger,
+  shouldPreserveCustomizedOverlay
+} from "./chunk-AW74INUW.js";
 import {
-  ensureDir
+  ensureDir,
+  fileExists
 } from "./chunk-77V75A7O.js";
 
+// src/generator/claude-command-adapters.ts
+import { readFile, readdir, writeFile } from "fs/promises";
+import path from "path";
+var CURSOR_COMMANDS_DIR_REL = ".cursor/commands";
+var CLAUDE_COMMANDS_DIR_REL = ".claude/commands";
+var RESERVED_ADAPTER_NAMES = /* @__PURE__ */ new Set(["agent-kit"]);
+function parseCommandFrontmatter(name, raw) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw);
+  if (!match) return null;
+  const body = match[1] ?? "";
+  const descMatch = /^description:\s*(.+)$/m.exec(body);
+  if (!descMatch) return null;
+  const description = (descMatch[1] ?? "").trim();
+  if (!description) return null;
+  return { name, description };
+}
+var CLAUDE_HITL_FALLBACK = `Cursor "Ask questions" is unavailable here: use AskUserQuestion when possible, else print one line \`HITL_GATE: <ask-id> | <label 1> | <label 2> | ...\` immediately followed by the same labels as one numbered list, one list per message, and WAIT for the answer (ask-id and labels: \`.cursor/skills/core/hitl-gates/SKILL.md\`). A headless reply arrives as \`HITL_REPLY: <ask-id> | operator reply <n> | <label>\`; cite that line as the Ask provenance.`;
+var MODEL_INVOCATION_DISABLED = /* @__PURE__ */ new Set([
+  "git-prod",
+  "kit-prod",
+  "backlog-delete",
+  "backlog-cancel",
+  "archive-plan",
+  "hotfix",
+  "run-plan-all"
+]);
+function renderClaudeCommandAdapter(command) {
+  const invocation = MODEL_INVOCATION_DISABLED.has(command.name) ? "disable-model-invocation: true\n" : "";
+  return `---
+description: ${command.description}
+${invocation}---
+
+Read \`.cursor/commands/${command.name}.md\` now and follow that contract exactly \u2014 it is the source of truth for /${command.name}; this file is only a thin adapter for Claude Code.
+
+Adapter rules (Claude Code CLI):
+- ${CLAUDE_HITL_FALLBACK}
+- Skip or cancel means stop.
+- Never \`/git-prod\` without an explicit operator yes.
+- Do not clone Cursor hooks or invent behavior beyond the SoT file.
+`;
+}
+async function discoverInstalledCommands(rootDir) {
+  const dir = path.join(rootDir, CURSOR_COMMANDS_DIR_REL);
+  let entries;
+  try {
+    entries = (await readdir(dir)).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+  const commands = [];
+  for (const file of entries.sort()) {
+    const name = file.slice(0, -3);
+    if (RESERVED_ADAPTER_NAMES.has(name)) continue;
+    try {
+      const raw = await readFile(path.join(dir, file), "utf8");
+      const parsed = parseCommandFrontmatter(name, raw);
+      if (parsed) commands.push(parsed);
+    } catch {
+    }
+  }
+  return commands;
+}
+async function generateClaudeCommandAdapters(rootDir) {
+  const commands = await discoverInstalledCommands(rootDir);
+  if (commands.length === 0) return [];
+  const ledger = await loadManagedHashLedger(rootDir);
+  const results = [];
+  let ledgerDirty = false;
+  for (const command of commands) {
+    const relPath = path.posix.join(CLAUDE_COMMANDS_DIR_REL, `${command.name}.md`);
+    const rendered = renderClaudeCommandAdapter(command);
+    const abs = resolveContained(rootDir, relPath);
+    if (!await isRealWriteTargetContained(rootDir, abs)) {
+      results.push({ relativePath: relPath, status: "skipped-symlink" });
+      continue;
+    }
+    if (!await fileExists(abs)) {
+      await ensureDir(path.dirname(abs));
+      await writeFile(abs, rendered, "utf8");
+      ledger.hashes[relPath] = contentHash(rendered);
+      ledgerDirty = true;
+      results.push({ relativePath: relPath, status: "applied" });
+      continue;
+    }
+    const localContent = await readFile(abs, "utf8");
+    if (localContent === rendered) {
+      if (ledger.hashes[relPath] !== contentHash(rendered)) {
+        ledger.hashes[relPath] = contentHash(rendered);
+        ledgerDirty = true;
+      }
+      results.push({ relativePath: relPath, status: "unchanged" });
+      continue;
+    }
+    if (shouldPreserveCustomizedOverlay(localContent, ledger.hashes[relPath])) {
+      results.push({ relativePath: relPath, status: "preserved-customized" });
+      continue;
+    }
+    await writeFile(abs, rendered, "utf8");
+    ledger.hashes[relPath] = contentHash(rendered);
+    ledgerDirty = true;
+    results.push({ relativePath: relPath, status: "refreshed" });
+  }
+  if (ledgerDirty) await saveManagedHashLedger(rootDir, ledger);
+  return results;
+}
+
 // src/generator/claude-session-start-hook.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import path2 from "path";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import path3 from "path";
 
 // src/generator/claude-settings-ledger.ts
-import { lstat, mkdir, readFile, writeFile } from "fs/promises";
-import path from "path";
+import { lstat, mkdir, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
 var CLAUDE_SETTINGS_LEDGER_REL = ".cursor/agent-kit.claude-settings.json";
 var ClaudeSettingsLedgerSymlinkError = class extends Error {
-  constructor(path3, detail) {
-    super(`Refusing to use Claude settings ledger ${path3}: ${detail}`);
-    this.path = path3;
+  constructor(path4, detail) {
+    super(`Refusing to use Claude settings ledger ${path4}: ${detail}`);
+    this.path = path4;
     this.name = "ClaudeSettingsLedgerSymlinkError";
   }
   path;
 };
 var ClaudeSettingsLedgerInvalidError = class extends Error {
-  constructor(path3) {
+  constructor(path4) {
     super(
-      `Claude settings ledger ${path3} is malformed or has an unknown schemaVersion; not overwriting without authorization.`
+      `Claude settings ledger ${path4} is malformed or has an unknown schemaVersion; not overwriting without authorization.`
     );
-    this.path = path3;
+    this.path = path4;
     this.name = "ClaudeSettingsLedgerInvalidError";
   }
   path;
@@ -98,7 +209,7 @@ async function readState(root) {
     );
   }
   if (!exists) return { abs, state: { kind: "missing" } };
-  const ledger = parseLedger(await readFile(abs, "utf8"));
+  const ledger = parseLedger(await readFile2(abs, "utf8"));
   return { abs, state: ledger ? { kind: "ok", ledger } : { kind: "invalid" } };
 }
 async function loadClaudeSettingsLedger(root) {
@@ -115,8 +226,8 @@ async function saveClaudeSettingsLedger(root, additions, opts = {}) {
     [...base.denyRowsWritten, ...additions.denyRowsWritten ?? []],
     [...base.hookEntriesWritten, ...additions.hookEntriesWritten ?? []]
   );
-  await mkdir(path.dirname(abs), { recursive: true });
-  await writeFile(abs, `${JSON.stringify(merged, null, 2)}
+  await mkdir(path2.dirname(abs), { recursive: true });
+  await writeFile2(abs, `${JSON.stringify(merged, null, 2)}
 `, "utf8");
   return merged;
 }
@@ -294,7 +405,7 @@ async function writeClaudeSessionStartHook(rootDir, opts = {}) {
   }
   let existing = null;
   try {
-    existing = await readFile2(abs, "utf8");
+    existing = await readFile3(abs, "utf8");
   } catch {
     existing = null;
   }
@@ -307,8 +418,8 @@ async function writeClaudeSessionStartHook(rootDir, opts = {}) {
     };
   }
   if (merged.status !== "unchanged") {
-    await ensureDir(path2.dirname(abs));
-    await writeFile2(abs, merged.content, "utf8");
+    await ensureDir(path3.dirname(abs));
+    await writeFile3(abs, merged.content, "utf8");
   }
   const result = {
     relativePath: CLAUDE_SETTINGS_REL,
@@ -334,7 +445,7 @@ async function planClaudeSettingsDrift(rootDir) {
   if (!await isRealWriteTargetContained(rootDir, abs)) return null;
   let raw;
   try {
-    raw = await readFile2(abs, "utf8");
+    raw = await readFile3(abs, "utf8");
   } catch {
     return null;
   }
@@ -400,6 +511,10 @@ function formatClaudeSettingsDrift(report, opts) {
 }
 
 export {
+  CLAUDE_COMMANDS_DIR_REL,
+  CLAUDE_HITL_FALLBACK,
+  discoverInstalledCommands,
+  generateClaudeCommandAdapters,
   CLAUDE_SETTINGS_REL,
   RESOLVE_AGENT_KIT_REL,
   SESSION_START_HOOK_MARKER,

package/dist/{contribute-YKK6YCSI.js → contribute-C6AW2P6J.js}

@@ -1,18 +1,18 @@
 import {
   REGISTRY_CLI_ARGS,
   resolveRegistryFromCli
-} from "./chunk-XWPO3VYQ.js";
+} from "./chunk-PNG7LO2F.js";
 import {
   logger
 } from "./chunk-ZB43YMHW.js";
 import {
   managedPairs
-} from "./chunk-6QV2BFGA.js";
+} from "./chunk-N3HTJVBR.js";
 import {
   loadAgentKitManifest,
   normalizeRelPath,
   resolveContained
-} from "./chunk-VS2JD2XC.js";
+} from "./chunk-AW74INUW.js";
 import "./chunk-5VCOWTTP.js";
 import "./chunk-77V75A7O.js";
 

package/dist/{diff-YTR7VOAN.js → diff-VHNR62SI.js}

@@ -1,18 +1,18 @@
 import {
   REGISTRY_CLI_ARGS,
   resolveRegistryFromCli
-} from "./chunk-XWPO3VYQ.js";
+} from "./chunk-PNG7LO2F.js";
 import {
   logger
 } from "./chunk-ZB43YMHW.js";
 import {
   diffAgainstRegistry,
   summarizeDiff
-} from "./chunk-YGBBHKBE.js";
-import "./chunk-6QV2BFGA.js";
+} from "./chunk-2RDRMGD3.js";
+import "./chunk-N3HTJVBR.js";
 import {
   loadAgentKitManifest
-} from "./chunk-VS2JD2XC.js";
+} from "./chunk-AW74INUW.js";
 import "./chunk-5VCOWTTP.js";
 import "./chunk-77V75A7O.js";