@dadado/agent-kit-cli 6.1.0 → 6.2.0

package/dist/ground-control-NMYYIVCV.js

@@ -0,0 +1,434 @@
+import {
+  blobId,
+  isTicketMerged
+} from "./chunk-QTBTKEXK.js";
+import {
+  GATE_EXIT_BRANCH_PREFIX,
+  GATE_EXIT_MARKER_RELPATH,
+  defaultExec,
+  findAuthenticatedForge,
+  gateExitBranch,
+  gateExitNotePath,
+  gateExitRedactions,
+  isGateExitStamp,
+  isSafeBaseRef,
+  listGateExitBranches,
+  readGateExitMarker,
+  resolveGateExitRefs,
+  writeGateExitMarker
+} from "./chunk-KVY425NM.js";
+import "./chunk-MUTTNRX4.js";
+import {
+  redactSecrets
+} from "./chunk-JEI6HACW.js";
+import {
+  findOnPath
+} from "./chunk-WGLPZXNU.js";
+import "./chunk-MAPOQEA2.js";
+import "./chunk-QTON2GQX.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+
+// src/commands/ground-control.ts
+import path from "path";
+import { defineCommand } from "citty";
+var GROUND_CONTROL_EXIT = {
+  ok: 0,
+  usage: 1,
+  /** `accept` on a branch that is not merged into the base yet. */
+  waiting: 2,
+  /** A git or forge step failed; the ticket is kept. */
+  failed: 3
+};
+async function openContext(cwd, env, exec) {
+  const root = path.resolve(cwd);
+  const git = (args) => exec("git", args, { cwd: root, env });
+  const top = await git(["rev-parse", "--show-toplevel"]);
+  if (top.code !== 0) return "not a git repository";
+  const origin = await git(["remote", "get-url", "origin"]);
+  const originUrl = origin.code === 0 ? origin.stdout.trim() : "";
+  return { root, env, exec, git, hasOrigin: originUrl.length > 0, originUrl };
+}
+async function fetchOrigin(ctx) {
+  if (!ctx.hasOrigin) return null;
+  const fetched = await ctx.git(["fetch", "--prune", "--quiet", "origin"]);
+  return fetched.code === 0 ? null : `git fetch --prune origin failed (${fetched.stderr.trim().split("\n")[0] ?? ""})`;
+}
+function stampOfBranch(short) {
+  const i = short.lastIndexOf(GATE_EXIT_BRANCH_PREFIX);
+  if (i < 0) return null;
+  const stamp = short.slice(i + GATE_EXIT_BRANCH_PREFIX.length);
+  return isGateExitStamp(stamp) ? stamp : null;
+}
+async function refExists(git, ref) {
+  return (await git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`])).code === 0;
+}
+async function readHeadline(git, ref, stamp) {
+  const shown = await git(["show", `${ref}:${gateExitNotePath(stamp)}`]);
+  if (shown.code !== 0) return null;
+  const first = shown.stdout.split("\n")[0]?.trim() ?? "";
+  return first || null;
+}
+async function locateBranch(ctx, stamp) {
+  const branch = gateExitBranch(stamp);
+  const remote = ctx.hasOrigin ? `refs/remotes/origin/${branch}` : null;
+  const local = `refs/heads/${branch}`;
+  return {
+    remote: remote && await refExists(ctx.git, remote) ? remote : null,
+    local: await refExists(ctx.git, local) ? local : null
+  };
+}
+async function baseRefsFor(ctx, entry) {
+  const requested = entry?.base && isSafeBaseRef(entry.base) ? entry.base : void 0;
+  return resolveGateExitRefs(ctx.git, ctx.hasOrigin, requested);
+}
+function shortRef(ref) {
+  return ref.replace(/^refs\/remotes\//, "").replace(/^refs\/heads\//, "");
+}
+async function groundControlStatus(input) {
+  const env = input.env ?? process.env;
+  const ctx = await openContext(input.cwd, env, input.exec ?? defaultExec);
+  if (typeof ctx === "string") return ctx;
+  const warnings = [];
+  const fetchError = await fetchOrigin(ctx);
+  if (fetchError) warnings.push(`${fetchError}; showing the last fetched state`);
+  const marker = await readGateExitMarker(ctx.root);
+  const entries = marker.kind === "ok" ? marker.marker.pending : [];
+  const refs = await resolveGateExitRefs(ctx.git, ctx.hasOrigin);
+  const listed = await listGateExitBranches(ctx.git, refs);
+  const local = ctx.hasOrigin ? await listGateExitBranches(ctx.git, {
+    ...refs,
+    scope: `refs/heads/${GATE_EXIT_BRANCH_PREFIX}`
+  }) : { ok: true, branches: [] };
+  const stamps = new Set(entries.map((e) => e.stamp));
+  for (const short of [...listed.branches, ...local.branches]) {
+    const stamp = stampOfBranch(short);
+    if (stamp) stamps.add(stamp);
+  }
+  const tickets = [];
+  for (const stamp of [...stamps].sort()) {
+    const entry = entries.find((e) => e.stamp === stamp);
+    const where = await locateBranch(ctx, stamp);
+    const branchRef = where.remote ?? where.local;
+    const ticketRefs = await baseRefsFor(ctx, entry);
+    let branchState = "none";
+    if (branchRef) {
+      branchState = await isTicketMerged(ctx.git, branchRef, ticketRefs.baseRef, stamp) ? "merged" : "unmerged";
+    }
+    if (!entry && branchState === "merged") continue;
+    const headline = (branchRef ? await readHeadline(ctx.git, branchRef, stamp) : null) ?? await readHeadline(ctx.git, ticketRefs.baseRef, stamp);
+    tickets.push({
+      stamp,
+      headline,
+      askId: entry?.askId ?? null,
+      labels: entry?.labels ?? [],
+      trigger: entry?.trigger ?? null,
+      openedAt: entry?.openedAt ?? null,
+      url: entry?.url ?? null,
+      branch: branchRef ? shortRef(branchRef) : null,
+      branchState,
+      inMarker: Boolean(entry)
+    });
+  }
+  return {
+    marker: marker.kind,
+    ...marker.kind === "invalid" ? { markerDetail: marker.detail } : {},
+    base: refs.base,
+    tickets,
+    skipped: marker.kind === "ok" ? marker.marker.skipped : [],
+    warnings
+  };
+}
+function formatGroundControlStatus(status) {
+  const lines = [];
+  const n = status.tickets.length;
+  lines.push(
+    n === 0 ? "Ground Control: no pending operator ticket." : `Ground Control: ${n} pending operator ticket${n === 1 ? "" : "s"} (base ${status.base}).`
+  );
+  for (const t of status.tickets) {
+    lines.push("");
+    lines.push(`- ${t.stamp}: ${t.headline?.replace(/^#\s*/, "") ?? "(note not readable)"}`);
+    if (t.askId) {
+      lines.push(
+        `  Ask id: ${t.askId}${t.labels.length ? ` | labels: ${t.labels.join(" / ")}` : ""}`
+      );
+    }
+    const branch = t.branchState === "none" ? "no gate-exit branch" : `${t.branch} (${t.branchState === "merged" ? "merged; accept to close the ticket" : "not merged"})`;
+    lines.push(`  Branch: ${branch}${t.url ? ` | review: ${t.url}` : ""}`);
+    if (!t.inMarker)
+      lines.push(
+        `  Not in ${GATE_EXIT_MARKER_RELPATH} (Countdown refuses until it is merged or discarded)`
+      );
+  }
+  lines.push("");
+  if (status.marker === "invalid") {
+    lines.push(
+      `Marker: ${GATE_EXIT_MARKER_RELPATH} is unreadable (${status.markerDetail ?? "?"}).`
+    );
+  } else if (status.marker === "absent") {
+    lines.push(`Marker: ${GATE_EXIT_MARKER_RELPATH} absent.`);
+  } else {
+    const pending = status.tickets.filter((t) => t.inMarker).length;
+    lines.push(
+      `Marker: ${GATE_EXIT_MARKER_RELPATH}, ${pending} pending entr${pending === 1 ? "y" : "ies"}.`
+    );
+  }
+  if (status.skipped.length > 0) {
+    lines.push(`Skipped runs: ${status.skipped.length} (latest: ${status.skipped.at(-1)}).`);
+  }
+  for (const w of status.warnings) lines.push(`Warning: ${w}`);
+  if (n > 0) {
+    lines.push(
+      "Next: read the note, then `agent-kit ground-control accept <stamp>` once merged, or `discard <stamp>`."
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function clearEntry(root, stamp) {
+  const marker = await readGateExitMarker(root);
+  if (marker.kind === "absent") return null;
+  if (marker.kind === "invalid") {
+    return `${GATE_EXIT_MARKER_RELPATH} is unreadable (${marker.detail}); left as is`;
+  }
+  const pending = marker.marker.pending.filter((e) => e.stamp !== stamp);
+  if (pending.length === marker.marker.pending.length) return null;
+  const next = { ...marker.marker, pending };
+  try {
+    await writeGateExitMarker(root, next);
+    return null;
+  } catch (err) {
+    return `could not write ${GATE_EXIT_MARKER_RELPATH}: ${String(err)}`;
+  }
+}
+async function prepareTriage(input) {
+  if (!isGateExitStamp(input.stamp)) {
+    return {
+      ok: false,
+      result: {
+        exitCode: GROUND_CONTROL_EXIT.usage,
+        error: `invalid stamp: expected YYYYMMDDTHHMMSSZ (as \`agent-kit ground-control status\` prints it)`
+      }
+    };
+  }
+  const env = input.env ?? process.env;
+  const redactions = gateExitRedactions(env);
+  const log = (line) => input.log?.(redactSecrets(line, redactions));
+  const ctx = await openContext(input.cwd, env, input.exec ?? defaultExec);
+  if (typeof ctx === "string") {
+    return { ok: false, result: { exitCode: GROUND_CONTROL_EXIT.usage, error: ctx } };
+  }
+  const marker = await readGateExitMarker(ctx.root);
+  if (marker.kind === "invalid") {
+    return {
+      ok: false,
+      result: {
+        exitCode: GROUND_CONTROL_EXIT.failed,
+        error: `${GATE_EXIT_MARKER_RELPATH} is unreadable (${marker.detail}); fix or remove it by hand`
+      }
+    };
+  }
+  const fetchError = await fetchOrigin(ctx);
+  if (fetchError) {
+    return {
+      ok: false,
+      result: { exitCode: GROUND_CONTROL_EXIT.failed, error: `${fetchError}; nothing changed` }
+    };
+  }
+  const entry = marker.kind === "ok" ? marker.marker.pending.find((e) => e.stamp === input.stamp) : void 0;
+  return { ok: true, ctx, entry, log };
+}
+async function deleteBranch(ctx, stamp, where, log) {
+  const branch = gateExitBranch(stamp);
+  let ok = true;
+  if (where.remote) {
+    const pushed = await ctx.git(["push", "--quiet", "origin", "--delete", `refs/heads/${branch}`]);
+    if (pushed.code === 0) log(`deleted origin/${branch}`);
+    else {
+      ok = false;
+      log(`could not delete origin/${branch}: ${pushed.stderr.trim().split("\n")[0] ?? ""}`);
+    }
+  }
+  if (where.local) {
+    const removed = await ctx.git(["branch", "-D", "--", branch]);
+    if (removed.code === 0) log(`deleted local ${branch}`);
+    else {
+      ok = false;
+      log(`could not delete local ${branch}: ${removed.stderr.trim().split("\n")[0] ?? ""}`);
+    }
+  }
+  return ok;
+}
+async function acceptTicket(input) {
+  const prep = await prepareTriage(input);
+  if (!prep.ok) return prep.result;
+  const { ctx, entry, log } = prep;
+  const stamp = input.stamp;
+  const refs = await baseRefsFor(ctx, entry);
+  const where = await locateBranch(ctx, stamp);
+  const branchRef = where.remote ?? where.local;
+  if (branchRef) {
+    if (!await isTicketMerged(ctx.git, branchRef, refs.baseRef, stamp)) {
+      log(`${shortRef(branchRef)} is not merged into ${refs.base} yet; waiting on the merge`);
+      return { exitCode: GROUND_CONTROL_EXIT.waiting };
+    }
+    if (!await deleteBranch(ctx, stamp, where, log)) {
+      return { exitCode: GROUND_CONTROL_EXIT.failed, error: "branch not deleted; ticket kept" };
+    }
+  } else {
+    const noteOnBase = await blobId(ctx.git, `${refs.baseRef}:${gateExitNotePath(stamp)}`);
+    if (!entry) {
+      return {
+        exitCode: GROUND_CONTROL_EXIT.usage,
+        error: `no ticket ${stamp}: not in ${GATE_EXIT_MARKER_RELPATH} and no gate-exit branch`
+      };
+    }
+    if (!noteOnBase && entry.branch) {
+      log(
+        `${entry.branch} is gone and its note is not on ${refs.base}; use \`agent-kit ground-control discard ${stamp}\``
+      );
+      return { exitCode: GROUND_CONTROL_EXIT.waiting };
+    }
+    log(
+      noteOnBase ? `the note of ${stamp} is on ${refs.base} (branch already deleted)` : `ticket ${stamp} never landed a branch; nothing to merge`
+    );
+  }
+  const markerError = await clearEntry(ctx.root, stamp);
+  if (markerError) return { exitCode: GROUND_CONTROL_EXIT.failed, error: markerError };
+  log(`accepted ${stamp}; ticket cleared`);
+  return { exitCode: GROUND_CONTROL_EXIT.ok };
+}
+async function discardTicket(input) {
+  const prep = await prepareTriage(input);
+  if (!prep.ok) return prep.result;
+  const { ctx, entry, log } = prep;
+  const stamp = input.stamp;
+  const branch = gateExitBranch(stamp);
+  const where = await locateBranch(ctx, stamp);
+  if (!entry && !where.remote && !where.local) {
+    return {
+      exitCode: GROUND_CONTROL_EXIT.usage,
+      error: `no ticket ${stamp}: not in ${GATE_EXIT_MARKER_RELPATH} and no gate-exit branch`
+    };
+  }
+  if (where.remote) {
+    const which = input.which ?? ((bin) => findOnPath(bin, { env: ctx.env }));
+    const forge = await findAuthenticatedForge({
+      originUrl: ctx.originUrl,
+      cwd: ctx.root,
+      exec: ctx.exec,
+      which,
+      env: ctx.env,
+      log
+    });
+    if (forge) {
+      const closed = forge.forge === "gh" ? await ctx.exec(
+        forge.bin,
+        ["pr", "close", branch, "--comment", "Discarded with agent-kit ground-control."],
+        { cwd: ctx.root, env: ctx.env }
+      ) : await ctx.exec(forge.bin, ["mr", "close", branch], { cwd: ctx.root, env: ctx.env });
+      log(
+        closed.code === 0 ? `${forge.forge === "gh" ? "PR" : "MR"} for ${branch} closed` : `${forge.forge} could not close the review for ${branch} (${closed.stderr.trim().split("\n")[0] ?? ""}); deleting the branch closes it on most forges`
+      );
+    } else {
+      log("no authenticated gh/glab; the review closes when its branch is deleted");
+    }
+  }
+  if (!await deleteBranch(ctx, stamp, where, log)) {
+    return { exitCode: GROUND_CONTROL_EXIT.failed, error: "branch not deleted; ticket kept" };
+  }
+  const markerError = await clearEntry(ctx.root, stamp);
+  if (markerError) return { exitCode: GROUND_CONTROL_EXIT.failed, error: markerError };
+  log(`discarded ${stamp}; ticket cleared`);
+  return { exitCode: GROUND_CONTROL_EXIT.ok };
+}
+var cwdArg = {
+  type: "string",
+  description: "Project root (default: current directory)",
+  default: process.cwd()
+};
+var stampArg = {
+  type: "positional",
+  description: "Gate-exit stamp (YYYYMMDDTHHMMSSZ, as `status` prints it)",
+  required: true
+};
+function groundControlErrorText(error, env = process.env) {
+  return redactSecrets(error, gateExitRedactions(env));
+}
+function report(result) {
+  if (result.error) logger.error(groundControlErrorText(result.error));
+  process.exitCode = result.exitCode;
+}
+var groundControlCommand = defineCommand({
+  meta: {
+    name: "ground-control",
+    description: "Ground Control: triage gate exits. status lists pending operator tickets; accept <stamp> clears a merged one; discard <stamp> closes and deletes it. Never merges, never git-prod."
+  },
+  subCommands: {
+    status: defineCommand({
+      meta: {
+        name: "status",
+        description: "List pending operator tickets, gate-exit branches and skipped runs"
+      },
+      args: {
+        cwd: cwdArg,
+        json: { type: "boolean", description: "Print JSON", default: false }
+      },
+      async run({ args }) {
+        const status = await groundControlStatus({ cwd: String(args.cwd) });
+        if (typeof status === "string") {
+          logger.error(groundControlErrorText(status));
+          process.exitCode = GROUND_CONTROL_EXIT.usage;
+          return;
+        }
+        const env = process.env;
+        const text = args.json ? `${JSON.stringify(status, null, 2)}
+` : formatGroundControlStatus(status);
+        process.stdout.write(redactSecrets(text, gateExitRedactions(env)));
+      }
+    }),
+    accept: defineCommand({
+      meta: {
+        name: "accept",
+        description: "Clear a ticket whose gate-exit branch is merged into the base, deleting the branch (exit 2 while unmerged)"
+      },
+      args: { stamp: stampArg, cwd: cwdArg },
+      async run({ args }) {
+        report(
+          await acceptTicket({
+            cwd: String(args.cwd),
+            stamp: String(args.stamp),
+            log: (line) => logger.info(`ground-control: ${line}`)
+          })
+        );
+      }
+    }),
+    discard: defineCommand({
+      meta: {
+        name: "discard",
+        description: "Close the PR/MR (gh/glab), delete the gate-exit branch and clear the ticket"
+      },
+      args: { stamp: stampArg, cwd: cwdArg },
+      async run({ args }) {
+        report(
+          await discardTicket({
+            cwd: String(args.cwd),
+            stamp: String(args.stamp),
+            log: (line) => logger.info(`ground-control: ${line}`)
+          })
+        );
+      }
+    })
+  }
+});
+export {
+  GROUND_CONTROL_EXIT,
+  acceptTicket,
+  discardTicket,
+  formatGroundControlStatus,
+  groundControlCommand,
+  groundControlErrorText,
+  groundControlStatus,
+  isTicketMerged
+};

package/dist/{handoff-MK5JG3J5.js → handoff-5AGE2D3T.js}

@@ -6,7 +6,8 @@ import {
   extractHandoffNamedPlans,
   namedPlanCandidatePaths,
   parsePlanFrontmatter
-} from "./chunk-WUWRGOUV.js";
+} from "./chunk-L5V3W3DY.js";
+import "./chunk-MUTTNRX4.js";
 import {
   PM_TOOL_LABELS
 } from "./chunk-F6C3GFKV.js";
@@ -15,7 +16,7 @@ import {
 } from "./chunk-ZB43YMHW.js";
 import {
   HANDOFF_REL
-} from "./chunk-C26I6HTO.js";
+} from "./chunk-C4Q77GGJ.js";
 import {
   ensureDir,
   fileExists,

package/dist/{hook-D2WHBKRN.js → hook-XCZWX462.js}

@@ -16,25 +16,26 @@ import {
 import {
   formatPlanIndexSection,
   writePlanIndex
-} from "./chunk-WUWRGOUV.js";
+} from "./chunk-L5V3W3DY.js";
+import "./chunk-MUTTNRX4.js";
 import {
   READINESS_SNAPSHOT_RELATIVE_PATH
 } from "./chunk-HAFRAXGV.js";
 import {
   stampLastCheckedAt
-} from "./chunk-2FQX2O4I.js";
+} from "./chunk-TW4BF5OE.js";
 import {
   loadContextConfig
 } from "./chunk-PFEUZXVT.js";
-import "./chunk-BBVBYQJO.js";
-import "./chunk-VTOUQAVR.js";
+import "./chunk-CWDXNBEU.js";
+import "./chunk-X45O2AIE.js";
 import {
   MANIFEST_RELATIVE_PATH
-} from "./chunk-DBPNGZNH.js";
+} from "./chunk-NSSXSZLL.js";
 import "./chunk-7HDQEK6T.js";
 import {
   HANDOFF_REL
-} from "./chunk-C26I6HTO.js";
+} from "./chunk-C4Q77GGJ.js";
 import {
   fileExists
 } from "./chunk-5B4DVO6C.js";

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   rewriteRootArgvToRun
-} from "./chunk-3XKVQS2K.js";
-import "./chunk-ESNAFDYT.js";
+} from "./chunk-Z7ABX5QI.js";
+import "./chunk-JEI6HACW.js";
 import "./chunk-WGLPZXNU.js";
 import "./chunk-MAPOQEA2.js";
 import {
@@ -16,7 +16,7 @@ import {
 import {
   KIT_VERSION
 } from "./chunk-7HDQEK6T.js";
-import "./chunk-C26I6HTO.js";
+import "./chunk-C4Q77GGJ.js";
 import "./chunk-5B4DVO6C.js";
 
 // src/index.ts
@@ -118,7 +118,15 @@ var CLI_HELP_GROUPS = [
   {
     id: "mission",
     title: "MISSION",
-    commands: ["handoff", "plan-index", "run", "run-plan", "run-plan-all"]
+    commands: [
+      "handoff",
+      "plan-index",
+      "run",
+      "run-plan",
+      "run-plan-all",
+      "countdown",
+      "ground-control"
+    ]
   },
   {
     id: "dashboard",
@@ -213,29 +221,31 @@ var main = defineCommand({
     version: KIT_VERSION
   },
   subCommands: {
-    init: () => import("./init-GVVBA2BM.js").then((m) => m.initCommand),
-    install: () => import("./install-R4HPI7VK.js").then((m) => m.installCommand),
-    scan: () => import("./scan-K6TQGV4S.js").then((m) => m.scanCommand),
-    add: () => import("./add-YTCDLPUS.js").then((m) => m.addCommand),
-    doctor: () => import("./doctor-SS6Y2T6H.js").then((m) => m.doctorCommand),
-    "setup-global": () => import("./setup-global-AT4DD3MG.js").then((m) => m.setupGlobalCommand),
-    status: () => import("./status-MPJHI5RP.js").then((m) => m.statusCommand),
-    update: () => import("./update-P62637ZI.js").then((m) => m.updateCommand),
+    init: () => import("./init-HKMRU2V4.js").then((m) => m.initCommand),
+    install: () => import("./install-X2J6KWZ5.js").then((m) => m.installCommand),
+    scan: () => import("./scan-UX4HARMJ.js").then((m) => m.scanCommand),
+    add: () => import("./add-Y2426TGU.js").then((m) => m.addCommand),
+    doctor: () => import("./doctor-VLZNXJNA.js").then((m) => m.doctorCommand),
+    "setup-global": () => import("./setup-global-ADJFMOZX.js").then((m) => m.setupGlobalCommand),
+    status: () => import("./status-UB6NL3Q3.js").then((m) => m.statusCommand),
+    update: () => import("./update-PFBFY7GT.js").then((m) => m.updateCommand),
     "cursor-awareness": () => import("./cursor-awareness-TN5JXD2C.js").then((m) => m.cursorAwarenessCommand),
     "public-inbound-radar": () => import("./public-inbound-radar-5U4JMBRU.js").then((m) => m.publicInboundRadarCommand),
     "remote-issues": () => import("./remote-issues-APYOMIJC.js").then((m) => m.remoteIssuesCommand),
     dogfood: () => import("./dogfood-2JAHSYQA.js").then((m) => m.dogfoodCommand),
-    diff: () => import("./diff-4MDU5SLE.js").then((m) => m.diffCommand),
-    contribute: () => import("./contribute-A7NCWTUM.js").then((m) => m.contributeCommand),
-    handoff: () => import("./handoff-MK5JG3J5.js").then((m) => m.handoffCommand),
-    "plan-index": () => import("./plan-index-V7T5MKL6.js").then((m) => m.planIndexCommand),
-    run: () => import("./run-YV6XTFZY.js").then((m) => m.runCommand),
-    "run-plan": () => import("./run-plan-KT443FO6.js").then((m) => m.runPlanCommand),
-    "run-plan-all": () => import("./run-YV6XTFZY.js").then((m) => m.runPlanAllCommand),
-    dashboard: () => import("./dashboard-YSNUGBFY.js").then((m) => m.dashboardCommand),
-    "dashboard-broadcast": () => import("./dashboard-broadcast-M4CMW7RX.js").then((m) => m.dashboardBroadcastCommand),
-    "mission-control": () => import("./mission-control-LJACEVVN.js").then((m) => m.missionControlCommand),
-    hook: () => import("./hook-D2WHBKRN.js").then((m) => m.hookCommand),
+    diff: () => import("./diff-MECE5RZB.js").then((m) => m.diffCommand),
+    contribute: () => import("./contribute-TVST3CJO.js").then((m) => m.contributeCommand),
+    handoff: () => import("./handoff-5AGE2D3T.js").then((m) => m.handoffCommand),
+    "plan-index": () => import("./plan-index-BNLUU6T5.js").then((m) => m.planIndexCommand),
+    run: () => import("./run-R66G276Q.js").then((m) => m.runCommand),
+    "run-plan": () => import("./run-plan-24Z5K4P3.js").then((m) => m.runPlanCommand),
+    "run-plan-all": () => import("./run-R66G276Q.js").then((m) => m.runPlanAllCommand),
+    countdown: () => import("./countdown-QXJD6TDB.js").then((m) => m.countdownCommand),
+    "ground-control": () => import("./ground-control-NMYYIVCV.js").then((m) => m.groundControlCommand),
+    dashboard: () => import("./dashboard-YNCFISNO.js").then((m) => m.dashboardCommand),
+    "dashboard-broadcast": () => import("./dashboard-broadcast-NK7PU72L.js").then((m) => m.dashboardBroadcastCommand),
+    "mission-control": () => import("./mission-control-MHQU73XC.js").then((m) => m.missionControlCommand),
+    hook: () => import("./hook-XCZWX462.js").then((m) => m.hookCommand),
     guard: () => import("./guard-EHXF76ID.js").then((m) => m.guardCommand),
     monitors: () => import("./monitors-PDXBLB3U.js").then((m) => m.monitorsCommand),
     validate: () => import("./validate-V2CW7J4B.js").then((m) => m.validateCommand)

package/dist/{init-GVVBA2BM.js → init-HKMRU2V4.js}

@@ -2,25 +2,25 @@ import {
   nextStepAfterInstall,
   performInstall,
   printInstallEpilogue
-} from "./chunk-TMFOLRU2.js";
+} from "./chunk-IR7FFPUU.js";
 import {
   NON_INTERACTIVE_ROOT_ARGS
-} from "./chunk-DBXDV5O7.js";
+} from "./chunk-TGNFGMPV.js";
 import {
   SkippedSymlinkError,
   logApplyStats
 } from "./chunk-HS7LVVLO.js";
-import "./chunk-3DGTPONS.js";
-import "./chunk-YP4OOK4T.js";
+import "./chunk-C2SJDYAM.js";
+import "./chunk-BEKQ6PVD.js";
 import "./chunk-HAFRAXGV.js";
-import "./chunk-PPKX55GI.js";
+import "./chunk-SPYIP76F.js";
 import "./chunk-WGLPZXNU.js";
 import "./chunk-MAPOQEA2.js";
 import {
   withCliProgress
 } from "./chunk-QTON2GQX.js";
 import "./chunk-PNFF6OU3.js";
-import "./chunk-U5F6RJN4.js";
+import "./chunk-GO3K752H.js";
 import "./chunk-F6C3GFKV.js";
 import {
   logger
@@ -31,19 +31,19 @@ import {
   confirmProjectRoot,
   isNonInteractive,
   syncPathCliToRuntime
-} from "./chunk-GN4SAZF2.js";
+} from "./chunk-VO73OL5V.js";
 import {
   assessEnvironment
 } from "./chunk-B3VR5YBQ.js";
-import "./chunk-2FQX2O4I.js";
+import "./chunk-TW4BF5OE.js";
 import "./chunk-PFEUZXVT.js";
-import "./chunk-BBVBYQJO.js";
-import "./chunk-VTOUQAVR.js";
-import "./chunk-DBPNGZNH.js";
+import "./chunk-CWDXNBEU.js";
+import "./chunk-X45O2AIE.js";
+import "./chunk-NSSXSZLL.js";
 import {
   KIT_VERSION
 } from "./chunk-7HDQEK6T.js";
-import "./chunk-C26I6HTO.js";
+import "./chunk-C4Q77GGJ.js";
 import "./chunk-5B4DVO6C.js";
 
 // src/commands/init.ts

package/dist/{install-R4HPI7VK.js → install-X2J6KWZ5.js}

@@ -3,29 +3,29 @@ import {
   nextStepAfterInstall,
   performInstall,
   printInstallEpilogue
-} from "./chunk-TMFOLRU2.js";
-import "./chunk-DBXDV5O7.js";
+} from "./chunk-IR7FFPUU.js";
+import "./chunk-TGNFGMPV.js";
 import "./chunk-HS7LVVLO.js";
-import "./chunk-3DGTPONS.js";
-import "./chunk-YP4OOK4T.js";
+import "./chunk-C2SJDYAM.js";
+import "./chunk-BEKQ6PVD.js";
 import "./chunk-HAFRAXGV.js";
-import "./chunk-PPKX55GI.js";
+import "./chunk-SPYIP76F.js";
 import "./chunk-WGLPZXNU.js";
 import "./chunk-MAPOQEA2.js";
 import "./chunk-QTON2GQX.js";
 import "./chunk-PNFF6OU3.js";
-import "./chunk-U5F6RJN4.js";
+import "./chunk-GO3K752H.js";
 import "./chunk-F6C3GFKV.js";
 import "./chunk-ZB43YMHW.js";
-import "./chunk-GN4SAZF2.js";
+import "./chunk-VO73OL5V.js";
 import "./chunk-B3VR5YBQ.js";
-import "./chunk-2FQX2O4I.js";
+import "./chunk-TW4BF5OE.js";
 import "./chunk-PFEUZXVT.js";
-import "./chunk-BBVBYQJO.js";
-import "./chunk-VTOUQAVR.js";
-import "./chunk-DBPNGZNH.js";
+import "./chunk-CWDXNBEU.js";
+import "./chunk-X45O2AIE.js";
+import "./chunk-NSSXSZLL.js";
 import "./chunk-7HDQEK6T.js";
-import "./chunk-C26I6HTO.js";
+import "./chunk-C4Q77GGJ.js";
 import "./chunk-5B4DVO6C.js";
 export {
   installCommand,