@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/cockpit-RZKLGYPN.js

@@ -0,0 +1,790 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  spawnGatewayIfDown
+} from "./chunk-LVGIFMCV.js";
+
+// packages/cleo/src/cli/lib/tui/cockpit.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createCleoClient as createCleoClient2 } from "@cleocode/core/gateway-client";
+
+// packages/cleo/src/cli/lib/pi-tui-loader.ts
+var PI_TUI_INSTALL_HINT = 'The `cleo tui` cockpit requires the optional "@earendil-works/pi-tui" package. Install it with `pnpm add @earendil-works/pi-tui` (or `npm i -g @earendil-works/pi-tui`) to enable the rich differential-rendered terminal board.';
+var PI_TUI_SPECIFIER = "@earendil-works/pi-tui";
+var realImporter = (specifier) => import(specifier);
+var importer = realImporter;
+function shapeCheck(candidate) {
+  if (candidate === null || typeof candidate !== "object") return null;
+  const mod = candidate;
+  const tuiOk = typeof mod.TUI === "function";
+  const terminalOk = typeof mod.ProcessTerminal === "function";
+  const textOk = typeof mod.Text === "function";
+  if (tuiOk && terminalOk && textOk) {
+    return candidate;
+  }
+  return null;
+}
+async function loadPiTui() {
+  try {
+    const mod = await importer(PI_TUI_SPECIFIER);
+    const candidate = mod.default ?? mod;
+    return shapeCheck(candidate);
+  } catch {
+    return null;
+  }
+}
+var cachedAvailable;
+async function isPiTuiAvailable() {
+  if (cachedAvailable !== void 0) return cachedAvailable;
+  cachedAvailable = await loadPiTui() !== null;
+  return cachedAvailable;
+}
+
+// packages/cleo/src/cli/lib/tui/dispatch.ts
+import { createCleoClient } from "@cleocode/core/gateway-client";
+function clampTier(raw) {
+  return raw === 0 || raw === 2 ? raw : 1;
+}
+async function dispatchWorker(baseUrl, taskId, tier = 1) {
+  try {
+    const client = createCleoClient({ baseUrl });
+    const spawn = client.orchestrate.spawn;
+    const res = await spawn({ body: { taskId, tier } });
+    if (res.response == null) {
+      return {
+        ok: false,
+        taskId,
+        code: "E_GATEWAY_UNREACHABLE",
+        message: "daemon gateway not reachable \u2014 start it with `cleo daemon serve`"
+      };
+    }
+    const envelope = res.data;
+    if (envelope && envelope.success === false) {
+      return {
+        ok: false,
+        taskId,
+        code: "E_SPAWN_REJECTED",
+        message: envelope.error?.message ?? "spawn rejected"
+      };
+    }
+    return { ok: true, taskId, tier, data: envelope?.data ?? {} };
+  } catch (e) {
+    const message = e instanceof Error ? e.message : "spawn failed";
+    return { ok: false, taskId, code: "E_SPAWN_ERROR", message };
+  }
+}
+function buildConductorLane(taskId, assignee) {
+  return [
+    { label: "Orchestrator", value: "you", hint: "cockpit dispatcher" },
+    { label: "Lead", value: "orchestrate", hint: "spawn pipeline" },
+    {
+      label: "Worker",
+      value: assignee && assignee.length > 0 ? assignee : "worktree",
+      hint: `isolated agent \xB7 ${taskId}`
+    }
+  ];
+}
+function renderConductorLane(roles) {
+  const chain = roles.map((r) => `${r.label}(${r.value})`).join(" \u2192 ");
+  return `Conductor: ${chain}`;
+}
+
+// packages/cleo/src/cli/lib/tui/kanban-board.ts
+import {
+  AGENT_LIFECYCLE_LANE_HINTS,
+  AGENT_LIFECYCLE_LANE_LABELS,
+  AGENT_LIFECYCLE_LANES,
+  resolveAgentLifecycleLane
+} from "@cleocode/core/tasks";
+var HIDDEN_STATUSES = /* @__PURE__ */ new Set(["archived", "proposed"]);
+function toSignal(row) {
+  const gates = row.gates != null ? {
+    implemented: row.gates.implemented === true,
+    testsPassed: row.gates.testsPassed === true,
+    qaPassed: row.gates.qaPassed === true
+  } : null;
+  return {
+    status: row.status ?? "pending",
+    blockedBy: row.blockedBy ?? null,
+    depends: row.depends ?? null,
+    ...typeof row.unmetDependsCount === "number" ? { unmetDependsCount: row.unmetDependsCount } : {},
+    gates,
+    readyToComplete: row.readyToComplete === true,
+    prAwaiting: row.prAwaiting === true,
+    hitlPending: row.hitlPending === true,
+    workerActive: row.workerActive === true,
+    ...typeof row.nextAction === "string" ? { nextAction: row.nextAction } : {}
+  };
+}
+function toCard(row) {
+  return {
+    id: row.id ?? "(no-id)",
+    title: row.title ?? "",
+    epic: row.parentId ?? null,
+    assignee: row.assignee ?? null,
+    proof: row.proof ?? null
+  };
+}
+function buildKanbanBoard(rows) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const lane of AGENT_LIFECYCLE_LANES) buckets.set(lane, []);
+  let total = 0;
+  for (const row of rows) {
+    if (row.status != null && HIDDEN_STATUSES.has(row.status)) continue;
+    const lane = resolveAgentLifecycleLane(toSignal(row));
+    buckets.get(lane)?.push(toCard(row));
+    total += 1;
+  }
+  const columns = AGENT_LIFECYCLE_LANES.map((lane) => {
+    const cards = buckets.get(lane) ?? [];
+    return {
+      lane,
+      label: AGENT_LIFECYCLE_LANE_LABELS[lane],
+      hint: AGENT_LIFECYCLE_LANE_HINTS[lane],
+      cards,
+      count: cards.length
+    };
+  });
+  return { columns, total };
+}
+function formatCardLine(card) {
+  const parts = [`  \u2022 ${card.id}`];
+  if (card.title) parts.push(truncate(card.title, 48));
+  const tags = [];
+  if (card.epic) tags.push(`epic:${card.epic}`);
+  if (card.assignee) tags.push(`@${card.assignee}`);
+  if (card.proof) tags.push(`proof:${card.proof}`);
+  const head = parts.join("  ");
+  return tags.length > 0 ? `${head}  [${tags.join(" ")}]` : head;
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return `${s.slice(0, Math.max(0, max - 1))}\u2026`;
+}
+function renderKanbanBoardText(board, options) {
+  const cap = options?.maxCardsPerLane ?? 12;
+  const lines = [];
+  lines.push(`CLEO Cockpit \u2014 Kanban (${board.total} task${board.total === 1 ? "" : "s"})`);
+  lines.push("");
+  for (const col of board.columns) {
+    lines.push(`\u25B8 ${col.label}  (${col.count})`);
+    if (col.cards.length === 0) {
+      lines.push(`    ${col.hint}`);
+    } else {
+      for (const card of col.cards.slice(0, cap)) {
+        lines.push(formatCardLine(card));
+      }
+      if (col.cards.length > cap) {
+        lines.push(`    \u2026 and ${col.cards.length - cap} more`);
+      }
+    }
+    lines.push("");
+  }
+  return lines;
+}
+
+// packages/cleo/src/cli/lib/tui/sse-client.ts
+import http from "node:http";
+import https from "node:https";
+var NOOP_SUBSCRIPTION = { unsubscribe: () => {
+} };
+function decodeSseRecord(record) {
+  const dataLines = [];
+  for (const rawLine of record.split("\n")) {
+    const line = rawLine.replace(/\r$/, "");
+    if (line.startsWith(":")) continue;
+    if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).replace(/^ /, ""));
+    }
+  }
+  if (dataLines.length === 0) return null;
+  try {
+    const parsed = JSON.parse(dataLines.join("\n"));
+    if (parsed === null || typeof parsed !== "object") return null;
+    const obj = parsed;
+    if (obj.kind !== "data" && obj.kind !== "done" && obj.kind !== "error") return null;
+    if (typeof obj.seq !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function subscribeOrchestrateEvents(options, handlers) {
+  let url;
+  try {
+    url = new URL("/v1/orchestrate/events", options.baseUrl);
+  } catch {
+    handlers.onError?.("invalid gateway base URL");
+    return NOOP_SUBSCRIPTION;
+  }
+  if (typeof options.taskId === "string" && options.taskId.length > 0) {
+    url.searchParams.set("taskId", options.taskId);
+  }
+  const transport = url.protocol === "https:" ? https : http;
+  let buffer = "";
+  let closed = false;
+  let request = null;
+  const teardown = (fireClose) => {
+    if (closed) return;
+    closed = true;
+    if (request !== null) {
+      request.removeAllListeners();
+      request.destroy();
+      request = null;
+    }
+    if (fireClose) handlers.onClose?.();
+  };
+  request = transport.get(
+    url,
+    {
+      headers: {
+        Accept: "text/event-stream",
+        ...options.headers ?? {}
+      }
+    },
+    (res) => {
+      const status = res.statusCode ?? 0;
+      if (status < 200 || status >= 300) {
+        res.resume();
+        handlers.onError?.(`gateway stream returned HTTP ${status}`);
+        teardown(true);
+        return;
+      }
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => {
+        if (closed) return;
+        buffer += chunk;
+        let sep = buffer.indexOf("\n\n");
+        while (sep !== -1) {
+          const record = buffer.slice(0, sep);
+          buffer = buffer.slice(sep + 2);
+          const frame = decodeSseRecord(record);
+          if (frame !== null) {
+            handlers.onFrame(frame);
+            if (frame.kind === "done" || frame.kind === "error") {
+              teardown(true);
+              return;
+            }
+          }
+          sep = buffer.indexOf("\n\n");
+        }
+      });
+      res.on("end", () => teardown(true));
+      res.on("error", (e) => {
+        handlers.onError?.(e.message);
+        teardown(true);
+      });
+    }
+  );
+  request.on("error", (e) => {
+    handlers.onError?.(e.message);
+    teardown(true);
+  });
+  return {
+    unsubscribe: () => teardown(false)
+  };
+}
+
+// packages/cleo/src/cli/lib/tui/worker-stream.ts
+var DEFAULT_OUTPUT_TAIL = 200;
+function emptyWorkerStreamView() {
+  return {
+    status: "connecting",
+    outputTail: [],
+    usage: null,
+    checkpoints: [],
+    lastFrameTs: null,
+    error: null
+  };
+}
+function readString(payload, key) {
+  const v = payload[key];
+  return typeof v === "string" ? v : void 0;
+}
+function readNumber(payload, key) {
+  const v = payload[key];
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function readUsage(payload) {
+  const source = payload.usage && typeof payload.usage === "object" ? payload.usage : payload;
+  const hasUsage = "inputTokens" in source || "outputTokens" in source || "totalTokens" in source || "records" in source;
+  if (!hasUsage) return null;
+  const inputTokens = readNumber(source, "inputTokens");
+  const outputTokens = readNumber(source, "outputTokens");
+  const totalTokens = "totalTokens" in source ? readNumber(source, "totalTokens") : inputTokens + outputTokens;
+  const records = "records" in source ? readNumber(source, "records") : 1;
+  return { inputTokens, outputTokens, totalTokens, records };
+}
+function readCheckpoint(payload) {
+  const cp = payload.checkpoint;
+  if (cp === null || typeof cp !== "object") return null;
+  const obj = cp;
+  const kind = obj.kind;
+  if (kind !== "commit" && kind !== "pr" && kind !== "test") return null;
+  const label = readString(obj, "label") ?? "";
+  return { kind, label };
+}
+function applyWorkerStreamFrame(view, frame, maxTail = DEFAULT_OUTPUT_TAIL) {
+  if (frame.kind === "error") {
+    return {
+      ...view,
+      status: "error",
+      error: frame.error?.message ?? "stream error"
+    };
+  }
+  const payload = frame.data && typeof frame.data === "object" ? frame.data : {};
+  const lastFrameTs = readString(payload, "ts") ?? (/* @__PURE__ */ new Date()).toISOString();
+  if (frame.kind === "done") {
+    return { ...view, status: "ended", lastFrameTs };
+  }
+  const usage = readUsage(payload);
+  if (usage !== null) {
+    return { ...view, status: "live", usage, lastFrameTs };
+  }
+  const checkpoint = readCheckpoint(payload);
+  if (checkpoint !== null) {
+    return {
+      ...view,
+      status: "live",
+      checkpoints: [...view.checkpoints, checkpoint],
+      lastFrameTs
+    };
+  }
+  const line = readString(payload, "line") ?? readString(payload, "output");
+  if (line !== void 0) {
+    const next = [...view.outputTail, line];
+    const outputTail = next.length > maxTail ? next.slice(next.length - maxTail) : next;
+    return { ...view, status: "live", outputTail, lastFrameTs };
+  }
+  return { ...view, status: "live", lastFrameTs };
+}
+function formatUsageMeter(usage) {
+  if (!usage || usage.totalTokens === 0) return "\u2014 tokens";
+  const tok = usage.totalTokens >= 1e3 ? `${(usage.totalTokens / 1e3).toFixed(1)}k` : String(usage.totalTokens);
+  const calls = usage.records === 1 ? "1 call" : `${usage.records} calls`;
+  return `${tok} tok \xB7 ${calls}`;
+}
+function renderWorkerStreamPanel(taskId, view, options) {
+  const tailLines = options?.tailLines ?? 8;
+  const lines = [];
+  const statusDot = view.status === "live" ? "\u25CF" : view.status === "ended" ? "\u2713" : view.status === "error" ? "\u2717" : view.status === "stalled" ? "\u25CC" : "\u25CB";
+  lines.push(
+    `\u2500\u2500 Worker ${taskId}  ${statusDot} ${view.status}  \xB7  ${formatUsageMeter(view.usage)}`
+  );
+  if (view.checkpoints.length > 0) {
+    const chips = view.checkpoints.map((c) => `${c.kind}:${c.label}`).join("  ");
+    lines.push(`   ${chips}`);
+  }
+  if (view.status === "error" && view.error) {
+    lines.push(`   error: ${view.error}`);
+  }
+  const tail = view.outputTail.slice(Math.max(0, view.outputTail.length - tailLines));
+  if (tail.length === 0) {
+    lines.push("   (waiting for worker output\u2026)");
+  } else {
+    for (const out of tail) lines.push(`   \u2502 ${out}`);
+  }
+  return lines;
+}
+
+// packages/cleo/src/cli/lib/tui/cockpit.ts
+var DEFAULT_TUI_BASE_URL = "http://127.0.0.1:7777";
+async function fetchTaskRows(baseUrl) {
+  const client = createCleoClient2({ baseUrl });
+  try {
+    const res = await client.tasks.list({ body: { limit: 500 } });
+    if (res.response == null) return null;
+    const tasks = res.data?.data?.tasks;
+    if (!Array.isArray(tasks)) return [];
+    return tasks;
+  } catch {
+    return null;
+  }
+}
+var DISPATCHABLE_LANES = /* @__PURE__ */ new Set(["backlog", "ready"]);
+var KanbanBoardComponent = class {
+  constructor(board, deps) {
+    this.board = board;
+    this.deps = deps;
+  }
+  board;
+  deps;
+  /** Index of the lane that currently holds keyboard focus. */
+  focusedLane = 0;
+  /** Index of the focused card WITHIN the focused lane. */
+  focusedCard = 0;
+  /** Two-step confirm latch — set on the first dispatch key, cleared on action/move. */
+  confirming = false;
+  /** Spawn tier for the next dispatch (cycled with `t`). */
+  tier = 1;
+  /** A transient single-line status message (dispatch result / hint). */
+  status = "";
+  /** The folded worker-stream view for the focused Running card, or null. */
+  workerView = null;
+  /** The task id the worker panel is currently bound to. */
+  workerTaskId = null;
+  /** The live SSE subscription for the worker panel, or null. */
+  workerSub = null;
+  /** Wire the render/refresh callbacks the loop owns. */
+  bind(requestRender, refresh) {
+    this.deps.requestRender = requestRender;
+    this.deps.refresh = refresh;
+  }
+  /** Replace the board model (e.g. after a refresh) and clamp focus. */
+  setBoard(board) {
+    this.board = board;
+    if (this.focusedLane >= board.columns.length) this.focusedLane = 0;
+    this.clampCardFocus();
+    this.reconcileWorkerPanel();
+  }
+  /** The currently-focused lane column, or undefined. */
+  currentLane() {
+    return this.board.columns[this.focusedLane];
+  }
+  /** The currently-focused card, or undefined. */
+  focusedCardModel() {
+    return this.currentLane()?.cards[this.focusedCard];
+  }
+  /** Keep {@link focusedCard} within the focused lane's card range. */
+  clampCardFocus() {
+    const count = this.currentLane()?.cards.length ?? 0;
+    if (count === 0) {
+      this.focusedCard = 0;
+      return;
+    }
+    if (this.focusedCard >= count) this.focusedCard = count - 1;
+    if (this.focusedCard < 0) this.focusedCard = 0;
+  }
+  /** Move keyboard focus one lane right (wraps), resetting card focus. */
+  focusNextLane() {
+    const n = this.board.columns.length || 1;
+    this.focusedLane = (this.focusedLane + 1) % n;
+    this.focusedCard = 0;
+    this.confirming = false;
+    this.clampCardFocus();
+    this.reconcileWorkerPanel();
+  }
+  /** Move keyboard focus one lane left (wraps), resetting card focus. */
+  focusPrevLane() {
+    const n = this.board.columns.length || 1;
+    this.focusedLane = (this.focusedLane - 1 + n) % n;
+    this.focusedCard = 0;
+    this.confirming = false;
+    this.clampCardFocus();
+    this.reconcileWorkerPanel();
+  }
+  /** Move card focus down within the lane (wraps). */
+  focusNextCard() {
+    const count = this.currentLane()?.cards.length ?? 0;
+    if (count === 0) return;
+    this.focusedCard = (this.focusedCard + 1) % count;
+    this.confirming = false;
+    this.reconcileWorkerPanel();
+  }
+  /** Move card focus up within the lane (wraps). */
+  focusPrevCard() {
+    const count = this.currentLane()?.cards.length ?? 0;
+    if (count === 0) return;
+    this.focusedCard = (this.focusedCard - 1 + count) % count;
+    this.confirming = false;
+    this.reconcileWorkerPanel();
+  }
+  /** The id of the currently-focused lane (for the status bar / tests). */
+  focusedLaneId() {
+    return this.currentLane()?.lane ?? "";
+  }
+  /** Cycle the spawn tier 1 → 2 → 0 → 1 (for the next dispatch). */
+  cycleTier() {
+    this.tier = clampTier((this.tier + 1) % 3);
+  }
+  /** The current spawn tier (for tests / status). */
+  currentTier() {
+    return this.tier;
+  }
+  /** The current transient status line (for tests). */
+  statusLine() {
+    return this.status;
+  }
+  /** Whether the component is awaiting a dispatch confirm (for tests). */
+  isConfirming() {
+    return this.confirming;
+  }
+  /**
+   * Handle the dispatch key (`d` / Enter) on the focused card.
+   *
+   * Two-step confirm — spawning is real + expensive. The first press latches
+   * `confirming` and shows the confirm prompt; the second press performs the
+   * spawn via the injected dispatch fn (SDK → gateway), surfaces the result
+   * inline, and (on success) re-fetches so the worker lands in the Running lane.
+   * NEVER throws — a failed dispatch sets the status line, never crashes.
+   */
+  async requestDispatch() {
+    const lane = this.focusedLaneId();
+    const card = this.focusedCardModel();
+    if (card === void 0) {
+      this.status = "No card focused to dispatch.";
+      this.deps.requestRender?.();
+      return;
+    }
+    if (!DISPATCHABLE_LANES.has(lane)) {
+      this.status = `Dispatch is only available on Backlog/Ready cards (focused: ${lane}).`;
+      this.confirming = false;
+      this.deps.requestRender?.();
+      return;
+    }
+    if (!this.confirming) {
+      this.confirming = true;
+      this.status = `Spawn a real worker for ${card.id} (tier ${this.tier})? Press [d] again to confirm, [Esc] to cancel.`;
+      this.deps.requestRender?.();
+      return;
+    }
+    this.confirming = false;
+    this.status = `Dispatching ${card.id} (tier ${this.tier})\u2026`;
+    this.deps.requestRender?.();
+    const result = await this.deps.dispatch(this.deps.baseUrl, card.id, this.tier);
+    if (result.ok) {
+      this.status = `Dispatched ${result.taskId} \u2192 Running (tier ${result.tier}).`;
+      await this.deps.refresh?.();
+    } else {
+      this.status = `Dispatch failed for ${result.taskId}: ${result.code} \u2014 ${result.message}`;
+    }
+    this.deps.requestRender?.();
+  }
+  /** Clear the confirm latch (Esc) without dispatching. */
+  cancelConfirm() {
+    if (this.confirming) {
+      this.confirming = false;
+      this.status = "Dispatch cancelled.";
+      this.deps.requestRender?.();
+    }
+  }
+  /**
+   * Bind / rebind the live worker stream to the focused card when (and only
+   * when) it is a Running card, tearing down any prior subscription. Idempotent
+   * for the same task — re-focusing the same Running card does not churn the
+   * socket.
+   */
+  reconcileWorkerPanel() {
+    const lane = this.focusedLaneId();
+    const card = this.focusedCardModel();
+    const targetId = lane === "running" && card !== void 0 ? card.id : null;
+    if (targetId === this.workerTaskId) return;
+    this.teardownWorkerPanel();
+    if (targetId === null) return;
+    this.workerTaskId = targetId;
+    this.workerView = emptyWorkerStreamView();
+    this.workerSub = this.deps.subscribe(
+      { baseUrl: this.deps.baseUrl, taskId: targetId },
+      {
+        onFrame: (frame) => {
+          if (this.workerTaskId !== targetId || this.workerView === null) return;
+          this.workerView = applyWorkerStreamFrame(this.workerView, frame);
+          this.deps.requestRender?.();
+        },
+        onError: (reason) => {
+          if (this.workerTaskId !== targetId) return;
+          this.status = `Worker stream for ${targetId} unavailable: ${reason}`;
+          this.deps.requestRender?.();
+        }
+      }
+    );
+  }
+  /** Tear down the active worker subscription + panel state (leak-free). */
+  teardownWorkerPanel() {
+    if (this.workerSub !== null) {
+      this.workerSub.unsubscribe();
+      this.workerSub = null;
+    }
+    this.workerView = null;
+    this.workerTaskId = null;
+  }
+  /** No cached state to clear — render is pure over the current board. */
+  invalidate() {
+  }
+  /** Render the board body plus the focus indicator, dispatch affordances,
+   * conductor lane, status line, and (on a Running card) the worker panel. */
+  render(_width) {
+    const lines = renderKanbanBoardText(this.board);
+    const lane = this.currentLane();
+    const card = this.focusedCardModel();
+    const focusCard = card !== void 0 ? `${card.id}` : "\u2014";
+    lines.push(`Focus: ${lane?.label ?? "\u2014"} \u203A ${focusCard}   (tier ${this.tier})`);
+    if (card !== void 0 && DISPATCHABLE_LANES.has(lane?.lane ?? "")) {
+      lines.push(renderConductorLane(buildConductorLane(card.id, card.assignee)));
+    }
+    if (this.workerView !== null && this.workerTaskId !== null) {
+      for (const l of renderWorkerStreamPanel(this.workerTaskId, this.workerView)) {
+        lines.push(l);
+      }
+    }
+    if (this.status.length > 0) lines.push(this.status);
+    lines.push(
+      "[\u2190/\u2192 h/l] lane   [\u2191/\u2193 j/k] card   [Tab] cycle lane   [d/Enter] dispatch   [t] tier   [Esc] cancel   [r] refresh   [q] quit"
+    );
+    return lines;
+  }
+};
+function runInteractiveLoop(piTui, component, refresh) {
+  return new Promise((resolve) => {
+    const terminal = new piTui.ProcessTerminal();
+    const tui = new piTui.TUI(terminal);
+    tui.addChild(component);
+    component.bind(
+      () => tui.requestRender(),
+      async () => {
+        await refresh();
+        tui.requestRender(true);
+      }
+    );
+    const dispose = tui.addInputListener((data) => {
+      if (data === "q" || data === "") {
+        component.teardownWorkerPanel();
+        dispose();
+        tui.stop();
+        resolve();
+        return { consume: true };
+      }
+      if (data === "\x1B[C" || data === "l" || data === "	") {
+        component.focusNextLane();
+        tui.requestRender();
+        return { consume: true };
+      }
+      if (data === "\x1B[D" || data === "h") {
+        component.focusPrevLane();
+        tui.requestRender();
+        return { consume: true };
+      }
+      if (data === "\x1B[B" || data === "j") {
+        component.focusNextCard();
+        tui.requestRender();
+        return { consume: true };
+      }
+      if (data === "\x1B[A" || data === "k") {
+        component.focusPrevCard();
+        tui.requestRender();
+        return { consume: true };
+      }
+      if (data === "d" || data === "\r" || data === "\n") {
+        void component.requestDispatch();
+        return { consume: true };
+      }
+      if (data === "t") {
+        component.cycleTier();
+        tui.requestRender();
+        return { consume: true };
+      }
+      if (data === "\x1B") {
+        component.cancelConfirm();
+        tui.requestRender();
+        return { consume: true };
+      }
+      if (data === "r") {
+        void refresh().then(() => tui.requestRender(true));
+        return { consume: true };
+      }
+      return void 0;
+    });
+    tui.start();
+    tui.requestRender(true);
+  });
+}
+async function runCockpit(options = {}, sink = (line) => process.stdout.write(`${line}
+`)) {
+  const baseUrl = options.baseUrl ?? DEFAULT_TUI_BASE_URL;
+  const dispatch = options.dispatch ?? dispatchWorker;
+  const subscribe = options.subscribe ?? subscribeOrchestrateEvents;
+  let gatewayAutoStarted = false;
+  const autoStart = options.autoStart !== false;
+  let autoStartFailReason;
+  let rows = await fetchTaskRows(baseUrl);
+  if (rows === null && autoStart) {
+    let port;
+    let host;
+    try {
+      const u = new URL(baseUrl);
+      const parsed = Number.parseInt(u.port, 10);
+      port = Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+      host = u.hostname || void 0;
+    } catch {
+    }
+    const spawnResult = await spawnGatewayIfDown({
+      ...options.spawnOpts ?? {},
+      ...port !== void 0 ? { port } : {},
+      ...host !== void 0 ? { host } : {}
+    });
+    if (spawnResult.reachable) {
+      gatewayAutoStarted = spawnResult.spawned;
+      rows = await fetchTaskRows(baseUrl);
+    } else {
+      autoStartFailReason = spawnResult.reason;
+    }
+  }
+  if (rows === null) {
+    sink("CLEO cockpit: the daemon gateway is not reachable.");
+    sink(`  Tried: ${baseUrl}/v1`);
+    if (autoStartFailReason !== void 0) {
+      sink(`  auto-start: ${autoStartFailReason}`);
+    }
+    try {
+      const { getCleoLogDir } = await import("@cleocode/core");
+      const errPath = join(getCleoLogDir(), "gateway.err");
+      const errContent = readFileSync(errPath, "utf8").trimEnd();
+      if (errContent.length > 0) {
+        const lastLine = errContent.split("\n").at(-1) ?? "";
+        if (lastLine.length > 0) {
+          sink(`  gateway.err: ${lastLine}`);
+        }
+      }
+    } catch {
+    }
+    sink("  Start it with:  cleo daemon serve");
+    sink("  (override the target with:  cleo tui --base-url <url>)");
+    return { outcome: "daemon-down", baseUrl, piTui: false, gatewayAutoStarted };
+  }
+  const board = buildKanbanBoard(rows);
+  const piTuiOk = await isPiTuiAvailable();
+  const interactive = options.once !== true && process.stdout.isTTY === true;
+  if (!piTuiOk || !interactive) {
+    for (const line of renderKanbanBoardText(board)) sink(line);
+    if (!piTuiOk) {
+      sink("");
+      sink(PI_TUI_INSTALL_HINT);
+      return { outcome: "degraded-pi", baseUrl, piTui: false, gatewayAutoStarted };
+    }
+    return { outcome: "rendered", baseUrl, piTui: false, gatewayAutoStarted };
+  }
+  const piTui = await loadPiTui();
+  if (piTui === null) {
+    for (const line of renderKanbanBoardText(board)) sink(line);
+    sink("");
+    sink(PI_TUI_INSTALL_HINT);
+    return { outcome: "degraded-pi", baseUrl, piTui: false, gatewayAutoStarted };
+  }
+  const component = new KanbanBoardComponent(board, { baseUrl, dispatch, subscribe });
+  const refresh = async () => {
+    const fresh = await fetchTaskRows(baseUrl);
+    if (fresh !== null) component.setBoard(buildKanbanBoard(fresh));
+  };
+  await runInteractiveLoop(piTui, component, refresh);
+  return { outcome: "rendered", baseUrl, piTui: true, gatewayAutoStarted };
+}
+export {
+  DEFAULT_TUI_BASE_URL,
+  KanbanBoardComponent,
+  runCockpit
+};
+//# sourceMappingURL=cockpit-RZKLGYPN.js.map