@dadado/agent-kit-cli 5.9.0 → 5.10.0

package/dist/index.js

@@ -274,7 +274,73 @@ var KNOWN_SHIPPED_OVERLAY_HASHES = /* @__PURE__ */ new Set([
   "481a9994ccecaa611173f9ef91a1dbe7458d89758c6a6b5e7c3bbbbf460888ce",
   "691d91fd1e9032b6f9315f29348d4473201917da257258afd74eb954298d8d71",
   "ab0808b7dbc333e523b87b126bb655353cde2574db30d849cc9c9037843bef8c",
-  "85514e26af694bbe38e7ddf625710a32719ddf6afc173843c9cdfbffdad8e466"
+  "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
@@ -1521,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"
@@ -1590,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"
@@ -1618,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"
@@ -2168,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}`);
@@ -2266,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}`,
@@ -2291,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",
@@ -2315,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",
@@ -2534,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) {
@@ -4016,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(
@@ -4104,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
@@ -4477,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
@@ -4532,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"));
@@ -4571,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 = [];
@@ -4586,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");
@@ -4622,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",
@@ -4633,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"],
@@ -4668,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")) ?? {};
@@ -4728,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,
@@ -4782,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
     }
   };
 }
@@ -4855,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",
@@ -5008,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);
@@ -5123,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;
@@ -5280,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);
@@ -5290,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, {
@@ -5303,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, {
@@ -5311,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;
@@ -5328,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)) {
@@ -5787,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;
@@ -5806,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);
@@ -5916,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");
@@ -5997,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
@@ -6040,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;
@@ -6049,7 +6723,7 @@ function defaultPlanIndexIo() {
   return {
     async readFile(absPath) {
       try {
-        return await readFile15(absPath, "utf8");
+        return await readFile17(absPath, "utf8");
       } catch {
         return null;
       }
@@ -6220,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)
 
@@ -6229,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.
@@ -6252,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 "";
   }
@@ -6379,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;
   }
@@ -6416,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 {
     }
