@dadado/agent-kit-cli 5.16.0 → 5.18.0

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

@@ -4,35 +4,146 @@ import {
 import {
   assertRealContained,
   assertRealParentContained,
+  contentHash,
   isRealWriteTargetContained,
-  resolveContained
-} from "./chunk-VS2JD2XC.js";
+  loadManagedHashLedger,
+  resolveContained,
+  saveManagedHashLedger,
+  shouldPreserveCustomizedOverlay
+} from "./chunk-WSJ77EHO.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/{chunk-5OXPNVCF.js → chunk-UEKWZ7BN.js}

@@ -1,6 +1,6 @@
 import {
   L0_ARTIFACTS
-} from "./chunk-6QV2BFGA.js";
+} from "./chunk-GSCXFJB7.js";
 import {
   copyRegistryFile,
   emptyStats,
@@ -12,7 +12,7 @@ import {
   recordOutcome,
   resolveProtectedGlobs,
   saveManagedHashLedger
-} from "./chunk-VS2JD2XC.js";
+} from "./chunk-WSJ77EHO.js";
 import {
   fileExists
 } from "./chunk-77V75A7O.js";

package/dist/chunk-WGLPZXNU.js

@@ -0,0 +1,45 @@
+// src/utils/find-on-path.ts
+import { constants } from "fs";
+import { access, stat } from "fs/promises";
+import path from "path";
+var DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
+async function findOnPath(bin, opts = {}) {
+  const env = opts.env ?? process.env;
+  const platform = opts.platform ?? process.platform;
+  const win = platform === "win32";
+  const pathApi = win ? path.win32 : path.posix;
+  const check = opts.accessFn ?? (async (file, mode2) => {
+    await access(file, mode2);
+    if (!(await stat(file)).isFile()) throw new Error("not a file");
+  });
+  const mode = win ? constants.F_OK : constants.X_OK;
+  if (!bin.trim()) return null;
+  const pathValue = (win ? env.Path ?? env.PATH ?? env.path : env.PATH) ?? "";
+  const exts = win ? (env.PATHEXT ?? DEFAULT_PATHEXT).split(";").filter(Boolean) : [""];
+  const hasExt = win && exts.some((ext) => bin.toLowerCase().endsWith(ext.toLowerCase()));
+  const suffixes = hasExt ? [""] : exts;
+  const tryFile = async (file) => {
+    for (const ext of suffixes) {
+      const candidate = `${file}${ext}`;
+      try {
+        await check(candidate, mode);
+        return candidate;
+      } catch {
+      }
+    }
+    return null;
+  };
+  if (bin.includes("/") || win && bin.includes("\\")) return tryFile(bin);
+  const delimiter = win ? ";" : ":";
+  for (const raw of pathValue.split(delimiter)) {
+    const dir = raw.trim().replace(/^"(.*)"$/, "$1");
+    if (!dir) continue;
+    const hit = await tryFile(pathApi.join(dir, bin));
+    if (hit) return hit;
+  }
+  return null;
+}
+
+export {
+  findOnPath
+};

package/dist/{chunk-VS2JD2XC.js → chunk-WSJ77EHO.js}

