@dadado/agent-kit-cli 5.8.0 → 5.10.0

package/dist/index.js

@@ -273,7 +273,74 @@ var KNOWN_SHIPPED_OVERLAY_HASHES = /* @__PURE__ */ new Set([
   "3a88df22375f90a3a6743f50d9a01129e0373f4ca8dff03fb744c1de3c149409",
   "481a9994ccecaa611173f9ef91a1dbe7458d89758c6a6b5e7c3bbbbf460888ce",
   "691d91fd1e9032b6f9315f29348d4473201917da257258afd74eb954298d8d71",
-  "ab0808b7dbc333e523b87b126bb655353cde2574db30d849cc9c9037843bef8c"
+  "ab0808b7dbc333e523b87b126bb655353cde2574db30d849cc9c9037843bef8c",
+  "85514e26af694bbe38e7ddf625710a32719ddf6afc173843c9cdfbffdad8e466",
+  "35b6c0cde7538fb1837d54ba841668e82ac7b9e3ef274adcea3d7f34ba4bfb64",
+  "4230e45f2ccd89cf8e25c56d21dfbfbe134613c686ea361243f94c49cf6802af",
+  "b4fbb2c15a1330ba36351a90490696fd558a347d25ac14af768017d6155335c0",
+  "c37ee51662b6eca65224d737911a4bb209a3742694b37a4d00ed29abc4e0b253",
+  "f46a0e36c1ee887ad7e62fa00a8facefe90605827de7bf2e6f90655d6660ed0e",
+  "40edd2d21be802af95501cf3492665ee48423439cfc64c14f17ed1e7eb8bdfdf",
+  "08c15346f42360bd7a4b4e803ca88e5f1727d9db106e7dc4d96523ee7aba129a",
+  "0cc36b633ca1a18fa472ed8040a5b927b4c918318dbd17f6163b706cd7a8acbe",
+  "0fdc92828174abba815db3799a274aca70cccacca573d949e412d4622928ec50",
+  "33fc7d6bc49cea32bd737e46aaf63ad2bedbc72a52615fc2b881e6ddbb34587a",
+  "45c475337798bdbf5bd3a42c1f085278d1563a9e76c1295961b1ce66a89b4820",
+  "484df32ebf132fb121ab1e31b0e64345058c9c82b2a39498cc06d1794c270f23",
+  "60aa86ca3f2873908e57c2830675eec393c114cd711b3b162d02be355792b697",
+  "85c307d01e36dc62d4a341c1932b0a7fae3663f28ec0e32ad5cda30f35ffca86",
+  "9133d73c070243947b3bf9ffec78d21d66a5cb7488c11a4bf731b3c9c3529b3c",
+  "c082e903d9569b297c93a41ea561718a5258dfefd6a0f0457402f565caa1bbd0",
+  "c10bcbc952e58e8f89818c5119cde7b54bab5b74c5b194b5d26b2b125ec1036a",
+  "ed68d0fe3dca46c159402a1ae62148d2482352718be792ff65fd38efae706bef",
+  "8356eda7f3597c3d3726b32f87f6f4da87999be93760e738748138acc2a3d73e",
+  "90a8e3a67e41c33b93da824290148e4af84d3d49848727fa88b34d8df9bad29a",
+  "ec51cebd225fc861072b62e4ee0292fd4ba01ba0817770e7a379ad41d7bd850a",
+  "3edb378d29c89081c9ad6439b077aa928a21aed864aed5ef02e819b75ac33d7a",
+  "634f1d9ac6f632074054c5b029567303d783f1fc01e62be588668d20044fadcc",
+  "bc5c76a5b63fad600c94786300284987f54d237e3f7d38bb8b520906a9685ba2",
+  "efcbbf40f1e616e2e7ae513765463806b192bd5e6b8acd3be832bf590c14a542",
+  "2ef2688b31b86a4bbf358f3662495a65314b2edf2b7b2215d71e5be9cff90d22",
+  "a9cad5b77ae12cfa907a4e460d39be75c8f864a27e7f85394bef67120a6fba45",
+  "c35c76052f76cb45a970fcb825d5ddc49f7e371441f0953735ffb9d072da2680",
+  "611279d799db865e5329ed8723d73ebd2d839c273b52aef12803b4b11a75a75a",
+  "28840c700bdf8968b6f02c6bbb9cf965643f30f0911b2622a9c01dfae233d8fb",
+  "947f39141a3f830cd29145a74058d48c2feb8fbcd958ea7f90522e46fb0c25c5",
+  "c8535a73997daf1800394626d0e4845c923544040bae85a724ca427f56ba9812",
+  "9486e4ae754782114b1ec7d22baf661a8f33413d01fcf3a0759f97f1eedd84c1",
+  "8453f7d9d818b101d0d7b0cf5d0985e57174285f4cb7899517d5af52bc6490d5",
+  "9a877468512ffa14e77940757b3532c20f6fda7878419c9986f6d9e03ca31081",
+  "db310ca8f9841b5937f475ab042d768f84bc00a29282fbcce159fc9bf7646921",
+  "052217cbd533ef7214bb55f9e7a7d8cb979f0a4b32e42f8b98b57ebd86935d25",
+  "0aab08e34dd433fd38fa3f4d6729d1a7a2f626387fdb2b9bc8a48bd0f84be2f3",
+  "4bdbc2837b195c529d83302bd3c830d7d669879757ac3f92ec1d1ac703b21522",
+  "744c0d44e26b8a8fb7272b07eff884da583a8b73a50f7a1e4a9be55ecb40b39e",
+  "7b791a2ec4ff31bb6f19d60bc19152fb1ee5139b56254b9a3ba783a7f1bf9016",
+  "7e5a4a5f88ee48f17fe40e66772da4816480b1fba5fff5a58026d05753614393",
+  "c0b51e50d6117ce597c096386a1928f803e3abf1a65f6948ff7b00583651db5e",
+  "d1c8ea35ae9bdb5dad47c3ab80d73d5a327a0379216bead38eda18c0f2836fe9",
+  "e299dd585ed6c37292758d2821663aa46a80d6c7964f67b3d1d3279cf746e764",
+  "51a5608322e14694fafad15cbb710663800dc315d4deb12516c1591ac94e3ed7",
+  "78d553f98cc172dd6f0f3b2e01056813a32a894f6bdca64e665265df84a8eb0b",
+  "90c466fbe5bf7e6f3936b8a46407fbd5d0d542582c39b697ecbb5ada1be482ce",
+  "d2f539aa6340b1e41f6f47d179a2c17666415b82e7bf02be9416061855b5534c",
+  "05034e22b01b830b1fe12df4834e6c57eb0b152539e469d8d4e393b2b61dd76d",
+  "3268c3549d9634aefe29e399961a3be0ebb6e205d454609411ea877da4552d51",
+  "5c583058ae2d35e9a650a7a0d2ee304be8e71e361b51ea6903b2cd6ac14fd6a1",
+  "7c3cb1f7f449b6a459532d1dc315d574b7148f0d373f3e3271a52ad0151e0eb4",
+  "1163b51a64118363c90db5f0b8f7280fcea335631768f83e64fdf1948b41df89",
+  "a1590ecae718e7c43f356ddfc76c983f499725970a1953bf6d4d2d4ebf8fa1dc",
+  "2b69c26c0dacd5596906178138f85b2b14076552e1995817ea64bf99f48e0ed2",
+  "6e3e62f4d47d66cc55f659cf37b7c1ff4f9b43581b9470e740d60768217c1a23",
+  "60a3ef8eddf0f262fce40a32b715ee4c2e68d52e18f74d790e68a0f54c8657f1",
+  "dfd40e3c2c62a2810030e21a78f71f2646eab19b3658e326ecb5cd8def258aad",
+  "ee5572cfba7b96285c433ea2f6e469a205c783fba216af6cf4aafefdbf33ff89",
+  "85cd5f00c51efcc263b45fe91d1e10278a866d9266392e0ed480cd8ef5da6cc1",
+  "8ea5a65412bf4b95fdbb57fcce7c1a046848f161cf8235a3d9b7e752068775a8",
+  "974b143673aa6bd202205264d82f30898777e5694d4269449f564fd536f402d7",
+  "2317949f51d8a9d31b700c3af60b6fd3bccff1a8520af7707d7909f42bc5cff2",
+  "18426bc3bc8fdf0ab7577d92e31310faf3b83001f8e6e6fe5ef1a1043230e178",
+  "24cc918e7ffa54df7f6007989fe62b83af1035c9bf6071cac8c4f848e28b04ca"
 ]);
 
 // src/lifecycle/paths.ts
@@ -942,6 +1009,9 @@ function loadPackageVersion() {
 }
 var KIT_VERSION = loadPackageVersion();
 var KIT_PACKAGE_SPEC = "@dadado/agent-kit-cli";
+function pinnedCliSpec(version = KIT_VERSION) {
+  return `${KIT_PACKAGE_SPEC}@${version}`;
+}
 
 // src/manifest/index.ts
 import path6 from "path";
@@ -1517,6 +1587,54 @@ var L0_ARTIFACTS = [
     source: ".cursor/rules/hitl-ask-questions.mdc",
     target: ".cursor/rules/hitl-ask-questions.mdc"
   },