@@ -6426,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) {
@@ -6504,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) {
@@ -6699,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);
@@ -6724,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`)."
@@ -6816,7 +7617,7 @@ import { spawn as spawn6 } from "child_process";
 import path32 from "path";
 
 // src/utils/terminal.ts
-import { readdir as readdir6 } from "fs/promises";
+import { readdir as readdir8 } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import path31 from "path";
 import { confirm, isCancel } from "@clack/prompts";
@@ -6830,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 [];
   }
@@ -7110,11 +7911,11 @@ 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 { 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 { 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";
@@ -7137,7 +7938,7 @@ 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.
@@ -7147,7 +7948,7 @@ async function discoverInstalledCommands(rootDir) {
   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 [];
   }
@@ -7156,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(path33.join(dir, file), "utf8");
+      const raw = await readFile19(path33.join(dir, file), "utf8");
       const parsed = parseCommandFrontmatter(name, raw);
       if (parsed) commands.push(parsed);
     } catch {
@@ -7182,7 +7983,7 @@ async function generateClaudeCommandAdapters(rootDir) {
       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);
@@ -7278,7 +8079,7 @@ async function generateClaudeKitLoadArtifacts(rootDir) {
 }
 
 // src/generator/claude-session-start-hook.ts
-import { readFile as readFile18, writeFile as writeFile10 } from "fs/promises";
+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";
@@ -7357,7 +8158,7 @@ async function writeClaudeSessionStartHook(rootDir) {
   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;
   }
@@ -7881,12 +8682,12 @@ async function applyPersonalization(input) {
 async function readRepositoryProfile(rootDir) {
   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 { 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";
@@ -7898,7 +8699,7 @@ async function migrateLegacyOnboardCommand(projectRoot, managedHashes = MANAGED_
   if (!await fileExists(legacyPath)) return "absent";
   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);
@@ -8433,32 +9234,354 @@ function shouldLiveRefresh(opts) {
   const tty = opts.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
   return tty;
 }
-
-// src/mission-control/snapshot.ts
-import { execFile as execFile6 } from "child_process";
-import { access as access8 } from "fs/promises";
-import path40 from "path";
-
-// ../../dashboard/lib/live-refresh.mjs
-import { join, resolve as resolve2 } from "path";
-var PERIODIC_REFRESH_MS = 15e3;
-var SNAPSHOT_REPO_SOURCE_RELS = Object.freeze([
-  ".cursor/plans",
-  ".cursor/HANDOFF.md",
-  ".cursor/agents",
-  ".cursor/commands",
-  ".cursor/memory",
-  ".cursor/context/config.json",
-  ".cursor/context/current",
-  ".cursor/context/readiness.json",
-  ".cursor/context/field-report-dismissals.json",
-  ".cursor/context/mission-timing.json",
-  ".cursor/context/flight-log.json",
-  ".cursor/context/field-report-cadence.json",
-  ".cursor/skills",
-  "package.json"
-]);
-
+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 path40 from "path";
+
+// ../../dashboard/lib/live-refresh.mjs
+import { join, resolve as resolve2 } from "path";
+var PERIODIC_REFRESH_MS = 15e3;
+var SNAPSHOT_REPO_SOURCE_RELS = Object.freeze([
+  ".cursor/plans",
+  ".cursor/HANDOFF.md",
+  ".cursor/agents",
+  ".cursor/commands",
+  ".cursor/memory",
+  ".cursor/context/config.json",
+  ".cursor/context/current",
+  ".cursor/context/readiness.json",
+  ".cursor/context/field-report-dismissals.json",
+  ".cursor/context/mission-timing.json",
+  ".cursor/context/flight-log.json",
+  ".cursor/context/field-report-cadence.json",
+  ".cursor/skills",
+  "package.json"
+]);
+
 // src/mission-control/snapshot.ts
 var DEFAULT_DATA_TIMEOUT_MS = 6e4;
 function dataScriptTimeoutMs(env = process.env) {
@@ -8636,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,
@@ -8648,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
@@ -8663,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,
@@ -8677,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;
@@ -8686,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);
@@ -8695,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) {
@@ -8719,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
@@ -8807,7 +9945,7 @@ 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 { readFile as readFile23, readdir as readdir10, stat as stat5 } from "fs/promises";
 import path41 from "path";
 import { promisify as promisify6 } from "util";
 
@@ -8832,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 [];
@@ -8880,7 +10018,7 @@ async function selectUntriagedMonitors(rootDir) {
   for (const name of allNames) {
     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 {
     }
@@ -8893,7 +10031,7 @@ async function selectUntriagedMonitors(rootDir) {
   const gitFreshSet = [...gitFresh].filter(untriaged).sort();
   let handoff = "";
   try {
-    handoff = await readFile21(path41.join(root, ".cursor", "HANDOFF.md"), "utf8");
+    handoff = await readFile23(path41.join(root, ".cursor", "HANDOFF.md"), "utf8");
   } catch {
     handoff = "";
   }
@@ -9011,7 +10149,7 @@ var planIndexCommand = defineCommand15({
 });
 
 // src/commands/run-plan.ts
-import path49 from "path";
+import path50 from "path";
 import { defineCommand as defineCommand16 } from "citty";
 
 // src/plan-loop/backends.ts
@@ -9019,7 +10157,677 @@ import { execFileSync as execFileSync2, spawn as spawn7 } from "child_process";
 import { createWriteStream } from "fs";
 import { access as access9 } from "fs/promises";
 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 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
+];
+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 last;
+}
+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");
+  feed(chunk) {
+    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) 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 (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);
+          }
+        }
+      }
+      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
+      });
+    }
+  }
+};
+
+// 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);
+}
+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",
@@ -9036,7 +10844,7 @@ function redactSecrets(text, secrets) {
 var REDACT_HOLD_MAX_CHARS = 64 * 1024;
 var RedactingStreamBuffer = class {
   pending = "";
-  decoder = new StringDecoder("utf8");
+  decoder = new StringDecoder3("utf8");
   secrets;
   keep;
   constructor(secrets) {
@@ -9177,6 +10985,8 @@ function spawnLogged(command, args, logPath, options = {}) {
   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;
@@ -9188,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 } : {}
       });
@@ -9196,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;
@@ -9220,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() {
@@ -9252,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"
     });
   }
 };
@@ -9303,7 +11263,7 @@ function checkClaudeVersion(bin, versionFn = defaultVersionFn) {
   }
   return { ok: true, version };
 }
-function claudeHeadlessArgs(opts) {
+function claudeHeadlessArgs(opts = {}) {
   const args = [
     "-p",
     "--output-format",
@@ -9311,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));
@@ -9322,7 +11285,6 @@ function claudeHeadlessArgs(opts) {
   if (opts.model) {
     args.push("--model", opts.model);
   }
-  args.push(opts.prompt);
   return args;
 }
 async function missingClaudeAdapter(workspace, prompt) {
@@ -9367,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)}`);
@@ -9445,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 path48 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 spawn8 } from "child_process";
-import path45 from "path";
-var CANONICAL_REL = path45.join(".cursor", "scripts", "plan-external-review.sh");
-var FALLBACK_REL = path45.join("scripts", "plan-external-review.sh");
+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;
@@ -9474,8 +11893,8 @@ async function armExternalPlanReview(root, options = {}) {
   const existsFn = options.existsFn ?? fileExists;
   const log = options.log ?? ((line) => console.log(line));
   const force = options.force === true;
-  const canonicalPath = path45.join(root, CANONICAL_REL);
-  const fallbackPath = path45.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)) {
@@ -9528,7 +11947,7 @@ async function armExternalPlanReview(root, options = {}) {
 }
 
 // src/plan-loop/persona-banners.ts
-import path46 from "path";
+import path48 from "path";
 import {
   blue,
   cyan as cyan4,
@@ -9564,7 +11983,7 @@ function resolveColor(name, fallback) {
 async function resolveCliPersonaId(root) {
   try {
     const cfg = await readJson(
-      path46.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];
@@ -9575,7 +11994,7 @@ async function resolveCliPersonaId(root) {
 }
 async function loadPersonaPack(root, personaId) {
   try {
-    const personaPath = path46.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;
@@ -9623,44 +12042,8 @@ function createPersonaBannerPrinter(persona) {
   };
 }
 
-// src/plan-loop/plan-state.ts
-import { readFile as readFile22, readdir as readdir9 } from "fs/promises";
-import path47 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] ? path47.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;
@@ -9726,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" };
@@ -9747,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");
@@ -9756,9 +12173,9 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 async function runPlanLoop(opts) {
-  const plansDir = path48.join(opts.root, ".cursor", "plans");
-  const stopFile = path48.join(opts.root, ".cursor", "loop.stop");
-  const logDir = path48.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/");
@@ -9779,7 +12196,7 @@ async function runPlanLoop(opts) {
   try {
     const persona = await loadCliRunPlanPersona(opts.root);
     const banners = createPersonaBannerPrinter(persona);
-    console.log(`Active plan: ${path48.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) {
@@ -9798,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) {
@@ -9822,30 +12240,47 @@ async function runPlanLoop(opts) {
         planExhausted = true;
         break;
       }
-      const logPath = path48.join(logDir, `tick-${stamp()}.log`);
-      const relLog = path48.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);
@@ -9914,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 ${path48.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);
   }
@@ -9961,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 }) {
@@ -9996,12 +12441,14 @@ var runPlanCommand = defineCommand16({
       return;
     }
     const code = await runPlanLoop({
-      root: path49.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;
   }
@@ -10009,12 +12456,12 @@ var runPlanCommand = defineCommand16({
 
 // src/commands/run.ts
 import { homedir as homedir4 } from "os";
-import path51 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 path50 from "path";
+import { mkdir as mkdir7, readFile as readFile28 } from "fs/promises";
+import path51 from "path";
 var RUN_CATALOG = [
   "run-plan",
   "run-plan-all",
@@ -10058,11 +12505,11 @@ function rewriteRootArgvToRun(argv) {
   return next;
 }
 function commandMarkdownPath(root, name) {
-  return path50.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(),
     ""
@@ -10083,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() {
@@ -10106,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) {
@@ -10123,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)}`);
@@ -10138,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 = path50.join(root, ".cursor", "loop-logs");
+  const logDir = path51.join(root, ".cursor", "loop-logs");
   await mkdir7(logDir, { recursive: true });
-  return path50.join(logDir, `run-${stamp2()}.log`);
+  return path51.join(logDir, `run-${stamp2()}.log`);
 }
 
 // src/commands/run.ts
 function displayPath(target, home = homedir4()) {
-  const resolvedHome = path51.resolve(home);
+  const resolvedHome = path52.resolve(home);
   if (target === resolvedHome) return "~";
-  const prefix = resolvedHome.endsWith(path51.sep) ? resolvedHome : `${resolvedHome}${path51.sep}`;
-  return target.startsWith(prefix) ? `~${path51.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 = path51.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>" };
@@ -10191,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 };
   }
@@ -10204,7 +12669,7 @@ async function executeRun(input) {
     const stdout = [
       "--dry-run: no agent will be started.",
       `Slash: ${slash}`,
-      `Command file: ${path51.relative(root, file.path)}`,
+      `Command file: ${path52.relative(root, file.path)}`,
       `Backend: ${detected.id} (${displayPath(detected.bin)})`,
       "Prompt:",
       prompt
@@ -10213,18 +12678,32 @@ async function executeRun(input) {
   }
   const logPath = await ensureDispatchLogPath(root);
   console.log(`Dispatch: ${slash} via ${detected.id}`);
-  console.log(`Command file: ${path51.relative(root, file.path)}`);
-  console.log(`Log: ${path51.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) };
   }
@@ -10259,6 +12738,16 @@ var runDispatchArgs = {
     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) {
@@ -10281,7 +12770,9 @@ async function runSlashCli(slash, args) {
     model: args.model ? String(args.model) : void 0,
     dryRun: Boolean(args["dry-run"]),
     maxTicks,
-    sleepSeconds
+    sleepSeconds,
+    noHitl: Boolean(args["no-hitl"]),
+    plain: Boolean(args.plain)
   });
   if (result.stdout) {
     console.log(result.stdout);
@@ -10294,7 +12785,7 @@ async function runSlashCli(slash, args) {
 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: {
@@ -10311,7 +12802,7 @@ var runCommand = defineCommand17({
 var runPlanAllCommand = defineCommand17({
   meta: {
     name: "run-plan-all",
-    description: "Headless /run-plan-all queue from the L0 file. Numbered-list HITL. Never git-prod."
+    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 }) {
@@ -10343,9 +12834,9 @@ var scanCommand = defineCommand18({
 
 // src/commands/setup-global.ts
 import { spawn as spawn9 } from "child_process";
-import { appendFile, mkdir as mkdir8, readFile as readFile26, writeFile as writeFile13 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir8, readFile as readFile29, writeFile as writeFile13 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import path52 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";
@@ -10354,9 +12845,9 @@ var SETUP_GLOBAL_MARKER = "# agent-kit setup-global";
 function planSetupGlobalSteps(env, options = {}) {
   const homeDir = options.homeDir ?? homedir5();
   const packageSpec = options.packageSpec ?? pinnedCliSpec();
-  const npmGlobalDir = path52.join(homeDir, NPM_GLOBAL_DIR_NAME);
-  const npmGlobalBin = path52.join(npmGlobalDir, "bin");
-  const npmrcPath = path52.join(homeDir, ".npmrc");
+  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;
@@ -10424,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 {
@@ -10655,7 +13146,7 @@ var setupGlobalCommand = defineCommand19({
 });
 
 // src/commands/status.ts
-import path53 from "path";
+import path54 from "path";
 import { defineCommand as defineCommand20 } from "citty";
 function profileStatus(profile) {
   if (!profile) return { origin: "none", evidence: [], profile: null };
@@ -10686,11 +13177,11 @@ var statusCommand = defineCommand20({
     }
   },
   async run({ args }) {
-    const rootDir = path53.resolve(args.cwd);
+    const rootDir = path54.resolve(args.cwd);
     const [manifest, rawProfile, scan, env] = await Promise.all([
       loadAgentKitManifest(rootDir),
       readJson(
-        path53.join(rootDir, ".cursor", "agent-kit.config.json")
+        path54.join(rootDir, ".cursor", "agent-kit.config.json")
       ),
       runScanner(rootDir),
       assessEnvironment()
@@ -10935,8 +13426,8 @@ ${err.recovery}
 });
 
 // src/commands/validate.ts
-import { readFile as readFile27 } from "fs/promises";
-import path54 from "path";
+import { readFile as readFile30 } from "fs/promises";
+import path55 from "path";
 import { defineCommand as defineCommand22 } from "citty";
 
 // src/invariants/plan-schema.ts
@@ -10969,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",
@@ -10983,9 +13474,9 @@ function validatePlanFrontmatterText(text) {
 // src/commands/validate.ts
 async function resolveEditedPath(cwd, explicit) {
   if (explicit) {
-    const filePath2 = path54.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;
     }
@@ -10993,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 = path54.isAbsolute(rel) ? rel : path54.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;
   }
@@ -11023,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 ? path54.resolve(cwd, fileArg) : path54.join(path54.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 }));
       }
     }),
@@ -11050,10 +13547,10 @@ var validateCommand = defineCommand22({
           process.exitCode = 2;
           return;
         }
-        const filePath = path54.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;
@@ -11072,19 +13569,22 @@ var validateCommand = defineCommand22({
       },
       async run({ args }) {
         const cwd = typeof args.cwd === "string" ? args.cwd : process.cwd();
-        const resolved = await resolveEditedPath(path54.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,
@@ -11118,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 = [
   "       ____",
   "    .-'    '-.",
@@ -11139,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("-")));