@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/chunk-PCCQUWE5.js

@@ -0,0 +1,817 @@
+import {
+  REPO_ROOT_ENV,
+  bundledDashboardCandidates,
+  findDashboardStart
+} from "./chunk-HFUH3HVS.js";
+import {
+  HELMET_ACCENT,
+  HELMET_FILL,
+  HELMET_OUTLINE,
+  LABEL_MUTED,
+  SPACE_MARKS,
+  STATUS_ERR,
+  STATUS_INFO,
+  STATUS_OK,
+  STATUS_WARN,
+  shouldUseVisualMotion,
+  shouldUseWelcomeColor,
+  spinnerFrame,
+  withKoloristColor,
+  wrapNarrow
+} from "./chunk-QTON2GQX.js";
+
+// src/mission-control/snapshot.ts
+import { execFile } from "child_process";
+import { access } from "fs/promises";
+import path from "path";
+
+// ../../dashboard/lib/live-refresh.mjs
+import { join, resolve } from "path";
+var PERIODIC_REFRESH_MS = 15e3;
+var SNAPSHOT_REPO_SOURCE_RELS = Object.freeze([
+  ".cursor/plans",
+  ".cursor/HANDOFF.md",
+  ".cursor/agents",
+  ".cursor/commands",
+  ".cursor/memory",
+  ".cursor/context/config.json",
+  ".cursor/context/current",
+  ".cursor/context/readiness.json",
+  ".cursor/context/field-report-dismissals.json",
+  ".cursor/context/mission-timing.json",
+  ".cursor/context/flight-log.json",
+  ".cursor/context/field-report-cadence.json",
+  ".cursor/skills",
+  "package.json"
+]);
+
+// src/mission-control/snapshot.ts
+var DEFAULT_DATA_TIMEOUT_MS = 6e4;
+function dataScriptTimeoutMs(env = process.env) {
+  const raw = env.AGENT_KIT_DASHBOARD_DATA_TIMEOUT_MS;
+  const n = raw != null && raw !== "" ? Number(raw) : DEFAULT_DATA_TIMEOUT_MS;
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_DATA_TIMEOUT_MS;
+}
+async function firstExisting(candidates) {
+  for (const candidate of candidates) {
+    try {
+      await access(candidate);
+      return path.resolve(candidate);
+    } catch {
+    }
+  }
+  return null;
+}
+async function findDashboardDataScript(cwd, env = process.env, options = {}) {
+  const startPath = await findDashboardStart(cwd, env, options);
+  if (startPath) {
+    const sibling = path.join(path.dirname(startPath), "dashboard-data.mjs");
+    try {
+      await access(sibling);
+      return sibling;
+    } catch {
+    }
+  }
+  return firstExisting(
+    bundledDashboardCandidates("dashboard-data.mjs", options.moduleUrl ?? import.meta.url)
+  );
+}
+async function loadDashboardSnapshot(opts) {
+  const env = opts.env ?? process.env;
+  const timeout = dataScriptTimeoutMs(env);
+  const run = opts.execFileFn ?? execFile;
+  const snapshotRoot = path.resolve(opts.snapshotRoot);
+  return new Promise((resolve2) => {
+    run(
+      process.execPath,
+      [opts.dataScript],
+      {
+        cwd: snapshotRoot,
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024,
+        timeout,
+        env: {
+          ...env,
+          [REPO_ROOT_ENV]: snapshotRoot
+        }
+      },
+      (err, stdout) => {
+        if (err) {
+          const killed = Boolean(
+            err && typeof err === "object" && "killed" in err && err.killed
+          );
+          const message = killed ? `dashboard-data.mjs timed out after ${timeout}ms (set AGENT_KIT_DASHBOARD_DATA_TIMEOUT_MS to raise)` : err.message;
+          resolve2({ ok: false, error: message });
+          return;
+        }
+        try {
+          const parsed = JSON.parse(String(stdout ?? ""));
+          if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            resolve2({ ok: false, error: "dashboard-data.mjs returned non-object JSON" });
+            return;
+          }
+          resolve2({ ok: true, snapshot: parsed });
+        } catch {
+          resolve2({ ok: false, error: "dashboard-data.mjs returned invalid JSON" });
+        }
+      }
+    );
+  });
+}
+
+// src/mission-control/view.ts
+var CHECKLIST_CAP = 8;
+var CREW_CAP = 12;
+var EARLIER_CAP = 4;
+var WARNING_CAP = 5;
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
+}
+function asString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function compactTodo(value) {
+  const rec = asRecord(value);
+  if (!rec) return asString(value);
+  return asString(rec.id) ?? asString(rec.content) ?? asString(rec.label);
+}
+function progressLabel(progress) {
+  const rec = asRecord(progress);
+  if (!rec) return "0 of 0 complete";
+  const labeled2 = asString(rec.label);
+  if (labeled2) return labeled2;
+  const completed = typeof rec.completed === "number" ? rec.completed : 0;
+  const total = typeof rec.total === "number" ? rec.total : 0;
+  return `${completed} of ${total} complete`;
+}
+function emptyMission() {
+  return {
+    status: "idle",
+    planFile: null,
+    mode: null,
+    progressLabel: "0 of 0 complete",
+    currentTodo: null,
+    nextTodo: null,
+    gaps: null
+  };
+}
+function emptyFlightLog() {
+  return { now: null, nowKind: null, earlier: [], warnings: [] };
+}
+function buildMcTuiView(snapshot, error = null) {
+  if (error) {
+    return {
+      mission: emptyMission(),
+      flightLog: emptyFlightLog(),
+      checklist: [],
+      crewMonitor: [],
+      error
+    };
+  }
+  const mc = asRecord(snapshot?.missionControl);
+  const now = asRecord(mc?.now);
+  const mission = now ? {
+    status: asString(now.status) ?? "idle",
+    planFile: asString(now.planFile),
+    mode: asString(now.mode),
+    progressLabel: progressLabel(now.progress),
+    currentTodo: compactTodo(now.currentTodo),
+    nextTodo: compactTodo(now.nextTodo),
+    gaps: asString(now.gaps)
+  } : emptyMission();
+  const flight = asRecord(mc?.flightLog);
+  const earlierRaw = Array.isArray(flight?.past) ? flight.past : [];
+  const warningRaw = Array.isArray(flight?.warnings) ? flight.warnings : [];
+  const flightLog = flight ? {
+    now: asString(flight.current),
+    nowKind: asString(flight.currentKind),
+    earlier: earlierRaw.map((entry) => asString(asRecord(entry)?.text) ?? asString(entry)).filter((text) => Boolean(text)).slice(0, EARLIER_CAP),
+    warnings: warningRaw.map((entry) => asString(asRecord(entry)?.text) ?? asString(asRecord(entry)?.title)).filter((text) => Boolean(text)).slice(0, WARNING_CAP)
+  } : emptyFlightLog();
+  const plansRaw = Array.isArray(mc?.plans) ? mc.plans : [];
+  const checklist = plansRaw.map((plan) => {
+    const rec = asRecord(plan);
+    if (!rec) return null;
+    const file = asString(rec.file);
+    if (!file) return null;
+    const lifecycle = asString(rec.lifecycle) ?? "unknown";
+    if (lifecycle === "completed") return null;
+    return {
+      file,
+      lifecycle,
+      progressLabel: progressLabel(rec.progress),
+      currentTodo: compactTodo(rec.currentTodo)
+    };
+  }).filter((row) => Boolean(row)).slice(0, CHECKLIST_CAP);
+  const feedCap = typeof mc?.monitorFeedCap === "number" && mc.monitorFeedCap > 0 ? Math.min(CREW_CAP, Math.floor(mc.monitorFeedCap)) : CREW_CAP;
+  const activityRaw = Array.isArray(mc?.activity) ? mc.activity : [];
+  const crewMonitor = activityRaw.map((event) => {
+    const rec = asRecord(event);
+    if (!rec) return null;
+    const label = asString(rec.label) ?? asString(rec.labelFull);
+    if (!label) return null;
+    return { kind: asString(rec.kind) ?? "activity", label };
+  }).filter((row) => Boolean(row)).slice(0, feedCap);
+  return { mission, flightLog, checklist, crewMonitor, error: null };
+}
+
+// src/mission-control/render.ts
+import { trueColor } from "kolorist";
+var DEFAULT_COLUMNS = 80;
+var MIN_COLUMNS = 40;
+var INNER_PAD = 2;
+var ESC = "\x1B";
+var ANSI_RE = new RegExp(`${ESC}\\[[0-9;]*m`, "g");
+var STATUS_OK_KEYS = /* @__PURE__ */ new Set([
+  "executing",
+  "completed",
+  "ok",
+  "run_plan",
+  "success",
+  "done",
+  "started",
+  "merged"
+]);
+var STATUS_WARN_KEYS = /* @__PURE__ */ new Set([
+  "awaiting",
+  "awaiting_user",
+  "warning",
+  "handoff",
+  "stopped",
+  "residual"
+]);
+var STATUS_ERR_KEYS = /* @__PURE__ */ new Set(["error", "failed", "fail", "blocked", "incomplete", "fix"]);
+var STATUS_INFO_KEYS = /* @__PURE__ */ new Set([
+  "backlog",
+  "queued",
+  "parked",
+  "delivery",
+  "memory",
+  "activity",
+  "advice",
+  "prompt"
+]);
+function hexPaint(hex, text, color) {
+  if (!color) return text;
+  return withKoloristColor(
+    () => trueColor(
+      Number.parseInt(hex.slice(1, 3), 16),
+      Number.parseInt(hex.slice(3, 5), 16),
+      Number.parseInt(hex.slice(5, 7), 16)
+    )(text)
+  );
+}
+function muted(text, color) {
+  return hexPaint(LABEL_MUTED, text, color);
+}
+function statusTokenHex(token) {
+  const key = token.trim().toLowerCase();
+  if (STATUS_OK_KEYS.has(key)) return STATUS_OK;
+  if (STATUS_WARN_KEYS.has(key)) return STATUS_WARN;
+  if (STATUS_ERR_KEYS.has(key)) return STATUS_ERR;
+  if (STATUS_INFO_KEYS.has(key)) return STATUS_INFO;
+  return HELMET_OUTLINE;
+}
+function paintStatus(text, color) {
+  return hexPaint(statusTokenHex(text), text, color);
+}
+function visibleLength(text) {
+  return text.replace(ANSI_RE, "").length;
+}
+function clipToVisible(text, max) {
+  if (visibleLength(text) <= max) return text;
+  return text.replace(ANSI_RE, "").slice(0, max);
+}
+function box(title, bodyLines, width, color) {
+  const inner = Math.max(8, width - 2);
+  const label = ` ${title} `;
+  const dashCount = Math.max(1, inner - label.length);
+  const top = `\u250C${label}${"\u2500".repeat(dashCount)}\u2510`;
+  const bottom = `\u2514${"\u2500".repeat(inner)}\u2518`;
+  const paintedTop = hexPaint(HELMET_FILL, top, color);
+  const paintedBottom = hexPaint(HELMET_OUTLINE, bottom, color);
+  const max = inner - INNER_PAD;
+  const rows = bodyLines.map((line) => {
+    const clipped = clipToVisible(line, max);
+    const pad = " ".repeat(Math.max(0, max - visibleLength(clipped)));
+    const content = ` ${clipped}${pad} `;
+    return `${hexPaint(HELMET_OUTLINE, "\u2502", color)}${content}${hexPaint(HELMET_OUTLINE, "\u2502", color)}`;
+  });
+  return [paintedTop, ...rows, paintedBottom];
+}
+function lineOrQuiet(text, fallback) {
+  const trimmed = text?.trim();
+  return trimmed ? trimmed : fallback;
+}
+function labeled(label, value, color, valueHex = HELMET_OUTLINE) {
+  return `${hexPaint(LABEL_MUTED, label, color)}${hexPaint(valueHex, value, color)}`;
+}
+function paintNowLine(flight, color) {
+  if (!flight.now) {
+    return labeled("NOW  ", "All clear", color, STATUS_OK);
+  }
+  const kind = flight.nowKind?.trim();
+  const prefix = kind ? `${hexPaint(LABEL_MUTED, "NOW ", color)}${hexPaint(statusTokenHex(kind), `(${kind})`, color)}${hexPaint(HELMET_OUTLINE, "  ", color)}` : hexPaint(LABEL_MUTED, "NOW   ", color);
+  return `${prefix}${hexPaint(HELMET_OUTLINE, flight.now, color)}`;
+}
+function renderMcTui(view, opts = {}) {
+  const color = shouldUseWelcomeColor(opts);
+  const motion = shouldUseVisualMotion(opts);
+  const columns = Math.max(
+    MIN_COLUMNS,
+    Math.floor(opts.columns ?? process.stdout.columns ?? DEFAULT_COLUMNS)
+  );
+  const mark = motion ? spinnerFrame(opts.frameIndex ?? 0) : SPACE_MARKS.tick;
+  const header = hexPaint(
+    HELMET_ACCENT,
+    `${mark} Mission Control ${SPACE_MARKS.star} terminal view (web dashboard unchanged)`,
+    color
+  );
+  const missionBody = view.error ? [
+    hexPaint(
+      STATUS_ERR,
+      wrapNarrow(view.error, columns - 4).split("\n")[0] ?? view.error,
+      color
+    )
+  ] : [
+    `${hexPaint(LABEL_MUTED, "status  ", color)}${paintStatus(view.mission.status, color)}${view.mission.mode ? hexPaint(HELMET_OUTLINE, `  \xB7  ${view.mission.mode}`, color) : ""}`,
+    labeled("plan    ", lineOrQuiet(view.mission.planFile, "none"), color),
+    labeled("todos   ", view.mission.progressLabel, color),
+    labeled("now     ", lineOrQuiet(view.mission.currentTodo, "none"), color),
+    labeled("next    ", lineOrQuiet(view.mission.nextTodo, "none"), color)
+  ];
+  const flightBody = [
+    paintNowLine(view.flightLog, color),
+    ...view.flightLog.warnings.map((w) => labeled("warn  ", w, color, STATUS_WARN)),
+    ...view.flightLog.earlier.length > 0 ? view.flightLog.earlier.map((t) => labeled("Earlier  ", t, color)) : [muted("Earlier  none", color)]
+  ];
+  const checklistBody = view.checklist.length === 0 ? [muted("no open plans", color)] : view.checklist.map((row) => {
+    const todo = row.currentTodo ? `  \xB7  ${row.currentTodo}` : "";
+    return `${hexPaint(HELMET_OUTLINE, `${row.file}  `, color)}${paintStatus(row.lifecycle, color)}${hexPaint(HELMET_OUTLINE, `  ${row.progressLabel}${todo}`, color)}`;
+  });
+  const crewBody = view.crewMonitor.length === 0 ? [muted("quiet", color)] : view.crewMonitor.map(
+    (row) => `${paintStatus(row.kind, color)}${hexPaint(HELMET_OUTLINE, `  ${row.label}`, color)}`
+  );
+  const panels = [
+    ...box("Mission", missionBody, columns, color),
+    ...box("Flight Log", flightBody, columns, color),
+    ...box("Checklist", checklistBody, columns, color),
+    ...box("Crew Monitor", crewBody, columns, color)
+  ];
+  const footer = muted("Third surface \xB7 local snapshot \xB7 q / Ctrl-C to quit live view", color);
+  return [header, ...panels, footer].join("\n");
+}
+function shouldLiveRefresh(opts) {
+  if (opts.once) return false;
+  const env = opts.env ?? process.env;
+  if (env.CI != null && env.CI !== "") return false;
+  const tty = opts.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
+  return tty;
+}
+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 now = 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(now - 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/loop.ts
+var CLEAR_HOME = "\x1B[2J\x1B[H";
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+function quitKeyOf(chunk) {
+  const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+  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,
+    env: opts.env
+  });
+  let frameIndex = 0;
+  let inFlight = false;
+  let stopped = false;
+  const paint = async (clear) => {
+    if (inFlight || stopped) return;
+    inFlight = true;
+    try {
+      const view = await opts.loadView();
+      if (stopped) return;
+      const frame = render(view, {
+        ...opts.renderOpts,
+        stdoutIsTTY: opts.stdoutIsTTY,
+        frameIndex
+      });
+      frameIndex += 1;
+      opts.hooks.write(clear ? `${CLEAR_HOME}${frame}
+` : `${frame}
+`);
+    } catch (err) {
+      if (stopped) return;
+      const message = err instanceof Error ? err.message : String(err);
+      const frame = renderMcTui(buildMcTuiView(null, message), {
+        ...opts.renderOpts,
+        stdoutIsTTY: opts.stdoutIsTTY,
+        frameIndex
+      });
+      frameIndex += 1;
+      opts.hooks.write(clear ? `${CLEAR_HOME}${frame}
+` : `${frame}
+`);
+    } finally {
+      inFlight = false;
+    }
+  };
+  await paint(false);
+  if (!live) return null;
+  opts.hooks.write(HIDE_CURSOR);
+  const intervalMs = opts.intervalMs ?? PERIODIC_REFRESH_MS;
+  const setInt = opts.hooks.setIntervalFn ?? setInterval;
+  const clearInt = opts.hooks.clearIntervalFn ?? clearInterval;
+  let timer;
+  try {
+    timer = setInt(() => {
+      void paint(true);
+    }, intervalMs);
+  } catch (err) {
+    opts.hooks.write(SHOW_CURSOR);
+    throw err;
+  }
+  const stdin = opts.hooks.stdin;
+  const attachQuit = Boolean(stdin?.isTTY);
+  let quitListener;
+  const restoreStdin = () => {
+    if (!stdin || !attachQuit) return;
+    if (quitListener) {
+      stdin.off?.("data", quitListener);
+      quitListener = void 0;
+    }
+    try {
+      stdin.setRawMode?.(false);
+    } catch {
+    }
+    stdin.pause?.();
+  };
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    clearInt(timer);
+    restoreStdin();
+    opts.hooks.write(SHOW_CURSOR);
+  };
+  if (attachQuit && stdin) {
+    stdin.setRawMode?.(true);
+    stdin.resume?.();
+    quitListener = (chunk) => {
+      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,
+    repaint: () => stopped ? Promise.resolve() : paint(true)
+  };
+}
+
+export {
+  ScrollRegion,
+  InputLine,
+  renderMcLive,
+  findDashboardDataScript,
+  loadDashboardSnapshot,
+  buildMcTuiView,
+  runMcTuiLoop
+};