@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/chunk-W24CMQ32.js

@@ -0,0 +1,525 @@
+import {
+  INTERACTIVE_DENY_RULES
+} from "./chunk-MAPOQEA2.js";
+import {
+  assertRealContained,
+  assertRealParentContained,
+  contentHash,
+  isRealWriteTargetContained,
+  loadManagedHashLedger,
+  resolveContained,
+  saveManagedHashLedger,
+  shouldPreserveCustomizedOverlay
+} from "./chunk-AW74INUW.js";
+import {
+  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 readFile3, writeFile as writeFile3 } from "fs/promises";
+import path3 from "path";
+
+// src/generator/claude-settings-ledger.ts
+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(path4, detail) {
+    super(`Refusing to use Claude settings ledger ${path4}: ${detail}`);
+    this.path = path4;
+    this.name = "ClaudeSettingsLedgerSymlinkError";
+  }
+  path;
+};
+var ClaudeSettingsLedgerInvalidError = class extends Error {
+  constructor(path4) {
+    super(
+      `Claude settings ledger ${path4} is malformed or has an unknown schemaVersion; not overwriting without authorization.`
+    );
+    this.path = path4;
+    this.name = "ClaudeSettingsLedgerInvalidError";
+  }
+  path;
+};
+function emptyLedger() {
+  return { schemaVersion: 1, denyRowsWritten: [], hookEntriesWritten: [] };
+}
+function hookKey(r) {
+  return `${r.event}\0${r.marker}`;
+}
+function normalize(denyRows, hooks) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const h of hooks) seen.set(hookKey(h), { event: h.event, marker: h.marker });
+  return {
+    schemaVersion: 1,
+    denyRowsWritten: [...new Set(denyRows)].sort(),
+    hookEntriesWritten: [...seen.values()].sort(
+      (a, b) => a.event.localeCompare(b.event) || a.marker.localeCompare(b.marker)
+    )
+  };
+}
+function parseLedger(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return null;
+  const o = data;
+  if (o.schemaVersion !== 1) return null;
+  if (!Array.isArray(o.denyRowsWritten) || !o.denyRowsWritten.every((r) => typeof r === "string")) {
+    return null;
+  }
+  if (!Array.isArray(o.hookEntriesWritten)) return null;
+  const hooks = [];
+  for (const h of o.hookEntriesWritten) {
+    if (typeof h !== "object" || h === null || typeof h.event !== "string" || typeof h.marker !== "string") {
+      return null;
+    }
+    hooks.push({
+      event: h.event,
+      marker: h.marker
+    });
+  }
+  return normalize(o.denyRowsWritten, hooks);
+}
+async function readState(root) {
+  const abs = resolveContained(root, CLAUDE_SETTINGS_LEDGER_REL);
+  let exists = true;
+  try {
+    await lstat(abs);
+  } catch {
+    exists = false;
+  }
+  try {
+    if (exists) await assertRealContained(root, abs);
+    else await assertRealParentContained(root, abs);
+  } catch (err) {
+    throw new ClaudeSettingsLedgerSymlinkError(
+      abs,
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+  if (!exists) return { abs, state: { kind: "missing" } };
+  const ledger = parseLedger(await readFile2(abs, "utf8"));
+  return { abs, state: ledger ? { kind: "ok", ledger } : { kind: "invalid" } };
+}
+async function loadClaudeSettingsLedger(root) {
+  const { state } = await readState(root);
+  return state.kind === "ok" ? state.ledger : null;
+}
+async function saveClaudeSettingsLedger(root, additions, opts = {}) {
+  const { abs, state } = await readState(root);
+  if (state.kind === "invalid" && !opts.overwriteInvalid) {
+    throw new ClaudeSettingsLedgerInvalidError(abs);
+  }
+  const base = state.kind === "ok" ? state.ledger : emptyLedger();
+  const merged = normalize(
+    [...base.denyRowsWritten, ...additions.denyRowsWritten ?? []],
+    [...base.hookEntriesWritten, ...additions.hookEntriesWritten ?? []]
+  );
+  await mkdir(path2.dirname(abs), { recursive: true });
+  await writeFile2(abs, `${JSON.stringify(merged, null, 2)}
+`, "utf8");
+  return merged;
+}
+
+// src/generator/claude-session-start-hook.ts
+var CLAUDE_SETTINGS_REL = ".claude/settings.json";
+var RESOLVE_AGENT_KIT_REL = ".cursor/hooks/agent/resolve-agent-kit.sh";
+var SESSION_START_HOOK_MARKER = "hook session-start --format claude";
+var SESSION_START_DEGRADED_TEXT = "Agent Kit hooks are running in degraded fail-open mode: the agent-kit CLI could not be resolved (checked AGENT_KIT_HOOK_BIN, node_modules/.bin/agent-kit, PATH), or it resolved to a node script and node is not on PATH. Slash command adapters still work; session-context injection is inactive. Fix: install the CLI (npm i -D @dadado/agent-kit-cli), put node on PATH, or set AGENT_KIT_HOOK_BIN.";
+function buildSessionStartHookCommand() {
+  const run = `{ if command -v run_agent_kit >/dev/null 2>&1; then run_agent_kit ${SESSION_START_HOOK_MARKER}; else exec $AGENT_KIT_RESOLVED ${SESSION_START_HOOK_MARKER}; fi; }`;
+  return `_AGENT_KIT_HOOK_ROOT="\${CLAUDE_PROJECT_DIR}"; . "\${CLAUDE_PROJECT_DIR}/${RESOLVE_AGENT_KIT_REL}" 2>/dev/null && resolve_agent_kit && ${run}; printf '%s' ${shellSingleQuote(SESSION_START_DEGRADED_TEXT)}`;
+}
+var GUARD_SHELL_HOOK_MARKER = "guard shell --format claude";
+function buildGuardShellHookCommand() {
+  const run = `{ if command -v run_agent_kit >/dev/null 2>&1; then run_agent_kit ${GUARD_SHELL_HOOK_MARKER}; else exec $AGENT_KIT_RESOLVED ${GUARD_SHELL_HOOK_MARKER}; fi; }`;
+  return `_AGENT_KIT_HOOK_ROOT="\${CLAUDE_PROJECT_DIR}"; . "\${CLAUDE_PROJECT_DIR}/${RESOLVE_AGENT_KIT_REL}" 2>/dev/null && resolve_agent_kit && ${run}; :`;
+}
+function buildGuardShellHookEntry() {
+  return { type: "command", command: buildGuardShellHookCommand(), timeout: 10 };
+}
+function shellSingleQuote(text) {
+  return `'${text.replace(/'/g, "'\\''")}'`;
+}
+function buildSessionStartHookEntry() {
+  return {
+    type: "command",
+    command: buildSessionStartHookCommand(),
+    timeout: 15,
+    statusMessage: "Loading Agent Kit session context"
+  };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function groupHasMarker(group, marker) {
+  if (!isPlainObject(group) || !Array.isArray(group.hooks)) return false;
+  return group.hooks.some(
+    (h) => isPlainObject(h) && typeof h.command === "string" && h.command.includes(marker)
+  );
+}
+function upsertMarkedGroup(arr, group, marker) {
+  const existingIndex = arr.findIndex((g) => groupHasMarker(g, marker));
+  if (existingIndex === -1) {
+    arr.push(group);
+    return "applied";
+  }
+  if (JSON.stringify(arr[existingIndex]) === JSON.stringify(group)) return "unchanged";
+  arr[existingIndex] = group;
+  return "refreshed";
+}
+var SESSION_START_EVENT = "SessionStart";
+var PRE_TOOL_USE_EVENT = "PreToolUse";
+function mergeSessionStartHookIntoSettings(existingRaw, opts = {}) {
+  const ledger = opts.ledger ?? null;
+  const authorized = opts.authorized ?? true;
+  const entry = buildSessionStartHookEntry();
+  const newGroup = { hooks: [entry] };
+  let root = {};
+  if (existingRaw !== null && existingRaw.trim() !== "") {
+    try {
+      const parsed = JSON.parse(existingRaw);
+      if (!isPlainObject(parsed)) throw new Error("root is not an object");
+      root = parsed;
+    } catch {
+      return {
+        content: null,
+        status: "unavailable",
+        instructions: instructionsBlock(entry)
+      };
+    }
+  }
+  const pending = { denyRows: [], hookEntries: [] };
+  const additions = { denyRowsWritten: [], hookEntriesWritten: [] };
+  const hooks = isPlainObject(root.hooks) ? { ...root.hooks } : {};
+  const sessionStart = Array.isArray(hooks.SessionStart) ? [...hooks.SessionStart] : [];
+  const preToolUse = Array.isArray(hooks.PreToolUse) ? [...hooks.PreToolUse] : [];
+  const upserts = [
+    upsertLedgerAwareGroup({
+      arr: sessionStart,
+      group: newGroup,
+      event: SESSION_START_EVENT,
+      marker: SESSION_START_HOOK_MARKER
+    }),
+    upsertLedgerAwareGroup({
+      arr: preToolUse,
+      group: { matcher: "Bash", hooks: [buildGuardShellHookEntry()] },
+      event: PRE_TOOL_USE_EVENT,
+      marker: GUARD_SHELL_HOOK_MARKER
+    })
+  ];
+  hooks.SessionStart = sessionStart;
+  hooks.PreToolUse = preToolUse;
+  root.hooks = hooks;
+  function upsertLedgerAwareGroup(g) {
+    const record = { event: g.event, marker: g.marker };
+    if (g.arr.some((x) => groupHasMarker(x, g.marker))) {
+      additions.hookEntriesWritten.push(record);
+      return upsertMarkedGroup(g.arr, g.group, g.marker);
+    }
+    if (ledger?.hookEntriesWritten.some((h) => h.event === g.event && h.marker === g.marker)) {
+      return "unchanged";
+    }
+    if (ledger === null && !authorized) {
+      pending.hookEntries.push(record);
+      return "unchanged";
+    }
+    additions.hookEntriesWritten.push(record);
+    return upsertMarkedGroup(g.arr, g.group, g.marker);
+  }
+  const status = upserts.reduce(
+    (acc, next, i) => i === 0 ? next : combineStatus(acc, next),
+    "unchanged"
+  );
+  const denyAdded = mergeKitDenyRules(root, { ledger, authorized }, pending, additions);
+  const finalStatus = denyAdded && status === "unchanged" ? "refreshed" : status;
+  return {
+    content: `${JSON.stringify(root, null, 2)}
+`,
+    status: finalStatus,
+    pending,
+    ledgerAdditions: additions
+  };
+}
+function combineStatus(a, b) {
+  return a === "unchanged" && b !== "unchanged" ? "refreshed" : a;
+}
+function mergeKitDenyRules(root, ctx, pending, additions) {
+  if (root.permissions !== void 0 && !isPlainObject(root.permissions)) return false;
+  const permissions = isPlainObject(root.permissions) ? { ...root.permissions } : {};
+  if (permissions.deny !== void 0 && !Array.isArray(permissions.deny)) return false;
+  const deny = Array.isArray(permissions.deny) ? [...permissions.deny] : [];
+  const written = new Set(ctx.ledger?.denyRowsWritten ?? []);
+  for (const rule of INTERACTIVE_DENY_RULES) {
+    if (deny.includes(rule)) additions.denyRowsWritten.push(rule);
+  }
+  const missing = INTERACTIVE_DENY_RULES.filter(
+    (rule) => !deny.includes(rule) && !written.has(rule)
+  );
+  const toAdd = ctx.ledger === null && !ctx.authorized ? [] : missing;
+  if (ctx.ledger === null && !ctx.authorized) pending.denyRows.push(...missing);
+  if (toAdd.length === 0) return false;
+  additions.denyRowsWritten.push(...toAdd);
+  permissions.deny = [...deny, ...toAdd];
+  root.permissions = permissions;
+  return true;
+}
+function instructionsBlock(entry) {
+  return [
+    `Could not parse the existing ${CLAUDE_SETTINGS_REL} as JSON, so Agent Kit did not touch it.`,
+    "Add these hooks by hand (create the arrays if they do not exist).",
+    "Under hooks.SessionStart:",
+    "",
+    JSON.stringify(entry, null, 2),
+    "",
+    'Under hooks.PreToolUse, in a group with "matcher": "Bash":',
+    "",
+    JSON.stringify(buildGuardShellHookEntry(), null, 2)
+  ].join("\n");
+}
+async function writeClaudeSessionStartHook(rootDir, opts = {}) {
+  const authorized = opts.authorized ?? true;
+  const abs = resolveContained(rootDir, CLAUDE_SETTINGS_REL);
+  if (!await isRealWriteTargetContained(rootDir, abs)) {
+    return { relativePath: CLAUDE_SETTINGS_REL, status: "skipped-symlink" };
+  }
+  let ledger;
+  try {
+    ledger = await loadClaudeSettingsLedger(rootDir);
+  } catch (err) {
+    if (err instanceof ClaudeSettingsLedgerSymlinkError) {
+      return { relativePath: CLAUDE_SETTINGS_REL, status: "skipped-symlink" };
+    }
+    throw err;
+  }
+  let existing = null;
+  try {
+    existing = await readFile3(abs, "utf8");
+  } catch {
+    existing = null;
+  }
+  const merged = mergeSessionStartHookIntoSettings(existing, { ledger, authorized });
+  if (merged.status === "unavailable" || merged.content === null) {
+    return {
+      relativePath: CLAUDE_SETTINGS_REL,
+      status: "unavailable",
+      instructions: merged.instructions
+    };
+  }
+  if (merged.status !== "unchanged") {
+    await ensureDir(path3.dirname(abs));
+    await writeFile3(abs, merged.content, "utf8");
+  }
+  const result = {
+    relativePath: CLAUDE_SETTINGS_REL,
+    status: merged.status
+  };
+  if (merged.pending && (merged.pending.denyRows.length || merged.pending.hookEntries.length)) {
+    result.pending = merged.pending;
+  }
+  if (authorized && merged.ledgerAdditions && ledgerGrows(ledger, merged.ledgerAdditions)) {
+    await saveClaudeSettingsLedger(rootDir, merged.ledgerAdditions, { overwriteInvalid: true });
+    result.ledgerPath = CLAUDE_SETTINGS_LEDGER_REL;
+  }
+  return result;
+}
+function ledgerGrows(ledger, add) {
+  if (ledger === null) return true;
+  const rows = new Set(ledger.denyRowsWritten);
+  const hooks = new Set(ledger.hookEntriesWritten.map((h) => `${h.event}\0${h.marker}`));
+  return add.denyRowsWritten.some((r) => !rows.has(r)) || add.hookEntriesWritten.some((h) => !hooks.has(`${h.event}\0${h.marker}`));
+}
+async function planClaudeSettingsDrift(rootDir) {
+  const abs = resolveContained(rootDir, CLAUDE_SETTINGS_REL);
+  if (!await isRealWriteTargetContained(rootDir, abs)) return null;
+  let raw;
+  try {
+    raw = await readFile3(abs, "utf8");
+  } catch {
+    return null;
+  }
+  let existing;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isPlainObject(parsed)) return null;
+    existing = parsed;
+  } catch {
+    return null;
+  }
+  const hooks = isPlainObject(existing.hooks) ? existing.hooks : {};
+  const groupsOf = (event) => Array.isArray(hooks[event]) ? hooks[event] : [];
+  const kitEntries = [
+    { event: SESSION_START_EVENT, marker: SESSION_START_HOOK_MARKER },
+    { event: PRE_TOOL_USE_EVENT, marker: GUARD_SHELL_HOOK_MARKER }
+  ];
+  const present = kitEntries.filter(
+    (e) => groupsOf(e.event).some((g) => groupHasMarker(g, e.marker))
+  );
+  if (present.length === 0) return null;
+  let ledger;
+  try {
+    ledger = await loadClaudeSettingsLedger(rootDir);
+  } catch (err) {
+    if (err instanceof ClaudeSettingsLedgerSymlinkError) return null;
+    throw err;
+  }
+  const merged = mergeSessionStartHookIntoSettings(raw, { ledger, authorized: false });
+  if (merged.content === null) return null;
+  const next = JSON.parse(merged.content);
+  const deny = (r) => isPlainObject(r.permissions) && Array.isArray(r.permissions.deny) ? r.permissions.deny.filter((x) => typeof x === "string") : [];
+  const had = new Set(deny(existing));
+  const denyRows = deny(next).filter((r) => !had.has(r));
+  const ambiguousDenyRows = merged.pending?.denyRows ?? [];
+  const missingEntries = kitEntries.filter((e) => !present.includes(e));
+  const ledgerHas = (e) => Boolean(ledger?.hookEntriesWritten.some((h) => h.event === e.event && h.marker === e.marker));
+  const hookEntries = missingEntries.filter((e) => !ledgerHas(e));
+  if (denyRows.length === 0 && ambiguousDenyRows.length === 0 && hookEntries.length === 0) {
+    return null;
+  }
+  return { denyRows, ambiguousDenyRows, hookEntries };
+}
+function formatClaudeSettingsDrift(report, opts) {
+  const rows = [...report.denyRows, ...report.ambiguousDenyRows];
+  const lines = [
+    `Claude settings drift in ${CLAUDE_SETTINGS_REL}${opts.protectedPath ? " (protected (skipped))" : ""}: update did not write it.`
+  ];
+  if (rows.length > 0) {
+    lines.push("Add to permissions.deny:", JSON.stringify(rows, null, 2));
+    if (report.ambiguousDenyRows.length > 0) {
+      lines.push(
+        `(${report.ambiguousDenyRows.length} row(s) ambiguous: no ${CLAUDE_SETTINGS_LEDGER_REL} ledger, so a deliberate deletion cannot be told apart.)`
+      );
+    }
+  }
+  if (report.hookEntries.length > 0) {
+    lines.push("Missing hook entries (add by hand or use the command below):");
+    for (const e of report.hookEntries) lines.push(`  ${e.event}: ${e.marker}`);
+  }
+  lines.push("Apply with: agent-kit update --claude");
+  return lines;
+}
+
+export {
+  CLAUDE_COMMANDS_DIR_REL,
+  CLAUDE_HITL_FALLBACK,
+  discoverInstalledCommands,
+  generateClaudeCommandAdapters,
+  CLAUDE_SETTINGS_REL,
+  RESOLVE_AGENT_KIT_REL,
+  SESSION_START_HOOK_MARKER,
+  GUARD_SHELL_HOOK_MARKER,
+  writeClaudeSessionStartHook,
+  planClaudeSettingsDrift,
+  formatClaudeSettingsDrift
+};

package/dist/chunk-WW3YZKHW.js

@@ -0,0 +1,165 @@
+import {
+  RESERVED_GATE_IDS,
+  checkClaudeVersion,
+  claudeChildEnv,
+  claudeHeadlessArgs,
+  claudeRedactions,
+  claudeRunCaps,
+  cursorAgentHeadlessArgs,
+  redactSecrets,
+  resolveHitlRunOptions,
+  spawnLogged
+} from "./chunk-OUQZC744.js";
+import {
+  fileExists
+} from "./chunk-77V75A7O.js";
+
+// src/plan-loop/dispatch.ts
+import { mkdir, readFile } from "fs/promises";
+import path from "path";
+var RUN_CATALOG = [
+  "run-plan",
+  "run-plan-all",
+  "continue-plan",
+  "start-project",
+  "backlog-add",
+  "backlog-edit",
+  "backlog-delete",
+  "backlog-cancel",
+  "git-staging"
+];
+var FIRST_CLASS_SLASH_COMMANDS = ["run-plan", "run-plan-all"];
+var RUN_PROMOTE_BLOCKED = RESERVED_GATE_IDS;
+function normalizeSlashName(raw) {
+  return raw.replace(/^\//, "").replace(/\.md$/i, "").trim();
+}
+function classifySlash(name) {
+  const n = normalizeSlashName(name);
+  if (RUN_PROMOTE_BLOCKED.includes(n)) return "promote-blocked";
+  if (n === "run-plan") return "run-plan";
+  if (RUN_CATALOG.includes(n)) return "catalog";
+  return "unknown";
+}
+function rewriteRootArgvToRun(argv) {
+  const idx = argv.findIndex((arg) => arg.length > 0 && !arg.startsWith("-"));
+  if (idx < 0) return argv;
+  const token = argv[idx];
+  if (!token || token === "run") return argv;
+  const kind = classifySlash(token);
+  if (kind === "unknown") return argv;
+  const slash = normalizeSlashName(token);
+  if (FIRST_CLASS_SLASH_COMMANDS.includes(slash)) {
+    if (token === slash) return argv;
+    const next2 = [...argv];
+    next2[idx] = slash;
+    return next2;
+  }
+  const next = [...argv];
+  next.splice(idx, 1, "run", slash);
+  return next;
+}
+function commandMarkdownPath(root, name) {
+  return path.join(root, ".cursor", "commands", `${normalizeSlashName(name)}.md`);
+}
+function buildDispatchPrompt(commandBody) {
+  return [
+    "Follow the Agent Kit command below. This session is headless: use numbered-list HITL (Ask questions is Cursor-only). Before each numbered list print one line `HITL_GATE: <ask-id> | <label 1> | <label 2> | ...` (ask-id and labels from the hitl-gates skill), then wait; the operator's answer arrives as `HITL_REPLY: <ask-id> | operator reply <n> | <label>`. Never /git-prod. No CLI --force promote.",
+    "",
+    commandBody.trimEnd(),
+    ""
+  ].join("\n");
+}
+function promoteBlockedMessage(name) {
+  const n = normalizeSlashName(name);
+  return `${n} is operator-gated and omitted from agent-kit run. Use the Cursor slash /${n} (explicit yes). Never auto /git-prod.`;
+}
+function unknownSlashMessage(name) {
+  return `Unknown or unsupported slash '${name}'. Catalog: ${RUN_CATALOG.join(", ")}. git-prod and kit-prod are omitted (operator-gated).`;
+}
+async function readCommandFile(root, name) {
+  const filePath = commandMarkdownPath(root, name);
+  if (!await fileExists(filePath)) {
+    return {
+      ok: false,
+      message: `Command file not found: ${filePath}. Install or refresh Agent Kit L0 so .cursor/commands/${normalizeSlashName(name)}.md exists.`
+    };
+  }
+  const body = await readFile(filePath, "utf8");
+  return { ok: true, path: filePath, body };
+}
+function stamp() {
+  const d = /* @__PURE__ */ new Date();
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}${p(d.getMilliseconds(), 3)}`;
+}
+function cursorAgentDispatchArgs(opts) {
+  return cursorAgentHeadlessArgs(opts);
+}
+function claudeDispatchArgs(opts = {}) {
+  return claudeHeadlessArgs(opts);
+}
+async function runHeadlessDispatch(opts) {
+  if (opts.backendId === "claude") {
+    const log = opts.log ?? ((line) => console.log(line));
+    const env = claudeChildEnv();
+    const redact = claudeRedactions(env);
+    const version = checkClaudeVersion(opts.bin, opts.versionFn);
+    if (!version.ok) throw new Error(`claude dispatch: ${version.message}`);
+    if (version.warning) log(version.warning);
+    const { caps, invalid } = claudeRunCaps(env);
+    for (const problem of invalid)
+      log(`claude dispatch: ignoring invalid ${problem}; running uncapped.`);
+    try {
+      return await spawnLogged(
+        opts.bin,
+        claudeDispatchArgs({ model: opts.model, ...caps }),
+        opts.logPath,
+        {
+          cwd: opts.workspace,
+          env,
+          redact,
+          spawnFn: opts.spawnFn,
+          hitl: resolveHitlRunOptions(opts.hitl, {
+            kind: "stdin-stream-json",
+            firstPrompt: opts.prompt
+          }),
+          render: opts.render,
+          onSpawn: opts.onSpawn,
+          backendId: "claude"
+        }
+      );
+    } catch (err) {
+      throw new Error(`claude dispatch failed to start: ${redactSecrets(String(err), redact)}`);
+    }
+  }
+  const args = cursorAgentDispatchArgs({
+    workspace: opts.workspace,
+    prompt: opts.prompt,
+    model: opts.model
+  });
+  return spawnLogged(opts.bin, args, opts.logPath, {
+    spawnFn: opts.spawnFn,
+    redact: claudeRedactions(process.env),
+    hitl: resolveHitlRunOptions(opts.hitl, { kind: "none", backend: "cursor-agent" }),
+    render: opts.render,
+    onSpawn: opts.onSpawn,
+    backendId: "cursor-agent"
+  });
+}
+async function ensureDispatchLogPath(root) {
+  const logDir = path.join(root, ".cursor", "loop-logs");
+  await mkdir(logDir, { recursive: true });
+  return path.join(logDir, `run-${stamp()}.log`);
+}
+
+export {
+  normalizeSlashName,
+  classifySlash,
+  rewriteRootArgvToRun,
+  buildDispatchPrompt,
+  promoteBlockedMessage,
+  unknownSlashMessage,
+  readCommandFile,
+  runHeadlessDispatch,
+  ensureDispatchLogPath
+};