@@ -1,6 +1,6 @@
 import {
   HANDOFF_REL
-} from "./chunk-5VCOWTTP.js";
+} from "./chunk-C26I6HTO.js";
 import {
   fileExists,
   readJson,
@@ -678,7 +678,10 @@ var KNOWN_SHIPPED_OVERLAY_HASHES = /* @__PURE__ */ new Set([
   "41d3eac7f116ec22535d830149979fe0a8dbf44625dd841bc9785cbd7c5ddc95",
   "80e11549ad3700d1e7345447aff1b3858e532e9347594ee4f028566c8c7b8a6a",
   "1ffbfa48a76d39f78db66f4ea250c451ae335c31d7e45d0fdc4d99bc714bae33",
-  "19a5aa359e740fa18d7cc19f0b11243bc53d8d016545bce35837deac7fe2ef7e"
+  "19a5aa359e740fa18d7cc19f0b11243bc53d8d016545bce35837deac7fe2ef7e",
+  "f1c7beac6a619520d744fd984bc16b322f3d545b9d8490801aee628dabd94aff",
+  "14d919d01637aa6b5acc92804dbb4ab56cecc88281aedd5cb7b5dcf8f7da958e",
+  "a8decf7b78e2b2c833b0808c3e108322cfb895fadaec159467973a681028d92a"
 ]);
 
 // src/lifecycle/paths.ts

package/dist/{chunk-VGZBARQC.js → chunk-YJMZ6UM2.js}

@@ -4,10 +4,10 @@ import {
 import {
   compareSemver,
   normalizeSemver
-} from "./chunk-XZZAVHH4.js";
+} from "./chunk-YMYLO5LG.js";
 import {
   MANIFEST_RELATIVE_PATH
-} from "./chunk-VS2JD2XC.js";
+} from "./chunk-WSJ77EHO.js";
 import {
   KIT_VERSION,
   pinnedCliSpec

package/dist/{chunk-XZZAVHH4.js → chunk-YMYLO5LG.js}

@@ -6,13 +6,13 @@ import {
 import {
   diffAgainstRegistry,
   summarizeDiff
-} from "./chunk-YGBBHKBE.js";
+} from "./chunk-6FXQINND.js";
 import {
   DEFAULT_REGISTRY_URL,
   assertSafeRegistrySource,
   loadAgentKitManifest,
   resolveRegistryRoot
-} from "./chunk-VS2JD2XC.js";
+} from "./chunk-WSJ77EHO.js";
 import {
   KIT_PACKAGE_SPEC,
   KIT_VERSION

package/dist/{chunk-XWPO3VYQ.js → chunk-ZDCEAGD4.js}

@@ -5,7 +5,7 @@ import {
   DEFAULT_REGISTRY_REF,
   DEFAULT_REGISTRY_URL,
   resolveRegistryRoot
-} from "./chunk-VS2JD2XC.js";
+} from "./chunk-WSJ77EHO.js";
 
 // src/lifecycle/resolve-cli.ts
 async function resolveRegistryFromCli(options) {

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

@@ -1,19 +1,19 @@
 import {
   REGISTRY_CLI_ARGS,
   resolveRegistryFromCli
-} from "./chunk-XWPO3VYQ.js";
+} from "./chunk-ZDCEAGD4.js";
 import {
   logger
 } from "./chunk-ZB43YMHW.js";
 import {
   managedPairs
-} from "./chunk-6QV2BFGA.js";
+} from "./chunk-GSCXFJB7.js";
 import {
   loadAgentKitManifest,
   normalizeRelPath,
   resolveContained
-} from "./chunk-VS2JD2XC.js";
-import "./chunk-5VCOWTTP.js";
+} from "./chunk-WSJ77EHO.js";
+import "./chunk-C26I6HTO.js";
 import "./chunk-77V75A7O.js";
 
 // src/commands/contribute.ts

package/dist/{diff-YTR7VOAN.js → diff-56KMRCER.js}

@@ -1,19 +1,19 @@
 import {
   REGISTRY_CLI_ARGS,
   resolveRegistryFromCli
-} from "./chunk-XWPO3VYQ.js";
+} from "./chunk-ZDCEAGD4.js";
 import {
   logger
 } from "./chunk-ZB43YMHW.js";
 import {
   diffAgainstRegistry,
   summarizeDiff
-} from "./chunk-YGBBHKBE.js";
-import "./chunk-6QV2BFGA.js";
+} from "./chunk-6FXQINND.js";
+import "./chunk-GSCXFJB7.js";
 import {
   loadAgentKitManifest
-} from "./chunk-VS2JD2XC.js";
-import "./chunk-5VCOWTTP.js";
+} from "./chunk-WSJ77EHO.js";
+import "./chunk-C26I6HTO.js";
 import "./chunk-77V75A7O.js";
 
 // src/commands/diff.ts

package/dist/doctor-AA64XVEY.js