+  {
+    source: ".cursor/skills/core/hitl-gates/SKILL.md",
+    target: ".cursor/skills/core/hitl-gates/SKILL.md"
+  },
+  {
+    source: ".cursor/skills/core/hitl-gates/procedures.md",
+    target: ".cursor/skills/core/hitl-gates/procedures.md"
+  },
+  {
+    source: ".cursor/skills/core/hitl-gates/run-plan-tick-contract.md",
+    target: ".cursor/skills/core/hitl-gates/run-plan-tick-contract.md"
+  },
+  {
+    source: ".cursor/skills/core/hitl-gates/start-project-intake.md",
+    target: ".cursor/skills/core/hitl-gates/start-project-intake.md"
+  },
+  {
+    source: ".cursor/skills/core/hitl-gates/run-plan-all-queue.md",
+    target: ".cursor/skills/core/hitl-gates/run-plan-all-queue.md"
+  },
+  {
+    source: ".cursor/skills/core/qa/SKILL.md",
+    target: ".cursor/skills/core/qa/SKILL.md"
+  },
+  {
+    source: ".cursor/skills/core/dashboard-broadcast/SKILL.md",
+    target: ".cursor/skills/core/dashboard-broadcast/SKILL.md"
+  },
+  {
+    source: ".cursor/skills/core/plan-review-triage/procedure.md",
+    target: ".cursor/skills/core/plan-review-triage/procedure.md"
+  },
+  {
+    source: ".cursor/skills/core/plan-external-review/procedure.md",
+    target: ".cursor/skills/core/plan-external-review/procedure.md"
+  },
+  {
+    source: ".cursor/skills/core/agent-kit-onboard/procedure.md",
+    target: ".cursor/skills/core/agent-kit-onboard/procedure.md"
+  },
+  {
+    source: ".cursor/skills/core/field-report-resolve/procedure.md",
+    target: ".cursor/skills/core/field-report-resolve/procedure.md"
+  },
+  {
+    source: ".cursor/skills/core/backlog-add/procedure.md",
+    target: ".cursor/skills/core/backlog-add/procedure.md"
+  },
   {
     source: "registry/rules/git-secrets-safety.mdc",
     target: ".cursor/rules/git-secrets-safety.mdc"
@@ -1586,11 +1704,8 @@ var L0_ARTIFACTS = [
     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" },
+  // Factory landing wraps: keep `.cursor/commands/kit-staging.md` and
+  // `kit-prod.md` on disk. They are not consumer L0 (surface diet).
   {
     source: ".cursor/commands/plan-external-review.md",
     target: ".cursor/commands/plan-external-review.md"
@@ -1614,6 +1729,10 @@ var L0_ARTIFACTS = [
     source: ".cursor/commands/cursor-update-awareness.md",
     target: ".cursor/commands/cursor-update-awareness.md"
   },
+  {
+    source: ".cursor/commands/qa.md",
+    target: ".cursor/commands/qa.md"
+  },
   {
     source: ".cursor/commands/update.md",
     target: ".cursor/commands/update.md"
@@ -2164,6 +2283,94 @@ function parseFeatureMapNames(markdown) {
   }
   return names;
 }
+var HEADING_NOISE = /* @__PURE__ */ new Set([
+  "changelog",
+  "improvements",
+  "bug fixes",
+  "get started",
+  "settings",
+  "powered by",
+  "powered by cloud agents",
+  "shared context",
+  "desktop improvements",
+  "desktop bug fixes",
+  "agents window improvements",
+  "agents window bug fixes",
+  "what's new in cursor",
+  "latest updates",
+  "release notes"
+]);
+var MAX_FEATURE_KEYWORD_GAPS = 12;
+function visibleTextFromHtml(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<svg[\s\S]*?<\/svg>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&#?\w+;/g, " ").replace(/\s+/g, " ").trim();
+}
+function normalizeFeatureKeyword(raw) {
+  let value = raw.replace(/^#+\s*/, "").replace(/\s+/g, " ").trim();
+  value = value.replace(/[.,:;]+$/g, "");
+  value = value.replace(/\s+(improvements|bug fixes)$/i, "").trim();
+  if (!value) return null;
+  if (value.startsWith("/")) {
+    const cmd = value.match(/^\/[a-z][a-z0-9-]{1,32}$/i);
+    return cmd?.[0] ? cmd[0].toLowerCase() : null;
+  }
+  const lower = value.toLowerCase();
+  if (HEADING_NOISE.has(lower)) return null;
+  if (/^\d+(\.\d+){1,2}$/.test(value)) return null;
+  if (value.length < 4 || value.length > 80) return null;
+  return value;
+}
+function slugifyFeatureKeyword(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+}
+function extractChangelogFeatureKeywords(changelogText) {
+  const text = String(changelogText ?? "");
+  const buckets = {
+    slash: [],
+    h1: [],
+    h2: [],
+    h3: []
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const push = (raw, bucket) => {
+    const keyword = normalizeFeatureKeyword(raw);
+    if (!keyword) return;
+    const key = keyword.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    buckets[bucket].push(keyword);
+  };
+  for (const match of text.matchAll(/<h1[^>]*>([\s\S]*?)<\/h1>/gi)) {
+    push(visibleTextFromHtml(match[1] ?? ""), "h1");
+  }
+  for (const match of text.matchAll(/<h2[^>]*>([\s\S]*?)<\/h2>/gi)) {
+    push(visibleTextFromHtml(match[1] ?? ""), "h2");
+  }
+  for (const match of text.matchAll(/<h3[^>]*>([\s\S]*?)<\/h3>/gi)) {
+    push(visibleTextFromHtml(match[1] ?? ""), "h3");
+  }
+  for (const match of text.matchAll(/^#\s+(.+)$/gm)) {
+    push(match[1] ?? "", "h1");
+  }
+  for (const match of text.matchAll(/^##\s+(.+)$/gm)) {
+    push(match[1] ?? "", "h2");
+  }
+  for (const match of text.matchAll(/^###\s+(.+)$/gm)) {
+    push(match[1] ?? "", "h3");
+  }
+  for (const match of text.matchAll(/(^|[\s>`(])(\/[a-z][a-z0-9-]{1,32})(?![/\w-])/gi)) {
+    push(match[2] ?? "", "slash");
+  }
+  return [...buckets.slash, ...buckets.h1, ...buckets.h2, ...buckets.h3];
+}
+function findMissingInventoryKeywords(keywords, haystack) {
+  const lower = String(haystack ?? "").toLowerCase();
+  return keywords.filter((keyword) => {
+    const needle = keyword.toLowerCase();
+    if (lower.includes(needle)) return false;
+    if (needle.startsWith("/") && lower.includes(needle.slice(1))) return false;
+    return true;
+  });
+}
 async function defaultFetchText(url) {
   if (!url.startsWith("https://")) {
     throw new Error(`Refusing non-HTTPS changelog URL: ${url}`);
@@ -2262,6 +2469,7 @@ async function checkCursorUpdateAwareness(cwd, options = {}) {
   const inventoryRefreshed = parseInventoryRefreshed(inventoryMd);
   const openActionIds = parseOpenActionIds(inventoryMd);
   const gaps = [];
+  let featuresMd = "";
   for (const id of openActionIds) {
     gaps.push({
       id: `open-action-${id}`,
@@ -2287,7 +2495,7 @@ async function checkCursorUpdateAwareness(cwd, options = {}) {
     }
   }
   try {
-    const featuresMd = await readFile7(featuresPath, "utf8");
+    featuresMd = await readFile7(featuresPath, "utf8");
     if (parseFeatureMapNames(featuresMd).length === 0) {
       gaps.push({
         id: "features-map-empty",
@@ -2311,6 +2519,23 @@ async function checkCursorUpdateAwareness(cwd, options = {}) {
     try {
       const body = options.changelogBody ?? await (options.fetchText ?? defaultFetchText)(changelogUrl);
       latestCursorVersion = extractLatestCursorVersion(body);
+      const haystack = `${inventoryMd}
+${featuresMd}`;
+      const missingKeywords = findMissingInventoryKeywords(
+        extractChangelogFeatureKeywords(body),
+        haystack
+      );
+      for (const keyword of missingKeywords.slice(0, MAX_FEATURE_KEYWORD_GAPS)) {
+        const slug = slugifyFeatureKeyword(keyword);
+        if (!slug) continue;
+        gaps.push({
+          id: `feature-keyword-miss:${slug}`,
+          severity: "advisory",
+          path: FEATURES_REL,
+          evidence: `Changelog names "${keyword}" which is not listed in native-audit or cursor-3-features`,
+          suggestedRoute: "backlog-add"
+        });
+      }
       if (latestCursorVersion && prefs.lastSeenCursorVersion && compareCursorVersion(latestCursorVersion, prefs.lastSeenCursorVersion) > 0) {
         gaps.push({
           id: "changelog-ahead",
@@ -2530,13 +2755,13 @@ function readPreferredBrowserFromConfig(configPath, fsHooks = {}) {
 }
 
 // src/commands/dashboard.ts
-function readPreferredBrowserFromWorkspace(cwd, readFile28 = readFileSync2) {
+function readPreferredBrowserFromWorkspace(cwd, readFile31 = readFileSync2) {
   const resolved = resolveContextConfigPath(path11.resolve(cwd), {
     existsSync,
     realpathSync
   });
   if (!resolved.ok) return null;
-  const value = readPreferredBrowserFromConfig(resolved.path, { readFileSync: readFile28 });
+  const value = readPreferredBrowserFromConfig(resolved.path, { readFileSync: readFile31 });
   return normalizePreferredBrowser(value);
 }
 function applyDashboardOpenEnv(env, opts) {
@@ -3659,21 +3884,81 @@ import { constants as constants3, access as access6, readFile as readFile10, sta
 import { homedir as homedir2 } from "os";
 import path16 from "path";
 var MIN_NODE_MAJOR = 20;
-async function checkBinOnPath(binName, env, platform) {
+var CLI_PACKAGE_JSON_REL = path16.join(
+  "lib",
+  "node_modules",
+  "@dadado",
+  "agent-kit-cli",
+  "package.json"
+);
+var DIST_INDEX_RE = /(?:\$\{basedir\}|\$basedir)?[^'"\s;]*dist\/index\.js/g;
+function extractDistIndexFromBinScript(contents) {
+  const found = [];
+  DIST_INDEX_RE.lastIndex = 0;
+  for (const match of contents.matchAll(DIST_INDEX_RE)) {
+    const raw = match[0]?.trim();
+    if (raw) found.push(raw.replace(/\\/g, "/"));
+  }
+  return found;
+}
+function expandBinDirVars(raw, binDir) {
+  return raw.replace(/\$\{basedir\}/g, binDir).replace(/\$basedir/g, binDir);
+}
+function packageJsonFromDistIndex(distIndex) {
+  return path16.join(path16.dirname(distIndex), "..", "package.json");
+}
+function parsePackageVersion(contents) {
+  try {
+    const parsed = JSON.parse(contents);
+    return typeof parsed.version === "string" && parsed.version.length > 0 ? parsed.version : null;
+  } catch {
+    return null;
+  }
+}
+async function readBinVersion(binPath, options = {}) {
+  const readFileImpl = options.readFileImpl ?? ((filePath) => readFile10(filePath, "utf8"));
+  const binDir = path16.dirname(binPath);
+  const candidates = [
+    path16.join(binDir, "..", CLI_PACKAGE_JSON_REL),
+    path16.join(binDir, "..", "node_modules", "@dadado", "agent-kit-cli", "package.json")
+  ];
+  try {
+    const contents = await readFileImpl(binPath);
+    for (const raw of extractDistIndexFromBinScript(contents)) {
+      const distIndex = path16.resolve(binDir, expandBinDirVars(raw, binDir));
+      candidates.push(packageJsonFromDistIndex(distIndex));
+    }
+  } catch {
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate2 of candidates) {
+    const resolved = path16.resolve(candidate2);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    try {
+      const version = parsePackageVersion(await readFileImpl(resolved));
+      if (version) return version;
+    } catch {
+    }
+  }
+  return null;
+}
+async function resolveBinOnPath(binName, env, platform) {
   const pathVar = env.PATH ?? env.Path ?? "";
-  if (!pathVar) return false;
+  if (!pathVar) return null;
   const dirs = pathVar.split(path16.delimiter).filter(Boolean);
   const candidates = platform === "win32" ? [binName, `${binName}.cmd`, `${binName}.exe`, `${binName}.bat`] : [binName];
   for (const dir of dirs) {
     for (const candidate2 of candidates) {
+      const abs = path16.join(dir, candidate2);
       try {
-        await access6(path16.join(dir, candidate2), platform === "win32" ? void 0 : constants3.X_OK);
-        return true;
+        await access6(abs, platform === "win32" ? void 0 : constants3.X_OK);
+        return abs;
       } catch {
       }
     }
   }
-  return false;
+  return null;
 }
 function isNodeVersionOk(nodeVersion, minMajor = MIN_NODE_MAJOR) {
   const match = /^v?(\d+)/.exec(nodeVersion);
@@ -3769,8 +4054,8 @@ async function assessEnvironment(options = {}) {
   const nodeVersion = options.nodeVersion ?? process.version;
   const homeDir = options.homeDir ?? homedir2();
   const binName = options.binName ?? "agent-kit";
-  const [binOnPath, npmPrefix] = await Promise.all([
-    checkBinOnPath(binName, env, platform).catch(() => false),
+  const [binPath, npmPrefix] = await Promise.all([
+    resolveBinOnPath(binName, env, platform).catch(() => null),
     checkNpmPrefixWritable(options).catch(
       () => ({
         prefix: null,
@@ -3779,8 +4064,11 @@ async function assessEnvironment(options = {}) {
       })
     )
   ]);
+  const binVersion = binPath ? await readBinVersion(binPath, options).catch(() => null) : null;
   return {
-    binOnPath,
+    binOnPath: binPath != null,
+    binPath,
+    binVersion,
     npmPrefixWritable: npmPrefix.writable,
     npmPrefix,
     nodeVersionOk: isNodeVersionOk(nodeVersion),
@@ -3949,21 +4237,30 @@ function buildPillars(scan) {
       )
     ]),
     pillar("quality-ci", [
-      check(
-        "quality.validation",
-        "Tests and validation",
-        scan.quality.hasTests || scan.quality.validationCommands.length > 0 ? "ready" : "manual",
-        false,
-        scan.infra.ciFiles.map((value) => ({ source: "file", value })),
-        scan.quality.hasTests || scan.quality.validationCommands.length > 0 ? [] : [
-          action(
-            "document-validation",
-            "manual",
-            "Document a repeatable repository validation command",
-            "user"
-          )
-        ]
-      )
+      (() => {
+        const hasValidation = scan.quality.hasTests || scan.quality.validationCommands.length > 0 || scan.quality.ciRunCommands.length > 0;
+        return check(
+          "quality.validation",
+          "Tests and validation",
+          hasValidation ? "ready" : "manual",
+          false,
+          [
+            ...scan.infra.ciFiles.map((value) => ({ source: "file", value })),
+            ...scan.quality.ciRunCommands.map((value) => ({
+              source: "file",
+              value: `ci:${value}`
+            }))
+          ],
+          hasValidation ? [] : [
+            action(
+              "document-validation",
+              "manual",
+              "Document a repeatable repository validation command",
+              "user"
+            )
+          ]
+        );
+      })()
     ]),
     pillar("deploy-infrastructure", [
       check(
@@ -4037,7 +4334,7 @@ function createReadinessReport(scan, options) {
 }
 
 // src/scanner/safe-fixes.ts
-import { readFile as readFile13, writeFile as writeFile5 } from "fs/promises";
+import { readFile as readFile15, writeFile as writeFile5 } from "fs/promises";
 import path24 from "path";
 
 // src/scanner/detect-repository.ts
@@ -4410,6 +4707,7 @@ async function detectIde(rootDir) {
 }
 
 // src/scanner/detect-infra.ts
+import { readFile as readFile12, readdir as readdir5 } from "fs/promises";
 import path20 from "path";
 
 // src/types.ts
@@ -4465,6 +4763,51 @@ var PM_TOOL_LABELS = {
 };
 
 // src/scanner/detect-infra.ts
+function extractRunCommands(yaml) {
+  const lines = yaml.split(/\r?\n/);
+  const commands = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const match = /^(\s*)(?:-\s+)?run:\s*(.*)$/.exec(line);
+    if (!match) continue;
+    const [, indent = "", inline = ""] = match;
+    const trimmedInline = inline.trim();
+    if (trimmedInline && !/^[|>][+-]?$/.test(trimmedInline)) {
+      commands.push(trimmedInline.replace(/^['"]|['"]$/g, ""));
+      continue;
+    }
+    const blockIndent = indent.length;
+    for (let j = i + 1; j < lines.length; j++) {
+      const blockLine = lines[j] ?? "";
+      if (!blockLine.trim()) continue;
+      const lineIndent = blockLine.length - blockLine.trimStart().length;
+      if (lineIndent <= blockIndent) break;
+      commands.push(blockLine.trim());
+    }
+  }
+  return Array.from(new Set(commands));
+}
+async function detectCiRunCommands(rootDir) {
+  const workflowsDir = path20.join(rootDir, ".github", "workflows");
+  if (!await fileExists(workflowsDir)) return [];
+  let entries;
+  try {
+    entries = await readdir5(workflowsDir);
+  } catch {
+    return [];
+  }
+  const workflowFiles = entries.filter((name) => /\.ya?ml$/.test(name));
+  const perFile = await Promise.all(
+    workflowFiles.map(async (name) => {
+      try {
+        return extractRunCommands(await readFile12(path20.join(workflowsDir, name), "utf8"));
+      } catch {
+        return [];
+      }
+    })
+  );
+  return Array.from(new Set(perFile.flat()));
+}
 async function detectInfra(rootDir) {
   const docker = await fileExists(path20.join(rootDir, "Dockerfile")) || await fileExists(path20.join(rootDir, "docker-compose.yml")) || await fileExists(path20.join(rootDir, "docker-compose.yaml"));
   const kubernetes = await fileExists(path20.join(rootDir, "k8s")) || await fileExists(path20.join(rootDir, "kubernetes"));
@@ -4504,11 +4847,12 @@ async function detectInfra(rootDir) {
       async (file) => await fileExists(path20.join(rootDir, file)) ? file : void 0
     )
   )).filter((file) => file !== void 0);
-  return { docker, kubernetes, ci, ciFiles, infrastructureFiles, deploymentFiles };
+  const ciRunCommands = ci === "github-actions" ? await detectCiRunCommands(rootDir) : [];
+  return { docker, kubernetes, ci, ciFiles, infrastructureFiles, deploymentFiles, ciRunCommands };
 }
 
 // src/scanner/detect-services.ts
-import { readFile as readFile12 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 import path21 from "path";
 async function detectProjectManagement(rootDir) {
   const tools = [];
@@ -4519,7 +4863,7 @@ async function detectProjectManagement(rootDir) {
   for (const configPath of mcpConfigPaths) {
     if (!await fileExists(configPath)) continue;
     try {
-      const raw = await readFile12(configPath, "utf8");
+      const raw = await readFile13(configPath, "utf8");
       const lower = raw.toLowerCase();
       if (lower.includes("clickup")) tools.push("clickup");
       if (lower.includes("jira") || lower.includes("atlassian")) tools.push("jira");
@@ -4555,6 +4899,7 @@ async function detectServices(rootDir) {
 }
 
 // src/scanner/detect-stack.ts
+import { readFile as readFile14, readdir as readdir6 } from "fs/promises";
 import path22 from "path";
 var PROJECT_MARKERS = [
   "package.json",
@@ -4566,8 +4911,152 @@ var PROJECT_MARKERS = [
   "build.gradle",
   "composer.json",
   "Cargo.toml",
-  "pnpm-workspace.yaml"
+  "pnpm-workspace.yaml",
+  "pubspec.yaml"
 ];
+var SUBDIR_SCAN_SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "build", ".dart_tool"]);
+async function scanSubdirectoryMarkers(rootDir) {
+  let entries;
+  try {
+    entries = await readdir6(rootDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const dirs = entries.filter((entry) => entry.isDirectory() && !SUBDIR_SCAN_SKIP.has(entry.name)).map((entry) => entry.name);
+  const candidates = dirs.flatMap((dir) => PROJECT_MARKERS.map((marker) => ({ dir, marker })));
+  const found = await Promise.all(
+    candidates.map(async (candidate2) => {
+      const exists2 = await fileExists(path22.join(rootDir, candidate2.dir, candidate2.marker));
+      return exists2 ? candidate2 : null;
+    })
+  );
+  return found.filter((hit) => hit !== null);
+}
+function isFlutterPubspec(content) {
+  return /^\s*flutter:\s*$/m.test(content) || /sdk:\s*flutter\b/.test(content);
+}
+var DART_VALIDATION_COMMANDS = [
+  "dart analyze --fatal-infos",
+  "dart format --output=none --set-exit-if-changed ."
+];
+async function detectDartFlavor(pubspecDir) {
+  let content = "";
+  try {
+    content = await readFile14(path22.join(pubspecDir, "pubspec.yaml"), "utf8");
+  } catch {
+  }
+  return { isFlutter: isFlutterPubspec(content) };
+}
+async function detectStackFromSubdirHits(rootDir, hits) {
+  const packageManagerEvidence = hits.map((hit) => ({
+    source: "file",
+    value: `${hit.dir}/${hit.marker}`
+  }));
+  const dartHits = hits.filter((hit) => hit.marker === "pubspec.yaml");
+  if (dartHits.length > 0) {
+    const flavors = await Promise.all(
+      dartHits.map((hit) => detectDartFlavor(path22.join(rootDir, hit.dir)))
+    );
+    const testCommands = Array.from(
+      new Set(flavors.map((flavor) => flavor.isFlutter ? "flutter test" : "dart test"))
+    );
+    return {
+      language: "dart",
+      framework: flavors.some((flavor) => flavor.isFlutter) ? "flutter" : "dart",
+      workspaces: true,
+      testCommands,
+      validationCommands: DART_VALIDATION_COMMANDS,
+      hasProjectFiles: true,
+      packageManagerEvidence
+    };
+  }
+  const nodeHit = hits.find((hit) => hit.marker === "package.json");
+  if (nodeHit) {
+    const subRoot = path22.join(rootDir, nodeHit.dir);
+    const packageJson = await readJson(path22.join(subRoot, "package.json")) ?? {};
+    const scripts = packageJson.scripts ?? {};
+    const packageManager = await detectPackageManager(subRoot, packageJson);
+    const commands = commandsForScripts(scripts, packageManager.packageManager);
+    return {
+      language: "node",
+      framework: "node",
+      packageManager: packageManager.packageManager,
+      packageManagerEvidence: [...packageManagerEvidence, ...packageManager.evidence],
+      scripts,
+      workspaces: true,
+      ...commands,
+      hasProjectFiles: true
+    };
+  }
+  const languageByMarker = [
+    { marker: "pyproject.toml", language: "python", testCommands: [], validationCommands: [] },
+    { marker: "requirements.txt", language: "python", testCommands: [], validationCommands: [] },
+    { marker: "go.mod", language: "go", testCommands: ["go test ./..."], validationCommands: [] },
+    {
+      marker: "Cargo.toml",
+      language: "rust",
+      testCommands: ["cargo test"],
+      validationCommands: ["cargo check"]
+    },
+    { marker: "composer.json", language: "php", testCommands: [], validationCommands: [] }
+  ];
+  for (const candidate2 of languageByMarker) {
+    if (hits.some((hit) => hit.marker === candidate2.marker)) {
+      return {
+        language: candidate2.language,
+        framework: candidate2.language,
+        workspaces: true,
+        testCommands: candidate2.testCommands,
+        validationCommands: candidate2.validationCommands,
+        hasProjectFiles: true,
+        packageManagerEvidence
+      };
+    }
+  }
+  return {
+    language: "unknown",
+    workspaces: true,
+    testCommands: [],
+    validationCommands: [],
+    hasProjectFiles: true,
+    packageManagerEvidence
+  };
+}
+var KNOWN_PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+function isDetectionEvidenceArray(value) {
+  return Array.isArray(value) && value.every(
+    (item) => item && typeof item === "object" && typeof item.value === "string" && typeof item.source === "string"
+  );
+}
+async function readConfirmedStack(rootDir) {
+  const configuration = await readJson(
+    path22.join(rootDir, ".cursor", "agent-kit.config.json")
+  );
+  const configured = configuration?.stack;
+  const language = configured?.language;
+  if (!configured || typeof language !== "string" || !language || language === "unknown") {
+    return void 0;
+  }
+  const testCommands = Array.isArray(configured.testCommands) ? configured.testCommands.filter((item) => typeof item === "string") : [];
+  const validationCommands = Array.isArray(configured.validationCommands) ? configured.validationCommands.filter((item) => typeof item === "string") : [];
+  if (testCommands.length === 0 && validationCommands.length === 0) return void 0;
+  const packageManager = typeof configured.packageManager === "string" && KNOWN_PACKAGE_MANAGERS.includes(configured.packageManager) ? configured.packageManager : void 0;
+  const scripts = configured.scripts && typeof configured.scripts === "object" && !Array.isArray(configured.scripts) ? configured.scripts : void 0;
+  const packageManagerEvidence = isDetectionEvidenceArray(
+    configured.packageManagerEvidence
+  ) ? configured.packageManagerEvidence : [{ source: "configuration", value: ".cursor/agent-kit.config.json#stack.language" }];
+  return {
+    language,
+    framework: typeof configured.framework === "string" ? configured.framework : void 0,
+    packageManager,
+    scripts,
+    workspaces: configured.workspaces === true,
+    testCommands,
+    validationCommands,
+    hasProjectFiles: true,
+    packageManagerEvidence
+  };
+}
 var LOCKFILES = [
   ["pnpm-lock.yaml", "pnpm"],
   ["yarn.lock", "yarn"],
@@ -4601,7 +5090,15 @@ function commandsForScripts(scripts, packageManager) {
   return { testCommands, validationCommands };
 }
 async function detectStack(rootDir) {
+  const confirmed = await readConfirmedStack(rootDir);
+  if (confirmed) return confirmed;
   const hasAnyProjectMarker = (await Promise.all(PROJECT_MARKERS.map((item) => fileExists(path22.join(rootDir, item))))).some(Boolean);
+  if (!hasAnyProjectMarker) {
+    const subdirHits = await scanSubdirectoryMarkers(rootDir);
+    if (subdirHits.length > 0) {
+      return detectStackFromSubdirHits(rootDir, subdirHits);
+    }
+  }
   const hasPackageJson = await fileExists(path22.join(rootDir, "package.json"));
   if (hasPackageJson) {
     const packageJson = await readJson(path22.join(rootDir, "package.json")) ?? {};
@@ -4661,6 +5158,17 @@ async function detectStack(rootDir) {
       hasProjectFiles: hasAnyProjectMarker
     };
   }
+  if (await fileExists(path22.join(rootDir, "pubspec.yaml"))) {
+    const { isFlutter } = await detectDartFlavor(rootDir);
+    return {
+      language: "dart",
+      framework: isFlutter ? "flutter" : "dart",
+      workspaces: false,
+      testCommands: [isFlutter ? "flutter test" : "dart test"],
+      validationCommands: DART_VALIDATION_COMMANDS,
+      hasProjectFiles: hasAnyProjectMarker
+    };
+  }
   return {
     language: "unknown",
     workspaces: false,
@@ -4715,7 +5223,8 @@ async function runScanner(rootDir) {
       testCommands: stack.testCommands,
       validationCommands: stack.validationCommands,
       ci: infra.ci,
-      hasTests: stack.testCommands.length > 0
+      hasTests: stack.testCommands.length > 0,
+      ciRunCommands: infra.ciRunCommands
     }
   };
 }
@@ -4788,9 +5297,12 @@ function createOnboardingState(report, generatedAt, deferredItems = report.defer
   const validDeferredCheckIds = new Set(
     deferredItems.filter((item) => item.reason.trim().length > 0).map((item) => item.checkId)
   );
-  const unresolvedEssential = report.pillars.flatMap((pillar2) => pillar2.checks).some(
-    (check2) => check2.essential && check2.status !== "ready" && (check2.status === "blocked" || !validDeferredCheckIds.has(check2.id))
-  );
+  const unresolvedEssential = report.pillars.flatMap((pillar2) => pillar2.checks).some((check2) => {
+    if (!check2.essential || check2.status === "ready") return false;
+    if (check2.status === "blocked") return true;
+    if (!validDeferredCheckIds.has(check2.id)) return true;
+    return check2.actions.length > 0;
+  });
   return {
     contractVersion: 1,
     status: unresolvedEssential ? "in_progress" : "completed",
@@ -4941,7 +5453,7 @@ async function executeSafeReadinessFixes(rootDir, options) {
   }
   const gitignoreRelativePath = ".gitignore";
   const gitignorePath = path24.join(beforeScan.rootDir, gitignoreRelativePath);
-  const existingGitignore = await fileExists(gitignorePath) ? await readFile13(gitignorePath, "utf8") : "";
+  const existingGitignore = await fileExists(gitignorePath) ? await readFile15(gitignorePath, "utf8") : "";
   const gitignoreAfterSecrets = mergeSecretIgnores(existingGitignore);
   const secretsChanged = gitignoreAfterSecrets !== existingGitignore;
   const mergedGitignore = mergeKitOwnedIgnores(gitignoreAfterSecrets);
@@ -5056,11 +5568,12 @@ var KIT_TIPS = [
   "agent-kit --help groups SETUP, MISSION, DASHBOARD, INTEGRITY."
 ];
 function shouldUseWelcomeColor(opts = {}) {
+  const env = opts.env ?? process.env;
   if (opts.color === false) return false;
-  if (process.env.NO_COLOR) return false;
-  if (process.env.NODE_DISABLE_COLORS) return false;
-  if (process.env.FORCE_COLOR === "0") return false;
-  if (process.env.CI != null && process.env.CI !== "") return false;
+  if (env.NO_COLOR) return false;
+  if (env.NODE_DISABLE_COLORS) return false;
+  if (env.FORCE_COLOR === "0") return false;
+  if (env.CI != null && env.CI !== "") return false;
   if (opts.color === true) return true;
   const tty = opts.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
   return tty;
@@ -5213,6 +5726,19 @@ async function withCliProgress(label, fn, opts) {
 }
 
 // src/commands/doctor.ts
+async function readDeferredEssentials(rootDir, report) {
+  const config = await readJson(
+    path26.join(rootDir, ".cursor", "context", "config.json")
+  );
+  const deferredItems = config?.onboarding?.deferredItems;
+  if (!Array.isArray(deferredItems)) return [];
+  const essentialIds = new Set(
+    report.pillars.flatMap((pillar2) => pillar2.checks).filter((check2) => check2.essential).map((check2) => check2.id)
+  );
+  return deferredItems.filter(
+    (item) => typeof item?.checkId === "string" && typeof item?.reason === "string" && essentialIds.has(item.checkId)
+  ).map((item) => ({ checkId: item.checkId, reason: item.reason }));
+}
 async function runDoctor(cwd, options = {}) {
   const rootDir = path26.resolve(cwd);
   const hooks = await assessHooksHealth(rootDir);
@@ -5223,7 +5749,13 @@ async function runDoctor(cwd, options = {}) {
       generatedAt: options.generatedAt
     });
     await writeReadinessSnapshot(rootDir, execution.after);
-    return { report: execution.after, safeChanges: execution.changes, hooks, env };
+    return {
+      report: execution.after,
+      safeChanges: execution.changes,
+      hooks,
+      env,
+      deferredEssentials: await readDeferredEssentials(rootDir, execution.after)
+    };
   }
   if (options.refreshProfile) {
     const refresh = await refreshRepositoryProfile(rootDir, {
@@ -5236,7 +5768,14 @@ async function runDoctor(cwd, options = {}) {
       generatedAt: options.generatedAt
     });
     await writeReadinessSnapshot(rootDir, report2);
-    return { report: report2, safeChanges: [], hooks, env, profileRefreshed: refresh.changed };
+    return {
+      report: report2,
+      safeChanges: [],
+      hooks,
+      env,
+      profileRefreshed: refresh.changed,
+      deferredEssentials: await readDeferredEssentials(rootDir, report2)
+    };
   }
   const scan = await runScanner(rootDir);
   const report = createReadinessReport(scan, {
@@ -5244,7 +5783,13 @@ async function runDoctor(cwd, options = {}) {
     generatedAt: options.generatedAt
   });
   await writeReadinessSnapshot(rootDir, report);
-  return { report, safeChanges: [], hooks, env };
+  return {
+    report,
+    safeChanges: [],
+    hooks,
+    env,
+    deferredEssentials: await readDeferredEssentials(rootDir, report)
+  };
 }
 function printDoctorSummary(result) {
   const { summary, pendingActions } = result.report;
@@ -5261,6 +5806,9 @@ function printDoctorSummary(result) {
       `  profile refreshed: ${result.profileRefreshed ? "yes (facts changed)" : "no (already current)"}`
     );
   }
+  for (const item of result.deferredEssentials) {
+    console.log(`  Deferred essential: ${item.checkId} \u2014 ${item.reason}`);
+  }
   console.log(`hooks: ${result.hooks.status}`);
   if (result.hooks.reasons.length > 0) {
     for (const reason of result.hooks.reasons.slice(0, 5)) {
@@ -5274,7 +5822,8 @@ function printDoctorSummary(result) {
     }
   }
   console.log("environment:");
-  console.log(`  - bin on PATH (agent-kit): ${result.env.binOnPath ? "ok" : "MISSING"}`);
+  const pathLabel = result.env.binOnPath ? `ok (v${result.env.binVersion ?? "unknown"} at ${result.env.binPath})` : "MISSING";
+  console.log(`  - bin on PATH (agent-kit): ${pathLabel}`);
   console.log(
     `  - npm prefix writable: ${result.env.npmPrefixWritable ? "ok" : "BLOCKED"}${result.env.npmPrefix.prefix ? ` (${result.env.npmPrefix.prefix})` : ""}`
   );
@@ -5719,9 +6268,187 @@ var guardCommand = defineCommand8({
 
 // src/commands/handoff.ts
 import { spawn as spawn4 } from "child_process";
-import { readFile as readFile14, readdir as readdir5, writeFile as writeFile6 } from "fs/promises";
+import { appendFile, readFile as readFile16, readdir as readdir7, writeFile as writeFile6 } from "fs/promises";
 import path27 from "path";
 import { defineCommand as defineCommand9 } from "citty";
+
+// src/invariants/handoff-prune.ts
+var HANDOFF_MACHINE_FIELD_LABELS = [
+  "Plan",
+  "Last updated",
+  "Mode",
+  "Phase completed",
+  "Next phase",
+  "Completed to-dos",
+  "Next to-dos",
+  "Parked plans",
+  "Backlog plans",
+  "Run queue",
+  "Queue cursor",
+  "Queue status",
+  "Queue outcomes",
+  "Gaps",
+  "Instruction for the next agent"
+];
+var HANDOFF_FIXED_SECTION_HEADING_PREFIXES = [
+  "## Work Status",
+  "## Session Context",
+  "## Files Touched",
+  "## Decisions Made",
+  "## Issues Found",
+  "## Run queue (multi-plan only)"
+];
+var HANDOFF_MAX_LINES = 200;
+var HANDOFF_MAX_LINE_LENGTH = 2e3;
+var MACHINE_FIELD_RE = new RegExp(
+  `^- \\*\\*(${HANDOFF_MACHINE_FIELD_LABELS.map((l) => l.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")}):\\*\\*`
+);
+function isChunkStart(line) {
+  return /^- \*\*/.test(line) || /^## /.test(line);
+}
+function isFixedSectionHeading(line) {
+  return HANDOFF_FIXED_SECTION_HEADING_PREFIXES.some((p) => line.startsWith(p));
+}
+function splitIntoChunks(lines) {
+  const firstStart = lines.findIndex(isChunkStart);
+  if (firstStart === -1) return { preamble: lines, chunks: [] };
+  const preamble = lines.slice(0, firstStart);
+  const chunks = [];
+  let current = [lines[firstStart]];
+  for (const line of lines.slice(firstStart + 1)) {
+    if (isChunkStart(line)) {
+      chunks.push({ lines: current, isMachineField: MACHINE_FIELD_RE.test(current[0] ?? "") });
+      current = [line];
+    } else {
+      current.push(line);
+    }
+  }
+  chunks.push({ lines: current, isMachineField: MACHINE_FIELD_RE.test(current[0] ?? "") });
+  return { preamble, chunks };
+}
+function pruneHandoffText(text, keep) {
+  if (!text.trim()) {
+    return { ok: false, reason: "empty file" };
+  }
+  const lines = text.split("\n");
+  const titleIdx = lines.findIndex((l) => /^# /.test(l));
+  if (titleIdx === -1) {
+    return { ok: false, reason: "no H1 title line found" };
+  }
+  let fixedStartIdx = lines.findIndex((l) => isFixedSectionHeading(l));
+  if (fixedStartIdx === -1) fixedStartIdx = lines.length;
+  const head = lines.slice(0, titleIdx + 1);
+  const narrativeLines = lines.slice(titleIdx + 1, fixedStartIdx);
+  const trailingLines = lines.slice(fixedStartIdx);
+  const { preamble, chunks } = splitIntoChunks(narrativeLines);
+  const machineFieldCount = chunks.filter((c) => c.isMachineField).length;
+  if (machineFieldCount === 0) {
+    return { ok: false, reason: "no machine-field bullets found; refusing to prune" };
+  }
+  if (fixedStartIdx === lines.length) {
+    return { ok: false, reason: "no recognized fixed-section heading found; refusing to prune" };
+  }
+  const narrativeChunks = chunks.filter((c) => !c.isMachineField);
+  if (narrativeChunks.length <= keep) {
+    return { ok: true, text, archived: [], keptCount: narrativeChunks.length };
+  }
+  const keptNarrativeIdx = /* @__PURE__ */ new Set();
+  let seen = 0;
+  const chunkIsNarrative = chunks.map((c) => !c.isMachineField);
+  for (let i = 0; i < chunks.length; i++) {
+    if (chunkIsNarrative[i]) {
+      if (seen < keep) keptNarrativeIdx.add(i);
+      seen++;
+    }
+  }
+  const keptChunks = [];
+  const archivedChunks = [];
+  chunks.forEach((c, i) => {
+    if (c.isMachineField || keptNarrativeIdx.has(i)) keptChunks.push(c);
+    else archivedChunks.push(c);
+  });
+  const newNarrativeLines = [...preamble, ...keptChunks.flatMap((c) => c.lines)];
+  const newLines = [...head, ...newNarrativeLines, ...trailingLines];
+  return {
+    ok: true,
+    text: newLines.join("\n"),
+    archived: archivedChunks.map((c) => c.lines.join("\n")),
+    keptCount: keptNarrativeIdx.size
+  };
+}
+function checkHandoffGrowth(text) {
+  if (!text.trim()) return [];
+  const lines = text.split("\n");
+  const warnings = [];
+  if (lines.length > HANDOFF_MAX_LINES) {
+    warnings.push({
+      code: "file-over-limit",
+      message: `HANDOFF.md is ${lines.length} lines, over the ${HANDOFF_MAX_LINES}-line growth-contract limit. Run \`agent-kit handoff --prune\` to archive older narrative entries.`
+    });
+  }
+  let firstOffendingLine = -1;
+  let overCount = 0;
+  lines.forEach((l, i) => {
+    if (l.length > HANDOFF_MAX_LINE_LENGTH) {
+      overCount++;
+      if (firstOffendingLine === -1) firstOffendingLine = i + 1;
+    }
+  });
+  if (overCount > 0) {
+    warnings.push({
+      code: "line-over-limit",
+      message: `HANDOFF.md has ${overCount} line(s) over the ${HANDOFF_MAX_LINE_LENGTH}-char growth-contract limit (first at line ${firstOffendingLine}). Wrap long paragraphs; do not widen the limit.`
+    });
+  }
+  return warnings;
+}
+
+// src/commands/handoff.ts
+var HANDOFF_PRUNE_DEFAULT_KEEP = 5;
+function pruneArchiveTimestamp(now2 = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now2.getFullYear()}-${pad(now2.getMonth() + 1)}-${pad(now2.getDate())}-${pad(now2.getHours())}${pad(now2.getMinutes())}`;
+}
+async function runPrune(cwd, keep) {
+  const handoffPath = path27.join(cwd, ".cursor", "HANDOFF.md");
+  if (!await fileExists(handoffPath)) {
+    logger.warn("No .cursor/HANDOFF.md to prune.");
+    return;
+  }
+  const original = await readFile16(handoffPath, "utf8");
+  const result = pruneHandoffText(original, keep);
+  if (!result.ok) {
+    logger.warn(`Refusing to prune: ${result.reason}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!result.archived || result.archived.length === 0) {
+    logger.info(
+      `HANDOFF.md already at or under ${keep} narrative ${keep === 1 ? "entry" : "entries"}; nothing to prune.`
+    );
+    return;
+  }
+  const archiveDir = path27.join(cwd, ".cursor", "context", "archive");
+  await ensureDir(archiveDir);
+  const archivePath = path27.join(archiveDir, `handoff-${pruneArchiveTimestamp()}.md`);
+  const header = [
+    `<!-- Pruned from .cursor/HANDOFF.md at ${(/* @__PURE__ */ new Date()).toISOString()} -->`,
+    `<!-- ${result.archived.length} narrative ${result.archived.length === 1 ? "entry" : "entries"} archived, keep=${keep} -->`,
+    ""
+  ].join("\n");
+  const body = `${result.archived.join("\n\n")}
+`;
+  if (await fileExists(archivePath)) {
+    await appendFile(archivePath, `
+${header}${body}`, "utf8");
+  } else {
+    await writeFile6(archivePath, `${header}${body}`, "utf8");
+  }
+  await writeFile6(handoffPath, result.text ?? original, "utf8");
+  logger.success(
+    `HANDOFF.md pruned: kept ${result.keptCount} narrative ${result.keptCount === 1 ? "entry" : "entries"}, archived ${result.archived.length} to ${path27.relative(cwd, archivePath)}.`
+  );
+}
 function parsePlanFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---/);
   if (!match?.[1]) return null;
@@ -5738,15 +6465,15 @@ function parsePlanFrontmatter(raw) {
 }
 async function findActivePlan(plansDir) {
   if (!await fileExists(plansDir)) return null;
-  const files = (await readdir5(plansDir)).filter((f) => f.endsWith(".plan.md")).sort().reverse();
+  const files = (await readdir7(plansDir)).filter((f) => f.endsWith(".plan.md")).sort().reverse();
   for (const file of files) {
-    const raw = await readFile14(path27.join(plansDir, file), "utf8");
+    const raw = await readFile16(path27.join(plansDir, file), "utf8");
     const fm = parsePlanFrontmatter(raw);
     if (fm?.todos?.some((t) => t.status !== "completed" && t.status !== "cancelled")) {
       return { file, raw };
     }
   }
-  return files[0] ? { file: files[0], raw: await readFile14(path27.join(plansDir, files[0]), "utf8") } : null;
+  return files[0] ? { file: files[0], raw: await readFile16(path27.join(plansDir, files[0]), "utf8") } : null;
 }
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 16);
@@ -5848,9 +6575,24 @@ var handoffCommand = defineCommand9({
       type: "string",
       description: "Project root directory",
       default: process.cwd()
+    },
+    prune: {
+      type: "boolean",
+      description: "Prune .cursor/HANDOFF.md in place instead of regenerating it: keep the most recent narrative entries, archive the rest to .cursor/context/archive/. Never auto-triggered.",
+      default: false
+    },
+    keep: {
+      type: "string",
+      description: `With --prune, how many recent narrative entries to keep in place (default ${HANDOFF_PRUNE_DEFAULT_KEEP}).`
     }
   },
   async run({ args }) {
+    if (args.prune) {
+      const keepArg = typeof args.keep === "string" ? Number.parseInt(args.keep, 10) : void 0;
+      const keep = keepArg !== void 0 && Number.isFinite(keepArg) && keepArg >= 0 ? keepArg : HANDOFF_PRUNE_DEFAULT_KEEP;
+      await runPrune(args.cwd, keep);
+      return;
+    }
     const profile = await loadProfile(args.cwd);
     const plansDir = path27.join(args.cwd, ".cursor", "plans");
     const handoffPath = path27.join(args.cwd, ".cursor", "HANDOFF.md");
@@ -5929,7 +6671,7 @@ function buildPreCompactUserMessage(payload = {}) {
 
 // src/hooks/session-start.ts
 import { spawn as spawn5 } from "child_process";
-import { access as access7, readFile as readFile16, stat as stat4 } from "fs/promises";
+import { access as access7, readFile as readFile18, stat as stat4 } from "fs/promises";
 import path29 from "path";
 
 // src/invariants/handoff-schema.ts
@@ -5972,7 +6714,7 @@ function validateHandoffText(text) {
 }
 
 // src/plan-index/plan-index.ts
-import { readFile as readFile15, writeFile as writeFile7 } from "fs/promises";
+import { readFile as readFile17, writeFile as writeFile7 } from "fs/promises";
 import path28 from "path";
 var PLAN_INDEX_REL = ".cursor/context/plan-index.json";
 var NONE = /^(none|n\/a|empty|nil)$/i;
@@ -5981,7 +6723,7 @@ function defaultPlanIndexIo() {
   return {
     async readFile(absPath) {
       try {
-        return await readFile15(absPath, "utf8");
+        return await readFile17(absPath, "utf8");
       } catch {
         return null;
       }
@@ -6152,6 +6894,137 @@ function extractPlanBasenames(raw) {
   return ids;
 }
 
+// src/hooks/handoff-excerpt.ts
+var HANDOFF_EXCERPT_MAX_LINES = 60;
+var HANDOFF_EXCERPT_MAX_BYTES = 12 * 1024;
+var HANDOFF_PROSE_LINE_MIN_BYTES = 160;
+var HANDOFF_MACHINE_FIELDS = /* @__PURE__ */ new Set([
+  "Plan",
+  "Last updated",
+  "Mode",
+  "In progress",
+  "Next",
+  "Next phase",
+  "Next to-dos",
+  "Backlog",
+  "Backlog plans",
+  "Parked plans",
+  "Run queue",
+  "Queue cursor",
+  "Queue status"
+]);
+var FIELD_BULLET = /^- \*\*([^*\n]+?):\*\*/;
+function byteLength(s) {
+  return Buffer.byteLength(s, "utf8");
+}
+function classify(lines) {
+  const entries = [];
+  let lastBullet = "structural";
+  for (const text of lines) {
+    let kind;
+    if (!text.trim() || /^#{1,6}\s/.test(text)) {
+      kind = "structural";
+    } else if (/^\s+\S/.test(text)) {
+      kind = lastBullet;
+    } else {
+      const m = FIELD_BULLET.exec(text);
+      kind = m?.[1] && HANDOFF_MACHINE_FIELDS.has(m[1].trim()) ? "machine" : "prose";
+      lastBullet = kind;
+    }
+    entries.push({ text, kind, bytes: byteLength(text) });
+  }
+  return entries;
+}
+function truncateToBytes(text, maxBytes) {
+  let used = 0;
+  let kept = "";
+  let keptChars = 0;
+  const total = Array.from(text).length;
+  for (const ch of text) {
+    const b = byteLength(ch);
+    if (used + b > maxBytes) break;
+    used += b;
+    kept += ch;
+    keptChars += 1;
+  }
+  return { kept: kept.trimEnd(), removedChars: total - keptChars };
+}
+var MARKER_RESERVE_BYTES = 32;
+function truncationMarker(removedChars) {
+  return ` \u2026[truncated ${removedChars} chars]`;
+}
+function droppedMarker(dropped) {
+  return `\u2026[${dropped} prose ${dropped === 1 ? "line" : "lines"} omitted by the excerpt byte cap; read .cursor/HANDOFF.md]`;
+}
+function proseShare(proseBytes, budget, floor) {
+  const n = proseBytes.length;
+  if (n === 0) return budget;
+  let share = Math.floor(budget / n);
+  for (let i = 0; i < 8; i++) {
+    const longer = proseBytes.filter((b) => b > share);
+    if (longer.length === 0) break;
+    const used = proseBytes.reduce((sum, b) => sum + Math.min(b, share), 0);
+    const slack = budget - used;
+    const step = Math.floor(slack / longer.length);
+    if (step <= 0) break;
+    share += step;
+  }
+  return Math.max(floor, share);
+}
+function capHandoffExcerpt(content, options = {}) {
+  const maxLines = options.maxLines ?? HANDOFF_EXCERPT_MAX_LINES;
+  const maxBytes = options.maxBytes ?? HANDOFF_EXCERPT_MAX_BYTES;
+  const floor = options.proseLineMinBytes ?? HANDOFF_PROSE_LINE_MIN_BYTES;
+  const lines = content.split(/\r?\n/).slice(0, maxLines);
+  const entries = classify(lines);
+  const join2 = (items) => items.map((e) => e.text).join("\n").trim();
+  const untouched = join2(entries);
+  const untouchedBytes = byteLength(untouched);
+  if (untouchedBytes <= maxBytes) {
+    return {
+      text: untouched,
+      bytes: untouchedBytes,
+      lines: lines.length,
+      truncatedLines: 0,
+      droppedLines: 0
+    };
+  }
+  const fixedBytes = entries.reduce((sum, e) => sum + (e.kind === "prose" ? 0 : e.bytes) + 1, 0);
+  const proseBudget = Math.max(0, maxBytes - fixedBytes);
+  const share = proseShare(
+    entries.filter((e) => e.kind === "prose").map((e) => e.bytes),
+    proseBudget,
+    floor
+  );
+  let truncatedLines = 0;
+  const shaped = entries.map((e) => {
+    if (e.kind !== "prose" || e.bytes <= share) return e;
+    const { kept, removedChars } = truncateToBytes(e.text, share - MARKER_RESERVE_BYTES);
+    const text2 = kept + truncationMarker(removedChars);
+    truncatedLines += 1;
+    return { text: text2, kind: e.kind, bytes: byteLength(text2) };
+  });
+  let total = shaped.reduce((sum, e) => sum + e.bytes + 1, 0) - 1;
+  let droppedLines = 0;
+  if (total > maxBytes) {
+    const keep = new Set(shaped.map((_, i) => i));
+    const noteBytes = byteLength(droppedMarker(99)) + 1;
+    for (let i = shaped.length - 1; i >= 0 && total + noteBytes > maxBytes; i--) {
+      const e = shaped[i];
+      if (!e || e.kind !== "prose") continue;
+      keep.delete(i);
+      total -= e.bytes + 1;
+      droppedLines += 1;
+    }
+    const remaining = shaped.filter((_, i) => keep.has(i));
+    remaining.push({ text: droppedMarker(droppedLines), kind: "structural", bytes: 0 });
+    const text2 = join2(remaining);
+    return { text: text2, bytes: byteLength(text2), lines: lines.length, truncatedLines, droppedLines };
+  }
+  const text = join2(shaped);
+  return { text, bytes: byteLength(text), lines: lines.length, truncatedLines, droppedLines };
+}
+
 // src/hooks/hard-rules.ts
 var HARD_RULES = `# Agent Kit session hard rules (manual mode default)
 
@@ -6161,7 +7034,7 @@ var HARD_RULES = `# Agent Kit session hard rules (manual mode default)
 4. **Read HANDOFF first** when resuming. Do not restart the plan from scratch.
 5. **Git:** suggest \`/git-staging\` after a phase with a diff; never \`/git-prod\` without explicit confirmation.
 6. **HITL slash commands win.** When waiting for confirmation on \`/git-staging\` or \`/git-prod\` (or similar), do not divert to continue-plan / phase-boundary chatter; stay on that routine until the user answers.
-7. **\`/start-project\` is plan bootstrap, not execute.** Broad Intake Review first, then two gates: (A) single composite question (with active plan: backlog+write / park+write / modify / cancel; without: write / modify / cancel) \u2014 approve/write the plan file only, (B) approve the first unit. Goal text in the same message is NOT permission to edit product files. Never "create plan and start Phase 1" in one turn. If HANDOFF already has an active plan, disposition is merged into Gate A composite options; never park silently. Gates use Ask questions per \`.cursor/rules/hitl-ask-questions.mdc\`. Fallback: one numbered list per message.
+7. **\`/start-project\` is plan bootstrap, not execute.** Broad Intake Review first, then two gates: (A) single composite question (with active plan: backlog+write / park+write / modify / cancel; without: write / write+backlog (\`Write plan and add to backlog\`) / modify / cancel): approve/write the plan file only, (B) approve the first unit. Goal text in the same message is NOT permission to edit product files. Never "create plan and start Phase 1" in one turn. If HANDOFF already has an active plan, disposition is merged into Gate A composite options; never park silently. Gates use Ask questions per \`.cursor/skills/core/hitl-gates/SKILL.md\` and \`.cursor/rules/hitl-ask-questions.mdc\`. Fallback: numbered list is path 1.
 8. **\`/continue-plan\` waits for yes.** Summarize next \`[to-do-id]\`, then stop until the user confirms before editing.
 9. **\`/run-plan-all\` is a pure orchestrator.** After the confirm queue Ask, dispatch one Task subagent per plan (run the \`/run-plan\` tick contract inside it); never implement to-dos, run tests, or write changelogs in the orchestrator window.
 10. **Backlog CRUD never activates.** \`/backlog-add\` enqueues (Broad Intake + write Ask + plan file + HANDOFF Backlog) without park, activate, or Gate B. \`/backlog-edit\` / \`/backlog-delete\` / \`/backlog-cancel\` require Ask confirm before mutate; delete archives from Backlog, cancel is soft in place. No Field Report cards for routine backlog CRUD.
@@ -6184,17 +7057,9 @@ Run \`/cursor-update-awareness\` (or \`agent-kit cursor-awareness --check\`) and
 // src/hooks/session-start.ts
 var NONE_PLACEHOLDERS = /* @__PURE__ */ new Set(["none", "n/a", "empty", "nil"]);
 var CURSOR_AWARENESS_SPAWN_TIMEOUT_MS = CHANGELOG_FETCH_TIMEOUT_MS + 3e3;
-async function readTextLimited(filePath, limit = 60) {
-  try {
-    const lines = (await readFile16(filePath, "utf8")).split(/\r?\n/);
-    return lines.slice(0, limit).join("\n").trim();
-  } catch {
-    return "";
-  }
-}
 async function readFull(filePath) {
   try {
-    return await readFile16(filePath, "utf8");
+    return await readFile18(filePath, "utf8");
   } catch {
     return "";
   }
@@ -6311,7 +7176,7 @@ async function readinessSection(root) {
   const snapshotPath = path29.join(root, ".cursor", "context", "readiness.json");
   let data;
   try {
-    data = JSON.parse(await readFile16(snapshotPath, "utf8"));
+    data = JSON.parse(await readFile18(snapshotPath, "utf8"));
   } catch {
     return null;
   }
@@ -6348,7 +7213,7 @@ async function dogfoodInboxSection(root) {
   for (const readme of candidateReadmes) {
     if (!await fileExists2(readme)) continue;
     try {
-      const text = await readFile16(readme, "utf8");
+      const text = await readFile18(readme, "utf8");
       if (parseUnprocessedDogfoodItems(text).length) return DOGFOOD_INBOX_HINT;
     } catch {
     }
@@ -6358,7 +7223,7 @@ async function dogfoodInboxSection(root) {
 async function loadUpdateCheckPrefs(root) {
   try {
     const data = JSON.parse(
-      await readFile16(path29.join(root, ".cursor", "context", "config.json"), "utf8")
+      await readFile18(path29.join(root, ".cursor", "context", "config.json"), "utf8")
     );
     const uc = data.updateCheck;
     if (!uc || typeof uc !== "object" || uc.enabled !== true) {
@@ -6436,7 +7301,7 @@ async function updateCheckSection(root) {
 async function loadCursorUpdateCheckPrefs(root) {
   try {
     const data = JSON.parse(
-      await readFile16(path29.join(root, ".cursor", "context", "config.json"), "utf8")
+      await readFile18(path29.join(root, ".cursor", "context", "config.json"), "utf8")
     );
     const uc = data.cursorUpdateCheck;
     if (!uc || typeof uc !== "object" || uc.enabled !== true) {
@@ -6631,7 +7496,7 @@ async function buildSessionStartAdditionalContext(rootDir, _payload = {}) {
   const root = path29.resolve(rootDir);
   const handoffPath = path29.join(root, ".cursor", "HANDOFF.md");
   const handoffFull = await readFull(handoffPath);
-  const handoff = await readTextLimited(handoffPath);
+  const handoff = capHandoffExcerpt(handoffFull);
   const parts = [HARD_RULES];
   if (await l0Present(root)) {
     const readiness = await readinessSection(root);
@@ -6656,10 +7521,14 @@ ${bullet}
 Rewrite machine lists as \`- **Field:**\` bullets before trusting Checklist / Current mission.`
     );
   }
-  if (handoff) {
+  if (handoff.text) {
+    const capped = handoff.truncatedLines > 0 || handoff.droppedLines > 0;
+    const note = capped ? `
+
+_Excerpt capped at ${Math.round(HANDOFF_EXCERPT_MAX_BYTES / 1024)} KB (${handoff.truncatedLines} lines truncated, ${handoff.droppedLines} dropped); read \`.cursor/HANDOFF.md\` for the full entries._` : "";
     parts.push(`## Current HANDOFF.md (excerpt)
 
-${handoff}`);
+${handoff.text}${note}`);
   } else {
     parts.push(
       "## HANDOFF.md\n\nNo handoff file yet. If starting work, create a plan with to-dos first (`/start-project`)."
@@ -6743,8 +7612,12 @@ var hookCommand = defineCommand10({
 import { intro, outro } from "@clack/prompts";
 import { defineCommand as defineCommand12 } from "citty";
 
-// src/utils/terminal.ts
-import { readdir as readdir6 } from "fs/promises";
+// src/lifecycle/path-cli.ts
+import { spawn as spawn6 } from "child_process";
+import path32 from "path";
+
+// src/utils/terminal.ts
+import { readdir as readdir8 } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import path31 from "path";
 import { confirm, isCancel } from "@clack/prompts";
@@ -6758,7 +7631,7 @@ var NESTED_REPO_SCAN_LIMIT = 200;
 async function findNestedRepoChildren(resolved) {
   let entries;
   try {
-    entries = await readdir6(resolved, { withFileTypes: true });
+    entries = await readdir8(resolved, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -6928,18 +7801,122 @@ function classifyInstallError(err) {
   };
 }
 
+// src/lifecycle/path-cli.ts
+function npxPinned(runtimeVersion, subcommand) {
+  return `npx -y ${pinnedCliSpec(runtimeVersion)} ${subcommand}`;
+}
+function isBinUnderPrefix(binPath, prefix) {
+  const bin = path32.resolve(binPath);
+  const root = path32.resolve(prefix);
+  return bin === root || bin.startsWith(`${root}${path32.sep}`);
+}
+function pathCliStatus(env, runtimeVersion) {
+  if (!env.binOnPath || !env.binPath) return "missing";
+  const running = normalizeSemver(runtimeVersion);
+  const pathVer = env.binVersion ? normalizeSemver(env.binVersion) : null;
+  if (!pathVer || !running) return "unknown";
+  try {
+    return compareSemver(pathVer, running) >= 0 ? "current" : "behind";
+  } catch {
+    return "unknown";
+  }
+}
+function driftLines(env, runtimeVersion) {
+  const pathVer = env.binVersion ?? "unknown";
+  const where = env.binPath ?? "(unresolved)";
+  return [
+    `This CLI is v${runtimeVersion}. PATH \`agent-kit\` is v${pathVer} at:`,
+    `  ${where}`,
+    "Do not run bare `agent-kit update` or `init` from that binary. It re-stamps the old version.",
+    "Keep using the pinned npx form until PATH matches:",
+    `  ${npxPinned(runtimeVersion, "update")}`,
+    `  ${npxPinned(runtimeVersion, "status")}`
+  ];
+}
+function isShadow(env) {
+  if (!env.binPath || !env.npmPrefix.prefix) return false;
+  return !isBinUnderPrefix(env.binPath, env.npmPrefix.prefix);
+}
+async function spawnNpmGlobalInstall(spec) {
+  return new Promise((resolve3) => {
+    const child = spawn6("npm", ["i", "-g", spec], { stdio: "inherit" });
+    child.on("error", (error) => resolve3({ ok: false, error }));
+    child.on("close", (code) => {
+      if (code === 0) resolve3({ ok: true });
+      else resolve3({ ok: false, error: new Error(`npm exited with code ${code ?? "unknown"}`) });
+    });
+  });
+}
+async function syncPathCliToRuntime(options = {}) {
+  const runtimeVersion = options.runtimeVersion ?? KIT_VERSION;
+  const assess = options.assessEnvironmentImpl ?? assessEnvironment;
+  let env = options.env ?? await assess();
+  const autoInstall = options.autoInstall ?? !isNonInteractive();
+  const lines = [];
+  let status = pathCliStatus(env, runtimeVersion);
+  if (status === "current") {
+    return { status, env, upgraded: false, lines };
+  }
+  if (status === "behind" || status === "unknown") {
+    lines.push(...driftLines(env, runtimeVersion));
+    if (isShadow(env)) {
+      lines.push(
+        "That PATH hit is not npm's global bin, so `npm i -g` may not replace it.",
+        "Run `hash -r` and `which -a agent-kit`. Put npm's global bin first, or remove the stale shim."
+      );
+    }
+  }
+  if (!autoInstall) {
+    return { status, env, upgraded: false, lines };
+  }
+  if (status === "missing") {
+    lines.push("No bare `agent-kit` on PATH yet (npx is ephemeral).");
+  }
+  if (!env.npmPrefixWritable) {
+    lines.push(
+      "npm's global prefix is not writable, so this process cannot upgrade PATH.",
+      `Run ${npxPinned(runtimeVersion, "setup-global")} (or fix prefix permissions).`
+    );
+    return { status, env, upgraded: false, lines };
+  }
+  const spec = pinnedCliSpec(runtimeVersion);
+  const install = options.npmInstallImpl ?? spawnNpmGlobalInstall;
+  lines.push(`Installing ${spec} into the writable npm prefix...`);
+  const outcome = await install(spec);
+  if (!outcome.ok) {
+    const detail = outcome.error instanceof Error ? outcome.error.message : "npm i -g failed";
+    lines.push(`Global install failed: ${detail}`);
+    return { status, env, upgraded: false, lines };
+  }
+  env = await assess();
+  status = pathCliStatus(env, runtimeVersion);
+  if (status === "current") {
+    lines.push(
+      `PATH \`agent-kit\` is now v${env.binVersion ?? runtimeVersion}.`,
+      "If this shell still shows the old version, run `hash -r` or open a new terminal."
+    );
+    return { status, env, upgraded: true, lines };
+  }
+  lines.push(
+    `Installed ${spec}, but PATH still resolves to v${env.binVersion ?? "unknown"} at:`,
+    `  ${env.binPath ?? "(unresolved)"}`,
+    "Run `hash -r` and `which -a agent-kit`. Until PATH matches, keep using the npx pin above."
+  );
+  return { status, env, upgraded: true, lines };
+}
+
 // src/commands/install.ts
-import path38 from "path";
+import path39 from "path";
 import { defineCommand as defineCommand11 } from "citty";
 import { bold, cyan as cyan3, green as green2, options as koloristOptions2 } from "kolorist";
 
 // src/generator/personalization.ts
-import { readFile as readFile19, writeFile as writeFile12 } from "fs/promises";
-import path36 from "path";
+import { readFile as readFile21, writeFile as writeFile12 } from "fs/promises";
+import path37 from "path";
 
 // src/generator/claude-command-adapters.ts
-import { readFile as readFile17, readdir as readdir7, writeFile as writeFile8 } from "fs/promises";
-import path32 from "path";
+import { readFile as readFile19, readdir as readdir9, writeFile as writeFile8 } from "fs/promises";
+import path33 from "path";
 var CURSOR_COMMANDS_DIR_REL = ".cursor/commands";
 var CLAUDE_COMMANDS_DIR_REL = ".claude/commands";
 var RESERVED_ADAPTER_NAMES = /* @__PURE__ */ new Set(["agent-kit"]);
@@ -6961,17 +7938,17 @@ description: ${command.description}
 Read \`.cursor/commands/${command.name}.md\` now and follow that contract exactly \u2014 it is the source of truth for /${command.name}; this file is only a thin adapter for Claude Code.
 
 Adapter rules (Claude Code CLI):
-- Cursor "Ask questions" is unavailable here: use AskUserQuestion when possible, else present the same labels as one numbered list per message and WAIT for the answer.
+- Cursor "Ask questions" is unavailable here: use AskUserQuestion when possible, else print one line \`HITL_GATE: <ask-id> | <label 1> | <label 2> | ...\` immediately followed by the same labels as one numbered list, one list per message, and WAIT for the answer (ask-id and labels: \`.cursor/skills/core/hitl-gates/SKILL.md\`). A headless reply arrives as \`HITL_REPLY: <ask-id> | operator reply <n> | <label>\`; cite that line as the Ask provenance.
 - Skip or cancel means stop.
 - Never \`/git-prod\` without an explicit operator yes.
 - Do not clone Cursor hooks or invent behavior beyond the SoT file.
 `;
 }
 async function discoverInstalledCommands(rootDir) {
-  const dir = path32.join(rootDir, CURSOR_COMMANDS_DIR_REL);
+  const dir = path33.join(rootDir, CURSOR_COMMANDS_DIR_REL);
   let entries;
   try {
-    entries = (await readdir7(dir)).filter((f) => f.endsWith(".md"));
+    entries = (await readdir9(dir)).filter((f) => f.endsWith(".md"));
   } catch {
     return [];
   }
@@ -6980,7 +7957,7 @@ async function discoverInstalledCommands(rootDir) {
     const name = file.slice(0, -3);
     if (RESERVED_ADAPTER_NAMES.has(name)) continue;
     try {
-      const raw = await readFile17(path32.join(dir, file), "utf8");
+      const raw = await readFile19(path33.join(dir, file), "utf8");
       const parsed = parseCommandFrontmatter(name, raw);
       if (parsed) commands.push(parsed);
     } catch {
@@ -6995,18 +7972,18 @@ async function generateClaudeCommandAdapters(rootDir) {
   const results = [];
   let ledgerDirty = false;
   for (const command of commands) {
-    const relPath = path32.posix.join(CLAUDE_COMMANDS_DIR_REL, `${command.name}.md`);
+    const relPath = path33.posix.join(CLAUDE_COMMANDS_DIR_REL, `${command.name}.md`);
     const rendered = renderClaudeCommandAdapter(command);
-    const abs = path32.join(rootDir, relPath);
+    const abs = path33.join(rootDir, relPath);
     if (!await fileExists(abs)) {
-      await ensureDir(path32.dirname(abs));
+      await ensureDir(path33.dirname(abs));
       await writeFile8(abs, rendered, "utf8");
       ledger.hashes[relPath] = contentHash(rendered);
       ledgerDirty = true;
       results.push({ relativePath: relPath, status: "applied" });
       continue;
     }
-    const localContent = await readFile17(abs, "utf8");
+    const localContent = await readFile19(abs, "utf8");
     if (localContent === rendered) {
       if (ledger.hashes[relPath] !== contentHash(rendered)) {
         ledger.hashes[relPath] = contentHash(rendered);
@@ -7030,7 +8007,7 @@ async function generateClaudeCommandAdapters(rootDir) {
 
 // src/generator/claude-kit-load.ts
 import { writeFile as writeFile9 } from "fs/promises";
-import path33 from "path";
+import path34 from "path";
 var CLAUDE_MD_REL = "CLAUDE.md";
 var AGENT_KIT_COMMAND_REL = ".claude/commands/agent-kit.md";
 function renderClaudeMd() {
@@ -7086,11 +8063,11 @@ Non-goals: not audits / \`/plan-external-review\`, not a second tick dialect (\`
 `;
 }
 async function writeUnlessExists(rootDir, relativePath, content) {
-  const target = path33.join(rootDir, relativePath);
+  const target = path34.join(rootDir, relativePath);
   if (await fileExists(target)) {
     return { relativePath, status: "skipped-customized" };
   }
-  await ensureDir(path33.dirname(target));
+  await ensureDir(path34.dirname(target));
   await writeFile9(target, content, "utf8");
   return { relativePath, status: "applied" };
 }
@@ -7102,8 +8079,8 @@ async function generateClaudeKitLoadArtifacts(rootDir) {
 }
 
 // src/generator/claude-session-start-hook.ts
-import { readFile as readFile18, writeFile as writeFile10 } from "fs/promises";
-import path34 from "path";
+import { readFile as readFile20, writeFile as writeFile10 } from "fs/promises";
+import path35 from "path";
 var CLAUDE_SETTINGS_REL = ".claude/settings.json";
 var RESOLVE_AGENT_KIT_REL = ".cursor/hooks/agent/resolve-agent-kit.sh";
 var SESSION_START_HOOK_MARKER = "hook session-start --format claude";
@@ -7178,10 +8155,10 @@ function instructionsBlock(entry) {
   ].join("\n");
 }
 async function writeClaudeSessionStartHook(rootDir) {
-  const abs = path34.join(rootDir, CLAUDE_SETTINGS_REL);
+  const abs = path35.join(rootDir, CLAUDE_SETTINGS_REL);
   let existing = null;
   try {
-    existing = await readFile18(abs, "utf8");
+    existing = await readFile20(abs, "utf8");
   } catch {
     existing = null;
   }
@@ -7196,14 +8173,14 @@ async function writeClaudeSessionStartHook(rootDir) {
   if (merged.status === "unchanged") {
     return { relativePath: CLAUDE_SETTINGS_REL, status: "unchanged" };
   }
-  await ensureDir(path34.dirname(abs));
+  await ensureDir(path35.dirname(abs));
   await writeFile10(abs, merged.content, "utf8");
   return { relativePath: CLAUDE_SETTINGS_REL, status: merged.status };
 }
 
 // src/generator/vscode.ts
 import { writeFile as writeFile11 } from "fs/promises";
-import path35 from "path";
+import path36 from "path";
 
 // src/generator/platform.ts
 function gitProviderLabel(profile) {
@@ -7227,10 +8204,10 @@ function prTerminology(profile) {
 // src/generator/vscode.ts
 async function generateVSCodeArtifacts(profile) {
   const results = [];
-  const vscodeDir = path35.join(profile.rootDir, ".vscode");
-  const githubDir = path35.join(profile.rootDir, ".github");
+  const vscodeDir = path36.join(profile.rootDir, ".vscode");
+  const githubDir = path36.join(profile.rootDir, ".github");
   await Promise.all([ensureDir(vscodeDir), ensureDir(githubDir)]);
-  const settingsPath = path35.join(vscodeDir, "settings.json");
+  const settingsPath = path36.join(vscodeDir, "settings.json");
   if (await fileExists(settingsPath)) {
     results.push({ relativePath: ".vscode/settings.json", status: "skipped-customized" });
   } else {
@@ -7254,7 +8231,7 @@ async function generateVSCodeArtifacts(profile) {
   }
   const provider = gitProviderLabel(profile);
   const prTerm = prTerminology(profile);
-  const copilotPath = path35.join(githubDir, "copilot-instructions.md");
+  const copilotPath = path36.join(githubDir, "copilot-instructions.md");
   if (await fileExists(copilotPath)) {
     results.push({ relativePath: ".github/copilot-instructions.md", status: "skipped-customized" });
   } else {
@@ -7272,7 +8249,7 @@ async function generateVSCodeArtifacts(profile) {
     results.push({ relativePath: ".github/copilot-instructions.md", status: "applied" });
   }
   if (profile.ide.plan === "vscode-pro") {
-    const securityPath = path35.join(vscodeDir, "security-review.agent.md");
+    const securityPath = path36.join(vscodeDir, "security-review.agent.md");
     if (await fileExists(securityPath)) {
       results.push({
         relativePath: ".vscode/security-review.agent.md",
@@ -7484,7 +8461,7 @@ function renderProjectContext(profile, skillItems = []) {
 `;
 }
 async function createOwnedFile(rootDir, relativePath, content, evidence) {
-  const target = path36.join(rootDir, relativePath);
+  const target = path37.join(rootDir, relativePath);
   if (await fileExists(target)) {
     return {
       kind: "file",
@@ -7494,7 +8471,7 @@ async function createOwnedFile(rootDir, relativePath, content, evidence) {
       evidence
     };
   }
-  await ensureDir(path36.dirname(target));
+  await ensureDir(path37.dirname(target));
   await writeFile12(target, content, "utf8");
   return {
     kind: "file",
@@ -7511,7 +8488,7 @@ async function packTargets(registryRoot, packId) {
 async function existingTargets(projectRoot, targets) {
   const checks = await Promise.all(
     targets.map(
-      async (target) => await fileExists(path36.join(projectRoot, target)) ? target : null
+      async (target) => await fileExists(path37.join(projectRoot, target)) ? target : null
     )
   );
   return checks.filter((target) => target !== null);
@@ -7533,14 +8510,14 @@ async function applyPersonalization(input) {
         componentResults.push({ ...item, status: "unavailable" });
         continue;
       }
-      const target = path36.posix.join(
+      const target = path37.posix.join(
         ".cursor",
         "skills",
         skill.path.includes("/core/") ? "core" : "community",
         skill.id,
         "SKILL.md"
       );
-      if (await fileExists(path36.join(input.rootDir, target))) {
+      if (await fileExists(path37.join(input.rootDir, target))) {
         componentResults.push({ ...item, status: "skipped-customized", path: target });
         protectedPaths.add(target);
         continue;
@@ -7685,7 +8662,7 @@ async function applyPersonalization(input) {
     protectedPaths: [...protectedPaths].sort(),
     ...claudeSessionStartInstructions ? { claudeSessionStartInstructions } : {}
   };
-  await writeJson(path36.join(input.rootDir, RESULT_PATH), result);
+  await writeJson(path37.join(input.rootDir, RESULT_PATH), result);
   return {
     result,
     manifest: {
@@ -7703,26 +8680,26 @@ async function applyPersonalization(input) {
   };
 }
 async function readRepositoryProfile(rootDir) {
-  const target = path36.join(rootDir, ".cursor/agent-kit.config.json");
+  const target = path37.join(rootDir, ".cursor/agent-kit.config.json");
   if (!await fileExists(target)) return null;
-  return JSON.parse(await readFile19(target, "utf8"));
+  return JSON.parse(await readFile21(target, "utf8"));
 }
 
 // src/lifecycle/onboard-migration.ts
 import { createHash as createHash4 } from "crypto";
-import { readFile as readFile20, unlink } from "fs/promises";
-import path37 from "path";
+import { readFile as readFile22, unlink } from "fs/promises";
+import path38 from "path";
 var LEGACY_ONBOARD_PATH = ".cursor/commands/onboard.md";
 var NAMESPACED_ONBOARD_PATH = ".cursor/commands/agent-kit-onboard.md";
 var MANAGED_LEGACY_HASHES = /* @__PURE__ */ new Set([
   "b274a68941813f19b185893cb7c5561dff027f53270890029992f208e24992fe"
 ]);
 async function migrateLegacyOnboardCommand(projectRoot, managedHashes = MANAGED_LEGACY_HASHES) {
-  const legacyPath = path37.join(projectRoot, LEGACY_ONBOARD_PATH);
+  const legacyPath = path38.join(projectRoot, LEGACY_ONBOARD_PATH);
   if (!await fileExists(legacyPath)) return "absent";
-  const namespacedPath = path37.join(projectRoot, NAMESPACED_ONBOARD_PATH);
+  const namespacedPath = path38.join(projectRoot, NAMESPACED_ONBOARD_PATH);
   if (!await fileExists(namespacedPath)) return "preserved-customized";
-  const content = await readFile20(legacyPath);
+  const content = await readFile22(legacyPath);
   const hash = createHash4("sha256").update(content).digest("hex");
   if (!managedHashes.has(hash)) return "preserved-customized";
   await unlink(legacyPath);
@@ -7810,8 +8787,15 @@ function paint(fn, text) {
 function printInstallEpilogue(env, options = {}) {
   const print = options.print ?? ((line) => console.log(line));
   const color = options.color ?? shouldUseWelcomeColor();
-  if (env.binOnPath) {
-    const line = "`agent-kit` is on PATH \u2014 run it directly, e.g. `agent-kit doctor`.";
+  const runtimeVersion = options.runtimeVersion ?? KIT_VERSION;
+  const status = pathCliStatus(env, runtimeVersion);
+  if (status === "current") {
+    const line = `PATH \`agent-kit\` is v${env.binVersion ?? runtimeVersion}. Run it directly, e.g. \`agent-kit doctor\`.`;
+    print(color ? paint(green2, line) : line);
+    return;
+  }
+  if (status === "behind" || status === "unknown") {
+    const line = `Keep using ${npxPinned(runtimeVersion, "<subcommand>")} until PATH is v${runtimeVersion}.`;
     print(color ? paint(green2, line) : line);
     return;
   }
@@ -7821,11 +8805,11 @@ function printInstallEpilogue(env, options = {}) {
     'If you try `agent-kit <subcommand>` next, you will see "command not',
     'found". Pick one:',
     "",
-    "  1. Keep using npx \u2014 works right now, no action needed",
-    "     npx @dadado/agent-kit-cli@latest <subcommand>",
+    "  1. Keep using npx (works right now, no action needed)",
+    `     ${npxPinned(runtimeVersion, "<subcommand>")}`,
     "",
     "  2. Put a bare `agent-kit` on PATH",
-    "     npx @dadado/agent-kit-cli@latest setup-global",
+    `     ${npxPinned(runtimeVersion, "setup-global")}`,
     "     (fixes a root-owned npm prefix if that's the blocker, or just installs)",
     "",
     "  3. Manual steps",
@@ -7833,7 +8817,7 @@ function printInstallEpilogue(env, options = {}) {
     "       mkdir -p ~/.npm-global",
     '       npm config set prefix "~/.npm-global"',
     '       export PATH="~/.npm-global/bin:$PATH"',
-    "       npm i -g @dadado/agent-kit-cli@latest"
+    `       npm i -g ${pinnedCliSpec(runtimeVersion)}`
   ];
   print(color ? paint(cyan3, divider) : divider);
   const heading = "Heads up: a bare `agent-kit` command won't work yet";
@@ -7844,10 +8828,12 @@ function printInstallEpilogue(env, options = {}) {
 async function printPostInstallSummary(result) {
   printReadinessNarrative(result);
   const env = await assessEnvironment();
-  printInstallEpilogue(env);
+  const sync = await syncPathCliToRuntime({ runtimeVersion: KIT_VERSION, env });
+  for (const line of sync.lines) console.log(line);
+  printInstallEpilogue(sync.env, { runtimeVersion: KIT_VERSION });
 }
 async function performInstall(options) {
-  const projectRoot = path38.resolve(options.cwd);
+  const projectRoot = path39.resolve(options.cwd);
   const packs = parsePackList(options.pack);
   const existing = await loadAgentKitManifest(projectRoot);
   const registry = await resolveRegistryFromCli({
@@ -7970,6 +8956,7 @@ ${err.recovery}
       throw err;
     }
     logger.info(`Installing into: ${projectRoot}`);
+    logger.info(`CLI v${KIT_VERSION}`);
     await warnIfRunningCliBehindNpm(projectRoot, { warn: (message) => logger.warn(message) });
     const packs = parsePackList(args.pack);
     for (const id of packs) {
@@ -8072,12 +9059,13 @@ ${err.recovery}
       logger.success(`L0 and readiness prepared in ${result.projectRoot}`);
       const nextStep = nextStepAfterInstall(pending);
       const env = await assessEnvironment();
+      const sync = await syncPathCliToRuntime({ runtimeVersion: KIT_VERSION, env });
+      for (const line of sync.lines) console.log(line);
+      printInstallEpilogue(sync.env, { runtimeVersion: KIT_VERSION });
       if (!nonInteractive) {
-        printInstallEpilogue(env);
         outro(nextStep);
       } else {
         logger.info(nextStep);
-        printInstallEpilogue(env);
       }
     } catch (err) {
       const hint = classifyInstallError(err);
@@ -8246,11 +9234,333 @@ function shouldLiveRefresh(opts) {
   const tty = opts.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
   return tty;
 }
+function renderProgressBar(opts) {
+  const width = Math.max(4, Math.floor(opts.width ?? 20));
+  const total = Math.max(0, Math.floor(opts.total));
+  const done = Math.min(total, Math.max(0, Math.floor(opts.done)));
+  const filled = total === 0 ? 0 : Math.round(done / total * width);
+  const color = opts.color ?? false;
+  const bar = `${hexPaint(HELMET_ACCENT, "\u2588".repeat(filled), color)}${hexPaint(
+    LABEL_MUTED,
+    "\u2591".repeat(width - filled),
+    color
+  )}`;
+  return `${hexPaint(HELMET_OUTLINE, "[", color)}${bar}${hexPaint(HELMET_OUTLINE, "]", color)} ${hexPaint(
+    HELMET_OUTLINE,
+    `${done}/${total}`,
+    color
+  )}`;
+}
+var ScrollRegion = class {
+  lines = [];
+  offset = 0;
+  capacity;
+  constructor(capacity = 500) {
+    this.capacity = Math.max(1, Math.floor(capacity));
+  }
+  get length() {
+    return this.lines.length;
+  }
+  get scrolledUp() {
+    return this.offset;
+  }
+  push(line) {
+    this.lines.push(line);
+    if (this.lines.length > this.capacity) {
+      this.lines.splice(0, this.lines.length - this.capacity);
+    }
+    if (this.offset > 0) this.offset = Math.min(this.offset, Math.max(0, this.lines.length - 1));
+  }
+  scrollUp(n = 1) {
+    this.offset = Math.min(Math.max(0, this.lines.length - 1), this.offset + Math.max(0, n));
+  }
+  scrollDown(n = 1) {
+    this.offset = Math.max(0, this.offset - Math.max(0, n));
+  }
+  scrollToBottom() {
+    this.offset = 0;
+  }
+  /** The last `height` lines (minus the scroll offset). */
+  viewport(height) {
+    const h = Math.max(0, Math.floor(height));
+    const end = Math.max(0, this.lines.length - this.offset);
+    const start = Math.max(0, end - h);
+    return { lines: this.lines.slice(start, end), above: start, below: this.lines.length - end };
+  }
+  all() {
+    return this.lines;
+  }
+};
+var KEY_LEFT = `${ESC}[D`;
+var KEY_RIGHT = `${ESC}[C`;
+var KEY_HOME_SET = /* @__PURE__ */ new Set([`${ESC}[H`, `${ESC}[1~`, `${ESC}OH`]);
+var KEY_END_SET = /* @__PURE__ */ new Set([`${ESC}[F`, `${ESC}[4~`, `${ESC}OF`]);
+var KEY_DELETE = `${ESC}[3~`;
+function splitKeys(chunk) {
+  const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+  const keys = [];
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i] ?? "";
+    if (ch === ESC && i + 1 < text.length) {
+      const next = text[i + 1];
+      if (next === "[" || next === "O") {
+        let j = i + 2;
+        while (j < text.length && !/[A-Za-z~]/.test(text[j] ?? "")) j += 1;
+        keys.push(text.slice(i, Math.min(text.length, j + 1)));
+        i = j + 1;
+        continue;
+      }
+    }
+    keys.push(ch);
+    i += 1;
+  }
+  return keys;
+}
+var InputLine = class {
+  buffer = "";
+  cursorPos = 0;
+  get value() {
+    return this.buffer;
+  }
+  get cursor() {
+    return this.cursorPos;
+  }
+  reset() {
+    this.buffer = "";
+    this.cursorPos = 0;
+  }
+  handleKey(chunk) {
+    let result = "ignored";
+    for (const key of splitKeys(chunk)) {
+      const r = this.handleOne(key);
+      if (r === "submit" || r === "sigint" || r === "eof") return r;
+      if (r === "edit") result = "edit";
+    }
+    return result;
+  }
+  handleOne(key) {
+    if (key === "\r" || key === "\n") return "submit";
+    if (key === "") return "sigint";
+    if (key === "") return this.buffer.length === 0 ? "eof" : "ignored";
+    if (key === "\x7F" || key === "\b") {
+      if (this.cursorPos === 0) return "ignored";
+      this.buffer = this.buffer.slice(0, this.cursorPos - 1) + this.buffer.slice(this.cursorPos);
+      this.cursorPos -= 1;
+      return "edit";
+    }
+    if (key === KEY_DELETE) {
+      if (this.cursorPos >= this.buffer.length) return "ignored";
+      this.buffer = this.buffer.slice(0, this.cursorPos) + this.buffer.slice(this.cursorPos + 1);
+      return "edit";
+    }
+    if (key === KEY_LEFT) {
+      if (this.cursorPos === 0) return "ignored";
+      this.cursorPos -= 1;
+      return "edit";
+    }
+    if (key === KEY_RIGHT) {
+      if (this.cursorPos >= this.buffer.length) return "ignored";
+      this.cursorPos += 1;
+      return "edit";
+    }
+    if (KEY_HOME_SET.has(key) || key === "
") {
+      this.cursorPos = 0;
+      return "edit";
+    }
+    if (KEY_END_SET.has(key) || key === "") {
+      this.cursorPos = this.buffer.length;
+      return "edit";
+    }
+    if (key === "") {
+      if (this.buffer.length === 0) return "ignored";
+      this.reset();
+      return "edit";
+    }
+    if (key === "") {
+      if (this.cursorPos === 0) return "ignored";
+      const head = this.buffer.slice(0, this.cursorPos).replace(/\S*\s*$/, "");
+      this.buffer = head + this.buffer.slice(this.cursorPos);
+      this.cursorPos = head.length;
+      return "edit";
+    }
+    if (key.startsWith(ESC)) return "ignored";
+    const code = key.codePointAt(0) ?? 0;
+    if (code < 32 || code === 127) return "ignored";
+    this.buffer = this.buffer.slice(0, this.cursorPos) + key + this.buffer.slice(this.cursorPos);
+    this.cursorPos += key.length;
+    return "edit";
+  }
+  /** `> text` with the cursor cell marked by reverse video (plain: `_` at the end). */
+  render(width, color, prompt = "> ") {
+    const max = Math.max(4, width - prompt.length - 1);
+    let start = 0;
+    if (this.cursorPos >= max) start = this.cursorPos - max + 1;
+    const visible = this.buffer.slice(start, start + max);
+    const at = this.cursorPos - start;
+    const before = visible.slice(0, at);
+    const cell = visible.slice(at, at + 1) || " ";
+    const after = visible.slice(at + 1);
+    const painted = color ? `${hexPaint(HELMET_OUTLINE, before, true)}${ESC}[7m${cell}${ESC}[0m${hexPaint(HELMET_OUTLINE, after, true)}` : `${before}${cell === " " && after === "" ? "_" : cell}${after}`;
+    return `${hexPaint(HELMET_ACCENT, prompt, color)}${painted}`;
+  }
+};
+var LIVE_MIN_LOG_ROWS = 3;
+var LIVE_MAX_LOG_ROWS = 40;
+var LIVE_CHECKLIST_CAP = 4;
+function formatElapsed(ms) {
+  const s = Math.max(0, Math.floor(ms / 1e3));
+  const m = Math.floor(s / 60);
+  const h = Math.floor(m / 60);
+  if (h > 0) return `${h}h ${m % 60}m`;
+  if (m > 0) return `${m}m ${s % 60}s`;
+  return `${s}s`;
+}
+function liveLineHex(kind) {
+  switch (kind) {
+    case "tool":
+      return HELMET_ACCENT;
+    case "result":
+      return STATUS_OK;
+    case "error":
+      return STATUS_ERR;
+    case "rate_limit":
+      return STATUS_WARN;
+    case "hitl":
+      return HELMET_ACCENT;
+    case "hook":
+    case "prompt":
+    case "note":
+      return LABEL_MUTED;
+    default:
+      return HELMET_OUTLINE;
+  }
+}
+function renderMcLive(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 rows = Math.max(12, Math.floor(opts.rows ?? process.stdout.rows ?? 24));
+  const inner = columns - 2 - INNER_PAD;
+  const now2 = opts.now ?? Date.now();
+  const running = view.crew.phase === "running" || view.crew.phase === "gate";
+  const mark = motion && running ? spinnerFrame(opts.frameIndex ?? 0) : SPACE_MARKS.tick;
+  const header = hexPaint(
+    HELMET_ACCENT,
+    `${mark} Mission Control ${SPACE_MARKS.star} live run ${SPACE_MARKS.tick} ${view.crew.backend ?? "agent"} ${SPACE_MARKS.tick} ${view.crew.phase}`,
+    color
+  );
+  const barWidth = Math.max(8, Math.min(24, Math.floor(inner / 3)));
+  const missionBody = [];
+  if (view.error) {
+    missionBody.push(
+      hexPaint(STATUS_ERR, wrapNarrow(view.error, inner).split("\n")[0] ?? "", color)
+    );
+  } else {
+    const m = view.mission;
+    missionBody.push(
+      `${labeled("plan     ", lineOrQuiet(m.planFile, "none"), color)}${m.mode ? hexPaint(LABEL_MUTED, `  \xB7  ${m.mode}`, color) : ""}`
+    );
+    const todoTail = m.currentTodo ? `  now ${m.currentTodo}` : "";
+    missionBody.push(
+      `${hexPaint(LABEL_MUTED, "to-dos   ", color)}${renderProgressBar({
+        done: m.todos.done,
+        total: m.todos.total,
+        width: barWidth,
+        color
+      })}${hexPaint(HELMET_OUTLINE, todoTail, color)}`
+    );
+    if (m.queue) {
+      const tail = m.queue.status ? `  ${m.queue.status}` : "";
+      missionBody.push(
+        `${hexPaint(LABEL_MUTED, "plans    ", color)}${renderProgressBar({
+          done: m.queue.done,
+          total: m.queue.total,
+          width: barWidth,
+          color
+        })}${hexPaint(HELMET_OUTLINE, tail, color)}`
+      );
+    }
+    if (m.nextTodo) missionBody.push(labeled("next     ", m.nextTodo, color));
+  }
+  if (view.gate) {
+    const g = view.gate;
+    const head = g.detection === "fallback" ? `${g.askId} (prose fallback)` : g.askId;
+    missionBody.push(
+      `${hexPaint(LABEL_MUTED, "gate     ", color)}${hexPaint(STATUS_WARN, head, color)}${hexPaint(
+        LABEL_MUTED,
+        "  \xB7  number or label replies; empty, skip, cancel or Ctrl-C stops",
+        color
+      )}`
+    );
+    g.labels.forEach((label, i) => {
+      missionBody.push(hexPaint(HELMET_OUTLINE, `         ${i + 1}. ${label}`, color));
+    });
+    missionBody.push(`         ${view.gate.input.render(inner - 9, color)}`);
+  }
+  const checklistBody = view.checklist.length === 0 ? [muted("no queue", color)] : view.checklist.slice(0, LIVE_CHECKLIST_CAP).map((row) => {
+    const markOf = row.state === "done" ? SPACE_MARKS.star : row.state === "current" ? "\u25B6" : SPACE_MARKS.tick;
+    const hex = row.state === "done" ? STATUS_OK : row.state === "current" ? HELMET_ACCENT : LABEL_MUTED;
+    return hexPaint(hex, `${markOf} ${row.label}`, color);
+  });
+  const c = view.crew;
+  const crewLine1 = [
+    c.backend ?? "agent",
+    c.pid !== void 0 ? `pid ${c.pid}` : "no pid",
+    c.phase,
+    formatElapsed(now2 - c.startedAt),
+    c.costUsd !== void 0 ? `$${c.costUsd.toFixed(c.costUsd < 0.1 ? 4 : 2)}` : null,
+    c.turns !== void 0 ? `${c.turns} turn${c.turns === 1 ? "" : "s"}` : null,
+    `${c.toolCalls} tool call${c.toolCalls === 1 ? "" : "s"}`
+  ].filter((part) => Boolean(part)).join(` ${SPACE_MARKS.tick} `);
+  const crewBody = [hexPaint(HELMET_OUTLINE, crewLine1, color)];
+  if (c.currentTool) {
+    crewBody.push(
+      `${hexPaint(LABEL_MUTED, "tool  ", color)}${hexPaint(HELMET_ACCENT, `${c.currentTool.name} ${SPACE_MARKS.tick} ${c.currentTool.summary}`, color)}`
+    );
+  } else if (c.lastResult) {
+    crewBody.push(
+      `${hexPaint(LABEL_MUTED, "last  ", color)}${hexPaint(c.lastResult.ok ? STATUS_OK : STATUS_ERR, `result ${c.lastResult.status}`, color)}`
+    );
+  }
+  if (c.rateLimit) {
+    crewBody.push(
+      `${hexPaint(LABEL_MUTED, "limit ", color)}${hexPaint(c.rateLimit.severe ? STATUS_ERR : STATUS_WARN, c.rateLimit.line, color)}`
+    );
+  }
+  if (c.logPath) crewBody.push(labeled("log   ", c.logPath, color, LABEL_MUTED));
+  let checklist = checklistBody;
+  let crew = crewBody;
+  const fixed = () => 1 + (missionBody.length + 2) + 2 + (checklist ? checklist.length + 2 : 0) + (crew.length + 2) + 1;
+  if (fixed() + LIVE_MIN_LOG_ROWS > rows) checklist = null;
+  if (fixed() + LIVE_MIN_LOG_ROWS > rows) crew = crew.slice(0, 1);
+  const logRows = Math.max(1, Math.min(LIVE_MAX_LOG_ROWS, rows - fixed()));
+  const viewport = view.flightLog.viewport(logRows);
+  const flightBody = viewport.lines.map(
+    (line) => hexPaint(liveLineHex(line.kind), line.text, color)
+  );
+  if (flightBody.length === 0) flightBody.push(muted("waiting for the agent stream", color));
+  const flightTitle = viewport.above > 0 || viewport.below > 0 ? `Flight Log ${SPACE_MARKS.tick} ${viewport.above} above${viewport.below > 0 ? ` ${SPACE_MARKS.tick} ${viewport.below} below` : ""}` : "Flight Log";
+  const panels = [
+    ...box("Mission", missionBody, columns, color),
+    ...box(flightTitle, flightBody, columns, color),
+    ...checklist ? box("Checklist", checklist, columns, color) : [],
+    ...box("Crew Monitor", crew, columns, color)
+  ];
+  const footer = muted(
+    view.gate ? "Third surface \xB7 live feed \xB7 Enter sends the reply \xB7 Ctrl-C stops the run" : "Third surface \xB7 live feed \xB7 q / Ctrl-C stops the run \xB7 log keeps the full NDJSON",
+    color
+  );
+  return [header, ...panels, footer].join("\n");
+}
 
 // src/mission-control/snapshot.ts
 import { execFile as execFile6 } from "child_process";
 import { access as access8 } from "fs/promises";
-import path39 from "path";
+import path40 from "path";
 
 // ../../dashboard/lib/live-refresh.mjs
 import { join, resolve as resolve2 } from "path";
@@ -8283,7 +9593,7 @@ async function firstExisting2(candidates) {
   for (const candidate2 of candidates) {
     try {
       await access8(candidate2);
-      return path39.resolve(candidate2);
+      return path40.resolve(candidate2);
     } catch {
     }
   }
@@ -8292,7 +9602,7 @@ async function firstExisting2(candidates) {
 async function findDashboardDataScript(cwd, env = process.env, options = {}) {
   const startPath = await findDashboardStart(cwd, env, options);
   if (startPath) {
-    const sibling = path39.join(path39.dirname(startPath), "dashboard-data.mjs");
+    const sibling = path40.join(path40.dirname(startPath), "dashboard-data.mjs");
     try {
       await access8(sibling);
       return sibling;
@@ -8307,7 +9617,7 @@ async function loadDashboardSnapshot(opts) {
   const env = opts.env ?? process.env;
   const timeout = dataScriptTimeoutMs(env);
   const run = opts.execFileFn ?? execFile6;
-  const snapshotRoot = path39.resolve(opts.snapshotRoot);
+  const snapshotRoot = path40.resolve(opts.snapshotRoot);
   return new Promise((resolve3) => {
     run(
       process.execPath,
@@ -8449,11 +9759,14 @@ function buildMcTuiView(snapshot, error = null) {
 var CLEAR_HOME = "\x1B[2J\x1B[H";
 var HIDE_CURSOR = "\x1B[?25l";
 var SHOW_CURSOR = "\x1B[?25h";
-function isQuitKey(chunk) {
+function quitKeyOf(chunk) {
   const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
-  return text === "q" || text === "Q" || text === "";
+  if (text === "q" || text === "Q") return "q";
+  if (text === "") return "Ctrl-C";
+  return null;
 }
 async function runMcTuiLoop(opts) {
+  const render = opts.render ?? ((view, renderOpts) => renderMcTui(view, renderOpts));
   const live = shouldLiveRefresh({
     once: opts.once,
     stdoutIsTTY: opts.stdoutIsTTY,
@@ -8461,12 +9774,14 @@ async function runMcTuiLoop(opts) {
   });
   let frameIndex = 0;
   let inFlight = false;
-  const paint2 = async (clear) => {
-    if (inFlight) return;
+  let stopped = false;
+  const paint3 = async (clear) => {
+    if (inFlight || stopped) return;
     inFlight = true;
     try {
       const view = await opts.loadView();
-      const frame = renderMcTui(view, {
+      if (stopped) return;
+      const frame = render(view, {
         ...opts.renderOpts,
         stdoutIsTTY: opts.stdoutIsTTY,
         frameIndex
@@ -8476,6 +9791,7 @@ async function runMcTuiLoop(opts) {
 ` : `${frame}
 `);
     } catch (err) {
+      if (stopped) return;
       const message = err instanceof Error ? err.message : String(err);
       const frame = renderMcTui(buildMcTuiView(null, message), {
         ...opts.renderOpts,
@@ -8490,7 +9806,7 @@ async function runMcTuiLoop(opts) {
       inFlight = false;
     }
   };
-  await paint2(false);
+  await paint3(false);
   if (!live) return null;
   opts.hooks.write(HIDE_CURSOR);
   const intervalMs = opts.intervalMs ?? PERIODIC_REFRESH_MS;
@@ -8499,7 +9815,7 @@ async function runMcTuiLoop(opts) {
   let timer;
   try {
     timer = setInt(() => {
-      void paint2(true);
+      void paint3(true);
     }, intervalMs);
   } catch (err) {
     opts.hooks.write(SHOW_CURSOR);
@@ -8508,7 +9824,6 @@ async function runMcTuiLoop(opts) {
   const stdin = opts.hooks.stdin;
   const attachQuit = Boolean(stdin?.isTTY);
   let quitListener;
-  let stopped = false;
   const restoreStdin = () => {
     if (!stdin || !attachQuit) return;
     if (quitListener) {
@@ -8532,14 +9847,24 @@ async function runMcTuiLoop(opts) {
     stdin.setRawMode?.(true);
     stdin.resume?.();
     quitListener = (chunk) => {
-      if (!isQuitKey(chunk)) return;
+      if (stopped) return;
+      if (opts.hooks.onKey?.(chunk)) return;
+      const key = quitKeyOf(chunk);
+      if (!key) return;
       stop();
+      if (opts.hooks.onQuit) {
+        opts.hooks.onQuit(key);
+        return;
+      }
       const exitFn = opts.hooks.exit ?? ((code) => process.exit(code));
       exitFn(0);
     };
     stdin.on("data", quitListener);
   }
-  return { stop };
+  return {
+    stop,
+    repaint: () => stopped ? Promise.resolve() : paint3(true)
+  };
 }
 
 // src/commands/mission-control.ts
@@ -8615,13 +9940,13 @@ var missionControlCommand = defineCommand13({
 });
 
 // src/commands/monitors.ts
-import path41 from "path";
+import path42 from "path";
 import { defineCommand as defineCommand14 } from "citty";
 
 // src/invariants/monitors-untriaged.ts
 import { execFile as execFile7 } from "child_process";
-import { readFile as readFile21, readdir as readdir8, stat as stat5 } from "fs/promises";
-import path40 from "path";
+import { readFile as readFile23, readdir as readdir10, stat as stat5 } from "fs/promises";
+import path41 from "path";
 import { promisify as promisify6 } from "util";
 
 // src/invariants/triage-heading.ts
@@ -8645,7 +9970,7 @@ function hasOpenGaps(content) {
 }
 async function listMonitorFiles(memoryDir) {
   try {
-    const names = await readdir8(memoryDir);
+    const names = await readdir10(memoryDir);
     return names.filter((n) => n.startsWith("plan-monitor-") && n.endsWith(".md")).sort();
   } catch {
     return [];
@@ -8662,7 +9987,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 = path40.basename(file);
+      const base = path41.basename(file);
       if (base.startsWith("plan-monitor-") && base.endsWith(".md")) {
         names.add(base);
       }
@@ -8685,15 +10010,15 @@ function monitorSlugFromName(fileName) {
   return fileName.replace(/^plan-monitor-/, "").replace(/\.md$/, "").toLowerCase();
 }
 async function selectUntriagedMonitors(rootDir) {
-  const root = path40.resolve(rootDir);
-  const memoryDir = path40.join(root, ".cursor", "memory");
+  const root = path41.resolve(rootDir);
+  const memoryDir = path41.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 = path40.join(memoryDir, name);
+    const abs = path41.join(memoryDir, name);
     try {
-      const [content, st] = await Promise.all([readFile21(abs, "utf8"), stat5(abs)]);
+      const [content, st] = await Promise.all([readFile23(abs, "utf8"), stat5(abs)]);
       byName.set(name, { content, mtimeMs: st.mtimeMs });
     } catch {
     }
@@ -8706,7 +10031,7 @@ async function selectUntriagedMonitors(rootDir) {
   const gitFreshSet = [...gitFresh].filter(untriaged).sort();
   let handoff = "";
   try {
-    handoff = await readFile21(path40.join(root, ".cursor", "HANDOFF.md"), "utf8");
+    handoff = await readFile23(path41.join(root, ".cursor", "HANDOFF.md"), "utf8");
   } catch {
     handoff = "";
   }
@@ -8726,8 +10051,8 @@ async function selectUntriagedMonitors(rootDir) {
     const row = byName.get(name);
     if (!row) continue;
     entries.push({
-      path: path40.join(memoryDir, name),
-      relativePath: path40.relative(root, path40.join(memoryDir, name)).split(path40.sep).join("/"),
+      path: path41.join(memoryDir, name),
+      relativePath: path41.relative(root, path41.join(memoryDir, name)).split(path41.sep).join("/"),
       mtimeMs: row.mtimeMs,
       hasTriageHeading: false,
       hasOpenGaps: hasOpenGaps(row.content),
@@ -8773,7 +10098,7 @@ var monitorsCommand = defineCommand14({
       process.exitCode = 2;
       return;
     }
-    const result = await selectUntriagedMonitors(path41.resolve(args.cwd));
+    const result = await selectUntriagedMonitors(path42.resolve(args.cwd));
     if (args.json) {
       console.log(JSON.stringify(result, null, 2));
       return;
@@ -8789,7 +10114,7 @@ var monitorsCommand = defineCommand14({
 });
 
 // src/commands/plan-index.ts
-import path42 from "path";
+import path43 from "path";
 import { defineCommand as defineCommand15 } from "citty";
 var planIndexCommand = defineCommand15({
   meta: {
@@ -8808,7 +10133,7 @@ var planIndexCommand = defineCommand15({
     }
   },
   async run({ args }) {
-    const root = path42.resolve(args.cwd);
+    const root = path43.resolve(args.cwd);
     const index = await writePlanIndex(root);
     if (args.json) {
       console.log(JSON.stringify(index, null, 2));
@@ -8824,90 +10149,760 @@ var planIndexCommand = defineCommand15({
 });
 
 // src/commands/run-plan.ts
-import path48 from "path";
+import path50 from "path";
 import { defineCommand as defineCommand16 } from "citty";
 
 // src/plan-loop/backends.ts
-import { execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
+import { execFileSync as execFileSync2, spawn as spawn7 } from "child_process";
 import { createWriteStream } from "fs";
 import { access as access9 } from "fs/promises";
-import path43 from "path";
+import path44 from "path";
+import { StringDecoder as StringDecoder3 } from "string_decoder";
+
+// src/plan-loop/hitl-relay.ts
+import { createInterface } from "readline";
 import { StringDecoder } from "string_decoder";
-var CLAUDE_ENV_PASSTHROUGH = [
-  "ANTHROPIC_BASE_URL",
-  "ANTHROPIC_AUTH_TOKEN",
-  "ANTHROPIC_API_KEY"
+var HITL_GATE_LINE_RE = /^HITL_GATE:\s*([a-z0-9-]+)\s*\|\s*(.+)$/;
+var HITL_REPLY_PREFIX = "HITL_REPLY:";
+var RESERVED_GATE_IDS = ["git-prod", "kit-prod"];
+var FALLBACK_ASK_ID = "prose-fallback";
+var HITL_UNANSWERED_EXIT_CODE = 4;
+var HITL_SIGINT_EXIT_CODE = 130;
+var NUMBERED_LINE_RE = /^\s*(\d+)\.\s+(.+?)\s*$/;
+var FALLBACK_WORDING_RES = [
+  /reply with (?:the |a )?number/i,
+  /ask questions is not available/i,
+  /skip or cancel means stop/i
 ];
-function redactSecrets(text, secrets) {
-  let out = text;
-  const ordered = secrets.filter((s) => s.value.length > 0).sort((a, b) => b.value.length - a.value.length);
-  for (const s of ordered) {
-    out = out.split(s.value).join(`[${s.label}]`);
+var TICK_SENTINEL_RE = /LOOP_TICK_RESULT:/;
+function parseHitlGateLine(line) {
+  const m = HITL_GATE_LINE_RE.exec(line.trim());
+  if (!m?.[1] || !m[2]) return null;
+  const labels = m[2].split("|").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (labels.length === 0) return null;
+  return { askId: m[1], labels, detection: "sentinel" };
+}
+function findHitlGateInText(text) {
+  let last = null;
+  for (const line of text.split(/\r?\n/)) {
+    const gate = parseHitlGateLine(line);
+    if (gate) last = gate;
   }
-  return out;
+  return last;
 }
-var REDACT_HOLD_MAX_CHARS = 64 * 1024;
-var RedactingStreamBuffer = class {
+function cleanFallbackLabel(raw) {
+  let label = raw.trim();
+  const bold3 = /^\*\*(.+?)\*\*/.exec(label);
+  if (bold3?.[1]) label = bold3[1];
+  else label = label.replace(/\*\*/g, "").replace(/^`(.+)`$/, "$1");
+  label = label.split(/\s+[—–]\s+/)[0] ?? label;
+  return label.replace(/[.:]+$/, "").trim();
+}
+function detectFallbackGate(text) {
+  if (!FALLBACK_WORDING_RES.some((re) => re.test(text))) return null;
+  const labels = [];
+  let expected = 1;
+  for (const line of text.split(/\r?\n/)) {
+    const m = NUMBERED_LINE_RE.exec(line);
+    if (!m?.[1] || !m[2]) continue;
+    const n = Number(m[1]);
+    if (n === 1) {
+      labels.length = 0;
+      expected = 1;
+    }
+    if (n !== expected) continue;
+    labels.push(cleanFallbackLabel(m[2]));
+    expected += 1;
+  }
+  if (labels.length < 2) return null;
+  return { askId: FALLBACK_ASK_ID, labels, detection: "fallback" };
+}
+function detectHitlGate(resultText, assistantTexts) {
+  if (TICK_SENTINEL_RE.test(resultText)) return null;
+  const fromResult = findHitlGateInText(resultText);
+  if (fromResult) return fromResult;
+  for (let i = assistantTexts.length - 1; i >= 0; i -= 1) {
+    const text = assistantTexts[i] ?? "";
+    if (TICK_SENTINEL_RE.test(text)) return null;
+    const gate = findHitlGateInText(text);
+    if (gate) return gate;
+  }
+  const fallback = detectFallbackGate(resultText);
+  if (fallback) return fallback;
+  for (let i = assistantTexts.length - 1; i >= 0; i -= 1) {
+    const gate = detectFallbackGate(assistantTexts[i] ?? "");
+    if (gate) return gate;
+  }
+  return null;
+}
+function isReservedGateId(askId) {
+  return RESERVED_GATE_IDS.includes(askId);
+}
+var STOP_WORDS = /* @__PURE__ */ new Set(["skip", "cancel"]);
+function resolveOperatorAnswer(input, labels) {
+  const text = input.trim();
+  if (!text) return { kind: "stop", cause: "empty" };
+  const exact = labels.indexOf(text);
+  if (exact !== -1) return { kind: "reply", n: exact + 1, label: labels[exact] ?? text };
+  if (/^\d+$/.test(text)) {
+    const n = Number(text);
+    const label = labels[n - 1];
+    if (n >= 1 && label !== void 0) return { kind: "reply", n, label };
+  }
+  const lower = text.toLowerCase();
+  if (STOP_WORDS.has(lower)) return { kind: "stop", cause: lower };
+  return { kind: "other", text };
+}
+function formatHitlReply(askId, answer) {
+  if (answer.kind === "reply") {
+    return `${HITL_REPLY_PREFIX} ${askId} | operator reply ${answer.n} | ${answer.label}`;
+  }
+  if (answer.kind === "other") {
+    return `${HITL_REPLY_PREFIX} ${askId} | operator reply other | ${answer.text}`;
+  }
+  throw new Error("a stop answer has no reply stamp");
+}
+function createTerminalAnswerReader(opts = {}) {
+  return (_gate, readOpts) => new Promise((resolve3) => {
+    const input = opts.input ?? process.stdin;
+    const output = opts.output ?? process.stdout;
+    const terminal = opts.terminal ?? Boolean(input.isTTY);
+    const rl = createInterface({ input, output, terminal });
+    let settled = false;
+    const finish = (answer) => {
+      if (settled) return;
+      settled = true;
+      readOpts.signal?.removeEventListener("abort", onAbort);
+      rl.close();
+      if (typeof input.pause === "function") {
+        input.pause();
+      }
+      resolve3(answer);
+    };
+    const onAbort = () => finish({ kind: "eof" });
+    if (readOpts.signal?.aborted) {
+      onAbort();
+      return;
+    }
+    readOpts.signal?.addEventListener("abort", onAbort, { once: true });
+    rl.on("SIGINT", () => finish({ kind: "sigint" }));
+    rl.on("close", () => finish({ kind: "eof" }));
+    rl.question("> ", (line) => finish({ kind: "line", text: line }));
+  });
+}
+function emptyHitlRecord() {
+  return { replies: [], fallbackDetections: 0 };
+}
+function operatorStop(askId, cause) {
+  return {
+    askId,
+    cause,
+    message: `stopped-by-operator: gate ${askId}, no reply (${cause})`,
+    exitCode: cause === "SIGINT" ? HITL_SIGINT_EXIT_CODE : HITL_UNANSWERED_EXIT_CODE
+  };
+}
+function operatorQuitStop(key) {
+  return {
+    askId: "none",
+    cause: "quit",
+    message: `stopped-by-operator: quit (${key}), no gate open`,
+    exitCode: HITL_SIGINT_EXIT_CODE
+  };
+}
+function unansweredStop(askId, cause) {
+  return {
+    askId,
+    cause,
+    message: `stopped: unanswered gate (${cause})`,
+    exitCode: HITL_UNANSWERED_EXIT_CODE
+  };
+}
+function noRelayStop(askId, backend) {
+  return {
+    askId,
+    cause: "no relay",
+    message: `stopped: unanswered gate (backend ${backend} has no relay)`,
+    exitCode: HITL_UNANSWERED_EXIT_CODE
+  };
+}
+function reservedStop(askId) {
+  return {
+    askId,
+    cause: "reserved",
+    message: `stopped: gate ${askId} is operator-gated; run the /${askId} slash yourself (never headless)`,
+    exitCode: HITL_UNANSWERED_EXIT_CODE
+  };
+}
+function formatGatePrompt(gate) {
+  const head = gate.detection === "fallback" ? `HITL gate (prose fallback, ask-id ${gate.askId})` : `HITL gate ${gate.askId}`;
+  const lines = [
+    "",
+    `${head}: reply with the number or the label; anything else is sent as "other"; empty, skip, cancel or Ctrl-C stops the run.`,
+    ...gate.labels.map((label, i) => `  ${i + 1}. ${label}`)
+  ];
+  return `${lines.join("\n")}
+`;
+}
+async function askOperator(gate, opts) {
+  if (isReservedGateId(gate.askId)) return { kind: "stop", stop: reservedStop(gate.askId) };
+  if (opts.policy === "off") return { kind: "stop", stop: unansweredStop(gate.askId, "--no-hitl") };
+  if (!opts.isTTY) return { kind: "stop", stop: unansweredStop(gate.askId, "no TTY") };
+  opts.onPromptStart?.();
+  let raw;
+  try {
+    opts.write(formatGatePrompt(gate));
+    raw = await opts.readAnswer(gate, { signal: opts.signal });
+  } finally {
+    opts.onPromptEnd?.();
+  }
+  if (opts.signal?.aborted) {
+    return { kind: "stop", stop: unansweredStop(gate.askId, "child exited") };
+  }
+  if (raw.kind === "eof") return { kind: "stop", stop: operatorStop(gate.askId, "EOF") };
+  if (raw.kind === "sigint") return { kind: "stop", stop: operatorStop(gate.askId, "SIGINT") };
+  const answer = resolveOperatorAnswer(raw.text, gate.labels);
+  if (answer.kind === "stop") return { kind: "stop", stop: operatorStop(gate.askId, answer.cause) };
+  const line = formatHitlReply(gate.askId, answer);
+  const stamp3 = {
+    askId: gate.askId,
+    reply: answer.kind === "reply" ? `operator reply ${answer.n}` : "operator reply other",
+    label: answer.kind === "reply" ? answer.label : answer.text,
+    line,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    detection: gate.detection
+  };
+  return { kind: "reply", stamp: stamp3 };
+}
+function formatHitlSummary(record) {
+  if (!record) return [];
+  const lines = record.replies.map(
+    (s) => `HITL ${s.askId}: ${s.reply} (${s.label}) ${s.at}${s.detection === "fallback" ? " [fallback]" : ""}`
+  );
+  if (record.fallbackDetections > 0) {
+    lines.push(`hitl-detect: prose-fallback x${record.fallbackDetections}`);
+  }
+  if (record.stop) lines.push(record.stop.message);
+  return lines;
+}
+function hitlExitCode(childExitCode, record) {
+  if (record?.stop) return record.stop.exitCode;
+  return childExitCode;
+}
+function userEventLine(text) {
+  return `${JSON.stringify({ type: "user", message: { role: "user", content: text } })}
+`;
+}
+var TurnWatcher = class {
+  constructor(onResult) {
+    this.onResult = onResult;
+  }
+  onResult;
   pending = "";
+  assistantTexts = [];
   decoder = new StringDecoder("utf8");
-  secrets;
-  keep;
-  constructor(secrets) {
-    this.secrets = secrets.filter((s) => s.value.length > 0);
-    this.keep = this.secrets.length > 0 ? Math.max(...this.secrets.map((s) => s.value.length)) - 1 : 0;
-  }
-  /** Append a chunk; returns the redacted text that is safe to emit now. */
-  push(chunk) {
+  feed(chunk) {
     const text = typeof chunk === "string" ? chunk : this.decoder.write(chunk);
-    if (this.secrets.length === 0) return text;
-    this.pending += text;
-    let cut = this.pending.lastIndexOf("\n") + 1;
-    if (cut === 0) {
-      if (this.pending.length < REDACT_HOLD_MAX_CHARS) return "";
-      cut = this.pending.length - this.keep;
+    if (!text) return;
+    const combined = this.pending + text;
+    const lines = combined.split("\n");
+    this.pending = lines.pop() ?? "";
+    for (const line of lines) this.take(line);
+  }
+  end() {
+    const rest = this.pending + this.decoder.end();
+    this.pending = "";
+    if (rest.trim()) this.take(rest);
+  }
+  take(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) return;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      return;
     }
-    if (cut <= 0) return "";
-    let moved = true;
-    while (moved) {
-      moved = false;
-      for (const s of this.secrets) {
-        let idx = this.pending.indexOf(s.value, Math.max(0, cut - s.value.length + 1));
-        while (idx !== -1 && idx < cut) {
-          if (idx + s.value.length > cut) {
-            cut = idx;
-            moved = true;
-            break;
+    if (typeof event !== "object" || event === null) return;
+    const ev = event;
+    if (ev.type === "assistant") {
+      const content = ev.message?.content;
+      if (typeof content === "string") {
+        if (content) this.assistantTexts.push(content);
+      } else if (Array.isArray(content)) {
+        for (const part of content) {
+          if (part && typeof part === "object" && part.type === "text" && typeof part.text === "string") {
+            this.assistantTexts.push(part.text);
           }
-          idx = this.pending.indexOf(s.value, idx + 1);
         }
-        if (moved) break;
       }
+      return;
+    }
+    if (ev.type === "result") {
+      const texts = this.assistantTexts;
+      this.assistantTexts = [];
+      this.onResult({
+        resultText: typeof ev.result === "string" ? ev.result : "",
+        assistantTexts: texts,
+        isError: ev.is_error === true,
+        subtype: typeof ev.subtype === "string" ? ev.subtype : null
+      });
     }
-    if (cut <= 0) return "";
-    const out = redactSecrets(this.pending.slice(0, cut), this.secrets);
-    this.pending = this.pending.slice(cut);
-    return out;
-  }
-  /** Emit whatever is still held back (call once, on stream end). */
-  flush() {
-    const rest = this.pending + this.decoder.end();
-    this.pending = "";
-    return this.secrets.length === 0 ? rest : redactSecrets(rest, this.secrets);
   }
 };
-function mergeChildEnv(overrides) {
-  const merged = { ...process.env };
-  if (!overrides) return merged;
-  for (const [key, value] of Object.entries(overrides)) {
-    if (value === void 0) delete merged[key];
-    else merged[key] = value;
-  }
-  return merged;
+
+// src/plan-loop/stream-render.ts
+import { StringDecoder as StringDecoder2 } from "string_decoder";
+import { trueColor as trueColor2 } from "kolorist";
+
+// src/plan-loop/stream-events.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var CLAUDE_NESTED_SESSION_KEYS = [
-  "CLAUDECODE",
-  "CLAUDE_CODE_SESSION_ID",
-  "CLAUDE_CODE_CHILD_SESSION",
+function asString2(value) {
+  return typeof value === "string" ? value : null;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+var SUMMARY_KEYS = [
+  "command",
+  "file_path",
+  "path",
+  "pattern",
+  "query",
+  "url",
+  "description",
+  "prompt",
+  "content"
+];
+function summarizeToolInput(input) {
+  if (typeof input === "string") return oneLine(input);
+  if (!isRecord(input)) return input === void 0 ? "" : oneLine(JSON.stringify(input));
+  for (const key of SUMMARY_KEYS) {
+    const value = input[key];
+    if (typeof value === "string" && value.trim()) return oneLine(value);
+  }
+  const keys = Object.keys(input);
+  if (keys.length === 0) return "";
+  return oneLine(JSON.stringify(input));
+}
+function firstLineOfContent(content) {
+  if (typeof content === "string") return firstNonEmptyLine(content);
+  if (Array.isArray(content)) {
+    for (const part of content) {
+      if (isRecord(part) && typeof part.text === "string") {
+        const line = firstNonEmptyLine(part.text);
+        if (line) return line;
+      }
+    }
+    return "";
+  }
+  if (isRecord(content)) return oneLine(JSON.stringify(content));
+  return "";
+}
+function firstNonEmptyLine(text) {
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed) return trimmed;
+  }
+  return "";
+}
+function parseAssistant(event) {
+  const message = event.message;
+  const content = isRecord(message) ? message.content : void 0;
+  if (typeof content === "string") return content ? [{ kind: "text", text: content }] : [];
+  if (!Array.isArray(content)) return [{ kind: "silent" }];
+  const out = [];
+  for (const part of content) {
+    if (!isRecord(part)) continue;
+    const type = asString2(part.type);
+    if (type === "text" && typeof part.text === "string") {
+      if (part.text) out.push({ kind: "text", text: part.text });
+    } else if (type === "tool_use" || type === "server_tool_use") {
+      out.push({
+        kind: "tool_use",
+        name: asString2(part.name) ?? "tool",
+        summary: summarizeToolInput(part.input)
+      });
+    }
+  }
+  return out.length > 0 ? out : [{ kind: "silent" }];
+}
+var HITL_REPLY_PREFIX2 = "HITL_REPLY:";
+function parseUser(event) {
+  const message = event.message;
+  const content = isRecord(message) ? message.content : void 0;
+  if (typeof content === "string") {
+    if (event.isReplay === true && content.startsWith(HITL_REPLY_PREFIX2)) {
+      return [{ kind: "hitl_reply", line: oneLine(content) }];
+    }
+    return [{ kind: "prompt", chars: content.length }];
+  }
+  if (!Array.isArray(content)) return [{ kind: "silent" }];
+  const out = [];
+  let promptChars = 0;
+  for (const part of content) {
+    if (!isRecord(part)) continue;
+    const type = asString2(part.type);
+    if (type === "tool_result") {
+      out.push({
+        kind: "tool_result",
+        ok: part.is_error !== true,
+        line: firstLineOfContent(part.content)
+      });
+    } else if (type === "text" && typeof part.text === "string") {
+      if (event.isReplay === true && part.text.startsWith(HITL_REPLY_PREFIX2)) {
+        out.push({ kind: "hitl_reply", line: oneLine(part.text) });
+        continue;
+      }
+      promptChars += part.text.length;
+    }
+  }
+  if (promptChars > 0) out.push({ kind: "prompt", chars: promptChars });
+  return out.length > 0 ? out : [{ kind: "silent" }];
+}
+function parseResult(event) {
+  const isError = event.is_error === true;
+  const subtype = asString2(event.subtype);
+  return {
+    kind: "result",
+    ok: !isError,
+    status: subtype ?? (isError ? "error" : "success"),
+    costUsd: asNumber(event.total_cost_usd),
+    durationMs: asNumber(event.duration_ms),
+    apiMs: asNumber(event.duration_api_ms),
+    turns: asNumber(event.num_turns)
+  };
+}
+function parseSystem(event) {
+  const subtype = asString2(event.subtype) ?? "";
+  if (!subtype.startsWith("hook_")) return { kind: "silent" };
+  const phase = subtype.slice("hook_".length);
+  const name = asString2(event.hook_name) ?? asString2(event.hook_event) ?? "hook";
+  const details = [];
+  const outcome = asString2(event.outcome);
+  if (outcome) details.push(outcome);
+  const exitCode = asNumber(event.exit_code);
+  if (exitCode !== void 0) details.push(`exit ${exitCode}`);
+  return { kind: "hook", name, phase, detail: details.join(", ") };
+}
+function percent(value) {
+  const n = asNumber(value);
+  return n === void 0 ? null : `${Math.round(n * 100)}%`;
+}
+function parseRateLimit(event) {
+  const info = isRecord(event.rate_limit_info) ? event.rate_limit_info : event;
+  const status = asString2(info.status) ?? "unknown";
+  const type = asString2(info.rateLimitType);
+  const parts = [];
+  if (type) parts.push(type);
+  parts.push(status);
+  const windows = isRecord(info.unifiedWindows) ? info.unifiedWindows : null;
+  if (windows) {
+    for (const [name, window] of Object.entries(windows)) {
+      if (!isRecord(window)) continue;
+      const used = percent(window.utilization);
+      if (used) parts.push(`${name} ${used}`);
+    }
+  }
+  return { kind: "rate_limit", line: parts.join(" \xB7 "), severe: status !== "allowed" };
+}
+function parseCursorToolCall(event) {
+  const call = isRecord(event.tool_call) ? event.tool_call : null;
+  const entry = call ? Object.entries(call).find(([, v]) => isRecord(v)) : void 0;
+  const name = entry ? entry[0].replace(/ToolCall$/, "") : "tool";
+  const body = entry && isRecord(entry[1]) ? entry[1] : {};
+  const subtype = asString2(event.subtype) ?? "";
+  if (subtype === "started") {
+    return { kind: "tool_use", name, summary: summarizeToolInput(body.args) };
+  }
+  if (subtype === "completed") {
+    const result = isRecord(body.result) ? body.result : null;
+    const failed = result !== null && ("error" in result || "failure" in result || "rejected" in result);
+    let line = "";
+    if (result) {
+      const payload = failed ? result.error ?? result.failure ?? result.rejected : result.success;
+      line = firstLineOfContent(
+        typeof payload === "string" ? payload : payload === void 0 ? result : payload
+      );
+    }
+    return { kind: "tool_result", ok: !failed, line };
+  }
+  return { kind: "silent" };
+}
+function parseStreamLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith("{")) return [{ kind: "unparsed" }];
+  let event;
+  try {
+    event = JSON.parse(trimmed);
+  } catch {
+    return [{ kind: "unparsed" }];
+  }
+  if (!isRecord(event)) return [{ kind: "unparsed" }];
+  switch (asString2(event.type)) {
+    case "assistant":
+      return parseAssistant(event);
+    case "user":
+      return parseUser(event);
+    case "result":
+      return [parseResult(event)];
+    case "system":
+      return [parseSystem(event)];
+    case "rate_limit_event":
+      return [parseRateLimit(event)];
+    case "tool_call":
+      return [parseCursorToolCall(event)];
+    default:
+      return [{ kind: "silent" }];
+  }
+}
+
+// src/plan-loop/stream-render.ts
+var PENDING_MAX_CHARS = 4 * 1024 * 1024;
+var MIN_COLUMNS2 = 40;
+function paint2(hex, text, color) {
+  if (!color) return text;
+  return withKoloristColor(
+    () => trueColor2(
+      Number.parseInt(hex.slice(1, 3), 16),
+      Number.parseInt(hex.slice(3, 5), 16),
+      Number.parseInt(hex.slice(5, 7), 16)
+    )(text)
+  );
+}
+function truncate(text, width) {
+  if (text.length <= width) return text;
+  return `${text.slice(0, Math.max(1, width - 1))}\u2026`;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const seconds = ms / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const rest = Math.round(seconds - minutes * 60);
+  return `${minutes}m ${rest}s`;
+}
+function formatCost(usd) {
+  return `$${usd.toFixed(usd < 0.1 ? 4 : 2)}`;
+}
+function renderStreamEvent(event, opts) {
+  const width = Math.max(MIN_COLUMNS2, opts.columns);
+  const color = opts.color;
+  switch (event.kind) {
+    case "text":
+      return event.text;
+    case "tool_use": {
+      const head = `${SPACE_MARKS.diamond} ${event.name}`;
+      const summary = truncate(event.summary, width - head.length - 3);
+      return paint2(HELMET_ACCENT, summary ? `${head} ${SPACE_MARKS.tick} ${summary}` : head, color);
+    }
+    case "tool_result": {
+      const label = event.ok ? "ok" : "error";
+      const head = `  ${SPACE_MARKS.tick} ${label}`;
+      const line = truncate(oneLine(event.line), width - head.length - 3);
+      const text = line ? `${head} ${SPACE_MARKS.tick} ${line}` : head;
+      return paint2(event.ok ? LABEL_MUTED : STATUS_ERR, text, color);
+    }
+    case "result": {
+      const parts = [`${SPACE_MARKS.star} result ${event.status}`];
+      if (event.costUsd !== void 0) parts.push(formatCost(event.costUsd));
+      if (event.durationMs !== void 0) parts.push(formatDuration(event.durationMs));
+      else if (event.apiMs !== void 0) parts.push(`${formatDuration(event.apiMs)} api`);
+      if (event.turns !== void 0) {
+        parts.push(`${event.turns} turn${event.turns === 1 ? "" : "s"}`);
+      }
+      return paint2(event.ok ? STATUS_OK : STATUS_ERR, parts.join(` ${SPACE_MARKS.tick} `), color);
+    }
+    case "hook": {
+      const detail = event.detail ? ` (${event.detail})` : "";
+      return paint2(
+        LABEL_MUTED,
+        truncate(`${SPACE_MARKS.tick} hook ${event.name} ${event.phase}${detail}`, width),
+        color
+      );
+    }
+    case "rate_limit":
+      return paint2(
+        event.severe ? STATUS_ERR : STATUS_WARN,
+        truncate(`! rate limit ${SPACE_MARKS.tick} ${event.line}`, width),
+        color
+      );
+    case "prompt":
+      return paint2(
+        LABEL_MUTED,
+        `${SPACE_MARKS.tick} prompt sent ${SPACE_MARKS.tick} ${event.chars} chars`,
+        color
+      );
+    case "hitl_reply":
+      return paint2(HELMET_ACCENT, truncate(`\u21A9 ${event.line}`, width), color);
+    default:
+      return null;
+  }
+}
+var StreamRenderer = class {
+  pending = "";
+  dropped = false;
+  textOpen = false;
+  decoder = new StringDecoder2("utf8");
+  write;
+  color;
+  columns;
+  constructor(opts = {}) {
+    this.write = opts.write ?? ((text) => process.stdout.write(text));
+    this.color = shouldUseWelcomeColor({
+      stdoutIsTTY: opts.isTTY ?? Boolean(process.stdout.isTTY),
+      env: opts.env
+    });
+    this.columns = opts.columns ?? process.stdout.columns ?? 80;
+  }
+  feed(chunk) {
+    try {
+      const text = typeof chunk === "string" ? chunk : this.decoder.write(chunk);
+      if (!text) return;
+      const combined = this.pending + text;
+      const lines = combined.split("\n");
+      this.pending = lines.pop() ?? "";
+      for (const line of lines) {
+        if (this.dropped) {
+          this.dropped = false;
+          continue;
+        }
+        this.renderLine(line);
+      }
+      if (this.pending.length > PENDING_MAX_CHARS) {
+        this.pending = "";
+        this.dropped = true;
+      }
+    } catch {
+    }
+  }
+  end() {
+    try {
+      const rest = this.pending + this.decoder.end();
+      this.pending = "";
+      if (rest && !this.dropped) this.renderLine(rest);
+      this.dropped = false;
+      this.closeText();
+    } catch {
+    }
+  }
+  renderLine(line) {
+    for (const event of parseStreamLine(line)) {
+      const rendered = renderStreamEvent(event, { color: this.color, columns: this.columns });
+      if (rendered === null) continue;
+      if (event.kind === "text") {
+        this.write(rendered);
+        this.textOpen = !rendered.endsWith("\n");
+        continue;
+      }
+      this.closeText();
+      this.write(`${rendered}
+`);
+    }
+  }
+  closeText() {
+    if (!this.textOpen) return;
+    this.textOpen = false;
+    this.write("\n");
+  }
+};
+function createStreamRenderer(opts = {}) {
+  return new StreamRenderer(opts);
+}
+
+// src/plan-loop/backends.ts
+var HITL_KILL_GRACE_MS = 5e3;
+function resolveHitlRunOptions(hitl, transport) {
+  return {
+    transport,
+    policy: hitl?.policy ?? "prompt",
+    isTTY: hitl?.isTTY ?? Boolean(process.stdin.isTTY),
+    readAnswer: hitl?.readAnswer ?? createTerminalAnswerReader(),
+    write: hitl?.write ?? ((text) => process.stdout.write(text)),
+    onPromptStart: hitl?.onPromptStart,
+    onPromptEnd: hitl?.onPromptEnd,
+    killAfterMs: hitl?.killAfterMs
+  };
+}
+var CLAUDE_ENV_PASSTHROUGH = [
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_API_KEY"
+];
+function redactSecrets(text, secrets) {
+  let out = text;
+  const ordered = secrets.filter((s) => s.value.length > 0).sort((a, b) => b.value.length - a.value.length);
+  for (const s of ordered) {
+    out = out.split(s.value).join(`[${s.label}]`);
+  }
+  return out;
+}
+var REDACT_HOLD_MAX_CHARS = 64 * 1024;
+var RedactingStreamBuffer = class {
+  pending = "";
+  decoder = new StringDecoder3("utf8");
+  secrets;
+  keep;
+  constructor(secrets) {
+    this.secrets = secrets.filter((s) => s.value.length > 0);
+    this.keep = this.secrets.length > 0 ? Math.max(...this.secrets.map((s) => s.value.length)) - 1 : 0;
+  }
+  /** Append a chunk; returns the redacted text that is safe to emit now. */
+  push(chunk) {
+    const text = typeof chunk === "string" ? chunk : this.decoder.write(chunk);
+    if (this.secrets.length === 0) return text;
+    this.pending += text;
+    let cut = this.pending.lastIndexOf("\n") + 1;
+    if (cut === 0) {
+      if (this.pending.length < REDACT_HOLD_MAX_CHARS) return "";
+      cut = this.pending.length - this.keep;
+    }
+    if (cut <= 0) return "";
+    let moved = true;
+    while (moved) {
+      moved = false;
+      for (const s of this.secrets) {
+        let idx = this.pending.indexOf(s.value, Math.max(0, cut - s.value.length + 1));
+        while (idx !== -1 && idx < cut) {
+          if (idx + s.value.length > cut) {
+            cut = idx;
+            moved = true;
+            break;
+          }
+          idx = this.pending.indexOf(s.value, idx + 1);
+        }
+        if (moved) break;
+      }
+    }
+    if (cut <= 0) return "";
+    const out = redactSecrets(this.pending.slice(0, cut), this.secrets);
+    this.pending = this.pending.slice(cut);
+    return out;
+  }
+  /** Emit whatever is still held back (call once, on stream end). */
+  flush() {
+    const rest = this.pending + this.decoder.end();
+    this.pending = "";
+    return this.secrets.length === 0 ? rest : redactSecrets(rest, this.secrets);
+  }
+};
+function mergeChildEnv(overrides) {
+  const merged = { ...process.env };
+  if (!overrides) return merged;
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === void 0) delete merged[key];
+    else merged[key] = value;
+  }
+  return merged;
+}
+var CLAUDE_NESTED_SESSION_KEYS = [
+  "CLAUDECODE",
+  "CLAUDE_CODE_SESSION_ID",
+  "CLAUDE_CODE_CHILD_SESSION",
   "CLAUDE_CODE_BRIDGE_SESSION_ID"
 ];
 function claudeChildEnv(overrides) {
@@ -8987,9 +10982,11 @@ async function whichBinary(bin) {
   }
 }
 function spawnLogged(command, args, logPath, options = {}) {
-  const spawnFn = options.spawnFn ?? spawn6;
+  const spawnFn = options.spawnFn ?? spawn7;
   const redact = options.redact ?? [];
   const redactedError = (err) => new Error(redactSecrets(String(err), redact));
+  const hitl = options.hitl;
+  const stdinTransport = hitl?.transport.kind === "stdin-stream-json";
   return new Promise((resolve3, reject) => {
     let out;
     let child;
@@ -9001,7 +10998,7 @@ function spawnLogged(command, args, logPath, options = {}) {
         reject(redactedError(err));
       });
       child = spawnFn(command, args, {
-        stdio: ["ignore", "pipe", "pipe"],
+        stdio: [stdinTransport ? "pipe" : "ignore", "pipe", "pipe"],
         ...options.cwd ? { cwd: options.cwd } : {},
         ...options.env ? { env: options.env } : {}
       });
@@ -9009,11 +11006,33 @@ function spawnLogged(command, args, logPath, options = {}) {
       reject(redactedError(err));
       return;
     }
+    const render = options.render ?? createStreamRenderer();
+    const relay = hitl ? createRelay(hitl, child, redactedError) : null;
     const emit = (text) => {
       if (text.length === 0) return;
-      process.stdout.write(text);
       out.write(text);
+      render.feed(text);
+      relay?.feed(text);
     };
+    if (relay?.startError) {
+      out.end();
+      reject(relay.startError);
+      return;
+    }
+    options.onSpawn?.({
+      backend: options.backendId ?? "claude",
+      pid: child.pid,
+      stop: (stop) => {
+        if (relay) {
+          relay.stop(stop);
+          return;
+        }
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+      }
+    });
     const buffers = [];
     const tee = (stream) => {
       if (!stream) return;
@@ -9033,14 +11052,138 @@ function spawnLogged(command, args, logPath, options = {}) {
     });
     child.on("close", (code) => {
       for (const buffer of buffers) emit(buffer.flush());
-      out.end((err) => {
-        const failure = err ?? logError;
-        if (failure) reject(redactedError(failure));
-        else resolve3({ exitCode: code ?? 1 });
-      });
+      render.end();
+      const finish = () => {
+        out.end((err) => {
+          const failure = err ?? logError;
+          if (failure) reject(redactedError(failure));
+          else if (relay) resolve3({ exitCode: code ?? 1, hitl: relay.record });
+          else resolve3({ exitCode: code ?? 1 });
+        });
+      };
+      if (relay) relay.closed().then(finish, finish);
+      else finish();
     });
   });
 }
+function createRelay(hitl, child, redactedError) {
+  const record = emptyHitlRecord();
+  const stdinTransport = hitl.transport.kind === "stdin-stream-json";
+  const abort = new AbortController();
+  const grace = hitl.killAfterMs ?? HITL_KILL_GRACE_MS;
+  let startError = null;
+  let closed = false;
+  let stdinEnded = false;
+  let pendingAsk = null;
+  const timers = [];
+  let resolveClosed = () => {
+  };
+  const closedPromise = new Promise((resolve3) => {
+    resolveClosed = resolve3;
+  });
+  const stdin = child.stdin;
+  if (hitl.transport.kind === "stdin-stream-json") {
+    if (!stdin) {
+      startError = new Error("claude child has no writable stdin (stream-json transport)");
+    } else {
+      stdin.on("error", () => {
+      });
+      try {
+        stdin.write(userEventLine(hitl.transport.firstPrompt));
+      } catch (err) {
+        startError = redactedError(err);
+      }
+    }
+  }
+  const endStdin = () => {
+    if (!stdinTransport || stdinEnded) return;
+    stdinEnded = true;
+    try {
+      stdin?.end();
+    } catch {
+    }
+  };
+  const stopChild = () => {
+    endStdin();
+    const term = setTimeout(() => {
+      if (closed) return;
+      child.kill("SIGTERM");
+      const kill = setTimeout(() => {
+        if (!closed) child.kill("SIGKILL");
+      }, grace);
+      kill.unref?.();
+      timers.push(kill);
+    }, grace);
+    term.unref?.();
+    timers.push(term);
+  };
+  const watcher = new TurnWatcher(({ resultText, assistantTexts }) => {
+    if (record.stop || closed) return;
+    const gate = detectHitlGate(resultText, assistantTexts);
+    if (!gate) {
+      endStdin();
+      return;
+    }
+    if (gate.detection === "fallback") record.fallbackDetections += 1;
+    if (hitl.transport.kind === "none") {
+      record.stop = noRelayStop(gate.askId, hitl.transport.backend);
+      return;
+    }
+    const ask = askOperator(gate, {
+      isTTY: hitl.isTTY,
+      policy: hitl.policy,
+      readAnswer: hitl.readAnswer,
+      write: hitl.write,
+      signal: abort.signal,
+      onPromptStart: hitl.onPromptStart,
+      onPromptEnd: hitl.onPromptEnd
+    }).then(
+      (outcome) => {
+        if (record.stop) return;
+        if (outcome.kind === "stop") {
+          record.stop = outcome.stop;
+          stopChild();
+          return;
+        }
+        if (closed || !stdin) {
+          record.stop = unansweredStop(gate.askId, "child exited");
+          return;
+        }
+        record.replies.push(outcome.stamp);
+        hitl.write(`\u2192 ${outcome.stamp.line}
+`);
+        stdin.write(userEventLine(outcome.stamp.line));
+      },
+      (err) => {
+        record.stop = unansweredStop(gate.askId, "child exited");
+        hitl.write(`hitl relay: ${redactedError(err).message}
+`);
+        stopChild();
+      }
+    );
+    pendingAsk = ask;
+  });
+  child.on("close", () => {
+    closed = true;
+    for (const t of timers) clearTimeout(t);
+    abort.abort();
+    watcher.end();
+    const settle = () => resolveClosed();
+    if (pendingAsk) pendingAsk.then(settle, settle);
+    else settle();
+  });
+  return {
+    startError,
+    record,
+    feed: (text) => watcher.feed(text),
+    closed: () => closedPromise,
+    stop: (stop) => {
+      if (closed || record.stop) return;
+      record.stop = stop;
+      stopChild();
+    }
+  };
+}
 var cursorAgentBackend = {
   id: "cursor-agent",
   async resolve() {
@@ -9065,7 +11208,11 @@ var cursorAgentBackend = {
     return spawnLogged("cursor-agent", args, opts.logPath, {
       spawnFn: opts.spawnFn,
       env,
-      redact: claudeRedactions(env ?? process.env)
+      redact: claudeRedactions(env ?? process.env),
+      hitl: resolveHitlRunOptions(opts.hitl, { kind: "none", backend: "cursor-agent" }),
+      render: opts.render,
+      onSpawn: opts.onSpawn,
+      backendId: "cursor-agent"
     });
   }
 };
@@ -9116,7 +11263,7 @@ function checkClaudeVersion(bin, versionFn = defaultVersionFn) {
   }
   return { ok: true, version };
 }
-function claudeHeadlessArgs(opts) {
+function claudeHeadlessArgs(opts = {}) {
   const args = [
     "-p",
     "--output-format",
@@ -9124,7 +11271,10 @@ function claudeHeadlessArgs(opts) {
     "--verbose",
     "--dangerously-skip-permissions",
     "--permission-prompts",
-    "none"
+    "none",
+    "--input-format",
+    "stream-json",
+    "--replay-user-messages"
   ];
   if (opts.maxTurns !== void 0) {
     args.push("--max-turns", String(opts.maxTurns));
@@ -9135,15 +11285,14 @@ function claudeHeadlessArgs(opts) {
   if (opts.model) {
     args.push("--model", opts.model);
   }
-  args.push(opts.prompt);
   return args;
 }
 async function missingClaudeAdapter(workspace, prompt) {
   const m = /^\/([A-Za-z0-9][A-Za-z0-9_-]*)/.exec(prompt.trimStart());
   if (!m?.[1]) return null;
-  const rel = path43.join(".claude", "commands", `${m[1]}.md`);
+  const rel = path44.join(".claude", "commands", `${m[1]}.md`);
   try {
-    await access9(path43.join(workspace, rel));
+    await access9(path44.join(workspace, rel));
     return null;
   } catch {
     return rel;
@@ -9180,15 +11329,22 @@ var claudeBackend = {
       (key) => `${key}=${env[key] ? "set" : "unset"}`
     ).join(" ");
     log(
-      `claude tick: claude -p (bypass permissions, stream-json${capText ? `, ${capText}` : ""}). env: ${presence}`
+      `claude tick: claude -p (bypass permissions, stream-json, stdin relay${capText ? `, ${capText}` : ""}). env: ${presence}`
     );
-    const args = claudeHeadlessArgs({ prompt: opts.prompt, model: opts.model, ...caps });
+    const args = claudeHeadlessArgs({ model: opts.model, ...caps });
     try {
       return await spawnLogged("claude", args, opts.logPath, {
         cwd: opts.workspace,
         env,
         spawnFn: opts.spawnFn,
-        redact
+        redact,
+        hitl: resolveHitlRunOptions(opts.hitl, {
+          kind: "stdin-stream-json",
+          firstPrompt: opts.prompt
+        }),
+        render: opts.render,
+        onSpawn: opts.onSpawn,
+        backendId: "claude"
       });
     } catch (err) {
       throw new Error(`claude backend failed to start: ${redactSecrets(String(err), redact)}`);
@@ -9258,14 +11414,464 @@ async function detectAgentBackend(requested, whichFn = whichBinary) {
 }
 
 // src/plan-loop/run-loop.ts
-import { mkdir as mkdir6, readFile as readFile24, rm as rm2, unlink as unlink2 } from "fs/promises";
-import path47 from "path";
+import { mkdir as mkdir6, readFile as readFile27, rm as rm2, unlink as unlink2 } from "fs/promises";
+import path49 from "path";
+
+// src/mission-control/live-run.ts
+import { readFile as readFile25 } from "fs/promises";
+import path46 from "path";
+
+// src/plan-loop/plan-state.ts
+import { readFile as readFile24, readdir as readdir11 } from "fs/promises";
+import path45 from "path";
+function countPendingTodos(raw) {
+  const lines = raw.split(/\r?\n/);
+  let inFront = 0;
+  let cont = false;
+  let n = 0;
+  for (const line of lines) {
+    if (line === "---") {
+      inFront += 1;
+      continue;
+    }
+    if (inFront !== 1) continue;
+    const idMatch = line.match(/^- id:\s*(\S+)/);
+    if (idMatch?.[1]) {
+      cont = idMatch[1] === "dogfood-poc";
+    }
+    if (/content:.*[Cc]ont[ií]nuo/.test(line)) {
+      cont = true;
+    }
+    if (/status:\s*(pending|in_progress)\b/.test(line) && !cont) {
+      n += 1;
+    }
+  }
+  return n;
+}
+async function findActivePlanFile(plansDir) {
+  if (!await fileExists(plansDir)) return null;
+  const files = (await readdir11(plansDir)).filter((f) => f.endsWith(".plan.md")).sort();
+  return files[0] ? path45.join(plansDir, files[0]) : null;
+}
+async function readPlan(planPath) {
+  return readFile24(planPath, "utf8");
+}
+
+// src/mission-control/live-feed.ts
+import { StringDecoder as StringDecoder4 } from "string_decoder";
+var LIVE_LOG_CAPACITY = 500;
+var PENDING_MAX_CHARS2 = 4 * 1024 * 1024;
+var LiveRunFeed = class {
+  log;
+  crew;
+  gate = null;
+  hitlReplies = 0;
+  pending = "";
+  dropped = false;
+  decoder = new StringDecoder4("utf8");
+  columns;
+  version = 0;
+  constructor(opts = {}) {
+    this.columns = Math.max(40, opts.columns ?? 80);
+    this.log = new ScrollRegion(opts.capacity ?? LIVE_LOG_CAPACITY);
+    this.crew = {
+      backend: opts.backend ?? null,
+      pid: void 0,
+      phase: "starting",
+      startedAt: (opts.now ?? Date.now)(),
+      toolCalls: 0,
+      currentTool: null,
+      lastResult: null,
+      rateLimit: null,
+      logPath: opts.logPath ?? null
+    };
+  }
+  /** Bumps on every change; a paint loop can skip a frame when nothing moved. */
+  get revision() {
+    return this.version;
+  }
+  setProcess(info) {
+    this.crew.backend = info.backend;
+    this.crew.pid = info.pid;
+    if (this.crew.phase === "starting") this.crew.phase = "running";
+    this.version += 1;
+  }
+  setPhase(phase) {
+    this.crew.phase = phase;
+    this.version += 1;
+  }
+  openGate(gate) {
+    this.gate = gate;
+    this.crew.phase = "gate";
+    this.version += 1;
+  }
+  closeGate() {
+    this.gate = null;
+    if (this.crew.phase === "gate") this.crew.phase = "running";
+    this.version += 1;
+  }
+  /** Append a status line the run lane produced itself (never from the stream). */
+  note(text, kind = "note") {
+    for (const line of text.split(/\r?\n/)) {
+      const trimmed = line.trimEnd();
+      if (trimmed) this.log.push({ kind, text: trimmed });
+    }
+    this.version += 1;
+  }
+  feed(chunk) {
+    try {
+      const text = typeof chunk === "string" ? chunk : this.decoder.write(chunk);
+      if (!text) return;
+      const combined = this.pending + text;
+      const lines = combined.split("\n");
+      this.pending = lines.pop() ?? "";
+      for (const line of lines) {
+        if (this.dropped) {
+          this.dropped = false;
+          continue;
+        }
+        this.takeLine(line);
+      }
+      if (this.pending.length > PENDING_MAX_CHARS2) {
+        this.pending = "";
+        this.dropped = true;
+      }
+    } catch {
+    }
+  }
+  end() {
+    try {
+      const rest = this.pending + this.decoder.end();
+      this.pending = "";
+      if (rest && !this.dropped) this.takeLine(rest);
+      this.dropped = false;
+      this.crew.currentTool = null;
+      if (this.crew.phase !== "done") this.crew.phase = "done";
+      this.version += 1;
+    } catch {
+    }
+  }
+  takeLine(line) {
+    for (const event of parseStreamLine(line)) {
+      const rendered = renderStreamEvent(event, { color: false, columns: this.columns });
+      if (rendered === null) continue;
+      switch (event.kind) {
+        case "text":
+          this.note(rendered, "text");
+          break;
+        case "tool_use":
+          this.crew.toolCalls += 1;
+          this.crew.currentTool = { name: event.name, summary: event.summary };
+          this.note(rendered, "tool");
+          break;
+        case "tool_result":
+          this.crew.currentTool = null;
+          this.note(rendered, event.ok ? "tool" : "error");
+          break;
+        case "result":
+          this.crew.currentTool = null;
+          this.crew.lastResult = { ok: event.ok, status: event.status };
+          if (event.costUsd !== void 0) this.crew.costUsd = event.costUsd;
+          if (event.turns !== void 0) this.crew.turns = event.turns;
+          this.note(rendered, event.ok ? "result" : "error");
+          break;
+        case "hook":
+          this.note(rendered, "hook");
+          break;
+        case "rate_limit":
+          this.crew.rateLimit = { line: event.line, severe: event.severe };
+          this.note(rendered, "rate_limit");
+          break;
+        case "prompt":
+          this.note(rendered, "prompt");
+          break;
+        case "hitl_reply":
+          this.hitlReplies += 1;
+          this.note(rendered, "hitl");
+          break;
+        default:
+          break;
+      }
+    }
+  }
+};
+function emptyLiveMission() {
+  return {
+    planFile: null,
+    mode: null,
+    todos: { done: 0, total: 0 },
+    currentTodo: null,
+    nextTodo: null,
+    queue: null
+  };
+}
+
+// src/mission-control/live-run.ts
+var LIVE_FRAME_MS = 120;
+var LIVE_PROGRESS_TTL_MS = 2e3;
+function shouldUseLiveTui(opts = {}) {
+  if (opts.plain) return false;
+  const env = opts.env ?? process.env;
+  const stdoutIsTTY = opts.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
+  const stdinIsTTY = opts.stdinIsTTY ?? Boolean(process.stdin.isTTY);
+  if (!stdoutIsTTY || !stdinIsTTY) return false;
+  return shouldUseWelcomeColor({ stdoutIsTTY, env });
+}
+function defaultMissionIo() {
+  return {
+    readFile: async (file) => {
+      try {
+        return await readFile25(file, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    findActivePlan: findActivePlanFile
+  };
+}
+var QUEUE_CURSOR_RE = /^- \*\*Queue cursor:\*\*\s*(.+)$/m;
+var QUEUE_STATUS_RE = /^- \*\*Queue status:\*\*\s*(.+)$/m;
+var MODE_RE = /^- \*\*Mode:\*\*\s*(.+)$/m;
+var QUEUE_DONE_STATUSES = /* @__PURE__ */ new Set(["exhausted", "completed", "done"]);
+function firstWord(raw) {
+  const word = raw?.trim().split(/\s+/)[0]?.replace(/[`*]/g, "");
+  return word ? word : null;
+}
+async function readLiveMission(root, io = defaultMissionIo()) {
+  const mission = emptyLiveMission();
+  const handoff = await io.readFile(path46.join(root, ".cursor", "HANDOFF.md")) ?? "";
+  const named = extractHandoffNamedPlans(handoff);
+  mission.mode = firstWord(MODE_RE.exec(handoff)?.[1]);
+  let cursorIndex = null;
+  let cursorPlan = null;
+  const cursorRaw = QUEUE_CURSOR_RE.exec(handoff)?.[1]?.trim() ?? "";
+  const indexMatch = /^(\d+)\b/.exec(cursorRaw);
+  if (indexMatch?.[1]) cursorIndex = Number(indexMatch[1]);
+  const currentMatch = /current:\s*`?([^`()]+?)`?\s*\)/i.exec(cursorRaw);
+  if (currentMatch?.[1]) {
+    const base = currentMatch[1].trim().split("/").pop() ?? "";
+    if (/\.plan\.md$/i.test(base)) cursorPlan = base;
+  }
+  const queueStatus = firstWord(QUEUE_STATUS_RE.exec(handoff)?.[1]);
+  const queue = named.runQueue;
+  const finished = queueStatus !== null && QUEUE_DONE_STATUSES.has(queueStatus.toLowerCase());
+  let checklist = [];
+  if (queue.length > 0) {
+    let cursor = null;
+    if (cursorIndex !== null && cursorIndex >= 0 && cursorIndex < queue.length) {
+      cursor = cursorIndex;
+    } else if (cursorPlan && queue.includes(cursorPlan)) {
+      cursor = queue.indexOf(cursorPlan);
+    }
+    const done = finished ? queue.length : cursor ?? 0;
+    mission.queue = {
+      done,
+      total: queue.length,
+      current: cursor !== null ? queue[cursor] ?? null : cursorPlan,
+      status: queueStatus
+    };
+    checklist = queue.map((file, i) => ({
+      label: file,
+      state: finished || cursor !== null && i < cursor ? "done" : i === cursor ? "current" : "pending"
+    }));
+  }
+  const plansDir = path46.join(root, ".cursor", "plans");
+  const planBase = (mission.queue && !finished ? mission.queue.current : null) ?? named.active;
+  const planPath = planBase ? path46.join(plansDir, planBase) : await io.findActivePlan(plansDir);
+  if (planPath) {
+    const raw = await io.readFile(planPath);
+    if (raw !== null) {
+      mission.planFile = path46.basename(planPath);
+      const { todos } = parsePlanFrontmatter2(raw);
+      const open = todos.filter((t) => t.status !== "cancelled");
+      mission.todos = {
+        done: open.filter((t) => t.status === "completed").length,
+        total: open.length
+      };
+      mission.currentTodo = todos.find((t) => t.status === "in_progress")?.id ?? null;
+      mission.nextTodo = todos.find((t) => t.status === "pending")?.id ?? null;
+      if (checklist.length === 0) {
+        checklist = open.map((t) => ({
+          label: t.id,
+          state: t.status === "completed" ? "done" : t.status === "in_progress" ? "current" : "pending"
+        }));
+        const current = checklist.findIndex((row) => row.state === "current");
+        if (current > 1) checklist = checklist.slice(current - 1);
+      }
+    }
+  }
+  return { mission, checklist };
+}
+function createLiveMissionLoader(root, opts = {}) {
+  const ttl = opts.ttlMs ?? LIVE_PROGRESS_TTL_MS;
+  const now2 = opts.now ?? Date.now;
+  let cached = null;
+  let readAt = Number.NEGATIVE_INFINITY;
+  let inFlight = null;
+  return async () => {
+    if (cached && now2() - readAt < ttl) return cached;
+    if (inFlight) return inFlight;
+    inFlight = readLiveMission(root, opts.io).then((state) => {
+      cached = state;
+      readAt = now2();
+      return state;
+    }).finally(() => {
+      inFlight = null;
+    });
+    return cached ?? inFlight;
+  };
+}
+async function withLiveTui(opts, run) {
+  const write = opts.write ?? ((chunk) => process.stdout.write(chunk));
+  const stdin = opts.stdin ?? process.stdin;
+  const env = opts.env ?? process.env;
+  const now2 = opts.now ?? Date.now;
+  const columns = opts.columns ?? process.stdout.columns ?? 80;
+  const rows = opts.rows ?? process.stdout.rows ?? 24;
+  const feed = new LiveRunFeed({
+    columns,
+    now: now2,
+    backend: opts.backend,
+    logPath: path46.relative(opts.root, opts.logPath) || opts.logPath
+  });
+  opts.onFeed?.(feed);
+  const missionLoader = opts.missionLoader ?? createLiveMissionLoader(opts.root, { now: now2 });
+  const input = new InputLine();
+  let pending = null;
+  let spawnInfo = null;
+  let quitRequested = null;
+  let handle = null;
+  const repaint = () => {
+    void handle?.repaint();
+  };
+  const settleGate = (answer) => {
+    const open = pending;
+    if (!open) return;
+    pending = null;
+    feed.closeGate();
+    open.settle(answer);
+  };
+  const readAnswer = (gate, readOpts) => new Promise((resolve3) => {
+    const onAbort = () => settleGate({ kind: "eof" });
+    if (readOpts.signal?.aborted) {
+      resolve3({ kind: "eof" });
+      return;
+    }
+    input.reset();
+    pending = {
+      gate,
+      settle: (answer) => {
+        readOpts.signal?.removeEventListener("abort", onAbort);
+        resolve3(answer);
+      }
+    };
+    readOpts.signal?.addEventListener("abort", onAbort, { once: true });
+    feed.openGate(gate);
+    repaint();
+  });
+  const stopRun = (stop) => {
+    if (pending) {
+      settleGate({ kind: "sigint" });
+      return;
+    }
+    if (quitRequested) return;
+    quitRequested = stop;
+    feed.setPhase("stopping");
+    feed.note(stop.message);
+    spawnInfo?.stop(stop);
+  };
+  const hooks = {
+    write,
+    stdin,
+    now: now2,
+    setIntervalFn: opts.setIntervalFn,
+    clearIntervalFn: opts.clearIntervalFn,
+    onKey: (chunk) => {
+      if (!pending) return false;
+      const result = input.handleKey(chunk);
+      if (result === "submit") settleGate({ kind: "line", text: input.value });
+      else if (result === "sigint") settleGate({ kind: "sigint" });
+      else if (result === "eof") settleGate({ kind: "eof" });
+      else if (result === "edit") repaint();
+      return true;
+    },
+    onQuit: (key) => {
+      write("\n");
+      stopRun(operatorQuitStop(key));
+    }
+  };
+  const loadView = async () => {
+    const state = await missionLoader();
+    return {
+      mission: state.mission,
+      checklist: state.checklist,
+      gate: pending ? {
+        askId: pending.gate.askId,
+        labels: pending.gate.labels,
+        detection: pending.gate.detection,
+        input
+      } : null,
+      flightLog: feed.log,
+      crew: feed.crew,
+      error: null
+    };
+  };
+  const seams = {
+    render: feed,
+    log: (line) => feed.note(line),
+    onSpawn: (info) => {
+      spawnInfo = info;
+      feed.setProcess({ backend: info.backend, pid: info.pid });
+      if (quitRequested) info.stop(quitRequested);
+    },
+    hitl: {
+      policy: opts.noHitl ? "off" : "prompt",
+      isTTY: true,
+      readAnswer,
+      write: (text) => feed.note(text, "hitl")
+    }
+  };
+  const onSignal = (signal) => {
+    handle?.stop();
+    stopRun(operatorQuitStop(signal));
+  };
+  const onSigint = () => onSignal("SIGINT");
+  const onSigterm = () => onSignal("SIGTERM");
+  const signals = opts.signals ?? true;
+  if (signals) {
+    process.prependListener("SIGINT", onSigint);
+    process.prependListener("SIGTERM", onSigterm);
+  }
+  try {
+    handle = await runMcTuiLoop({
+      loadView,
+      render: (view, renderOpts) => renderMcLive(view, { ...renderOpts, columns, rows, now: now2() }),
+      stdoutIsTTY: true,
+      env,
+      intervalMs: opts.intervalMs ?? LIVE_FRAME_MS,
+      renderOpts: { stdoutIsTTY: true, env, columns },
+      hooks
+    });
+    const result = await run(seams);
+    feed.setPhase("done");
+    if (handle) await handle.repaint();
+    return result;
+  } finally {
+    if (pending) settleGate({ kind: "eof" });
+    handle?.stop();
+    if (signals) {
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+    }
+    write("\n");
+  }
+}
 
 // src/plan-loop/external-review.ts
-import { spawn as spawn7 } from "child_process";
-import path44 from "path";
-var CANONICAL_REL = path44.join(".cursor", "scripts", "plan-external-review.sh");
-var FALLBACK_REL = path44.join("scripts", "plan-external-review.sh");
+import { spawn as spawn8 } from "child_process";
+import path47 from "path";
+var CANONICAL_REL = path47.join(".cursor", "scripts", "plan-external-review.sh");
+var FALLBACK_REL = path47.join("scripts", "plan-external-review.sh");
 function isPlanExhaustedReason(reason) {
   const r = reason.trim().toLowerCase();
   if (!r) return false;
@@ -9283,12 +11889,12 @@ function shouldArmExternalPlanReview(input) {
   return false;
 }
 async function armExternalPlanReview(root, options = {}) {
-  const spawnFn = options.spawnFn ?? spawn7;
+  const spawnFn = options.spawnFn ?? spawn8;
   const existsFn = options.existsFn ?? fileExists;
   const log = options.log ?? ((line) => console.log(line));
   const force = options.force === true;
-  const canonicalPath = path44.join(root, CANONICAL_REL);
-  const fallbackPath = path44.join(root, FALLBACK_REL);
+  const canonicalPath = path47.join(root, CANONICAL_REL);
+  const fallbackPath = path47.join(root, FALLBACK_REL);
   let scriptPath = null;
   let scriptRel = CANONICAL_REL;
   if (await existsFn(canonicalPath)) {
@@ -9341,7 +11947,7 @@ async function armExternalPlanReview(root, options = {}) {
 }
 
 // src/plan-loop/persona-banners.ts
-import path45 from "path";
+import path48 from "path";
 import {
   blue,
   cyan as cyan4,
@@ -9377,7 +11983,7 @@ function resolveColor(name, fallback) {
 async function resolveCliPersonaId(root) {
   try {
     const cfg = await readJson(
-      path45.join(root, ".cursor", "context", "config.json")
+      path48.join(root, ".cursor", "context", "config.json")
     );
     const modes = cfg?.agentPersona?.modes ?? cfg?.workspaceSkin?.modes;
     const id = modes?.[CLI_RUN_PLAN_MODE];
@@ -9388,7 +11994,7 @@ async function resolveCliPersonaId(root) {
 }
 async function loadPersonaPack(root, personaId) {
   try {
-    const personaPath = path45.join(root, "registry", "personas", "core", personaId, "persona.json");
+    const personaPath = path48.join(root, "registry", "personas", "core", personaId, "persona.json");
     const pack = await readJson(personaPath);
     if (!pack || typeof pack.id !== "string") return null;
     return pack;
@@ -9436,44 +12042,8 @@ function createPersonaBannerPrinter(persona) {
   };
 }
 
-// src/plan-loop/plan-state.ts
-import { readFile as readFile22, readdir as readdir9 } from "fs/promises";
-import path46 from "path";
-function countPendingTodos(raw) {
-  const lines = raw.split(/\r?\n/);
-  let inFront = 0;
-  let cont = false;
-  let n = 0;
-  for (const line of lines) {
-    if (line === "---") {
-      inFront += 1;
-      continue;
-    }
-    if (inFront !== 1) continue;
-    const idMatch = line.match(/^- id:\s*(\S+)/);
-    if (idMatch?.[1]) {
-      cont = idMatch[1] === "dogfood-poc";
-    }
-    if (/content:.*[Cc]ont[ií]nuo/.test(line)) {
-      cont = true;
-    }
-    if (/status:\s*(pending|in_progress)\b/.test(line) && !cont) {
-      n += 1;
-    }
-  }
-  return n;
-}
-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] ? path46.join(plansDir, files[0]) : null;
-}
-async function readPlan(planPath) {
-  return readFile22(planPath, "utf8");
-}
-
 // src/plan-loop/sentinel.ts
-import { readFile as readFile23 } from "fs/promises";
+import { readFile as readFile26 } from "fs/promises";
 var SENTINEL_RE = /LOOP_TICK_RESULT:\s*(continue|stop(?:\s*[—\-].*)?)/i;
 function takeFromText(text) {
   if (!text) return null;
@@ -9539,14 +12109,14 @@ function parseTickResultStatus(content) {
 }
 async function parseTickResultStatusFromLogFile(logPath) {
   try {
-    return parseTickResultStatus(await readFile23(logPath, "utf8"));
+    return parseTickResultStatus(await readFile26(logPath, "utf8"));
   } catch {
     return null;
   }
 }
 async function parseSentinelFromLogFile(logPath) {
   try {
-    const content = await readFile23(logPath, "utf8");
+    const content = await readFile26(logPath, "utf8");
     return parseSentinelFromLog(content);
   } catch {
     return { kind: "missing" };
@@ -9560,6 +12130,40 @@ function formatSentinelLine(sentinel) {
 
 // src/plan-loop/run-loop.ts
 var TICK_PROMPT = '/run-plan - single tick from the headless runner (agent-kit run-plan). Read .cursor/HANDOFF.md and the active plan in .cursor/plans/. Mark the next to-do as in_progress in the frontmatter, execute ONLY that to-do, mark completed and update HANDOFF. If there is a commitable diff: run /git-staging without asking for confirmation. NEVER /git-prod. Do NOT re-arm an internal Loop skill - the external runner starts the next agent. End the response with exactly one line: "LOOP_TICK_RESULT: continue" if implementable to-dos remain, or "LOOP_TICK_RESULT: stop - <reason>" (plan exhausted, external blocker, or human decision needed).';
+async function runTickWithSpinner(label, backend, opts, plain) {
+  if (shouldUseLiveTui({ plain })) {
+    return withLiveTui(
+      {
+        root: opts.workspace,
+        backend: backend.id,
+        logPath: opts.logPath,
+        noHitl: opts.hitl?.policy === "off"
+      },
+      (seams) => backend.run({
+        ...opts,
+        hitl: seams.hitl,
+        render: seams.render,
+        onSpawn: seams.onSpawn,
+        log: seams.log
+      })
+    );
+  }
+  if (!shouldUseVisualMotion()) return backend.run(opts);
+  const spinner = new TtySpinner({ motion: true });
+  spinner.start(label);
+  try {
+    return await backend.run({
+      ...opts,
+      hitl: {
+        ...opts.hitl,
+        onPromptStart: () => spinner.stop(),
+        onPromptEnd: () => spinner.start(label)
+      }
+    });
+  } finally {
+    spinner.stop();
+  }
+}
 function stamp() {
   const d = /* @__PURE__ */ new Date();
   const p = (n, w = 2) => String(n).padStart(w, "0");
@@ -9569,9 +12173,9 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 async function runPlanLoop(opts) {
-  const plansDir = path47.join(opts.root, ".cursor", "plans");
-  const stopFile = path47.join(opts.root, ".cursor", "loop.stop");
-  const logDir = path47.join(opts.root, ".cursor", "loop-logs");
+  const plansDir = path49.join(opts.root, ".cursor", "plans");
+  const stopFile = path49.join(opts.root, ".cursor", "loop.stop");
+  const logDir = path49.join(opts.root, ".cursor", "loop-logs");
   const planPath = await findActivePlanFile(plansDir);
   if (!planPath) {
     logger.error("No active plan in .cursor/plans/");
@@ -9592,7 +12196,7 @@ async function runPlanLoop(opts) {
   try {
     const persona = await loadCliRunPlanPersona(opts.root);
     const banners = createPersonaBannerPrinter(persona);
-    console.log(`Active plan: ${path47.basename(planPath)}`);
+    console.log(`Active plan: ${path49.basename(planPath)}`);
     console.log(`Pending to-dos: ${await pending()} | max ticks: ${opts.maxTicks}`);
     console.log(`Backend: ${opts.backend.id}`);
     if (persona) {
@@ -9611,6 +12215,7 @@ async function runPlanLoop(opts) {
     let tick = 0;
     let stopReason;
     let planExhausted = false;
+    let exitCode = 0;
     while (true) {
       tick += 1;
       if (tick > opts.maxTicks) {
@@ -9635,30 +12240,47 @@ async function runPlanLoop(opts) {
         planExhausted = true;
         break;
       }
-      const logPath = path47.join(logDir, `tick-${stamp()}.log`);
-      const relLog = path47.relative(opts.root, logPath);
+      const logPath = path49.join(logDir, `tick-${stamp()}.log`);
+      const relLog = path49.relative(opts.root, logPath);
       console.log("");
       const tickLine = `=== tick ${tick}/${opts.maxTicks} - pending: ${before} - log: ${relLog} ===`;
       if (banners) banners.tickStart(tickLine);
       else console.log(tickLine);
       let agentExit = 0;
+      let hitlStop;
       try {
-        const result = await withCliProgress(
+        const result = await runTickWithSpinner(
           `tick ${tick}`,
-          () => opts.backend.run({
+          opts.backend,
+          {
             workspace: opts.root,
             prompt: TICK_PROMPT,
             model: opts.model,
-            logPath
-          })
+            logPath,
+            hitl: { policy: opts.noHitl ? "off" : "prompt" }
+          },
+          opts.plain === true
         );
         agentExit = result.exitCode;
+        for (const line of formatHitlSummary(result.hitl)) console.log(line);
+        hitlStop = result.hitl?.stop;
       } catch (err) {
         logger.error(String(err));
         return 1;
       }
+      if (hitlStop) {
+        const msg = `${opts.backend.id} tick ended at a HITL gate without a reply - stopping. See log: ${relLog}`;
+        if (banners) {
+          banners.tickEnd("hitl stop");
+          banners.stop(msg);
+        } else {
+          console.log(msg);
+        }
+        exitCode = hitlStop.exitCode;
+        break;
+      }
       try {
-        const logText = await readFile24(logPath, "utf8");
+        const logText = await readFile27(logPath, "utf8");
         if (logText.includes("Too many MCP tools")) {
           const msg = "Too many MCP tools for the headless model - disable servers (cursor-agent mcp disable <id>) and run again.";
           if (banners) banners.stop(msg);
@@ -9727,12 +12349,12 @@ 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 ${path47.relative(opts.root, logDir)}/`
+      `Loop finished after ${tick} tick(s). Pending now: ${pendingNow}. Logs in ${path49.relative(opts.root, logDir)}/`
     );
     if (planExhausted || shouldArmExternalPlanReview({ pending: pendingNow, stopReason })) {
       await armExternalPlanReview(opts.root);
     }
-    return 0;
+    return exitCode;
   } finally {
     process.off("SIGINT", onSigInt);
   }
@@ -9774,6 +12396,16 @@ var runPlanCommand = defineCommand16({
       type: "boolean",
       description: "Print the tick prompt and exit without starting an agent",
       default: false
+    },
+    "no-hitl": {
+      type: "boolean",
+      description: `CI: never prompt; a HITL gate stops the run with exit ${HITL_UNANSWERED_EXIT_CODE} (no default answer)`,
+      default: false
+    },
+    plain: {
+      type: "boolean",
+      description: "Status lines instead of the Mission Control live view (the default on a TTY; non-TTY, NO_COLOR and CI are always plain)",
+      default: false
     }
   },
   async run({ args }) {
@@ -9809,12 +12441,14 @@ var runPlanCommand = defineCommand16({
       return;
     }
     const code = await runPlanLoop({
-      root: path48.resolve(args.cwd),
+      root: path50.resolve(args.cwd),
       maxTicks,
       sleepSeconds,
       model: args.model ? String(args.model) : void 0,
       dryRun: Boolean(args["dry-run"]),
-      backend
+      backend,
+      noHitl: Boolean(args["no-hitl"]),
+      plain: Boolean(args.plain)
     });
     process.exitCode = code;
   }
@@ -9822,12 +12456,12 @@ var runPlanCommand = defineCommand16({
 
 // src/commands/run.ts
 import { homedir as homedir4 } from "os";
-import path50 from "path";
+import path52 from "path";
 import { defineCommand as defineCommand17 } from "citty";
 
 // src/plan-loop/dispatch.ts
-import { mkdir as mkdir7, readFile as readFile25 } from "fs/promises";
-import path49 from "path";
+import { mkdir as mkdir7, readFile as readFile28 } from "fs/promises";
+import path51 from "path";
 var RUN_CATALOG = [
   "run-plan",
   "run-plan-all",
@@ -9840,6 +12474,7 @@ var RUN_CATALOG = [
   "git-staging",
   "kit-staging"
 ];
+var FIRST_CLASS_SLASH_COMMANDS = ["run-plan", "run-plan-all"];
 var RUN_PROMOTE_BLOCKED = ["git-prod", "kit-prod"];
 function normalizeSlashName(raw) {
   return raw.replace(/^\//, "").replace(/\.md$/i, "").trim();
@@ -9851,12 +12486,30 @@ function classifySlash(name) {
   if (RUN_CATALOG.includes(n)) return "catalog";
   return "unknown";
 }
+function rewriteRootArgvToRun(argv) {
+  const idx = argv.findIndex((arg) => arg.length > 0 && !arg.startsWith("-"));
+  if (idx < 0) return argv;
+  const token = argv[idx];
+  if (!token || token === "run") return argv;
+  const kind = classifySlash(token);
+  if (kind === "unknown") return argv;
+  const slash = normalizeSlashName(token);
+  if (FIRST_CLASS_SLASH_COMMANDS.includes(slash)) {
+    if (token === slash) return argv;
+    const next2 = [...argv];
+    next2[idx] = slash;
+    return next2;
+  }
+  const next = [...argv];
+  next.splice(idx, 1, "run", slash);
+  return next;
+}
 function commandMarkdownPath(root, name) {
-  return path49.join(root, ".cursor", "commands", `${normalizeSlashName(name)}.md`);
+  return path51.join(root, ".cursor", "commands", `${normalizeSlashName(name)}.md`);
 }
 function buildDispatchPrompt(commandBody) {
   return [
-    "Follow the Agent Kit command below. This session is headless: use numbered-list HITL (Ask questions is Cursor-only). Never /git-prod. No CLI --force promote.",
+    "Follow the Agent Kit command below. This session is headless: use numbered-list HITL (Ask questions is Cursor-only). Before each numbered list print one line `HITL_GATE: <ask-id> | <label 1> | <label 2> | ...` (ask-id and labels from the hitl-gates skill), then wait; the operator's answer arrives as `HITL_REPLY: <ask-id> | operator reply <n> | <label>`. Never /git-prod. No CLI --force promote.",
     "",
     commandBody.trimEnd(),
     ""
@@ -9877,7 +12530,7 @@ async function readCommandFile(root, name) {
       message: `Command file not found: ${filePath}. Install or refresh Agent Kit L0 so .cursor/commands/${normalizeSlashName(name)}.md exists.`
     };
   }
-  const body = await readFile25(filePath, "utf8");
+  const body = await readFile28(filePath, "utf8");
   return { ok: true, path: filePath, body };
 }
 function stamp2() {
@@ -9900,7 +12553,7 @@ function cursorAgentDispatchArgs(opts) {
   args.push(opts.prompt);
   return args;
 }
-function claudeDispatchArgs(opts) {
+function claudeDispatchArgs(opts = {}) {
   return claudeHeadlessArgs(opts);
 }
 async function runHeadlessDispatch(opts) {
@@ -9917,9 +12570,21 @@ async function runHeadlessDispatch(opts) {
     try {
       return await spawnLogged(
         opts.bin,
-        claudeDispatchArgs({ prompt: opts.prompt, model: opts.model, ...caps }),
+        claudeDispatchArgs({ model: opts.model, ...caps }),
         opts.logPath,
-        { cwd: opts.workspace, env, redact, spawnFn: opts.spawnFn }
+        {
+          cwd: opts.workspace,
+          env,
+          redact,
+          spawnFn: opts.spawnFn,
+          hitl: resolveHitlRunOptions(opts.hitl, {
+            kind: "stdin-stream-json",
+            firstPrompt: opts.prompt
+          }),
+          render: opts.render,
+          onSpawn: opts.onSpawn,
+          backendId: "claude"
+        }
       );
     } catch (err) {
       throw new Error(`claude dispatch failed to start: ${redactSecrets(String(err), redact)}`);
@@ -9932,24 +12597,28 @@ async function runHeadlessDispatch(opts) {
   });
   return spawnLogged(opts.bin, args, opts.logPath, {
     spawnFn: opts.spawnFn,
-    redact: claudeRedactions(process.env)
+    redact: claudeRedactions(process.env),
+    hitl: resolveHitlRunOptions(opts.hitl, { kind: "none", backend: "cursor-agent" }),
+    render: opts.render,
+    onSpawn: opts.onSpawn,
+    backendId: "cursor-agent"
   });
 }
 async function ensureDispatchLogPath(root) {
-  const logDir = path49.join(root, ".cursor", "loop-logs");
+  const logDir = path51.join(root, ".cursor", "loop-logs");
   await mkdir7(logDir, { recursive: true });
-  return path49.join(logDir, `run-${stamp2()}.log`);
+  return path51.join(logDir, `run-${stamp2()}.log`);
 }
 
 // src/commands/run.ts
 function displayPath(target, home = homedir4()) {
-  const resolvedHome = path50.resolve(home);
+  const resolvedHome = path52.resolve(home);
   if (target === resolvedHome) return "~";
-  const prefix = resolvedHome.endsWith(path50.sep) ? resolvedHome : `${resolvedHome}${path50.sep}`;
-  return target.startsWith(prefix) ? `~${path50.sep}${target.slice(prefix.length)}` : target;
+  const prefix = resolvedHome.endsWith(path52.sep) ? resolvedHome : `${resolvedHome}${path52.sep}`;
+  return target.startsWith(prefix) ? `~${path52.sep}${target.slice(prefix.length)}` : target;
 }
 async function executeRun(input) {
-  const root = path50.resolve(input.cwd);
+  const root = path52.resolve(input.cwd);
   const slash = normalizeSlashName(input.slash);
   if (!slash) {
     return { exitCode: 1, error: "Provide a slash: agent-kit run <slash>" };
@@ -9985,7 +12654,9 @@ async function executeRun(input) {
       sleepSeconds: input.sleepSeconds,
       model: input.model,
       dryRun: false,
-      backend
+      backend,
+      noHitl: input.noHitl === true,
+      plain: input.plain === true
     });
     return { exitCode: code };
   }
@@ -9998,7 +12669,7 @@ async function executeRun(input) {
     const stdout = [
       "--dry-run: no agent will be started.",
       `Slash: ${slash}`,
-      `Command file: ${path50.relative(root, file.path)}`,
+      `Command file: ${path52.relative(root, file.path)}`,
       `Backend: ${detected.id} (${displayPath(detected.bin)})`,
       "Prompt:",
       prompt
@@ -10007,93 +12678,135 @@ async function executeRun(input) {
   }
   const logPath = await ensureDispatchLogPath(root);
   console.log(`Dispatch: ${slash} via ${detected.id}`);
-  console.log(`Command file: ${path50.relative(root, file.path)}`);
-  console.log(`Log: ${path50.relative(root, logPath)}`);
+  console.log(`Command file: ${path52.relative(root, file.path)}`);
+  console.log(`Log: ${path52.relative(root, logPath)}`);
   try {
-    const result = await runHeadlessDispatch({
+    const dispatch = {
       backendId: detected.id,
       bin: detected.bin,
       workspace: root,
       prompt,
       model: input.model,
       logPath
+    };
+    const result = shouldUseLiveTui({ plain: input.plain }) ? await withLiveTui(
+      { root, backend: detected.id, logPath, noHitl: input.noHitl === true },
+      (seams) => runHeadlessDispatch({
+        ...dispatch,
+        hitl: seams.hitl,
+        render: seams.render,
+        onSpawn: seams.onSpawn,
+        log: seams.log
+      })
+    ) : await runHeadlessDispatch({
+      ...dispatch,
+      hitl: { policy: input.noHitl ? "off" : "prompt" }
     });
-    return { exitCode: result.exitCode };
+    for (const line of formatHitlSummary(result.hitl)) console.log(line);
+    return { exitCode: hitlExitCode(result.exitCode, result.hitl) };
   } catch (err) {
     return { exitCode: 1, error: String(err) };
   }
 }
+var runDispatchArgs = {
+  cwd: {
+    type: "string",
+    description: "Project root (default: current directory)",
+    default: process.cwd()
+  },
+  backend: {
+    type: "string",
+    description: `Agent CLI (${listDetectBackendIds().join(" | ")}; default: auto)`,
+    default: "auto"
+  },
+  model: {
+    type: "string",
+    description: "Optional model id passed to the agent CLI",
+    default: ""
+  },
+  "dry-run": {
+    type: "boolean",
+    description: "Print the resolved backend and prompt, then exit without starting an agent",
+    default: false
+  },
+  "max-ticks": {
+    type: "string",
+    description: "For run-plan alias only: maximum ticks (default: 10)",
+    default: "10"
+  },
+  sleep: {
+    type: "string",
+    description: "For run-plan alias only: seconds between ticks (default: 5)",
+    default: "5"
+  },
+  "no-hitl": {
+    type: "boolean",
+    description: `CI: never prompt; a HITL gate stops the run with exit ${HITL_UNANSWERED_EXIT_CODE} (no default answer)`,
+    default: false
+  },
+  plain: {
+    type: "boolean",
+    description: "Status lines instead of the Mission Control live view (the default on a TTY; non-TTY, NO_COLOR and CI are always plain)",
+    default: false
+  }
+};
+async function runSlashCli(slash, args) {
+  const maxTicks = Number.parseInt(String(args["max-ticks"]), 10);
+  const sleepSeconds = Number.parseFloat(String(args.sleep));
+  if (!Number.isFinite(maxTicks) || maxTicks < 1) {
+    logger.error("--max-ticks must be a positive integer");
+    process.exitCode = 1;
+    return;
+  }
+  if (!Number.isFinite(sleepSeconds) || sleepSeconds < 0) {
+    logger.error("--sleep must be a non-negative number");
+    process.exitCode = 1;
+    return;
+  }
+  const result = await executeRun({
+    slash,
+    cwd: String(args.cwd),
+    backend: String(args.backend),
+    model: args.model ? String(args.model) : void 0,
+    dryRun: Boolean(args["dry-run"]),
+    maxTicks,
+    sleepSeconds,
+    noHitl: Boolean(args["no-hitl"]),
+    plain: Boolean(args.plain)
+  });
+  if (result.stdout) {
+    console.log(result.stdout);
+  }
+  if (result.error) {
+    logger.error(result.error);
+  }
+  process.exitCode = result.exitCode;
+}
 var runCommand = defineCommand17({
   meta: {
     name: "run",
-    description: "Start one headless session from an L0 slash file. Numbered-list HITL. Never git-prod."
+    description: "Start one headless session from an L0 slash file. Numbered-list HITL answered from the terminal (claude backend). Never git-prod."
   },
   args: {
     slash: {
       type: "positional",
-      description: "Slash name (e.g. backlog-add, run-plan, continue-plan)",
+      description: "Slash name (e.g. run-plan-all, backlog-add, continue-plan)",
       required: true
     },
-    cwd: {
-      type: "string",
-      description: "Project root (default: current directory)",
-      default: process.cwd()
-    },
-    backend: {
-      type: "string",
-      description: `Agent CLI (${listDetectBackendIds().join(" | ")}; default: auto)`,
-      default: "auto"
-    },
-    model: {
-      type: "string",
-      description: "Optional model id passed to the agent CLI",
-      default: ""
-    },
-    "dry-run": {
-      type: "boolean",
-      description: "Print the resolved backend and prompt, then exit without starting an agent",
-      default: false
-    },
-    "max-ticks": {
-      type: "string",
-      description: "For run-plan alias only: maximum ticks (default: 10)",
-      default: "10"
-    },
-    sleep: {
-      type: "string",
-      description: "For run-plan alias only: seconds between ticks (default: 5)",
-      default: "5"
-    }
+    ...runDispatchArgs
   },
   async run({ args }) {
-    const maxTicks = Number.parseInt(String(args["max-ticks"]), 10);
-    const sleepSeconds = Number.parseFloat(String(args.sleep));
-    if (!Number.isFinite(maxTicks) || maxTicks < 1) {
-      logger.error("--max-ticks must be a positive integer");
-      process.exitCode = 1;
-      return;
-    }
-    if (!Number.isFinite(sleepSeconds) || sleepSeconds < 0) {
-      logger.error("--sleep must be a non-negative number");
-      process.exitCode = 1;
-      return;
-    }
-    const result = await executeRun({
-      slash: String(args.slash ?? ""),
-      cwd: String(args.cwd),
-      backend: String(args.backend),
-      model: args.model ? String(args.model) : void 0,
-      dryRun: Boolean(args["dry-run"]),
-      maxTicks,
-      sleepSeconds
-    });
-    if (result.stdout) {
-      console.log(result.stdout);
-    }
-    if (result.error) {
-      logger.error(result.error);
-    }
-    process.exitCode = result.exitCode;
+    await runSlashCli(String(args.slash ?? ""), args);
+  }
+});
+var runPlanAllCommand = defineCommand17({
+  meta: {
+    name: "run-plan-all",
+    description: "Headless /run-plan-all queue from the L0 file. Numbered-list HITL answered from the terminal (claude backend). Never git-prod."
+  },
+  args: runDispatchArgs,
+  async run({ args }) {
+    await runSlashCli("run-plan-all", args);
   }
 });
 
@@ -10120,22 +12833,21 @@ var scanCommand = defineCommand18({
 });
 
 // src/commands/setup-global.ts
-import { spawn as spawn8 } from "child_process";
-import { appendFile, mkdir as mkdir8, readFile as readFile26, writeFile as writeFile13 } from "fs/promises";
+import { spawn as spawn9 } from "child_process";
+import { appendFile as appendFile2, mkdir as mkdir8, readFile as readFile29, writeFile as writeFile13 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import path51 from "path";
+import path53 from "path";
 import { confirm as confirm2, isCancel as isCancel2 } from "@clack/prompts";
 import { defineCommand as defineCommand19 } 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";
-var DEFAULT_PACKAGE_SPEC = "@dadado/agent-kit-cli";
 function planSetupGlobalSteps(env, options = {}) {
   const homeDir = options.homeDir ?? homedir5();
-  const packageSpec = options.packageSpec ?? DEFAULT_PACKAGE_SPEC;
-  const npmGlobalDir = path51.join(homeDir, NPM_GLOBAL_DIR_NAME);
-  const npmGlobalBin = path51.join(npmGlobalDir, "bin");
-  const npmrcPath = path51.join(homeDir, ".npmrc");
+  const packageSpec = options.packageSpec ?? pinnedCliSpec();
+  const npmGlobalDir = path53.join(homeDir, NPM_GLOBAL_DIR_NAME);
+  const npmGlobalBin = path53.join(npmGlobalDir, "bin");
+  const npmrcPath = path53.join(homeDir, ".npmrc");
   const npmrcPrefixValue = `~/${NPM_GLOBAL_DIR_NAME}`;
   const pathExportLine = `export PATH="${npmGlobalBin}:$PATH"`;
   const shellProfile = env.shellProfile;
@@ -10203,9 +12915,9 @@ var defaultFsImpl = {
   mkdir: async (dir) => {
     await mkdir8(dir, { recursive: true });
   },
-  readFile: (filePath) => readFile26(filePath, "utf8"),
+  readFile: (filePath) => readFile29(filePath, "utf8"),
   writeFile: (filePath, content) => writeFile13(filePath, content, "utf8"),
-  appendFile: (filePath, content) => appendFile(filePath, content, "utf8")
+  appendFile: (filePath, content) => appendFile2(filePath, content, "utf8")
 };
 async function safeReadFile(fs, filePath) {
   try {
@@ -10215,7 +12927,7 @@ async function safeReadFile(fs, filePath) {
   }
 }
 var defaultNpmInstallImpl = (packageSpec) => new Promise((resolve3) => {
-  const child = spawn8("npm", ["i", "-g", packageSpec], { stdio: "inherit" });
+  const child = spawn9("npm", ["i", "-g", packageSpec], { stdio: "inherit" });
   child.on("error", (error) => resolve3({ ok: false, error }));
   child.on("close", (code) => {
     if (code === 0) resolve3({ ok: true });
@@ -10266,11 +12978,48 @@ async function runSetupGlobal(options = {}) {
   const homeDir = options.homeDir ?? homedir5();
   const env = await assessEnvironmentImpl(options);
   const plan = planSetupGlobalSteps(env, { homeDir, packageSpec: options.packageSpec });
-  if (plan.alreadyWritable) {
+  if (plan.alreadyWritable && pathCliStatus(env, KIT_VERSION) === "current") {
     printHeader(env, print);
-    print(green4("npm's global prefix is already writable \u2014 nothing to fix."));
+    print(green4("npm's global prefix is writable and PATH `agent-kit` matches this CLI."));
     return { exitCode: 0, mutated: false, outcome: "already-ok", env, plan };
   }
+  if (plan.alreadyWritable) {
+    printHeader(env, print);
+    print(
+      `PATH \`agent-kit\` is ${env.binVersion ? `v${env.binVersion}` : "missing or unreadable"}; this CLI is v${KIT_VERSION}.`
+    );
+    print(`Prefix is writable. Next step is only: npm i -g ${plan.packageSpec}`);
+    if (options.dryRun) {
+      print("Dry run: no changes.");
+      print(`  npm i -g ${plan.packageSpec}`);
+      return { exitCode: 0, mutated: false, outcome: "dry-run", env, plan };
+    }
+    const nonInteractiveWritable = options.nonInteractive ?? isNonInteractive();
+    if (nonInteractiveWritable) {
+      print("No changes made. Run this yourself:");
+      print(`  npm i -g ${plan.packageSpec}`);
+      print("  hash -r");
+      print("  agent-kit --version");
+      return { exitCode: 0, mutated: false, outcome: "manual-instructions", env, plan };
+    }
+    const confirmStep2 = options.confirmImpl ?? defaultConfirmImpl;
+    const npmInstall2 = options.npmInstallImpl ?? defaultNpmInstallImpl;
+    const proceedInstall2 = await confirmStep2(`Run: npm i -g ${plan.packageSpec}?`);
+    if (!proceedInstall2) {
+      print(yellow3("Cancelled: no changes made."));
+      return { exitCode: 1, mutated: false, outcome: "cancelled", env, plan };
+    }
+    const installResult2 = await npmInstall2(plan.packageSpec);
+    if (!installResult2.ok) {
+      const hint = classifyInstallError(installResult2.error);
+      print(`  npm install failed: ${hint.message}`);
+      print(hint.recovery);
+      return { exitCode: 1, mutated: false, outcome: "error", env, plan };
+    }
+    print(green4(`  done: ${plan.packageSpec} installed globally.`));
+    print("  If this shell still shows the old version: hash -r (or open a new terminal).");
+    return { exitCode: 0, mutated: true, outcome: "completed", env, plan };
+  }
   if (options.dryRun) {
     printHeader(env, print);
     print("Dry run \u2014 no changes will be made. Steps that would run:");
@@ -10397,7 +13146,7 @@ var setupGlobalCommand = defineCommand19({
 });
 
 // src/commands/status.ts
-import path52 from "path";
+import path54 from "path";
 import { defineCommand as defineCommand20 } from "citty";
 function profileStatus(profile) {
   if (!profile) return { origin: "none", evidence: [], profile: null };
@@ -10428,13 +13177,14 @@ var statusCommand = defineCommand20({
     }
   },
   async run({ args }) {
-    const rootDir = path52.resolve(args.cwd);
-    const [manifest, rawProfile, scan] = await Promise.all([
+    const rootDir = path54.resolve(args.cwd);
+    const [manifest, rawProfile, scan, env] = await Promise.all([
       loadAgentKitManifest(rootDir),
       readJson(
-        path52.join(rootDir, ".cursor", "agent-kit.config.json")
+        path54.join(rootDir, ".cursor", "agent-kit.config.json")
       ),
-      runScanner(rootDir)
+      runScanner(rootDir),
+      assessEnvironment()
     ]);
     const readiness = createReadinessReport(scan, { generatorVersion: KIT_VERSION });
     const profile = profileStatus(rawProfile);
@@ -10470,6 +13220,17 @@ var statusCommand = defineCommand20({
         `  registry:   ${manifest.registry?.url ?? "(default)"} @ ${manifest.registry?.ref ?? "(default)"}`
       );
       if (manifest.installedAt) console.log(`  installed at: ${manifest.installedAt}`);
+      if (manifest.version !== KIT_VERSION) {
+        console.log(
+          `  overlay:    this CLI is v${KIT_VERSION}; apply with the same binary, not a stale PATH hit:`
+        );
+        console.log(`              ${npxPinned(KIT_VERSION, "update")}`);
+      }
+      const pathStatus = pathCliStatus(env, KIT_VERSION);
+      if (pathStatus === "behind" || pathStatus === "unknown") {
+        console.log(`  PATH bin:   v${env.binVersion ?? "unknown"} at ${env.binPath}`);
+        console.log("              bare `agent-kit update` will re-stamp that older version");
+      }
     }
     console.log("Repository readiness");
     console.log(
@@ -10656,6 +13417,8 @@ ${err.recovery}
       logApplyStats(stats);
       const transition = next.version === existing.version ? `unchanged at v${next.version}` : `v${existing.version} \u2192 v${next.version}`;
       logger.success(`Update complete: ${transition} (L3 protected paths left untouched).`);
+      const sync = await syncPathCliToRuntime({ runtimeVersion: KIT_VERSION });
+      for (const line of sync.lines) console.log(line);
     } finally {
       await registry.unlock?.();
     }
@@ -10663,8 +13426,8 @@ ${err.recovery}
 });
 
 // src/commands/validate.ts
-import { readFile as readFile27 } from "fs/promises";
-import path53 from "path";
+import { readFile as readFile30 } from "fs/promises";
+import path55 from "path";
 import { defineCommand as defineCommand22 } from "citty";
 
 // src/invariants/plan-schema.ts
@@ -10697,7 +13460,7 @@ function validatePlanFrontmatterText(text) {
       cite: CITE5
     });
   }
-  const hasTodoItem = /^- id:\s*\S+/m.test(block);
+  const hasTodoItem = /^\s*- id:\s*\S+/m.test(block);
   if (/^todos:/m.test(block) && !hasTodoItem && !/^todos:\s*\[\s*\]/m.test(block)) {
     warnings.push({
       code: "empty-todos",
@@ -10711,9 +13474,9 @@ function validatePlanFrontmatterText(text) {
 // src/commands/validate.ts
 async function resolveEditedPath(cwd, explicit) {
   if (explicit) {
-    const filePath2 = path53.resolve(cwd, explicit);
+    const filePath2 = path55.resolve(cwd, explicit);
     try {
-      return { filePath: filePath2, content: await readFile27(filePath2, "utf8") };
+      return { filePath: filePath2, content: await readFile30(filePath2, "utf8") };
     } catch {
       return null;
     }
@@ -10721,9 +13484,9 @@ 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 = path53.isAbsolute(rel) ? rel : path53.resolve(cwd, rel);
+  const filePath = path55.isAbsolute(rel) ? rel : path55.resolve(cwd, rel);
   try {
-    return { filePath, content: await readFile27(filePath, "utf8") };
+    return { filePath, content: await readFile30(filePath, "utf8") };
   } catch {
     return null;
   }
@@ -10751,15 +13514,21 @@ var validateCommand = defineCommand22({
       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 ? path53.resolve(cwd, fileArg) : path53.join(path53.resolve(cwd), ".cursor", "HANDOFF.md");
+        const filePath = fileArg ? path55.resolve(cwd, fileArg) : path55.join(path55.resolve(cwd), ".cursor", "HANDOFF.md");
         let content = "";
         try {
-          content = await readFile27(filePath, "utf8");
+          content = await readFile30(filePath, "utf8");
         } catch {
           console.log(JSON.stringify({ ok: true, warnings: [], note: "file missing" }));
           return;
         }
-        const warnings = validateHandoffText(content);
+        const warnings = [
+          ...validateHandoffText(content),
+          ...checkHandoffGrowth(content).map((w) => ({
+            ...w,
+            cite: "agent-kit handoff --prune (see .cursor/context/templates/handoff.md)"
+          }))
+        ];
         console.log(JSON.stringify({ ok: warnings.length === 0, warnings }));
       }
     }),
@@ -10778,10 +13547,10 @@ var validateCommand = defineCommand22({
           process.exitCode = 2;
           return;
         }
-        const filePath = path53.resolve(cwd, fileArg);
+        const filePath = path55.resolve(cwd, fileArg);
         let content = "";
         try {
-          content = await readFile27(filePath, "utf8");
+          content = await readFile30(filePath, "utf8");
         } catch {
           console.log(JSON.stringify({ ok: true, warnings: [], note: "file missing" }));
           return;
@@ -10800,19 +13569,22 @@ var validateCommand = defineCommand22({
       },
       async run({ args }) {
         const cwd = typeof args.cwd === "string" ? args.cwd : process.cwd();
-        const resolved = await resolveEditedPath(path53.resolve(cwd));
+        const resolved = await resolveEditedPath(path55.resolve(cwd));
         if (!resolved) {
           console.log(JSON.stringify({}));
           return;
         }
         const { filePath, content } = resolved;
         if (isHandoffPath(filePath)) {
-          const warnings = validateHandoffText(content);
+          const warnings = [
+            ...validateHandoffText(content).map((w) => w.message),
+            ...checkHandoffGrowth(content).map((w) => w.message)
+          ];
           if (!warnings.length) {
             console.log(JSON.stringify({}));
             return;
           }
-          const msg = warnings.map((w) => w.message).join(" ");
+          const msg = warnings.join(" ");
           console.log(
             JSON.stringify({
               user_message: msg,
@@ -10846,7 +13618,7 @@ var validateCommand = defineCommand22({
 import { bold as bold2, gray as gray4, underline } from "kolorist";
 
 // src/welcome/screen.ts
-import { blue as blue2, cyan as cyan6, gray as gray3, lightCyan, trueColor as trueColor2, white as white2 } from "kolorist";
+import { blue as blue2, cyan as cyan6, gray as gray3, lightCyan, trueColor as trueColor3, white as white2 } from "kolorist";
 var HELMET_ASCII = [
   "       ____",
   "    .-'    '-.",
@@ -10867,7 +13639,7 @@ function hexToRgb(hex) {
 }
 function outlineAnsi(line) {
   const [r, g, b] = hexToRgb(HELMET_OUTLINE);
-  return trueColor2(r, g, b)(line);
+  return trueColor3(r, g, b)(line);
 }
 function hasCliSubcommand(rawArgs) {
   return Boolean(rawArgs?.some((arg) => !arg.startsWith("-")));
@@ -10913,7 +13685,7 @@ function renderWelcomeScreen(opts = {}) {
     })(),
     "",
     muted2(
-      "Chat HITL (start-project, git-staging/prod, run-plan-all) stays in Cursor slash commands."
+      "Terminal: agent-kit run-plan-all (same as agent-kit run run-plan-all). Cursor chat: /run-plan-all."
     ),
     muted2(
       `${shouldUseVisualMotion(opts) ? SPACE_MARKS.star : SPACE_MARKS.tick} ${tipAt(
@@ -10938,7 +13710,7 @@ var CLI_HELP_GROUPS = [
   {
     id: "mission",
     title: "MISSION",
-    commands: ["handoff", "plan-index", "run", "run-plan"]
+    commands: ["handoff", "plan-index", "run", "run-plan", "run-plan-all"]
   },
   {
     id: "dashboard",
@@ -11004,7 +13776,7 @@ async function renderGroupedRootHelp(cmd) {
   lines.push(
     g(`Use \`${name} <command> --help\` for more information about a command.`),
     g(
-      "Ask questions is Cursor-only. Use `agent-kit run <slash>` for headless numbered-list HITL. `/git-prod` stays operator-gated."
+      "Ask questions is Cursor-only. Use `agent-kit run-plan-all` or `agent-kit run <slash>` for headless numbered-list HITL. `/git-prod` stays operator-gated."
     ),
     g(`${tipMark} ${tip}`),
     ""
@@ -11013,6 +13785,9 @@ async function renderGroupedRootHelp(cmd) {
 }
 
 // src/index.ts
+var rewrittenArgv = rewriteRootArgvToRun(process.argv.slice(2));
+process.argv.length = 2;
+process.argv.push(...rewrittenArgv);
 var main = defineCommand23({
   meta: {
     name: "agent-kit",
@@ -11035,6 +13810,7 @@ var main = defineCommand23({
     "plan-index": planIndexCommand,
     run: runCommand,
     "run-plan": runPlanCommand,
+    "run-plan-all": runPlanAllCommand,
     dashboard: dashboardCommand,
     "dashboard-broadcast": dashboardBroadcastCommand,
     "mission-control": missionControlCommand,