@dadado/agent-kit-cli 5.5.0 → 5.7.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { defineCommand as defineCommand20, runMain, showUsage } from "citty";
+import { defineCommand as defineCommand21, runMain, showUsage } from "citty";
 
 // src/commands/add.ts
 import { defineCommand } from "citty";
@@ -219,7 +219,15 @@ var KNOWN_SHIPPED_OVERLAY_HASHES = /* @__PURE__ */ new Set([
   "34e559ad9036d93d9cbc96d394bc2bbeb10ce50ead00d58a914158ae19daa76c",
   "359a142aeadd769a9b89ac909ae5129940e7e6b0892b70256098c584d97631ce",
   "8eab94f7a78149db1bbbc0fd45f21dc2d874209d534bcff39077fd6e1d2c42fb",
-  "9be406f92f7dca71f3af814b14fb26b011f9f12c37c789f7ddc3d647b1a7ab60"
+  "9be406f92f7dca71f3af814b14fb26b011f9f12c37c789f7ddc3d647b1a7ab60",
+  "bb67ddcdd9ab58ed89287421f5e4b6ebfb3941e6a789287ddec9b9c25b56b1ed",
+  "7343ecd797f484eea1a3ebc11e87c75d90f617bd627bfc367a1eca5a1628bdf1",
+  "8a723b4808f14413fc173a6ce33370067ffc78d0c2e05a21c4406d7fa3e66457",
+  "65554e304a70b77e07fe40facf0ef305d6216399bfbb811db2491ce2f31d86d7",
+  "f8cc89a52fb1ec17f7f26ecd5cb18f79a5e9c7b7ffe7a6899465aa4090433b98",
+  "543e6596e7ce9f3ce4de642f1ea7e5d437d553fa28c0d56eb0f244ec8526ce17",
+  "71c6d1cce604c4a275db7c9a5c48f1753604bf35e083be054511ebc91f4977e6",
+  "8d0fd61bcbb9e035dea3a8b9f298a48c226bb28785923cb07e1154cf084934ad"
 ]);
 
 // src/lifecycle/paths.ts
@@ -1517,11 +1525,20 @@ var L0_ARTIFACTS = [
     source: ".cursor/commands/dashboard.md",
     target: ".cursor/commands/dashboard.md"
   },
+  {
+    source: ".cursor/commands/dashboard-broadcast.md",
+    target: ".cursor/commands/dashboard-broadcast.md"
+  },
   {
     source: ".cursor/commands/git-staging.md",
     target: ".cursor/commands/git-staging.md"
   },
   { source: ".cursor/commands/git-prod.md", target: ".cursor/commands/git-prod.md" },