@@ -0,0 +1,237 @@
+import {
+  assessHooksHealth,
+  executeSafeReadinessFixes,
+  refreshRepositoryProfile
+} from "./chunk-HRILMD5N.js";
+import {
+  writeReadinessSnapshot
+} from "./chunk-ZXKZBTXE.js";
+import "./chunk-TZYKLR5J.js";
+import "./chunk-WGLPZXNU.js";
+import "./chunk-MAPOQEA2.js";
+import {
+  withCliProgress
+} from "./chunk-QTON2GQX.js";
+import {
+  detectWorkspaceParent,
+  workspaceParentAdvisoryLines
+} from "./chunk-P6PMKYWU.js";
+import {
+  createReadinessReport
+} from "./chunk-PNFF6OU3.js";
+import {
+  runScanner
+} from "./chunk-ZCTSUQRR.js";
+import "./chunk-F6C3GFKV.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import {
+  assessEnvironment
+} from "./chunk-4IWG5CVE.js";
+import {
+  warnIfRunningCliBehindNpm
+} from "./chunk-YMYLO5LG.js";
+import "./chunk-NQ7IQ5XT.js";
+import "./chunk-6FXQINND.js";
+import "./chunk-GSCXFJB7.js";
+import "./chunk-WSJ77EHO.js";
+import {
+  KIT_VERSION
+} from "./chunk-7HDQEK6T.js";
+import "./chunk-C26I6HTO.js";
+import {
+  readJson
+} from "./chunk-77V75A7O.js";
+
+// src/commands/doctor.ts
+import path from "path";
+import { defineCommand } from "citty";
+async function readDeferredEssentials(rootDir, report) {
+  const config = await readJson(
+    path.join(rootDir, ".cursor", "context", "config.json")
+  );
+  const deferredItems = config?.onboarding?.deferredItems;
+  if (!Array.isArray(deferredItems)) return [];
+  const essentialIds = new Set(
+    report.pillars.flatMap((pillar) => pillar.checks).filter((check) => check.essential).map((check) => check.id)
+  );
+  return deferredItems.filter(
+    (item) => typeof item?.checkId === "string" && typeof item?.reason === "string" && essentialIds.has(item.checkId)
+  ).map((item) => ({ checkId: item.checkId, reason: item.reason }));
+}
+async function runDoctor(cwd, options = {}) {
+  const rootDir = path.resolve(cwd);
+  const hooks = await assessHooksHealth(rootDir);
+  const workspaceParent = await detectWorkspaceParent(rootDir);
+  if (workspaceParent) {
+    const scan2 = await runScanner(rootDir);
+    const report2 = createReadinessReport(scan2, {
+      generatorVersion: KIT_VERSION,
+      generatedAt: options.generatedAt
+    });
+    return {
+      report: report2,
+      safeChanges: [],
+      hooks,
+      env: await assessEnvironment(),
+      deferredEssentials: [],
+      workspaceParent
+    };
+  }
+  const env = await assessEnvironment();
+  if (options.fixSafe) {
+    const execution = await executeSafeReadinessFixes(rootDir, {
+      generatorVersion: KIT_VERSION,
+      generatedAt: options.generatedAt
+    });
+    await writeReadinessSnapshot(rootDir, execution.after);
+    return {
+      report: execution.after,
+      safeChanges: execution.changes,
+      hooks,
+      env,
+      deferredEssentials: await readDeferredEssentials(rootDir, execution.after)
+    };
+  }
+  if (options.refreshProfile) {
+    const refresh = await refreshRepositoryProfile(rootDir, {
+      generatorVersion: KIT_VERSION,
+      generatedAt: options.generatedAt
+    });
+    const scan2 = await runScanner(rootDir);
+    const report2 = createReadinessReport(scan2, {
+      generatorVersion: KIT_VERSION,
+      generatedAt: options.generatedAt
+    });
+    await writeReadinessSnapshot(rootDir, report2);
+    return {
+      report: report2,
+      safeChanges: [],
+      hooks,
+      env,
+      profileRefreshed: refresh.changed,
+      deferredEssentials: await readDeferredEssentials(rootDir, report2)
+    };
+  }
+  const scan = await runScanner(rootDir);
+  const report = createReadinessReport(scan, {
+    generatorVersion: KIT_VERSION,
+    generatedAt: options.generatedAt
+  });
+  await writeReadinessSnapshot(rootDir, report);
+  return {
+    report,
+    safeChanges: [],
+    hooks,
+    env,
+    deferredEssentials: await readDeferredEssentials(rootDir, report)
+  };
+}
+function printDoctorSummary(result, rootDir) {
+  if (result.workspaceParent) {
+    for (const line of workspaceParentAdvisoryLines(rootDir, result.workspaceParent, "doctor")) {
+      console.log(line);
+    }
+    return;
+  }
+  const { summary, pendingActions } = result.report;
+  const fixed = result.safeChanges.filter((change) => change.status === "applied").length;
+  const nextAction = pendingActions[0];
+  console.log("Repository readiness");
+  console.log(
+    `  ready: ${summary.ready}, choices: ${summary.needs_choice}, manual: ${summary.manual}, blocked: ${summary.blocked}`
+  );
+  console.log(`  safe fixes applied: ${fixed}`);
+  console.log(`  pending actions: ${pendingActions.length}`);
+  if (result.profileRefreshed !== void 0) {
+    console.log(
+      `  profile refreshed: ${result.profileRefreshed ? "yes (facts changed)" : "no (already current)"}`
+    );
+  }
+  for (const item of result.deferredEssentials) {
+    console.log(`  Deferred essential: ${item.checkId} \u2014 ${item.reason}`);
+  }
+  console.log(`hooks: ${result.hooks.status}`);
+  if (result.hooks.reasons.length > 0) {
+    for (const reason of result.hooks.reasons.slice(0, 5)) {
+      console.log(`  - ${reason}`);
+    }
+  }
+  if (result.hooks.advisories.length > 0) {
+    console.log("hooks advisories (soft; install via cp, see git-hooks/README.md):");
+    for (const tip of result.hooks.advisories.slice(0, 5)) {
+      console.log(`  - ${tip}`);
+    }
+  }
+  console.log("environment:");
+  const pathLabel = result.env.binOnPath ? `ok (v${result.env.binVersion ?? "unknown"} at ${result.env.binPath})` : "MISSING";
+  console.log(`  - bin on PATH (agent-kit): ${pathLabel}`);
+  console.log(
+    `  - npm prefix writable: ${result.env.npmPrefixWritable ? "ok" : "BLOCKED"}${result.env.npmPrefix.prefix ? ` (${result.env.npmPrefix.prefix})` : ""}`
+  );
+  if (!result.env.npmPrefixWritable && result.env.npmPrefix.reason) {
+    console.log(`    - ${result.env.npmPrefix.reason}`);
+  }
+  console.log(
+    `  - node version >= 20: ${result.env.nodeVersionOk ? "ok" : "TOO OLD"} (${result.env.nodeVersion})`
+  );
+  console.log(
+    `  - shell profile: ${result.env.shellProfile ?? "not detected (zsh/bash only)"}${result.env.shell ? ` (shell: ${result.env.shell})` : ""}`
+  );
+  if (process.env.ALLOW_MAIN_PUSH === "1") {
+    console.log("\u26A0\uFE0F  WARNING: ALLOW_MAIN_PUSH=1 is set in environment");
+    console.log("   This disables main-push protection for agent Shell commands.");
+    console.log("   Consider unsetting it: unset ALLOW_MAIN_PUSH");
+  }
+  console.log(
+    nextAction ? `Next: ${nextAction.recommendation}` : "Next: repository readiness checks are complete"
+  );
+}
+var doctorCommand = defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Diagnose repository readiness; optional --fix-safe local repairs."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd()
+    },
+    json: {
+      type: "boolean",
+      description: "Print deterministic machine-readable JSON without status messages",
+      default: false
+    },
+    "fix-safe": {
+      type: "boolean",
+      description: "Apply only local, reversible, merge-safe readiness fixes",
+      default: false
+    },
+    "refresh-profile": {
+      type: "boolean",
+      description: "Reconcile .cursor/agent-kit.config.json with current scanner facts: fresh values win on shared keys, unrecognized existing keys are preserved",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (!args.json) {
+      await warnIfRunningCliBehindNpm(args.cwd, { warn: (message) => logger.warn(message) });
+    }
+    const run = () => runDoctor(args.cwd, {
+      fixSafe: args["fix-safe"],
+      refreshProfile: args["refresh-profile"]
+    });
+    const result = args.json ? await run() : await withCliProgress("doctor", run);
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    printDoctorSummary(result, path.resolve(args.cwd));
+  }
+});
+export {
+  doctorCommand,
+  printDoctorSummary,
+  runDoctor
+};