+  {
+    source: ".cursor/commands/kit-staging.md",
+    target: ".cursor/commands/kit-staging.md"
+  },
+  { source: ".cursor/commands/kit-prod.md", target: ".cursor/commands/kit-prod.md" },
   {
     source: ".cursor/commands/plan-external-review.md",
     target: ".cursor/commands/plan-external-review.md"
@@ -1545,6 +1562,10 @@ var L0_ARTIFACTS = [
     source: ".cursor/commands/cursor-update-awareness.md",
     target: ".cursor/commands/cursor-update-awareness.md"
   },
+  {
+    source: ".cursor/commands/update.md",
+    target: ".cursor/commands/update.md"
+  },
   // Context (templates + example config; private config.json is not L0)
   {
     source: ".cursor/context/templates/plan-external-review-prompt.md",
@@ -2377,6 +2398,7 @@ import { defineCommand as defineCommand4 } from "citty";
 import { randomBytes, timingSafeEqual } from "crypto";
 import { networkInterfaces } from "os";
 import { resolve } from "path";
+var REPO_ROOT_ENV = "MISSION_CONTROL_REPO_ROOT";
 var KIT_ROOT_ENV_KEYS = Object.freeze(["MISSION_CONTROL_KIT_ROOT", "AGENT_KIT_HOME"]);
 var CONTEXT_CONFIG_REL = ".cursor/context/config.json";
 var CONFIG_PERSONA_IDS = Object.freeze(["autopilot", "night-shift", "ghost-runner"]);
@@ -2562,14 +2584,14 @@ function resolveDashboardSnapshotRoot(cwd) {
   return abs;
 }
 function runStartScript(startPath, env) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const child = spawn2(process.execPath, [startPath], {
       cwd: path11.dirname(path11.dirname(startPath)),
       env,
       stdio: "inherit"
     });
     child.on("error", reject);
-    child.on("close", (code) => resolve2(code ?? 1));
+    child.on("close", (code) => resolve3(code ?? 1));
   });
 }
 var dashboardCommand = defineCommand4({
@@ -2679,14 +2701,14 @@ async function findDashboardBroadcastStart(cwd, env = process.env, options = {})
   return null;
 }
 function runStartScript2(startPath, env) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const child = spawn3(process.execPath, [startPath], {
       cwd: path12.dirname(path12.dirname(startPath)),
       env,
       stdio: "inherit"
     });
     child.on("error", reject);
-    child.on("close", (code) => resolve2(code ?? 1));
+    child.on("close", (code) => resolve3(code ?? 1));
   });
 }
 var dashboardBroadcastCommand = defineCommand5({
@@ -3385,9 +3407,9 @@ function buildPillars(scan) {
       check(
         "stack.detected",
         "Stack and package manager",
-        scan.stack.language !== "unknown" || scan.purpose.value !== "unknown" ? "ready" : "needs_choice",
+        scan.stack.language !== "unknown" || scan.stack.hasProjectFiles ? "ready" : "needs_choice",
         true,
-        scan.stack.packageManagerEvidence ?? scan.purpose.evidence
+        scan.stack.packageManagerEvidence ?? []
       )
     ]),
     pillar("quality-ci", [
@@ -3521,7 +3543,40 @@ async function detectContext(rootDir) {
     )
   };
 }
+var REPOSITORY_PURPOSE_VALUES = [
+  "application",
+  "library",
+  "monorepo",
+  "documentation",
+  "knowledge",
+  "operations",
+  "automation",
+  "mixed",
+  "unknown"
+];
+function isRepositoryPurpose(value) {
+  return typeof value === "string" && REPOSITORY_PURPOSE_VALUES.includes(value);
+}
+async function readConfirmedPurpose(rootDir) {
+  const configuration = await readJson(
+    path16.join(rootDir, ".cursor", "agent-kit.config.json")
+  );
+  const configuredPurpose = configuration?.purpose;
+  if (!configuredPurpose || !isRepositoryPurpose(configuredPurpose.value) || configuredPurpose.value === "unknown") {
+    return void 0;
+  }
+  const categories = Array.isArray(configuredPurpose.categories) ? configuredPurpose.categories.filter(isRepositoryPurpose) : [];
+  const evidence = Array.isArray(configuredPurpose.evidence) ? configuredPurpose.evidence : [];
+  return {
+    value: configuredPurpose.value,
+    categories: categories.length > 0 ? categories : [configuredPurpose.value],
+    confidence: "high",
+    evidence: evidence.length > 0 ? evidence : [{ source: "configuration", value: ".cursor/agent-kit.config.json#purpose.value" }]
+  };
+}
 async function detectPurpose(rootDir, stack) {
+  const confirmed = await readConfirmedPurpose(rootDir);
+  if (confirmed) return confirmed;
   const entries = await listDirectory(rootDir);
   const lowerEntries = entries.map((entry) => entry.toLowerCase());
   const packageJson = await readJson(path16.join(rootDir, "package.json"));
@@ -3586,6 +3641,13 @@ var REQUIRED_SECRET_PATTERNS = [
   "*credentials*.json",
   "*service-account*.json"
 ];
+var KIT_OWNED_IGNORE_PATTERNS = [
+  ".cursor/HANDOFF.md",
+  ".cursor/dogfood/",
+  ".cursor/context/readiness.json",
+  ".cursor/context/flight-log.json",
+  ".cursor/context/mission-timing.json"
+];
 async function detectSafety(rootDir, trackedFiles) {
   const gitignorePath = path16.join(rootDir, ".gitignore");
   const hasGitignore = await fileExists(gitignorePath);
@@ -3725,7 +3787,8 @@ async function detectProvider(rootDir, remoteUrl) {
     evidence: remoteEvidence
   };
 }
-function inferWorkflow(currentBranch) {
+function inferWorkflow(currentBranch, hasLocalStaging, hasRemoteStaging) {
+  if (hasLocalStaging || hasRemoteStaging) return "homolog-prod";
   if (!currentBranch) return "unknown";
   if (currentBranch === "main" || currentBranch === "master") return "feature-pr";
   if (currentBranch.includes("develop") || currentBranch.includes("release")) return "gitflow";
@@ -3778,6 +3841,8 @@ async function detectGit(rootDir) {
   const localBranches = localBranchOutput?.split("\n").filter(Boolean);
   const remoteBranches = remoteBranchOutput?.split("\n").filter(Boolean);
   const defaultBranch = remoteHead?.split("/").slice(1).join("/") || (localBranches?.includes("main") ? "main" : localBranches?.includes("master") ? "master" : void 0);
+  const hasLocalStaging = localBranches?.includes("staging") ?? false;
+  const hasRemoteStaging = remoteBranches?.some((branch) => branch === "origin/staging" || branch.endsWith("/staging")) ?? false;
   return {
     provider: provider.provider,
     providerKind: provider.providerKind,
@@ -3790,11 +3855,9 @@ async function detectGit(rootDir) {
     currentBranch,
     defaultBranch,
     isDirty: Boolean(status),
-    hasLocalStaging: localBranches?.includes("staging") ?? false,
-    hasRemoteStaging: remoteBranches?.some(
-      (branch) => branch === "origin/staging" || branch.endsWith("/staging")
-    ) ?? false,
-    workflow: inferWorkflow(currentBranch)
+    hasLocalStaging,
+    hasRemoteStaging,
+    workflow: inferWorkflow(currentBranch, hasLocalStaging, hasRemoteStaging)
   };
 }
 
@@ -4252,17 +4315,23 @@ function preferenceDefaults(onboarding, onboarded) {
     }
   };
 }
-function mergeSecretIgnores(existing) {
+function mergeIgnorePatterns(existing, patterns) {
   const activeLines = new Set(
     existing.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"))
   );
-  const missing = REQUIRED_SECRET_PATTERNS.filter((pattern) => !activeLines.has(pattern));
+  const missing = patterns.filter((pattern) => !activeLines.has(pattern));
   if (missing.length === 0) return existing;
   const prefix = existing.length === 0 ? "" : existing.endsWith("\n") ? existing : `${existing}
 `;
   return `${prefix}${missing.join("\n")}
 `;
 }
+function mergeSecretIgnores(existing) {
+  return mergeIgnorePatterns(existing, REQUIRED_SECRET_PATTERNS);
+}
+function mergeKitOwnedIgnores(existing) {
+  return mergeIgnorePatterns(existing, KIT_OWNED_IGNORE_PATTERNS);
+}
 function recordChange(changes, id, relativePath, changed, dryRun, evidence) {
   changes.push({
     id,
@@ -4279,6 +4348,39 @@ function appliedActions(changes) {
     owner: "system"
   }));
 }
+function withoutGeneratedAtForComparison(profile) {
+  const { generatedAt: _generatedAt, ...detection } = isObject(profile.detection) ? profile.detection : {};
+  return { ...profile, detection };
+}
+function reconcileFreshOverExisting(desired, existing) {
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(desired)) {
+    const existingValue = existing[key];
+    merged[key] = isObject(value) && isObject(existingValue) ? reconcileFreshOverExisting(value, existingValue) : value;
+  }
+  return merged;
+}
+async function refreshRepositoryProfile(rootDir, options) {
+  const generatedAt = options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const scan = await runScanner(rootDir);
+  const report = createReadinessReport(scan, {
+    generatorVersion: options.generatorVersion,
+    generatedAt
+  });
+  const desiredProfile = createProfile(scan, report, generatedAt);
+  const profilePath = path23.join(scan.rootDir, PROFILE_RELATIVE_PATH);
+  const existingProfile = await readJson(profilePath) ?? {};
+  const reconciled = reconcileFreshOverExisting(desiredProfile, existingProfile);
+  const meaningfulChange = !jsonEqual(
+    withoutGeneratedAtForComparison(existingProfile),
+    withoutGeneratedAtForComparison(reconciled)
+  );
+  if (!meaningfulChange) {
+    return { changed: false, profile: existingProfile };
+  }
+  await writeJson(profilePath, reconciled);
+  return { changed: true, profile: reconciled };
+}
 async function executeSafeReadinessFixes(rootDir, options) {
   const dryRun = options.dryRun ?? false;
   const generatedAt = options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
@@ -4304,18 +4406,32 @@ async function executeSafeReadinessFixes(rootDir, options) {
   const gitignoreRelativePath = ".gitignore";
   const gitignorePath = path23.join(beforeScan.rootDir, gitignoreRelativePath);
   const existingGitignore = await fileExists(gitignorePath) ? await readFile13(gitignorePath, "utf8") : "";
-  const mergedGitignore = mergeSecretIgnores(existingGitignore);
+  const gitignoreAfterSecrets = mergeSecretIgnores(existingGitignore);
+  const secretsChanged = gitignoreAfterSecrets !== existingGitignore;
+  const mergedGitignore = mergeKitOwnedIgnores(gitignoreAfterSecrets);
   const gitignoreChanged = mergedGitignore !== existingGitignore;
+  const kitOwnedChanged = mergedGitignore !== gitignoreAfterSecrets;
   if (gitignoreChanged && !dryRun) await writeFile5(gitignorePath, mergedGitignore, "utf8");
   recordChange(
     changes,
     "merge-secret-ignores",
     gitignoreRelativePath,
-    gitignoreChanged,
+    secretsChanged,
+    dryRun,
+    relativeEvidence(
+      gitignoreRelativePath,
+      secretsChanged ? "required secret patterns are missing" : "required patterns are present"
+    )
+  );
+  recordChange(
+    changes,
+    "merge-kit-owned-ignores",
+    gitignoreRelativePath,
+    kitOwnedChanged,
     dryRun,
     relativeEvidence(
       gitignoreRelativePath,
-      gitignoreChanged ? "required secret patterns are missing" : "required patterns are present"
+      kitOwnedChanged ? "kit-owned session/derived paths are missing" : "kit-owned session/derived paths are present"
     )
   );
   const profilePath = path23.join(beforeScan.rootDir, PROFILE_RELATIVE_PATH);
@@ -4379,7 +4495,10 @@ async function writeReadinessSnapshot(rootDir, report) {
 
 // src/welcome/visual-kit.ts
 import { cyan as cyan2, gray, options as koloristOptions } from "kolorist";
+var KOLORIST_TRUECOLOR = 3;
 var HELMET_OUTLINE = "#e2e8f0";
+var HELMET_FILL = "#0C8DEB";
+var HELMET_ACCENT = "#00D0E7";
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var SPACE_MARKS = {
   star: "\u2726",
@@ -4405,6 +4524,18 @@ function shouldUseWelcomeColor(opts = {}) {
   const tty = opts.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
   return tty;
 }
+function withKoloristColor(fn) {
+  const prevEnabled = koloristOptions.enabled;
+  const prevLevel = koloristOptions.supportLevel;
+  koloristOptions.enabled = true;
+  koloristOptions.supportLevel = KOLORIST_TRUECOLOR;
+  try {
+    return fn();
+  } finally {
+    koloristOptions.enabled = prevEnabled;
+    koloristOptions.supportLevel = prevLevel;
+  }
+}
 function shouldUseVisualMotion(opts = {}) {
   if (process.env.AGENT_KIT_REDUCED_MOTION === "1") return false;
   return shouldUseWelcomeColor(opts);
@@ -4553,6 +4684,19 @@ async function runDoctor(cwd, options = {}) {
     await writeReadinessSnapshot(rootDir, execution.after);
     return { report: execution.after, safeChanges: execution.changes, hooks, env };
   }
+  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 };
+  }
   const scan = await runScanner(rootDir);
   const report = createReadinessReport(scan, {
     generatorVersion: KIT_VERSION,
@@ -4571,6 +4715,11 @@ function printDoctorSummary(result) {
   );
   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)"}`
+    );
+  }
   console.log(`hooks: ${result.hooks.status}`);
   if (result.hooks.reasons.length > 0) {
     for (const reason of result.hooks.reasons.slice(0, 5)) {
@@ -4625,10 +4774,18 @@ var doctorCommand = defineCommand7({
       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 }) {
-    const run = () => runDoctor(args.cwd, { fixSafe: args["fix-safe"] });
+    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));
@@ -5083,13 +5240,13 @@ function printV3Guidance() {
   logger.info("Resume in IDE: /resume, summaries and transcripts.");
 }
 function runCursorHandoff(scriptPath, cwd) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const child = spawn4("sh", [scriptPath, "handoff"], {
       cwd,
       stdio: "inherit"
     });
     child.on("error", (err) => reject(err));
-    child.on("close", (code) => resolve2(code ?? 1));
+    child.on("close", (code) => resolve3(code ?? 1));
   });
 }
 var handoffCommand = defineCommand9({
@@ -5171,11 +5328,13 @@ function formatSessionStartOutput(additionalContext, format) {
 var SESSION_START_DEGRADED_MESSAGE = "Agent Kit session-start context is unavailable this session (internal error, fail-open mode). Nothing else is affected; retry next session.";
 
 // src/hooks/pre-compact.ts
+var CONTEXT_USAGE_CAP_PERCENT = 50;
 function buildPreCompactUserMessage(payload = {}) {
   const pct = payload.context_usage_percent;
   const trigger = payload.trigger || "auto";
   const pctTxt = pct !== void 0 && pct !== null ? `~${pct}%` : "high";
-  const msg = `Context compacting (${trigger}, usage ${pctTxt}). Update \`.cursor/HANDOFF.md\` and open a new chat with \`/continue-plan\` so the next agent starts fresh.`;
+  const overCap = pct === void 0 || pct === null || pct >= CONTEXT_USAGE_CAP_PERCENT;
+  const msg = overCap ? `Context compacting (${trigger}, usage ${pctTxt}) \u2014 over the ${CONTEXT_USAGE_CAP_PERCENT}% per-agent context-usage cap. Update \`.cursor/HANDOFF.md\` now (forced checkpoint) and open a new chat with \`/continue-plan\` so the next agent starts fresh.` : `Context compacting (${trigger}, usage ${pctTxt}). Update \`.cursor/HANDOFF.md\` and open a new chat with \`/continue-plan\` so the next agent starts fresh.`;
   return { user_message: msg };
 }
 
@@ -5440,7 +5599,7 @@ async function loadUpdateCheckPrefs(root) {
   }
 }
 function runUpdateCheckJson(root) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const child = spawn5(
       process.execPath,
       [
@@ -5459,20 +5618,20 @@ function runUpdateCheckJson(root) {
     child.stdout?.on("data", (chunk) => {
       out += chunk.toString("utf8");
     });
-    child.on("error", () => resolve2(null));
+    child.on("error", () => resolve3(null));
     child.on("close", () => {
       try {
         const parsed = JSON.parse(out.trim());
-        resolve2(parsed && typeof parsed === "object" ? parsed : null);
+        resolve3(parsed && typeof parsed === "object" ? parsed : null);
       } catch {
-        resolve2(null);
+        resolve3(null);
       }
     });
   });
 }
 async function updateCheckSection(root) {
   if (await loadUpdateCheckPrefs(root) === null) return null;
-  const result = await new Promise((resolve2) => {
+  const result = await new Promise((resolve3) => {
     const child = spawn5(
       "agent-kit",
       ["update", "--check", "--json", "--respect-prefs", "--stamp", "--cwd", root],
@@ -5483,17 +5642,17 @@ async function updateCheckSection(root) {
       out += chunk.toString("utf8");
     });
     child.on("error", () => {
-      void runUpdateCheckJson(root).then(resolve2);
+      void runUpdateCheckJson(root).then(resolve3);
     });
     child.on("close", (code) => {
       if (code !== 0 && !out.trim()) {
-        void runUpdateCheckJson(root).then(resolve2);
+        void runUpdateCheckJson(root).then(resolve3);
         return;
       }
       try {
-        resolve2(JSON.parse(out.trim()));
+        resolve3(JSON.parse(out.trim()));
       } catch {
-        void runUpdateCheckJson(root).then(resolve2);
+        void runUpdateCheckJson(root).then(resolve3);
       }
     });
   });
@@ -5518,7 +5677,7 @@ async function loadCursorUpdateCheckPrefs(root) {
   }
 }
 function runCursorAwarenessJson(root) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const child = spawn5(
       process.execPath,
       [
@@ -5537,13 +5696,13 @@ function runCursorAwarenessJson(root) {
     child.stdout?.on("data", (chunk) => {
       out += chunk.toString("utf8");
     });
-    child.on("error", () => resolve2(null));
+    child.on("error", () => resolve3(null));
     child.on("close", () => {
       try {
         const parsed = JSON.parse(out.trim());
-        resolve2(parsed && typeof parsed === "object" ? parsed : null);
+        resolve3(parsed && typeof parsed === "object" ? parsed : null);
       } catch {
-        resolve2(null);
+        resolve3(null);
       }
     });
   });
@@ -5560,13 +5719,13 @@ async function cursorAwarenessSection(root, deps = {}) {
   if (await loadCursorUpdateCheckPrefs(root) === null) return null;
   const spawnFn = deps.spawnFn ?? spawn5;
   const runFallback = deps.runFallback ?? runCursorAwarenessJson;
-  const result = await new Promise((resolve2) => {
+  const result = await new Promise((resolve3) => {
     let settled = false;
     let fallbackStarted = false;
     const finish = (value) => {
       if (settled) return;
       settled = true;
-      resolve2(value);
+      resolve3(value);
     };
     const startFallback = () => {
       if (settled || fallbackStarted) return;
@@ -5608,7 +5767,7 @@ async function cursorAwarenessSection(root, deps = {}) {
 var AUDIT_SESSION_NS_PREFIX = "agent-kit-audit-";
 var AUDIT_SESSION_LIST_TIMEOUT_MS = 2e3;
 function runAuditSessionCommand(cmd, args) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const child = spawn5(cmd, args, {
       stdio: ["ignore", "pipe", "ignore"],
       timeout: AUDIT_SESSION_LIST_TIMEOUT_MS,
@@ -5618,8 +5777,8 @@ function runAuditSessionCommand(cmd, args) {
     child.stdout?.on("data", (chunk) => {
       out += chunk.toString("utf8");
     });
-    child.on("error", () => resolve2(null));
-    child.on("close", () => resolve2(out));
+    child.on("error", () => resolve3(null));
+    child.on("close", () => resolve3(out));
   });
 }
 function parseTmuxDetachedAuditSessions(out, nowEpochSeconds) {
@@ -6111,6 +6270,10 @@ Mid-session refresh: \`/agent-kit\`.
 
 Cursor Ask questions is not available in this CLI. When a command requires a choice, list the same labels as a numbered list and wait. Skip or cancel means stop. Never \`/git-prod\` without an explicit operator yes.
 
+## Commit messages
+
+Never append \`Co-Authored-By: Claude ...\` or \`Claude-Session: https://claude.ai/code/...\` (or any session-ID trailer) to commit messages, PR descriptions, or PR bodies in this repo. This overrides the harness's default git-commit template. Plain Conventional Commits messages only.
+
 ## Non-goals
 
 - Not Action A7 (Windsurf / VS Code generator parity)
@@ -6125,18 +6288,20 @@ description: Load Agent Kit session context (HANDOFF, project-context, commands)
 disable-model-invocation: true
 ---
 
-Read these files if they exist, then summarize the active plan, next to-do, and any Gaps. Do not scan the whole repository first.
+Read these files if they exist. Prefer a one-shot ASCII Mission Control snapshot over a plain HANDOFF paraphrase.
 
-1. \`AGENTS.md\`
-2. \`.cursor/project-context.md\`
-3. \`.cursor/HANDOFF.md\`
-4. The plan file named in HANDOFF \`- **Plan:**\` under \`.cursor/plans/\`
+1. Run \`agent-kit mission-control --once\` (or \`npx @dadado/agent-kit-cli mission-control --once\`) in the project root and paste the stdout frame as the snapshot. Do not start a live loop: Claude Code cannot sustain one across turns.
+2. If that command is missing or fails, fall back to reading:
+   - \`AGENTS.md\`
+   - \`.cursor/project-context.md\`
+   - \`.cursor/HANDOFF.md\`
+   - The plan file named in HANDOFF \`- **Plan:**\` under \`.cursor/plans/\`
 
 If HANDOFF is missing, say so and point at \`/agent-kit-onboard\` or \`/start-project\` rather than inventing a plan.
 
 HITL: numbered-list fallback for Ask questions labels. Never \`/git-prod\` from this skill.
 
-Non-goals: not audits / \`/plan-external-review\`, not \`--backend claude\` ticks, not A7, not Cursor hook clones.
+Non-goals: not audits / \`/plan-external-review\`, not \`--backend claude\` ticks, not A7, not Cursor hook clones, not a continuous TUI loop.
 `;
 }
 async function writeUnlessExists(rootDir, relativePath, content) {
@@ -7143,21 +7308,416 @@ ${hint.recovery}
   }
 });
 
-// src/commands/monitors.ts
-import path38 from "path";
+// src/commands/mission-control.ts
 import { defineCommand as defineCommand13 } from "citty";
 
-// src/invariants/monitors-untriaged.ts
+// src/mission-control/render.ts
+import { gray as gray2, trueColor } from "kolorist";
+var DEFAULT_COLUMNS = 80;
+var MIN_COLUMNS = 40;
+var INNER_PAD = 2;
+function hexPaint(hex, text, color) {
+  if (!color) return text;
+  return withKoloristColor(
+    () => trueColor(
+      Number.parseInt(hex.slice(1, 3), 16),
+      Number.parseInt(hex.slice(3, 5), 16),
+      Number.parseInt(hex.slice(5, 7), 16)
+    )(text)
+  );
+}
+function muted(text, color) {
+  if (!color) return text;
+  return withKoloristColor(() => gray2(text));
+}
+function box(title, bodyLines, width, color) {
+  const inner = Math.max(8, width - 2);
+  const label = ` ${title} `;
+  const dashCount = Math.max(1, inner - label.length);
+  const top = `\u250C${label}${"\u2500".repeat(dashCount)}\u2510`;
+  const bottom = `\u2514${"\u2500".repeat(inner)}\u2518`;
+  const paintedTop = hexPaint(HELMET_FILL, top, color);
+  const paintedBottom = hexPaint(HELMET_OUTLINE, bottom, color);
+  const rows = bodyLines.map((line) => {
+    const clipped = line.length > inner - INNER_PAD ? line.slice(0, inner - INNER_PAD) : line;
+    const pad = " ".repeat(Math.max(0, inner - INNER_PAD - clipped.length));
+    const content = ` ${clipped}${pad} `;
+    return `${hexPaint(HELMET_OUTLINE, "\u2502", color)}${content}${hexPaint(HELMET_OUTLINE, "\u2502", color)}`;
+  });
+  return [paintedTop, ...rows, paintedBottom];
+}
+function lineOrQuiet(text, fallback) {
+  const trimmed = text?.trim();
+  return trimmed ? trimmed : fallback;
+}
+function renderMcTui(view, opts = {}) {
+  const color = shouldUseWelcomeColor(opts);
+  const motion = shouldUseVisualMotion(opts);
+  const columns = Math.max(
+    MIN_COLUMNS,
+    Math.floor(opts.columns ?? process.stdout.columns ?? DEFAULT_COLUMNS)
+  );
+  const mark = motion ? spinnerFrame(opts.frameIndex ?? 0) : SPACE_MARKS.tick;
+  const header = hexPaint(
+    HELMET_ACCENT,
+    `${mark} Mission Control ${SPACE_MARKS.star} terminal view (web dashboard unchanged)`,
+    color
+  );
+  const missionBody = view.error ? [wrapNarrow(view.error, columns - 4).split("\n")[0] ?? view.error] : [
+    `status  ${view.mission.status}${view.mission.mode ? `  \xB7  ${view.mission.mode}` : ""}`,
+    `plan    ${lineOrQuiet(view.mission.planFile, "none")}`,
+    `todos   ${view.mission.progressLabel}`,
+    `now     ${lineOrQuiet(view.mission.currentTodo, "none")}`,
+    `next    ${lineOrQuiet(view.mission.nextTodo, "none")}`
+  ];
+  const nowLabel = view.flightLog.now ? `NOW ${view.flightLog.nowKind ? `(${view.flightLog.nowKind})` : ""}  ${view.flightLog.now}` : "NOW  All clear";
+  const flightBody = [
+    nowLabel,
+    ...view.flightLog.warnings.length > 0 ? view.flightLog.warnings.map((w) => `warn  ${w}`) : [],
+    ...view.flightLog.earlier.length > 0 ? view.flightLog.earlier.map((t) => `Earlier  ${t}`) : [muted("Earlier  none", color)]
+  ];
+  const checklistBody = view.checklist.length === 0 ? [muted("no open plans", color)] : view.checklist.map((row) => {
+    const todo = row.currentTodo ? `  \xB7  ${row.currentTodo}` : "";
+    return `${row.file}  ${row.lifecycle}  ${row.progressLabel}${todo}`;
+  });
+  const crewBody = view.crewMonitor.length === 0 ? [muted("quiet", color)] : view.crewMonitor.map((row) => `${row.kind}  ${row.label}`);
+  const panels = [
+    ...box("Mission", missionBody, columns, color),
+    ...box("Flight Log", flightBody, columns, color),
+    ...box("Checklist", checklistBody, columns, color),
+    ...box("Crew Monitor", crewBody, columns, color)
+  ];
+  const footer = muted("Third surface \xB7 local snapshot \xB7 q / Ctrl-C to quit live view", color);
+  return [header, ...panels, footer].join("\n");
+}
+function shouldLiveRefresh(opts) {
+  if (opts.once) return false;
+  const env = opts.env ?? process.env;
+  if (env.CI != null && env.CI !== "") return false;
+  const tty = opts.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
+  return tty;
+}
+
+// src/mission-control/snapshot.ts
 import { execFile as execFile5 } from "child_process";
-import { readFile as readFile20, readdir as readdir8, stat as stat5 } from "fs/promises";
+import { access as access8 } from "fs/promises";
 import path37 from "path";
+
+// ../../dashboard/lib/live-refresh.mjs
+import { join, resolve as resolve2 } from "path";
+var PERIODIC_REFRESH_MS = 15e3;
+var SNAPSHOT_REPO_SOURCE_RELS = Object.freeze([
+  ".cursor/plans",
+  ".cursor/HANDOFF.md",
+  ".cursor/agents",
+  ".cursor/commands",
+  ".cursor/memory",
+  ".cursor/context/config.json",
+  ".cursor/context/current",
+  ".cursor/context/readiness.json",
+  ".cursor/context/field-report-dismissals.json",
+  ".cursor/context/mission-timing.json",
+  ".cursor/context/flight-log.json",
+  ".cursor/context/field-report-cadence.json",
+  ".cursor/skills",
+  "package.json"
+]);
+
+// src/mission-control/snapshot.ts
+var DEFAULT_DATA_TIMEOUT_MS = 6e4;
+function dataScriptTimeoutMs(env = process.env) {
+  const raw = env.AGENT_KIT_DASHBOARD_DATA_TIMEOUT_MS;
+  const n = raw != null && raw !== "" ? Number(raw) : DEFAULT_DATA_TIMEOUT_MS;
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_DATA_TIMEOUT_MS;
+}
+async function firstExisting2(candidates) {
+  for (const candidate2 of candidates) {
+    try {
+      await access8(candidate2);
+      return path37.resolve(candidate2);
+    } catch {
+    }
+  }
+  return null;
+}
+async function findDashboardDataScript(cwd, env = process.env, options = {}) {
+  const startPath = await findDashboardStart(cwd, env, options);
+  if (startPath) {
+    const sibling = path37.join(path37.dirname(startPath), "dashboard-data.mjs");
+    try {
+      await access8(sibling);
+      return sibling;
+    } catch {
+    }
+  }
+  return firstExisting2(
+    bundledDashboardCandidates("dashboard-data.mjs", options.moduleUrl ?? import.meta.url)
+  );
+}
+async function loadDashboardSnapshot(opts) {
+  const env = opts.env ?? process.env;
+  const timeout = dataScriptTimeoutMs(env);
+  const run = opts.execFileFn ?? execFile5;
+  const snapshotRoot = path37.resolve(opts.snapshotRoot);
+  return new Promise((resolve3) => {
+    run(
+      process.execPath,
+      [opts.dataScript],
+      {
+        cwd: snapshotRoot,
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024,
+        timeout,
+        env: {
+          ...env,
+          [REPO_ROOT_ENV]: snapshotRoot
+        }
+      },
+      (err, stdout) => {
+        if (err) {
+          const killed = Boolean(
+            err && typeof err === "object" && "killed" in err && err.killed
+          );
+          const message = killed ? `dashboard-data.mjs timed out after ${timeout}ms (set AGENT_KIT_DASHBOARD_DATA_TIMEOUT_MS to raise)` : err.message;
+          resolve3({ ok: false, error: message });
+          return;
+        }
+        try {
+          const parsed = JSON.parse(String(stdout ?? ""));
+          if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            resolve3({ ok: false, error: "dashboard-data.mjs returned non-object JSON" });
+            return;
+          }
+          resolve3({ ok: true, snapshot: parsed });
+        } catch {
+          resolve3({ ok: false, error: "dashboard-data.mjs returned invalid JSON" });
+        }
+      }
+    );
+  });
+}
+
+// src/mission-control/loop.ts
+var CLEAR_HOME = "\x1B[2J\x1B[H";
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+async function runMcTuiLoop(opts) {
+  const live = shouldLiveRefresh({
+    once: opts.once,
+    stdoutIsTTY: opts.stdoutIsTTY,
+    env: opts.env
+  });
+  let frameIndex = 0;
+  const paint2 = async (clear) => {
+    const view = await opts.loadView();
+    const frame = renderMcTui(view, {
+      ...opts.renderOpts,
+      stdoutIsTTY: opts.stdoutIsTTY,
+      frameIndex
+    });
+    frameIndex += 1;
+    opts.hooks.write(clear ? `${CLEAR_HOME}${frame}
+` : `${frame}
+`);
+  };
+  await paint2(false);
+  if (!live) return null;
+  opts.hooks.write(HIDE_CURSOR);
+  const intervalMs = opts.intervalMs ?? PERIODIC_REFRESH_MS;
+  const setInt = opts.hooks.setIntervalFn ?? setInterval;
+  const clearInt = opts.hooks.clearIntervalFn ?? clearInterval;
+  const timer = setInt(() => {
+    void paint2(true);
+  }, intervalMs);
+  const stop = () => {
+    clearInt(timer);
+    opts.hooks.write(SHOW_CURSOR);
+  };
+  return { stop };
+}
+
+// src/mission-control/view.ts
+var CHECKLIST_CAP = 8;
+var CREW_CAP = 12;
+var EARLIER_CAP = 4;
+var WARNING_CAP = 5;
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
+}
+function asString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function compactTodo(value) {
+  const rec = asRecord(value);
+  if (!rec) return asString(value);
+  return asString(rec.id) ?? asString(rec.content) ?? asString(rec.label);
+}
+function progressLabel(progress) {
+  const rec = asRecord(progress);
+  if (!rec) return "0 of 0 complete";
+  const labeled = asString(rec.label);
+  if (labeled) return labeled;
+  const completed = typeof rec.completed === "number" ? rec.completed : 0;
+  const total = typeof rec.total === "number" ? rec.total : 0;
+  return `${completed} of ${total} complete`;
+}
+function emptyMission() {
+  return {
+    status: "idle",
+    planFile: null,
+    mode: null,
+    progressLabel: "0 of 0 complete",
+    currentTodo: null,
+    nextTodo: null,
+    gaps: null
+  };
+}
+function emptyFlightLog() {
+  return { now: null, nowKind: null, earlier: [], warnings: [] };
+}
+function buildMcTuiView(snapshot, error = null) {
+  if (error) {
+    return {
+      mission: emptyMission(),
+      flightLog: emptyFlightLog(),
+      checklist: [],
+      crewMonitor: [],
+      error
+    };
+  }
+  const mc = asRecord(snapshot?.missionControl);
+  const now2 = asRecord(mc?.now);
+  const mission = now2 ? {
+    status: asString(now2.status) ?? "idle",
+    planFile: asString(now2.planFile),
+    mode: asString(now2.mode),
+    progressLabel: progressLabel(now2.progress),
+    currentTodo: compactTodo(now2.currentTodo),
+    nextTodo: compactTodo(now2.nextTodo),
+    gaps: asString(now2.gaps)
+  } : emptyMission();
+  const flight = asRecord(mc?.flightLog);
+  const earlierRaw = Array.isArray(flight?.past) ? flight.past : [];
+  const warningRaw = Array.isArray(flight?.warnings) ? flight.warnings : [];
+  const flightLog = flight ? {
+    now: asString(flight.current),
+    nowKind: asString(flight.currentKind),
+    earlier: earlierRaw.map((entry) => asString(asRecord(entry)?.text) ?? asString(entry)).filter((text) => Boolean(text)).slice(0, EARLIER_CAP),
+    warnings: warningRaw.map((entry) => asString(asRecord(entry)?.text) ?? asString(asRecord(entry)?.title)).filter((text) => Boolean(text)).slice(0, WARNING_CAP)
+  } : emptyFlightLog();
+  const plansRaw = Array.isArray(mc?.plans) ? mc.plans : [];
+  const checklist = plansRaw.map((plan) => {
+    const rec = asRecord(plan);
+    if (!rec) return null;
+    const file = asString(rec.file);
+    if (!file) return null;
+    const lifecycle = asString(rec.lifecycle) ?? "unknown";
+    if (lifecycle === "completed") return null;
+    return {
+      file,
+      lifecycle,
+      progressLabel: progressLabel(rec.progress),
+      currentTodo: compactTodo(rec.currentTodo)
+    };
+  }).filter((row) => Boolean(row)).slice(0, CHECKLIST_CAP);
+  const feedCap = typeof mc?.monitorFeedCap === "number" && mc.monitorFeedCap > 0 ? Math.min(CREW_CAP, Math.floor(mc.monitorFeedCap)) : CREW_CAP;
+  const activityRaw = Array.isArray(mc?.activity) ? mc.activity : [];
+  const crewMonitor = activityRaw.map((event) => {
+    const rec = asRecord(event);
+    if (!rec) return null;
+    const label = asString(rec.label) ?? asString(rec.labelFull);
+    if (!label) return null;
+    return { kind: asString(rec.kind) ?? "activity", label };
+  }).filter((row) => Boolean(row)).slice(0, feedCap);
+  return { mission, flightLog, checklist, crewMonitor, error: null };
+}
+
+// src/commands/mission-control.ts
+var missionControlCommand = defineCommand13({
+  meta: {
+    name: "mission-control",
+    description: "ASCII Mission Control (mission, flight log, checklist, crew monitor) without a browser."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd(),
+      description: "Workspace to snapshot (nearest .cursor/agent-kit.json, else git root)"
+    },
+    once: {
+      type: "boolean",
+      default: false,
+      description: "Print one frame and exit (Claude Code / non-TTY / CI)"
+    }
+  },
+  async run({ args }) {
+    const snapshotRoot = resolveDashboardSnapshotRoot(args.cwd);
+    const dataScript = await findDashboardDataScript(args.cwd);
+    if (!dataScript) {
+      logger.error("No dashboard/dashboard-data.mjs found.");
+      console.error(
+        [
+          "",
+          "The Mission Control snapshot script is not available in this workspace.",
+          "The TUI reuses the Path C dashboard data collector; it does not start an HTTP server.",
+          "",
+          "Recovery (pick one):",
+          "  1. Upgrade the CLI: npx @dadado/agent-kit-cli@latest mission-control",
+          "  2. Set MISSION_CONTROL_KIT_ROOT or AGENT_KIT_HOME to an agent-kit checkout",
+          "  3. Place an agent-kit sibling: ../agent-kit/dashboard/dashboard-data.mjs",
+          ""
+        ].join("\n")
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const handle = await runMcTuiLoop({
+      once: Boolean(args.once),
+      stdoutIsTTY: Boolean(process.stdout.isTTY),
+      env: process.env,
+      renderOpts: { stdoutIsTTY: Boolean(process.stdout.isTTY) },
+      loadView: async () => {
+        const loaded = await loadDashboardSnapshot({
+          dataScript,
+          snapshotRoot
+        });
+        if (!loaded.ok) return buildMcTuiView(null, loaded.error);
+        return buildMcTuiView(loaded.snapshot);
+      },
+      hooks: {
+        write: (chunk) => {
+          process.stdout.write(chunk);
+        }
+      }
+    });
+    if (!handle) return;
+    const onSignal = () => {
+      handle.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+  }
+});
+
+// src/commands/monitors.ts
+import path39 from "path";
+import { defineCommand as defineCommand14 } from "citty";
+
+// src/invariants/monitors-untriaged.ts
+import { execFile as execFile6 } from "child_process";
+import { readFile as readFile20, readdir as readdir8, stat as stat5 } from "fs/promises";
+import path38 from "path";
 import { promisify as promisify5 } from "util";
 
 // src/invariants/triage-heading.ts
 var TRIAGE_HEADING_RE = /^#{2,6}\s+(?:Triage note|Follow-?up plan|Residuals plan)\b/im;
 
 // src/invariants/monitors-untriaged.ts
-var execFileAsync4 = promisify5(execFile5);
+var execFileAsync4 = promisify5(execFile6);
 var CITE4 = "agent-kit monitors --untriaged (ADR 2026-07-27_plan-review-triage-untriaged-not-mtime; never newest-mtime-wins)";
 function hasOpenGaps(content) {
   if (/###\s+Still open[^\n]*\n+(?:\s*\n)*(?:None\.|none\.|\*None\*)/i.test(content)) {
@@ -7191,7 +7751,7 @@ async function gitFreshMonitorNames(rootDir) {
     for (const line of stdout.split("\n")) {
       if (!line.trim()) continue;
       const file = line.slice(3).trim().replace(/^.* -> /, "");
-      const base = path37.basename(file);
+      const base = path38.basename(file);
       if (base.startsWith("plan-monitor-") && base.endsWith(".md")) {
         names.add(base);
       }
@@ -7214,13 +7774,13 @@ function monitorSlugFromName(fileName) {
   return fileName.replace(/^plan-monitor-/, "").replace(/\.md$/, "").toLowerCase();
 }
 async function selectUntriagedMonitors(rootDir) {
-  const root = path37.resolve(rootDir);
-  const memoryDir = path37.join(root, ".cursor", "memory");
+  const root = path38.resolve(rootDir);
+  const memoryDir = path38.join(root, ".cursor", "memory");
   const allNames = await listMonitorFiles(memoryDir);
   const selectionOrder = ["git-fresh", "handoff-aligned", "untriaged-scan"];
   const byName = /* @__PURE__ */ new Map();
   for (const name of allNames) {
-    const abs = path37.join(memoryDir, name);
+    const abs = path38.join(memoryDir, name);
     try {
       const [content, st] = await Promise.all([readFile20(abs, "utf8"), stat5(abs)]);
       byName.set(name, { content, mtimeMs: st.mtimeMs });
@@ -7235,7 +7795,7 @@ async function selectUntriagedMonitors(rootDir) {
   const gitFreshSet = [...gitFresh].filter(untriaged).sort();
   let handoff = "";
   try {
-    handoff = await readFile20(path37.join(root, ".cursor", "HANDOFF.md"), "utf8");
+    handoff = await readFile20(path38.join(root, ".cursor", "HANDOFF.md"), "utf8");
   } catch {
     handoff = "";
   }
@@ -7255,8 +7815,8 @@ async function selectUntriagedMonitors(rootDir) {
     const row = byName.get(name);
     if (!row) continue;
     entries.push({
-      path: path37.join(memoryDir, name),
-      relativePath: path37.relative(root, path37.join(memoryDir, name)).split(path37.sep).join("/"),
+      path: path38.join(memoryDir, name),
+      relativePath: path38.relative(root, path38.join(memoryDir, name)).split(path38.sep).join("/"),
       mtimeMs: row.mtimeMs,
       hasTriageHeading: false,
       hasOpenGaps: hasOpenGaps(row.content),
@@ -7275,7 +7835,7 @@ async function selectUntriagedMonitors(rootDir) {
 }
 
 // src/commands/monitors.ts
-var monitorsCommand = defineCommand13({
+var monitorsCommand = defineCommand14({
   meta: {
     name: "monitors",
     description: "Select untriaged plan monitors (--untriaged; SoT for chat triage)."
@@ -7302,7 +7862,7 @@ var monitorsCommand = defineCommand13({
       process.exitCode = 2;
       return;
     }
-    const result = await selectUntriagedMonitors(path38.resolve(args.cwd));
+    const result = await selectUntriagedMonitors(path39.resolve(args.cwd));
     if (args.json) {
       console.log(JSON.stringify(result, null, 2));
       return;
@@ -7318,8 +7878,8 @@ var monitorsCommand = defineCommand13({
 });
 
 // src/commands/run-plan.ts
-import path43 from "path";
-import { defineCommand as defineCommand14 } from "citty";
+import path44 from "path";
+import { defineCommand as defineCommand15 } from "citty";
 
 // src/plan-loop/backends.ts
 import { execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
@@ -7333,7 +7893,7 @@ async function which(bin) {
   }
 }
 function spawnLogged(command, args, logPath) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const out = createWriteStream(logPath, { flags: "w" });
     const child = spawn6(command, args, {
       stdio: ["ignore", "pipe", "pipe"]
@@ -7349,7 +7909,7 @@ function spawnLogged(command, args, logPath) {
       reject(err);
     });
     child.on("close", (code) => {
-      out.end(() => resolve2({ exitCode: code ?? 1 }));
+      out.end(() => resolve3({ exitCode: code ?? 1 }));
     });
   });
 }
@@ -7404,13 +7964,13 @@ function listBackendIds() {
 
 // src/plan-loop/run-loop.ts
 import { mkdir as mkdir6, readFile as readFile23, rm as rm2, unlink as unlink2 } from "fs/promises";
-import path42 from "path";
+import path43 from "path";
 
 // src/plan-loop/external-review.ts
 import { spawn as spawn7 } from "child_process";
-import path39 from "path";
-var CANONICAL_REL = path39.join(".cursor", "scripts", "plan-external-review.sh");
-var FALLBACK_REL = path39.join("scripts", "plan-external-review.sh");
+import path40 from "path";
+var CANONICAL_REL = path40.join(".cursor", "scripts", "plan-external-review.sh");
+var FALLBACK_REL = path40.join("scripts", "plan-external-review.sh");
 function isPlanExhaustedReason(reason) {
   const r = reason.trim().toLowerCase();
   if (!r) return false;
@@ -7432,8 +7992,8 @@ async function armExternalPlanReview(root, options = {}) {
   const existsFn = options.existsFn ?? fileExists;
   const log = options.log ?? ((line) => console.log(line));
   const force = options.force === true;
-  const canonicalPath = path39.join(root, CANONICAL_REL);
-  const fallbackPath = path39.join(root, FALLBACK_REL);
+  const canonicalPath = path40.join(root, CANONICAL_REL);
+  const fallbackPath = path40.join(root, FALLBACK_REL);
   let scriptPath = null;
   let scriptRel = CANONICAL_REL;
   if (await existsFn(canonicalPath)) {
@@ -7451,7 +8011,7 @@ async function armExternalPlanReview(root, options = {}) {
   }
   log("Plan exhausted: arming optional external plan review (opt-in handled by script)...");
   const args = force ? [scriptPath, "--force", "--print"] : [scriptPath, "--print"];
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const child = spawnFn("bash", args, {
       cwd: root,
       env: { ...process.env, AGENT_KIT_HEADLESS: "1" }
@@ -7472,7 +8032,7 @@ async function armExternalPlanReview(root, options = {}) {
       log(
         `tip: external plan review launcher failed (${err.message}). Manual: ${scriptRel} or /plan-external-review`
       );
-      resolve2({ invoked: true, exitCode: null, output });
+      resolve3({ invoked: true, exitCode: null, output });
     });
     child.on("close", (code) => {
       if (code !== 0 && code !== null) {
@@ -7480,17 +8040,17 @@ async function armExternalPlanReview(root, options = {}) {
           `tip: external plan review exited ${code} (ignored; does not fail the loop). Manual: ${scriptRel} or /plan-external-review`
         );
       }
-      resolve2({ invoked: true, exitCode: code, output });
+      resolve3({ invoked: true, exitCode: code, output });
     });
   });
 }
 
 // src/plan-loop/persona-banners.ts
-import path40 from "path";
+import path41 from "path";
 import {
   blue,
   cyan as cyan4,
-  gray as gray2,
+  gray as gray3,
   green as green3,
   lightGray,
   lightGreen,
@@ -7503,7 +8063,7 @@ var CLI_RUN_PLAN_MODE = "cli-run-plan";
 var DEFAULT_CLI_PERSONA_ID = "ghost-runner";
 var COLORS = {
   white,
-  gray: gray2,
+  gray: gray3,
   green: green3,
   cyan: cyan4,
   magenta,
@@ -7522,7 +8082,7 @@ function resolveColor(name, fallback) {
 async function resolveCliPersonaId(root) {
   try {
     const cfg = await readJson(
-      path40.join(root, ".cursor", "context", "config.json")
+      path41.join(root, ".cursor", "context", "config.json")
     );
     const modes = cfg?.agentPersona?.modes ?? cfg?.workspaceSkin?.modes;
     const id = modes?.[CLI_RUN_PLAN_MODE];
@@ -7533,7 +8093,7 @@ async function resolveCliPersonaId(root) {
 }
 async function loadPersonaPack(root, personaId) {
   try {
-    const personaPath = path40.join(root, "registry", "personas", "core", personaId, "persona.json");
+    const personaPath = path41.join(root, "registry", "personas", "core", personaId, "persona.json");
     const pack = await readJson(personaPath);
     if (!pack || typeof pack.id !== "string") return null;
     return pack;
@@ -7550,7 +8110,7 @@ function createPersonaBannerPrinter(persona) {
   const banners = persona.cliBanners;
   if (!banners.tickStart && !banners.tickEnd && !banners.phaseComplete) return null;
   const primary = resolveColor(persona.ansiPalette?.primary, white);
-  const secondary = resolveColor(persona.ansiPalette?.secondary, gray2);
+  const secondary = resolveColor(persona.ansiPalette?.secondary, gray3);
   const accent = resolveColor(persona.ansiPalette?.accent, green3);
   return {
     tickStart(detail) {
@@ -7583,7 +8143,7 @@ function createPersonaBannerPrinter(persona) {
 
 // src/plan-loop/plan-state.ts
 import { readFile as readFile21, readdir as readdir9 } from "fs/promises";
-import path41 from "path";
+import path42 from "path";
 function countPendingTodos(raw) {
   const lines = raw.split(/\r?\n/);
   let inFront = 0;
@@ -7611,7 +8171,7 @@ function countPendingTodos(raw) {
 async function findActivePlanFile(plansDir) {
   if (!await fileExists(plansDir)) return null;
   const files = (await readdir9(plansDir)).filter((f) => f.endsWith(".plan.md")).sort();
-  return files[0] ? path41.join(plansDir, files[0]) : null;
+  return files[0] ? path42.join(plansDir, files[0]) : null;
 }
 async function readPlan(planPath) {
   return readFile21(planPath, "utf8");
@@ -7688,9 +8248,9 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 async function runPlanLoop(opts) {
-  const plansDir = path42.join(opts.root, ".cursor", "plans");
-  const stopFile = path42.join(opts.root, ".cursor", "loop.stop");
-  const logDir = path42.join(opts.root, ".cursor", "loop-logs");
+  const plansDir = path43.join(opts.root, ".cursor", "plans");
+  const stopFile = path43.join(opts.root, ".cursor", "loop.stop");
+  const logDir = path43.join(opts.root, ".cursor", "loop-logs");
   const planPath = await findActivePlanFile(plansDir);
   if (!planPath) {
     logger.error("No active plan in .cursor/plans/");
@@ -7711,7 +8271,7 @@ async function runPlanLoop(opts) {
   try {
     const persona = await loadCliRunPlanPersona(opts.root);
     const banners = createPersonaBannerPrinter(persona);
-    console.log(`Active plan: ${path42.basename(planPath)}`);
+    console.log(`Active plan: ${path43.basename(planPath)}`);
     console.log(`Pending to-dos: ${await pending()} | max ticks: ${opts.maxTicks}`);
     console.log(`Backend: ${opts.backend.id}`);
     if (persona) {
@@ -7754,8 +8314,8 @@ async function runPlanLoop(opts) {
         planExhausted = true;
         break;
       }
-      const logPath = path42.join(logDir, `tick-${stamp()}.log`);
-      const relLog = path42.relative(opts.root, logPath);
+      const logPath = path43.join(logDir, `tick-${stamp()}.log`);
+      const relLog = path43.relative(opts.root, logPath);
       console.log("");
       const tickLine = `=== tick ${tick}/${opts.maxTicks} - pending: ${before} - log: ${relLog} ===`;
       if (banners) banners.tickStart(tickLine);
@@ -7834,7 +8394,7 @@ async function runPlanLoop(opts) {
     const finishDetail = `after ${tick} tick(s); pending: ${pendingNow}`;
     if (banners) banners.phaseComplete(finishDetail);
     console.log(
-      `Loop finished after ${tick} tick(s). Pending now: ${pendingNow}. Logs in ${path42.relative(opts.root, logDir)}/`
+      `Loop finished after ${tick} tick(s). Pending now: ${pendingNow}. Logs in ${path43.relative(opts.root, logDir)}/`
     );
     if (planExhausted || shouldArmExternalPlanReview({ pending: pendingNow, stopReason })) {
       await armExternalPlanReview(opts.root);
@@ -7846,7 +8406,7 @@ async function runPlanLoop(opts) {
 }
 
 // src/commands/run-plan.ts
-var runPlanCommand = defineCommand14({
+var runPlanCommand = defineCommand15({
   meta: {
     name: "run-plan",
     description: "Headless continuous plan runner (one fresh agent per tick). Never git-prod."
@@ -7905,7 +8465,7 @@ var runPlanCommand = defineCommand14({
       return;
     }
     const code = await runPlanLoop({
-      root: path43.resolve(args.cwd),
+      root: path44.resolve(args.cwd),
       maxTicks,
       sleepSeconds,
       model: args.model ? String(args.model) : void 0,
@@ -7917,8 +8477,8 @@ var runPlanCommand = defineCommand14({
 });
 
 // src/commands/scan.ts
-import { defineCommand as defineCommand15 } from "citty";
-var scanCommand = defineCommand15({
+import { defineCommand as defineCommand16 } from "citty";
+var scanCommand = defineCommand16({
   meta: {
     name: "scan",
     description: "Scan the repository and print the detected profile."
@@ -7942,9 +8502,9 @@ var scanCommand = defineCommand15({
 import { spawn as spawn8 } from "child_process";
 import { appendFile, mkdir as mkdir7, readFile as readFile24, writeFile as writeFile12 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import path44 from "path";
+import path45 from "path";
 import { confirm as confirm2, isCancel as isCancel2 } from "@clack/prompts";
-import { defineCommand as defineCommand16 } from "citty";
+import { defineCommand as defineCommand17 } from "citty";
 import { cyan as cyan5, green as green4, yellow as yellow3 } from "kolorist";
 var NPM_GLOBAL_DIR_NAME = ".npm-global";
 var SETUP_GLOBAL_MARKER = "# agent-kit setup-global";
@@ -7952,9 +8512,9 @@ var DEFAULT_PACKAGE_SPEC = "@dadado/agent-kit-cli";
 function planSetupGlobalSteps(env, options = {}) {
   const homeDir = options.homeDir ?? homedir4();
   const packageSpec = options.packageSpec ?? DEFAULT_PACKAGE_SPEC;
-  const npmGlobalDir = path44.join(homeDir, NPM_GLOBAL_DIR_NAME);
-  const npmGlobalBin = path44.join(npmGlobalDir, "bin");
-  const npmrcPath = path44.join(homeDir, ".npmrc");
+  const npmGlobalDir = path45.join(homeDir, NPM_GLOBAL_DIR_NAME);
+  const npmGlobalBin = path45.join(npmGlobalDir, "bin");
+  const npmrcPath = path45.join(homeDir, ".npmrc");
   const npmrcPrefixValue = `~/${NPM_GLOBAL_DIR_NAME}`;
   const pathExportLine = `export PATH="${npmGlobalBin}:$PATH"`;
   const shellProfile = env.shellProfile;
@@ -8033,12 +8593,12 @@ async function safeReadFile(fs, filePath) {
     return "";
   }
 }
-var defaultNpmInstallImpl = (packageSpec) => new Promise((resolve2) => {
+var defaultNpmInstallImpl = (packageSpec) => new Promise((resolve3) => {
   const child = spawn8("npm", ["i", "-g", packageSpec], { stdio: "inherit" });
-  child.on("error", (error) => resolve2({ ok: false, error }));
+  child.on("error", (error) => resolve3({ ok: false, error }));
   child.on("close", (code) => {
-    if (code === 0) resolve2({ ok: true });
-    else resolve2({ ok: false, error: new Error(`npm exited with code ${code ?? "unknown"}`) });
+    if (code === 0) resolve3({ ok: true });
+    else resolve3({ ok: false, error: new Error(`npm exited with code ${code ?? "unknown"}`) });
   });
 });
 var defaultConfirmImpl = async (message) => {
@@ -8187,7 +8747,7 @@ ${verifyStep.title}`);
   }
   return { exitCode: 0, mutated, outcome: "completed", env, plan };
 }
-var setupGlobalCommand = defineCommand16({
+var setupGlobalCommand = defineCommand17({
   meta: {
     name: "setup-global",
     description: "Self-heal a root-owned npm prefix: relocate to ~/.npm-global, fix PATH, reinstall globally."
@@ -8216,8 +8776,8 @@ var setupGlobalCommand = defineCommand16({
 });
 
 // src/commands/status.ts
-import path45 from "path";
-import { defineCommand as defineCommand17 } from "citty";
+import path46 from "path";
+import { defineCommand as defineCommand18 } from "citty";
 function profileStatus(profile) {
   if (!profile) return { origin: "none", evidence: [], profile: null };
   if ("detection" in profile && profile.detection && typeof profile.detection === "object") {
@@ -8230,7 +8790,7 @@ function profileStatus(profile) {
   }
   return { origin: "legacy-wizard", evidence: [], profile };
 }
-var statusCommand = defineCommand17({
+var statusCommand = defineCommand18({
   meta: {
     name: "status",
     description: "Show installed kit version, manifest, and optional profile."
@@ -8247,11 +8807,11 @@ var statusCommand = defineCommand17({
     }
   },
   async run({ args }) {
-    const rootDir = path45.resolve(args.cwd);
+    const rootDir = path46.resolve(args.cwd);
     const [manifest, rawProfile, scan] = await Promise.all([
       loadAgentKitManifest(rootDir),
       readJson(
-        path45.join(rootDir, ".cursor", "agent-kit.config.json")
+        path46.join(rootDir, ".cursor", "agent-kit.config.json")
       ),
       runScanner(rootDir)
     ]);
@@ -8306,13 +8866,13 @@ var statusCommand = defineCommand17({
 });
 
 // src/commands/update.ts
-import { defineCommand as defineCommand18 } from "citty";
+import { defineCommand as defineCommand19 } from "citty";
 
 // src/lifecycle/check-updates.ts
-import { execFile as execFile6 } from "child_process";
-import path46 from "path";
+import { execFile as execFile7 } from "child_process";
+import path47 from "path";
 import { promisify as promisify6 } from "util";
-var execFileAsync5 = promisify6(execFile6);
+var execFileAsync5 = promisify6(execFile7);
 var SEMVER_CORE = /^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/i;
 var FACTORY_URL_MARKERS = ["agent-kit-dev"];
 var FACTORY_REFS = /* @__PURE__ */ new Set(["staging", "homologacao", "develop", "dev"]);
@@ -8401,11 +8961,11 @@ function intervalElapsed2(lastCheckedAt, intervalDays) {
   return Date.now() - last >= ms;
 }
 async function loadContextConfig2(cwd) {
-  const configPath = path46.join(cwd, ".cursor", "context", "config.json");
+  const configPath = path47.join(cwd, ".cursor", "context", "config.json");
   return readJson(configPath);
 }
 async function stampLastCheckedAt(cwd) {
-  const configPath = path46.join(cwd, ".cursor", "context", "config.json");
+  const configPath = path47.join(cwd, ".cursor", "context", "config.json");
   const existing = await loadContextConfig2(cwd) ?? {};
   const prev = existing.updateCheck && typeof existing.updateCheck === "object" ? { ...existing.updateCheck } : {};
   existing.updateCheck = {
@@ -8417,7 +8977,7 @@ async function stampLastCheckedAt(cwd) {
 }
 async function readLocalKitVersion(registryRoot) {
   for (const rel of ["packages/cli/package.json", "package.json"]) {
-    const data = await readJson(path46.join(registryRoot, rel));
+    const data = await readJson(path47.join(registryRoot, rel));
     if (data && typeof data.version === "string" && data.version.length > 0) {
       return data.version;
     }
@@ -8438,7 +8998,7 @@ async function checkAgainstLocalRegistry(cwd, manifest, options) {
       status: "error",
       installedVersion: manifest.version,
       latestVersion: null,
-      registryUrl: path46.resolve(registryPath),
+      registryUrl: path47.resolve(registryPath),
       registryRef: "local",
       applyRecommended: false,
       message: `Failed to resolve --registry: ${msg}`
@@ -8660,7 +9220,7 @@ async function checkForUpdates(cwd, options = {}) {
 }
 
 // src/commands/update.ts
-var updateCommand = defineCommand18({
+var updateCommand = defineCommand19({
   meta: {
     name: "update",
     description: "Re-apply L0/packs/skills from the registry (never overwrites L3). --check = notify-only."
@@ -8795,8 +9355,8 @@ ${err.recovery}
 
 // src/commands/validate.ts
 import { readFile as readFile25 } from "fs/promises";
-import path47 from "path";
-import { defineCommand as defineCommand19 } from "citty";
+import path48 from "path";
+import { defineCommand as defineCommand20 } from "citty";
 
 // src/invariants/plan-schema.ts
 var CITE5 = "agent-kit validate plan (.cursor/context/templates/plan.md)";
@@ -8842,7 +9402,7 @@ function validatePlanFrontmatterText(text) {
 // src/commands/validate.ts
 async function resolveEditedPath(cwd, explicit) {
   if (explicit) {
-    const filePath2 = path47.resolve(cwd, explicit);
+    const filePath2 = path48.resolve(cwd, explicit);
     try {
       return { filePath: filePath2, content: await readFile25(filePath2, "utf8") };
     } catch {
@@ -8852,7 +9412,7 @@ async function resolveEditedPath(cwd, explicit) {
   const payload = await readStdinJson();
   const rel = typeof payload.file_path === "string" && payload.file_path || typeof payload.path === "string" && payload.path || typeof payload.file === "string" && payload.file || "";
   if (!rel) return null;
-  const filePath = path47.isAbsolute(rel) ? rel : path47.resolve(cwd, rel);
+  const filePath = path48.isAbsolute(rel) ? rel : path48.resolve(cwd, rel);
   try {
     return { filePath, content: await readFile25(filePath, "utf8") };
   } catch {
@@ -8866,13 +9426,13 @@ function isPlanPath(filePath) {
   const norm = filePath.replace(/\\/g, "/");
   return norm.includes("/.cursor/plans/") && norm.endsWith(".plan.md");
 }
-var validateCommand = defineCommand19({
+var validateCommand = defineCommand20({
   meta: {
     name: "validate",
     description: "Advisory validators for HANDOFF / plan frontmatter (hook adapter)."
   },
   subCommands: {
-    handoff: defineCommand19({
+    handoff: defineCommand20({
       meta: { name: "handoff", description: "Validate HANDOFF machine fields" },
       args: {
         cwd: { type: "string", default: process.cwd() },
@@ -8882,7 +9442,7 @@ var validateCommand = defineCommand19({
       async run({ args }) {
         const cwd = typeof args.cwd === "string" ? args.cwd : process.cwd();
         const fileArg = typeof args.file === "string" ? args.file : void 0;
-        const filePath = fileArg ? path47.resolve(cwd, fileArg) : path47.join(path47.resolve(cwd), ".cursor", "HANDOFF.md");
+        const filePath = fileArg ? path48.resolve(cwd, fileArg) : path48.join(path48.resolve(cwd), ".cursor", "HANDOFF.md");
         let content = "";
         try {
           content = await readFile25(filePath, "utf8");
@@ -8894,7 +9454,7 @@ var validateCommand = defineCommand19({
         console.log(JSON.stringify({ ok: warnings.length === 0, warnings }));
       }
     }),
-    plan: defineCommand19({
+    plan: defineCommand20({
       meta: { name: "plan", description: "Validate plan frontmatter" },
       args: {
         cwd: { type: "string", default: process.cwd() },
@@ -8909,7 +9469,7 @@ var validateCommand = defineCommand19({
           process.exitCode = 2;
           return;
         }
-        const filePath = path47.resolve(cwd, fileArg);
+        const filePath = path48.resolve(cwd, fileArg);
         let content = "";
         try {
           content = await readFile25(filePath, "utf8");
@@ -8921,7 +9481,7 @@ var validateCommand = defineCommand19({
         console.log(JSON.stringify({ ok: warnings.length === 0, warnings }));
       }
     }),
-    "after-edit": defineCommand19({
+    "after-edit": defineCommand20({
       meta: {
         name: "after-edit",
         description: "Advisory afterFileEdit: annotate HANDOFF/plan issues (never block)"
@@ -8931,7 +9491,7 @@ var validateCommand = defineCommand19({
       },
       async run({ args }) {
         const cwd = typeof args.cwd === "string" ? args.cwd : process.cwd();
-        const resolved = await resolveEditedPath(path47.resolve(cwd));
+        const resolved = await resolveEditedPath(path48.resolve(cwd));
         if (!resolved) {
           console.log(JSON.stringify({}));
           return;
@@ -8974,19 +9534,10 @@ var validateCommand = defineCommand19({
 });
 
 // src/welcome/help-groups.ts
-import { bold as bold2, gray as gray4, underline } from "kolorist";
+import { bold as bold2, gray as gray5, underline } from "kolorist";
 
 // src/welcome/screen.ts
-import {
-  blue as blue2,
-  cyan as cyan6,
-  gray as gray3,
-  options as koloristOptions3,
-  lightCyan,
-  trueColor,
-  white as white2
-} from "kolorist";
-var KOLORIST_TRUECOLOR = 3;
+import { blue as blue2, cyan as cyan6, gray as gray4, lightCyan, trueColor as trueColor2, white as white2 } from "kolorist";
 var HELMET_ASCII = [
   "       ____",
   "    .-'    '-.",
@@ -9007,19 +9558,7 @@ function hexToRgb(hex) {
 }
 function outlineAnsi(line) {
   const [r, g, b] = hexToRgb(HELMET_OUTLINE);
-  return trueColor(r, g, b)(line);
-}
-function withKoloristColor(fn) {
-  const prevEnabled = koloristOptions3.enabled;
-  const prevLevel = koloristOptions3.supportLevel;
-  koloristOptions3.enabled = true;
-  koloristOptions3.supportLevel = KOLORIST_TRUECOLOR;
-  try {
-    return fn();
-  } finally {
-    koloristOptions3.enabled = prevEnabled;
-    koloristOptions3.supportLevel = prevLevel;
-  }
+  return trueColor2(r, g, b)(line);
 }
 function hasCliSubcommand(rawArgs) {
   return Boolean(rawArgs?.some((arg) => !arg.startsWith("-")));
@@ -9039,6 +9578,7 @@ var WELCOME_UTILITY_HINTS = [
   { cmd: "agent-kit doctor", hint: "repository readiness" },
   { cmd: "agent-kit status", hint: "installed kit version" },
   { cmd: "agent-kit dashboard", hint: "Mission Control panel" },
+  { cmd: "agent-kit mission-control", hint: "Mission Control TUI" },
   { cmd: "agent-kit init", hint: "guided install entry" }
 ];
 function renderWelcomeScreen(opts = {}) {
@@ -9046,27 +9586,27 @@ function renderWelcomeScreen(opts = {}) {
   const color = shouldUseWelcomeColor(opts);
   const title = color ? white2("Mission Kit") : "Mission Kit";
   const product = color ? cyan6("agent-kit") : "agent-kit";
-  const muted = (s) => color ? gray3(s) : s;
+  const muted2 = (s) => color ? gray4(s) : s;
   const lines = [
     renderHelmetAscii(color),
     "",
     `${title}  \xB7  ${product} v${version}`,
-    muted("HITL framework for AI-assisted IDEs  \xB7  @dadado/agent-kit-cli"),
+    muted2("HITL framework for AI-assisted IDEs  \xB7  @dadado/agent-kit-cli"),
     "",
-    muted("Try:"),
+    muted2("Try:"),
     ...(() => {
       const width = Math.max(...WELCOME_UTILITY_HINTS.map(({ cmd }) => cmd.length));
       return WELCOME_UTILITY_HINTS.map(({ cmd, hint }) => {
         const pad = " ".repeat(width - cmd.length + 2);
         const left = color ? cyan6(`  ${cmd}`) : `  ${cmd}`;
-        return `${left}${pad}${muted(hint)}`;
+        return `${left}${pad}${muted2(hint)}`;
       });
     })(),
     "",
-    muted(
+    muted2(
       "Chat HITL (start-project, git-staging/prod, run-plan-all) stays in Cursor slash commands."
     ),
-    muted(
+    muted2(
       `${shouldUseVisualMotion(opts) ? SPACE_MARKS.star : SPACE_MARKS.tick} ${tipAt(
         [...version].reduce((n, c) => n + c.charCodeAt(0), 0)
       )}`
@@ -9094,7 +9634,7 @@ var CLI_HELP_GROUPS = [
   {
     id: "dashboard",
     title: "DASHBOARD",
-    commands: ["dashboard", "dashboard-broadcast", "monitors"]
+    commands: ["dashboard", "dashboard-broadcast", "mission-control", "monitors"]
   },
   {
     id: "integrity",
@@ -9120,7 +9660,7 @@ async function resolveSubMeta(subCommands) {
 async function renderGroupedRootHelp(cmd) {
   const color = shouldUseWelcomeColor();
   const u = (s) => color ? underline(bold2(s)) : s;
-  const g = (s) => color ? gray4(s) : s;
+  const g = (s) => color ? gray5(s) : s;
   const meta = await resolveCommandMeta(cmd.meta);
   const name = meta?.name ?? "agent-kit";
   const version = meta?.version ?? KIT_VERSION;
@@ -9164,7 +9704,7 @@ async function renderGroupedRootHelp(cmd) {
 }
 
 // src/index.ts
-var main = defineCommand20({
+var main = defineCommand21({
   meta: {
     name: "agent-kit",
     description: "HITL framework for AI-assisted IDEs (Mission Kit family)",
@@ -9186,6 +9726,7 @@ var main = defineCommand20({
     "run-plan": runPlanCommand,
     dashboard: dashboardCommand,
     "dashboard-broadcast": dashboardBroadcastCommand,
+    "mission-control": missionControlCommand,
     hook: hookCommand,
     guard: guardCommand,
     monitors: monitorsCommand,