package/dist/{handoff-3UI6VKVG.js → handoff-34SDU4FF.js}

@@ -6,7 +6,7 @@ import {
   extractHandoffNamedPlans,
   namedPlanCandidatePaths,
   parsePlanFrontmatter
-} from "./chunk-KD2MYBB6.js";
+} from "./chunk-3J3I2W22.js";
 import {
   PM_TOOL_LABELS
 } from "./chunk-F6C3GFKV.js";
@@ -15,7 +15,7 @@ import {
 } from "./chunk-ZB43YMHW.js";
 import {
   HANDOFF_REL
-} from "./chunk-5VCOWTTP.js";
+} from "./chunk-C26I6HTO.js";
 import {
   ensureDir,
   fileExists,

package/dist/{hook-MUV6Y7UW.js → hook-KRIXBLNW.js}

@@ -16,25 +16,25 @@ import {
 import {
   formatPlanIndexSection,
   writePlanIndex
-} from "./chunk-KD2MYBB6.js";
+} from "./chunk-3J3I2W22.js";
 import {
   READINESS_SNAPSHOT_RELATIVE_PATH
 } from "./chunk-ZXKZBTXE.js";
 import {
   stampLastCheckedAt
-} from "./chunk-XZZAVHH4.js";
+} from "./chunk-YMYLO5LG.js";
 import {
   loadContextConfig
 } from "./chunk-NQ7IQ5XT.js";
-import "./chunk-YGBBHKBE.js";
-import "./chunk-6QV2BFGA.js";
+import "./chunk-6FXQINND.js";
+import "./chunk-GSCXFJB7.js";
 import {
   MANIFEST_RELATIVE_PATH
-} from "./chunk-VS2JD2XC.js";
+} from "./chunk-WSJ77EHO.js";
+import "./chunk-7HDQEK6T.js";
 import {
   HANDOFF_REL
-} from "./chunk-5VCOWTTP.js";
-import "./chunk-7HDQEK6T.js";
+} from "./chunk-C26I6HTO.js";
 import {
   fileExists
 } from "./chunk-77V75A7O.js";