@jun133/kitty 0.0.8 → 0.0.9

package/dist/chunk-6NJJLOY3.mjs

@@ -0,0 +1,2129 @@
+import {
+  SessionStore,
+  parseRuntimeMemoryAssetMetadata
+} from "./chunk-4BN45TQG.mjs";
+import {
+  BackgroundExecutionStore,
+  ControlPlaneLedger,
+  EXTENSION_ENV_KEYS,
+  ExecutionStore,
+  SessionEventStore,
+  buildProjectMap,
+  createRuntimeUiEvent,
+  formatRuntimeUiEventLine,
+  getErrorMessage,
+  isProcessAlive,
+  loadProjectContext,
+  reconcileBackgroundExecutions,
+  resolveProjectRoots,
+  runHostTurn,
+  summarizeExecution,
+  summarizeExecutionSet,
+  terminateBackgroundExecution,
+  terminatePid,
+  writeStderrLine,
+  writeStdoutLine
+} from "./chunk-ELBEXOR7.mjs";
+import {
+  PRESERVED_PROJECT_STATE_ENTRY_NAMES,
+  PROJECT_STATE_DIR_NAME,
+  PROJECT_STATE_ENV_EXAMPLE_FILE_NAME,
+  PROJECT_STATE_ENV_FILE_NAME,
+  PROJECT_STATE_IGNORE_FILE_NAME,
+  getProjectStatePaths
+} from "./chunk-3KMC6H5K.mjs";
+
+// src/observability/terminalLog.ts
+import fs from "fs";
+import path from "path";
+var outputMirrorSuppressDepth = 0;
+var outputMirrorWriteCount = 0;
+function createTerminalLogWriter(rootDir, sessionId, now = /* @__PURE__ */ new Date()) {
+  const timestamp = now.toISOString();
+  const date = timestamp.slice(0, 10).replaceAll("-", "");
+  const terminalDir = path.join(getProjectStatePaths(rootDir).observabilityDir, "terminal", date);
+  fs.mkdirSync(terminalDir, { recursive: true });
+  const logPath = path.join(terminalDir, `${safePathPart(sessionId)}.log`);
+  return {
+    write(text) {
+      fs.appendFileSync(logPath, text, "utf8");
+    }
+  };
+}
+function mirrorProcessOutputToTerminalLog(writer) {
+  const stdoutWrite = process.stdout.write.bind(process.stdout);
+  const stderrWrite = process.stderr.write.bind(process.stderr);
+  const writeSync = fs.writeSync;
+  let active = true;
+  process.stdout.write = ((chunk, ...args) => {
+    if (active && outputMirrorSuppressDepth === 0) {
+      writeMirroredProcessChunk(writer, chunk);
+    }
+    return stdoutWrite(chunk, ...args);
+  });
+  process.stderr.write = ((chunk, ...args) => {
+    if (active && outputMirrorSuppressDepth === 0) {
+      writeMirroredProcessChunk(writer, chunk);
+    }
+    return stderrWrite(chunk, ...args);
+  });
+  fs.writeSync = ((fd, buffer, ...args) => {
+    if (active && outputMirrorSuppressDepth === 0 && (fd === 1 || fd === 2)) {
+      writeMirroredProcessChunk(writer, buffer);
+    }
+    return writeSync(fd, buffer, ...args);
+  });
+  return () => {
+    active = false;
+    process.stdout.write = stdoutWrite;
+    process.stderr.write = stderrWrite;
+    fs.writeSync = writeSync;
+    writer.dispose?.();
+  };
+}
+function safePathPart(value) {
+  const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || `session-${process.pid}`;
+}
+function mirrorInteractionShellToTerminalLog(shell, writer) {
+  return {
+    input: mirrorInput(shell.input, writer),
+    output: mirrorOutput(shell.output, writer),
+    createTurnDisplay(options) {
+      return mirrorTurnDisplay(shell.createTurnDisplay(options), writer);
+    },
+    dispose() {
+      shell.dispose?.();
+    }
+  };
+}
+function mirrorOutput(output, writer) {
+  return {
+    plain(text) {
+      writeOutputAndForward(writer, `${text}
+`, () => output.plain(text));
+    },
+    info(text) {
+      writeOutputAndForward(writer, `${text}
+`, () => output.info(text));
+    },
+    warn(text) {
+      writeOutputAndForward(writer, `${text}
+`, () => output.warn(text));
+    },
+    error(text) {
+      writeOutputAndForward(writer, `${text}
+`, () => output.error(text));
+    },
+    dim(text) {
+      writeOutputAndForward(writer, `${text}
+`, () => output.dim(text));
+    },
+    heading(text) {
+      writeOutputAndForward(writer, `${text}
+`, () => output.heading(text));
+    },
+    interrupt(text) {
+      writeOutputAndForward(writer, `${text}
+`, () => output.interrupt(text));
+    }
+  };
+}
+function writeOutputAndForward(writer, text, forward) {
+  outputMirrorWriteCount += 1;
+  writer.write(text);
+  outputMirrorSuppressDepth += 1;
+  try {
+    forward();
+  } finally {
+    outputMirrorSuppressDepth -= 1;
+  }
+}
+function mirrorTurnDisplay(display, writer) {
+  return {
+    callbacks: {
+      ...display.callbacks,
+      onAssistantDelta(delta) {
+        forwardWithFallback(writer, () => display.callbacks.onAssistantDelta?.(delta), delta);
+      },
+      onAssistantText(text) {
+        forwardWithFallback(writer, () => display.callbacks.onAssistantText?.(text), text);
+      },
+      onAssistantDone(text) {
+        display.callbacks.onAssistantDone?.(text);
+      },
+      onReasoningDelta(delta) {
+        forwardWithFallback(writer, () => display.callbacks.onReasoningDelta?.(delta), delta);
+      },
+      onReasoning(text) {
+        forwardWithFallback(writer, () => display.callbacks.onReasoning?.(text), text);
+      },
+      onStatus(message) {
+        forwardWithFallback(writer, () => display.callbacks.onStatus?.(message), `${message}
+`);
+      },
+      onToolCall(name, args) {
+        forwardWithFallback(writer, () => display.callbacks.onToolCall?.(name, args), formatRuntimeUiEventLine(createRuntimeUiEvent({
+          channel: "lead",
+          kind: "tool_call",
+          toolName: name
+        })));
+      },
+      onToolResult(name, output) {
+        forwardWithFallback(writer, () => display.callbacks.onToolResult?.(name, output), formatRuntimeUiEventLine(createRuntimeUiEvent({
+          channel: "lead",
+          kind: "tool_result",
+          toolName: name
+        })));
+      },
+      onToolError(name, error) {
+        forwardWithFallback(writer, () => display.callbacks.onToolError?.(name, error), formatRuntimeUiEventLine(createRuntimeUiEvent({
+          channel: "lead",
+          kind: "tool_error",
+          toolName: name
+        })));
+      }
+    },
+    flush() {
+      display.flush();
+    },
+    dispose() {
+      display.dispose();
+    }
+  };
+}
+function forwardWithFallback(writer, forward, fallback) {
+  const before = outputMirrorWriteCount;
+  forward();
+  if (outputMirrorWriteCount === before && fallback.length > 0) {
+    outputMirrorWriteCount += 1;
+    writer.write(`${fallback}
+`);
+  }
+}
+function mirrorInput(input, writer) {
+  return {
+    async readInput(promptLabel) {
+      const result = await input.readInput(promptLabel);
+      if (result.kind === "submit") {
+        writer.write(`${promptLabel ?? "> "}${result.value}
+`);
+      }
+      return result;
+    },
+    bindInterrupt(handler) {
+      return input.bindInterrupt(handler);
+    }
+  };
+}
+function bufferToText(chunk) {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  if (Buffer.isBuffer(chunk)) {
+    return chunk.toString("utf8");
+  }
+  return String(chunk ?? "");
+}
+function writeMirroredProcessChunk(writer, chunk) {
+  const text = bufferToText(chunk);
+  if (isTransientTerminalFrame(text)) {
+    return;
+  }
+  outputMirrorWriteCount += 1;
+  writer.write(text);
+}
+function isTransientTerminalFrame(text) {
+  const normalized = stripAnsi(text).replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
+  return /^\r?\[[ ■]{4}\] thinking\s*$/.test(normalized);
+}
+function stripAnsi(value) {
+  return value.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
+}
+
+// src/interaction/sessionDriver.ts
+import process3 from "process";
+
+// src/execution/kinds.ts
+var EXECUTION_KINDS = ["background", "subagent"];
+
+// src/execution/lifecycle.ts
+function collectRunningExecutionProcesses(rootDir, cwd) {
+  reconcileRunningExecutions(rootDir);
+  return new ExecutionStore(rootDir).list({ kinds: EXECUTION_KINDS, statuses: ["running"], cwd }).filter((execution) => typeof execution.pid === "number" && execution.pid > 0).map((execution) => ({
+    kind: execution.kind,
+    id: execution.id,
+    pid: execution.pid,
+    summary: formatRunningExecutionSummary(execution)
+  }));
+}
+function terminateRunningExecutionProcesses(rootDir, processes) {
+  const terminatedPids = [];
+  const failedPids = [];
+  for (const processInfo of processes) {
+    try {
+      terminateRunningExecution(rootDir, processInfo);
+      terminatedPids.push(processInfo.pid);
+    } catch {
+      failedPids.push(processInfo.pid);
+    }
+  }
+  return { terminatedPids, failedPids };
+}
+function reconcileRunningExecutions(rootDir) {
+  reconcileBackgroundExecutions(rootDir);
+  const store = new ExecutionStore(rootDir);
+  for (const execution of store.list({ kinds: EXECUTION_KINDS, statuses: ["running"] })) {
+    if (typeof execution.pid !== "number" || isProcessAlive(execution.pid)) {
+      continue;
+    }
+    store.close(execution.id, {
+      status: "stale",
+      summary: `${execution.kind} process disappeared before reporting completion: pid=${execution.pid}`
+    });
+  }
+}
+function terminateRunningExecution(rootDir, processInfo) {
+  if (processInfo.kind === "background") {
+    terminateBackgroundExecution(rootDir, processInfo.id);
+    return;
+  }
+  terminatePid(processInfo.pid);
+  new ExecutionStore(rootDir).close(processInfo.id, {
+    status: "aborted",
+    summary: `${processInfo.kind} execution terminated by host lifecycle.`
+  });
+}
+function formatRunningExecutionSummary(execution) {
+  const subject = execution.kind === "background" ? execution.command : execution.actorName;
+  return `${execution.kind} ${execution.id} pid=${execution.pid ?? ""} ${subject ?? ""}`.trim();
+}
+
+// src/interaction/exitGuard.ts
+var defaultInteractiveExitGuard = {
+  collectRunningProcesses,
+  terminateProcesses
+};
+async function collectRunningProcesses(cwd) {
+  const roots = await resolveProjectRoots(cwd);
+  return collectRunningExecutionProcesses(roots.stateRootDir, cwd);
+}
+async function terminateProcesses(processes, cwd) {
+  const roots = await resolveProjectRoots(cwd);
+  return terminateRunningExecutionProcesses(roots.stateRootDir, processes);
+}
+
+// src/runtime/scene.ts
+function buildRuntimeScene(status) {
+  const executions = status.executions.active.map(buildExecutionScene);
+  const blockedExecutions = executions.filter((execution) => execution.risk === "blocked");
+  const watchExecutions = executions.filter((execution) => execution.risk === "watch");
+  const activeBackground = executions.filter((execution) => execution.kind === "background");
+  const blockedBackground = activeBackground.filter((execution) => execution.risk !== "none");
+  return {
+    headline: buildHeadline(status, blockedExecutions, watchExecutions),
+    focus: readFocus(status),
+    nextAction: readNextAction(status, blockedExecutions, watchExecutions),
+    blocked: readBlocked(blockedExecutions),
+    cost: readCost(status),
+    recovery: readRecovery(status, executions),
+    skills: {
+      ready: status.skills.ready,
+      total: status.skills.total,
+      nextAction: readSkillsNextAction(status)
+    },
+    memory: {
+      assets: status.memory.assets.length,
+      latestSessionMemory: Boolean(status.sessions.latest?.hasMemory),
+      nextAction: readMemoryNextAction(status)
+    },
+    background: {
+      active: activeBackground.length,
+      blocked: blockedBackground.length,
+      nextAction: readBackgroundNextAction(activeBackground)
+    },
+    executions
+  };
+}
+function buildExecutionScene(execution) {
+  const risk = readExecutionRisk(execution);
+  return {
+    id: execution.id,
+    kind: execution.kind,
+    status: execution.status,
+    health: execution.health?.message ?? `Execution is ${execution.status}.`,
+    risk,
+    summary: readExecutionSummary(execution),
+    nextAction: readExecutionNextAction(execution, risk),
+    lastOutput: execution.outputPreview ? truncateText(execution.outputPreview, 160) : void 0
+  };
+}
+function buildHeadline(status, blockedExecutions, watchExecutions) {
+  if (!status.sessions.latest) {
+    return "No active session yet.";
+  }
+  if (blockedExecutions.length > 0) {
+    return `${blockedExecutions.length} execution(s) need attention.`;
+  }
+  if (watchExecutions.length > 0) {
+    return `${watchExecutions.length} execution(s) should be watched.`;
+  }
+  if (status.executions.active.length > 0) {
+    return `${status.executions.active.length} execution(s) are running.`;
+  }
+  return "Ready to continue the latest session.";
+}
+function readFocus(status) {
+  const focus = status.sessions.latest?.focus;
+  if (focus) {
+    return truncateText(focus, 120);
+  }
+  const title = status.sessions.latest?.title;
+  if (title) {
+    return truncateText(title, 120);
+  }
+  return "none";
+}
+function readNextAction(status, blockedExecutions, watchExecutions) {
+  const urgent = blockedExecutions[0] ?? watchExecutions[0];
+  if (urgent) {
+    return urgent.nextAction;
+  }
+  if (status.executions.active.length > 0) {
+    return "Let active work finish, or inspect it with `kitty status` / `kitty background`.";
+  }
+  if (!status.sessions.latest) {
+    return "Start a session with `kitty`.";
+  }
+  return "Continue from the current session focus.";
+}
+function readBlocked(blockedExecutions) {
+  if (blockedExecutions.length === 0) {
+    return "no";
+  }
+  return blockedExecutions.slice(0, 3).map((execution) => `${execution.kind} ${execution.id}: ${execution.health}`).join(" | ");
+}
+function readCost(status) {
+  const budget = status.sessions.latest?.contextBudget;
+  const latest = status.modelRequests.recent[0];
+  const budgetText = budget ? `${Math.round(budget.usageRatio * 100)}% context${budget.compressed ? ", compressed" : ""}` : "context unknown";
+  const layout = budget?.cacheLayout;
+  const layoutText = layout ? `stable ${readStableRatio(layout.stablePrefixChars, layout.volatileTailChars)}` : "cache layout unknown";
+  const usageText = latest?.usage ? readUsageCost(latest.usage) : latest ? "provider usage unavailable" : "no model request yet";
+  return `${budgetText}; ${layoutText}; ${usageText}`;
+}
+function readStableRatio(stableChars, volatileChars) {
+  const total = stableChars + volatileChars;
+  return total > 0 ? `${Math.round(stableChars / total * 100)}%` : "unknown";
+}
+function readUsageCost(usage) {
+  const cached = usage.cacheHitTokens ?? usage.cacheReadTokens;
+  const hitRate = usage.cacheHitRate === void 0 ? void 0 : `${Math.round(usage.cacheHitRate * 100)}% hit`;
+  return [
+    usage.totalTokens === void 0 ? void 0 : `${usage.totalTokens} tokens`,
+    cached === void 0 ? "cache unknown" : `${cached} cached`,
+    hitRate
+  ].filter(Boolean).join(", ");
+}
+function readRecovery(status, executions) {
+  const risky = executions.filter((execution) => execution.risk !== "none").length;
+  if (risky > 0) {
+    return `${risky} execution(s) need recovery attention.`;
+  }
+  if (status.wakeSignals.recent.length > 0) {
+    return `${status.wakeSignals.recent.length} wake signal(s) recorded.`;
+  }
+  return "no recovery action needed";
+}
+function readSkillsNextAction(status) {
+  if (status.skills.total === 0) {
+    return "No runtime skills discovered.";
+  }
+  if (status.skills.needsAttention.length > 0) {
+    return "Inspect skill issues before relying on those skills.";
+  }
+  return "Skills are ready; load full skill content only when needed.";
+}
+function readMemoryNextAction(status) {
+  if (!status.sessions.latest) {
+    return "No session memory yet.";
+  }
+  if (!status.sessions.latest.hasMemory && status.memory.assets.length === 0) {
+    return "Continue the session until useful memory is saved.";
+  }
+  if (!status.sessions.latest.hasMemory && status.memory.assets.length > 0) {
+    return "Review memory assets when prior evidence is needed.";
+  }
+  return "Session memory is available; use assets only when needed.";
+}
+function readBackgroundNextAction(backgrounds) {
+  if (backgrounds.length === 0) {
+    return "No active background work.";
+  }
+  const blocked = backgrounds.find((execution) => execution.risk === "blocked");
+  if (blocked) {
+    return blocked.nextAction;
+  }
+  const watch = backgrounds.find((execution) => execution.risk === "watch");
+  if (watch) {
+    return watch.nextAction;
+  }
+  return "Background work is running; wait or inspect latest output.";
+}
+function readExecutionRisk(execution) {
+  switch (execution.health?.state) {
+    case "deadline_passed":
+    case "stale":
+      return "blocked";
+    case "no_output":
+      return "watch";
+    case "running":
+    case "settled":
+    case void 0:
+      return "none";
+  }
+}
+function readExecutionSummary(execution) {
+  if (execution.assignment?.objective) {
+    return truncateText(execution.assignment.objective, 120);
+  }
+  if (execution.summary) {
+    return truncateText(execution.summary, 120);
+  }
+  if (execution.command) {
+    return truncateText(execution.command, 120);
+  }
+  return `${execution.kind} execution`;
+}
+function readExecutionNextAction(execution, risk) {
+  if (execution.kind === "background") {
+    if (risk === "blocked") {
+      return `Inspect or stop with \`kitty background stop ${execution.id}\`.`;
+    }
+    if (risk === "watch") {
+      return `Wait for first output or inspect with \`kitty background wait ${execution.id}\`.`;
+    }
+    return `Inspect with \`kitty background wait ${execution.id}\` if you need the result now.`;
+  }
+  if (risk === "blocked") {
+    return `Inspect execution ${execution.id} in status before continuing.`;
+  }
+  if (risk === "watch") {
+    return `Watch execution ${execution.id} for output or deadline.`;
+  }
+  if (execution.waitPolicy === "block_lead_until_complete") {
+    return "Lead should wait for this execution to finish.";
+  }
+  return "Execution is active.";
+}
+function truncateText(value, maxChars) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxChars) {
+    return normalized;
+  }
+  return `${normalized.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+
+// src/utils/console.ts
+import chalk from "chalk";
+var ANSI_RESET = "\x1B[0m";
+var ui = {
+  info(message) {
+    writeStdoutLine(`${chalk.cyan("[i]")} ${message}`);
+  },
+  success(message) {
+    writeStdoutLine(`${chalk.green("[ok]")} ${message}`);
+  },
+  warn(message) {
+    writeStdoutLine(`${chalk.yellow("!")} ${message}`);
+  },
+  error(message) {
+    writeStderrLine(`${chalk.red("[x]")} ${message}`);
+  },
+  dim(message) {
+    writeStdoutLine(`${chalk.gray(message)}${ANSI_RESET}`);
+  },
+  heading(message) {
+    writeStdoutLine(chalk.bold(message));
+  },
+  plain(message) {
+    writeStdoutLine(message);
+  }
+};
+
+// src/cli/cliValues.ts
+function truncateCliValue(value, maxChars) {
+  if (value.length <= maxChars) {
+    return value;
+  }
+  return `${value.slice(0, maxChars)}...`;
+}
+
+// src/cli/commands/background.ts
+function formatBackgroundExecution(execution) {
+  const scene = buildExecutionScene(execution);
+  return [
+    execution.id,
+    execution.status,
+    `risk=${scene.risk}`,
+    execution.pid === void 0 ? void 0 : `pid=${execution.pid}`,
+    `health=${truncateCliValue(scene.health, 90)}`,
+    execution.deadlineAt ? `deadline=${execution.deadlineAt}` : void 0,
+    `summary=${truncateCliValue(scene.summary, 90)}`,
+    `next=${scene.nextAction}`,
+    scene.lastOutput ? `lastOutput=${truncateCliValue(scene.lastOutput, 120)}` : void 0
+  ].filter(Boolean).join("  ");
+}
+
+// src/config/preflight.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import dotenv from "dotenv";
+
+// src/config/envKeys.ts
+var KITTY_BASE_ENV = {
+  apiKey: "KITTY_API_KEY",
+  provider: "KITTY_PROVIDER",
+  baseUrl: "KITTY_BASE_URL",
+  model: "KITTY_MODEL",
+  profile: "KITTY_PROFILE",
+  thinking: "KITTY_THINKING",
+  reasoningEffort: "KITTY_REASONING_EFFORT",
+  maxOutputTokens: "KITTY_MAX_OUTPUT_TOKENS",
+  contextWindowMessages: "KITTY_CONTEXT_WINDOW_MESSAGES",
+  maxContextChars: "KITTY_MAX_CONTEXT_CHARS",
+  contextSummaryChars: "KITTY_CONTEXT_SUMMARY_CHARS",
+  maxReadBytes: "KITTY_MAX_READ_BYTES",
+  projectDocMaxBytes: "KITTY_PROJECT_DOC_MAX_BYTES",
+  commandStallTimeoutMs: "KITTY_COMMAND_STALL_TIMEOUT_MS",
+  showReasoning: "KITTY_SHOW_REASONING",
+  telegramToken: "KITTY_TELEGRAM_TOKEN",
+  telegramAllowedUserIds: "KITTY_TELEGRAM_ALLOWED_USER_IDS",
+  telegramApiBaseUrl: "KITTY_TELEGRAM_API_BASE_URL",
+  telegramProxyUrl: "KITTY_TELEGRAM_PROXY_URL",
+  telegramPollingTimeoutSeconds: "KITTY_TELEGRAM_POLLING_TIMEOUT_SECONDS",
+  telegramPollingLimit: "KITTY_TELEGRAM_POLLING_LIMIT",
+  telegramPollingRetryBackoffMs: "KITTY_TELEGRAM_POLLING_RETRY_BACKOFF_MS",
+  telegramMessageChunkChars: "KITTY_TELEGRAM_MESSAGE_CHUNK_CHARS",
+  telegramTypingIntervalMs: "KITTY_TELEGRAM_TYPING_INTERVAL_MS",
+  telegramDeliveryMaxRetries: "KITTY_TELEGRAM_DELIVERY_MAX_RETRIES",
+  telegramDeliveryBaseDelayMs: "KITTY_TELEGRAM_DELIVERY_BASE_DELAY_MS",
+  telegramDeliveryMaxDelayMs: "KITTY_TELEGRAM_DELIVERY_MAX_DELAY_MS"
+};
+var KITTY_ENV = {
+  ...KITTY_BASE_ENV,
+  extensions: EXTENSION_ENV_KEYS
+};
+
+// src/config/providerPresets.ts
+var PROVIDER_PRESETS = [
+  {
+    label: "YLS Codex + GPT-5.4",
+    provider: "openai",
+    baseUrl: "https://code.ylsagi.com/codex",
+    model: "gpt-5.4",
+    thinking: "disabled",
+    reasoningEffort: "xhigh",
+    activeByDefault: false
+  },
+  {
+    label: "TTAPI + GPT-5.4",
+    provider: "openai",
+    baseUrl: "https://w.ciykj.cn",
+    model: "gpt-5.4",
+    thinking: "disabled",
+    reasoningEffort: "xhigh",
+    activeByDefault: false
+  },
+  {
+    label: "DeepSeek official V4",
+    provider: "deepseek",
+    baseUrl: "https://api.deepseek.com",
+    model: "deepseek-v4-flash",
+    thinking: "enabled",
+    reasoningEffort: "max",
+    activeByDefault: true
+  }
+];
+
+// src/config/preflight.ts
+async function inspectConfigPreflight(rootDir) {
+  const normalizedRoot = path2.resolve(rootDir);
+  const kittyDir = path2.join(normalizedRoot, PROJECT_STATE_DIR_NAME);
+  const envPath = path2.join(kittyDir, PROJECT_STATE_ENV_FILE_NAME);
+  const files = await Promise.all([
+    inspectFile(kittyDir),
+    inspectFile(envPath),
+    inspectFile(path2.join(kittyDir, PROJECT_STATE_ENV_EXAMPLE_FILE_NAME)),
+    inspectFile(path2.join(kittyDir, PROJECT_STATE_IGNORE_FILE_NAME))
+  ]);
+  const parsedEnv = await readEnvFile(envPath);
+  const expectedKeys = readExpectedEnvKeys();
+  const activeKeys = Object.keys(parsedEnv).sort();
+  const missingKeys = expectedKeys.filter((key) => !(key in parsedEnv));
+  const provider = parsedEnv[KITTY_ENV.provider] ?? "";
+  const model = parsedEnv[KITTY_ENV.model] ?? "";
+  const baseUrl = parsedEnv[KITTY_ENV.baseUrl] ?? "";
+  const providerPreset = readProviderPresetLabel({ provider, model, baseUrl });
+  const ready = files.every((file) => file.exists) && missingKeys.length === 0;
+  return {
+    rootDir: normalizedRoot,
+    kittyDir,
+    files,
+    env: {
+      activeKeys,
+      missingKeys,
+      providerPreset,
+      provider,
+      model,
+      baseUrl,
+      apiKeyPresent: Boolean(parsedEnv[KITTY_ENV.apiKey]?.trim())
+    },
+    ready,
+    nextSteps: buildPreflightNextSteps({
+      filesReady: files.every((file) => file.exists),
+      missingKeys,
+      apiKeyPresent: Boolean(parsedEnv[KITTY_ENV.apiKey]?.trim()),
+      ready
+    })
+  };
+}
+function formatConfigPreflightReport(report) {
+  return [
+    `project: ${report.rootDir}`,
+    `state: ${report.kittyDir}`,
+    ...report.files.map((file) => `file: ${file.exists ? "ok" : "missing"} ${file.path}`),
+    `env keys: ${report.env.activeKeys.length} active / ${readExpectedEnvKeys().length} expected`,
+    report.env.missingKeys.length > 0 ? `missing keys: ${report.env.missingKeys.join(", ")}` : "missing keys: none",
+    `provider: ${report.env.provider || "(missing)"}`,
+    `model: ${report.env.model || "(missing)"}`,
+    `baseUrl: ${report.env.baseUrl || "(missing)"}`,
+    `provider preset: ${formatProviderPresetFact(report)}`,
+    `api key: ${report.env.apiKeyPresent ? "present" : "missing"}`,
+    `preflight: ${report.ready ? "ready" : "not_ready"}`,
+    "next:",
+    ...report.nextSteps.map((step) => `- ${step}`)
+  ];
+}
+function buildPreflightNextSteps(input) {
+  if (!input.filesReady) {
+    return ["run `kitty init` to create the local .kitty files"];
+  }
+  if (input.missingKeys.length > 0) {
+    return ["open `.kitty/.env` and fill the missing keys", "rerun `kitty doctor`"];
+  }
+  if (!input.apiKeyPresent) {
+    return ["set `KITTY_API_KEY` in `.kitty/.env`", "rerun `kitty doctor`"];
+  }
+  if (input.ready) {
+    return ["run `kitty doctor` to verify provider connectivity", "start Kitty with `kitty`"];
+  }
+  return ["review `.kitty/.env`", "rerun `kitty doctor`"];
+}
+function readExpectedEnvKeys() {
+  return [
+    ...Object.values(KITTY_BASE_ENV),
+    ...Object.values(KITTY_ENV.extensions)
+  ].sort();
+}
+async function inspectFile(targetPath) {
+  return {
+    path: targetPath,
+    exists: await exists(targetPath)
+  };
+}
+async function readEnvFile(envPath) {
+  try {
+    return dotenv.parse(await fs2.readFile(envPath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+function readProviderPresetLabel(input) {
+  return PROVIDER_PRESETS.find(
+    (preset) => preset.provider === input.provider && preset.model === input.model && preset.baseUrl === input.baseUrl
+  )?.label;
+}
+function formatProviderPresetFact(report) {
+  if (report.env.providerPreset) {
+    return report.env.providerPreset;
+  }
+  if (report.env.provider || report.env.model || report.env.baseUrl) {
+    return "custom";
+  }
+  return "missing";
+}
+async function exists(targetPath) {
+  try {
+    await fs2.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/runtime/status.ts
+import fs7 from "fs/promises";
+import path6 from "path";
+
+// src/runtime/memory/store.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+async function listRuntimeMemoryAssets(rootDir) {
+  const paths = getProjectStatePaths(rootDir);
+  const assets = (await Promise.all([
+    listMemoryAssetsInDirectory(paths.rootDir, paths.evidenceMemoryDir, "evidence"),
+    listMemoryAssetsInDirectory(paths.rootDir, paths.projectMemoryDir, "project"),
+    listMemoryAssetsInDirectory(paths.rootDir, paths.sessionMemoryDir, "session"),
+    listMemoryAssetsInDirectory(paths.rootDir, paths.userMemoryDir, "user")
+  ])).flat();
+  return assets.sort((left, right) => (right.updatedAt ?? "").localeCompare(left.updatedAt ?? ""));
+}
+async function listMemoryAssetsInDirectory(rootDir, memoryDir, kind) {
+  const entries = await fs3.readdir(memoryDir, { withFileTypes: true }).catch(() => []);
+  const assets = await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map(async (entry) => {
+    const absolutePath = path3.join(memoryDir, entry.name);
+    const stat = await fs3.stat(absolutePath);
+    const body = await fs3.readFile(absolutePath, "utf8").catch(() => "");
+    const basename = entry.name.slice(0, -".md".length);
+    const id = kind === "session" ? basename : `${kind}/${basename}`;
+    const metadata = parseRuntimeMemoryAssetMetadata(body, { kind, basename });
+    return {
+      id,
+      kind: metadata.kind ?? kind,
+      title: metadata.title,
+      path: path3.relative(rootDir, absolutePath),
+      absolutePath,
+      updatedAt: metadata.updatedAt ?? stat.mtime.toISOString(),
+      size: stat.size,
+      evidenceRefs: metadata.evidenceRefs,
+      scope: metadata.scope,
+      tags: metadata.tags
+    };
+  }));
+  return assets;
+}
+
+// src/runtime/memory/search.ts
+import fs4 from "fs/promises";
+
+// src/runtime/memory/writer.ts
+import fs5 from "fs/promises";
+import path4 from "path";
+
+// src/runtime/memory/sinks.ts
+import fs6 from "fs/promises";
+import path5 from "path";
+
+// src/runtime/status.ts
+var DEFAULT_RECENT_LIMIT = 10;
+async function buildRuntimeStatus(rootDir) {
+  const paths = getProjectStatePaths(rootDir);
+  const sessionStore = new SessionStore(paths.sessionsDir, {
+    memorySessionsDir: paths.sessionMemoryDir
+  });
+  const [sessionRead, memoryAssets, control, projectMap, projectContext, modelRequests] = await Promise.all([
+    sessionStore.listReadable?.(DEFAULT_RECENT_LIMIT) ?? sessionStore.list(DEFAULT_RECENT_LIMIT).then((sessions2) => ({ sessions: sessions2, skipped: [] })),
+    listRuntimeMemoryAssets(paths.rootDir),
+    readControlPlaneStatus(paths.rootDir),
+    buildProjectMap(paths.rootDir),
+    loadProjectContext(paths.rootDir, { projectDocMaxBytes: 24576 }),
+    readRecentModelRequests(paths.observabilityEventsDir)
+  ]);
+  const sessions = sessionRead.sessions.map(summarizeSession);
+  const taskLifecycle = sessions[0] ? readTaskLifecycleStatus(paths.rootDir, sessions[0].id) : void 0;
+  const statusWithoutScene = {
+    rootDir: paths.rootDir,
+    stateDir: paths.kittyDir,
+    sessions: {
+      total: sessions.length,
+      latest: sessions[0],
+      recent: sessions,
+      skipped: sessionRead.skipped.length
+    },
+    memory: {
+      assets: memoryAssets
+    },
+    skills: summarizeSkills(projectContext.skills),
+    projectMap: summarizeProjectMap(projectMap),
+    modelRequests: {
+      recent: modelRequests
+    },
+    taskLifecycle,
+    executions: control.executions,
+    wakeSignals: control.wakeSignals
+  };
+  return {
+    ...statusWithoutScene,
+    scene: buildRuntimeScene(statusWithoutScene)
+  };
+}
+function summarizeProjectMap(projectMap) {
+  return {
+    rootDir: projectMap.rootDir,
+    topLevelDirectories: projectMap.topLevelDirectories,
+    entryFiles: projectMap.entryFiles,
+    testDirectories: projectMap.testDirectories,
+    packageScripts: projectMap.packageScripts,
+    specDocuments: projectMap.specDocuments,
+    git: projectMap.git,
+    updatedAt: projectMap.updatedAt
+  };
+}
+function summarizeSession(session) {
+  return {
+    id: session.id,
+    title: session.title,
+    cwd: session.cwd,
+    updatedAt: session.updatedAt,
+    messageCount: session.messageCount,
+    focus: session.taskState?.focus ?? session.checkpoint?.focus,
+    hasMemory: Boolean(session.sessionMemory?.summary.trim()),
+    contextBudget: session.contextBudget ? {
+      limitChars: session.contextBudget.limitChars,
+      estimatedChars: session.contextBudget.estimatedChars,
+      remainingChars: session.contextBudget.remainingChars,
+      usageRatio: session.contextBudget.usageRatio,
+      compressed: session.contextBudget.compressed,
+      compressionMode: session.contextBudget.compressionMode,
+      compressionReason: session.contextBudget.compressionReason,
+      sources: session.contextBudget.sources,
+      promptHotspots: session.contextBudget.promptHotspots,
+      cacheLayout: session.contextBudget.cacheLayout
+    } : void 0,
+    workset: session.workset ? {
+      total: session.workset.files.length,
+      files: session.workset.files.slice(-10).map((file) => ({
+        path: file.path,
+        readCount: file.readCount,
+        changedCount: file.changedCount,
+        lastTool: file.lastTool,
+        lastChangeId: file.lastChangeId,
+        reason: file.reason
+      }))
+    } : void 0
+  };
+}
+async function readRecentModelRequests(eventsDir) {
+  const files = await fs7.readdir(eventsDir).catch(() => []);
+  const jsonlFiles = files.filter((file) => file.endsWith(".jsonl")).sort().slice(-3);
+  const records = [];
+  for (const file of jsonlFiles) {
+    const content = await fs7.readFile(path6.join(eventsDir, file), "utf8").catch(() => "");
+    for (const line of content.split(/\r?\n/)) {
+      if (!line.trim()) {
+        continue;
+      }
+      const record = parseObservabilityRecord(line);
+      if (!record || record.event !== "model.request" || record.status !== "completed") {
+        continue;
+      }
+      records.push(summarizeModelRequest(record));
+    }
+  }
+  return records.slice(-DEFAULT_RECENT_LIMIT).reverse();
+}
+function parseObservabilityRecord(line) {
+  try {
+    const parsed = JSON.parse(line);
+    return parsed && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function summarizeModelRequest(record) {
+  const details = record.details ?? {};
+  const usage = readUsageSummary(details.usage);
+  return {
+    timestamp: record.timestamp,
+    provider: typeof details.provider === "string" ? details.provider : void 0,
+    model: record.model,
+    durationMs: record.durationMs,
+    usageAvailable: typeof details.usageAvailable === "boolean" ? details.usageAvailable : Boolean(usage),
+    usage
+  };
+}
+function readUsageSummary(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const record = value;
+  const usage = {
+    inputTokens: readNumber(record.inputTokens),
+    outputTokens: readNumber(record.outputTokens),
+    totalTokens: readNumber(record.totalTokens),
+    reasoningTokens: readNumber(record.reasoningTokens),
+    cacheReadTokens: readNumber(record.cacheReadTokens),
+    cacheCreationTokens: readNumber(record.cacheCreationTokens),
+    cacheHitTokens: readNumber(record.cacheHitTokens),
+    cacheMissTokens: readNumber(record.cacheMissTokens),
+    cacheHitRate: readNumber(record.cacheHitRate)
+  };
+  return Object.values(usage).some((item) => typeof item === "number") ? usage : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function summarizeSkills(skills) {
+  const summaries = skills.map((skill) => ({
+    name: skill.name,
+    path: skill.path,
+    status: skill.health.status,
+    resources: skill.health.resourceCount,
+    dependencies: skill.health.dependencyCount,
+    issues: skill.health.issues
+  }));
+  return {
+    total: summaries.length,
+    ready: summaries.filter((skill) => skill.status === "ready").length,
+    needsAttention: summaries.filter((skill) => skill.status !== "ready")
+  };
+}
+function readControlPlaneStatus(rootDir) {
+  const ledger = new ControlPlaneLedger(rootDir);
+  try {
+    const executions = ledger.executions.list();
+    return {
+      executions: summarizeExecutionSet(executions, { recentLimit: DEFAULT_RECENT_LIMIT }),
+      wakeSignals: {
+        recent: ledger.wakeSignals.list().map(summarizeWakeSignal).slice(0, DEFAULT_RECENT_LIMIT)
+      }
+    };
+  } finally {
+    ledger.close();
+  }
+}
+function readTaskLifecycleStatus(rootDir, sessionId) {
+  const ledger = new ControlPlaneLedger(rootDir);
+  try {
+    const lifecycle = ledger.taskLifecycle.loadCurrent(sessionId);
+    return lifecycle ? summarizeTaskLifecycle(lifecycle) : void 0;
+  } finally {
+    ledger.close();
+  }
+}
+function summarizeTaskLifecycle(lifecycle) {
+  return {
+    id: lifecycle.id,
+    sessionId: lifecycle.sessionId,
+    stage: lifecycle.stage,
+    reason: lifecycle.reason,
+    activeExecutionIds: lifecycle.activeExecutionIds,
+    activeTodoIds: lifecycle.activeTodoIds,
+    verificationFacts: lifecycle.verificationFacts,
+    completionFacts: lifecycle.completionFacts,
+    updatedAt: lifecycle.updatedAt,
+    completedAt: lifecycle.completedAt
+  };
+}
+function summarizeWakeSignal(signal) {
+  return {
+    id: signal.id,
+    executionId: signal.executionId,
+    reason: signal.reason,
+    createdAt: signal.createdAt
+  };
+}
+
+// src/cli/commands/memory.ts
+async function readMemoryListForCli(cwd) {
+  return (await buildRuntimeStatus(cwd)).memory;
+}
+function formatMemoryListForCli(memory) {
+  if (memory.assets.length === 0) {
+    return "No runtime memory assets yet.";
+  }
+  return memory.assets.map((asset) => [
+    asset.id,
+    asset.kind,
+    asset.updatedAt ?? "",
+    `bytes=${asset.size}`,
+    asset.evidenceRefs.length > 0 ? `evidence=${asset.evidenceRefs.join(",")}` : void 0,
+    asset.path
+  ].filter(Boolean).join("  ")).join("\n");
+}
+
+// src/cli/commands/runtimeStatusPresenter.ts
+function formatRuntimeStatusText(status) {
+  const lines = [];
+  lines.push(`Project: ${status.rootDir}`);
+  lines.push(`State: ${status.stateDir}`);
+  lines.push("");
+  lines.push("Scene:");
+  lines.push(`- Now: ${status.scene.headline}`);
+  lines.push(`- Focus: ${status.scene.focus}`);
+  lines.push(`- Next: ${status.scene.nextAction}`);
+  lines.push(`- Blocked: ${status.scene.blocked}`);
+  lines.push(`- Background: ${status.scene.background.active} active / ${status.scene.background.blocked} need attention`);
+  lines.push(`- Background next: ${status.scene.background.nextAction}`);
+  lines.push(`- Skills: ${status.scene.skills.ready}/${status.scene.skills.total} ready; ${status.scene.skills.nextAction}`);
+  lines.push(`- Memory: ${status.scene.memory.assets} asset(s), session=${status.scene.memory.latestSessionMemory ? "yes" : "no"}; ${status.scene.memory.nextAction}`);
+  lines.push(`- Cost: ${status.scene.cost}`);
+  lines.push(`- Recovery: ${status.scene.recovery}`);
+  lines.push("");
+  lines.push("Current workspace:");
+  lines.push(`- Focus: ${status.scene.focus}`);
+  lines.push(`- Session: ${readSessionLine(status)}`);
+  lines.push(`- Next: ${status.scene.nextAction}`);
+  lines.push(`- Blocked: ${status.scene.blocked}`);
+  lines.push(`- Context budget: ${readContextBudgetLine(status)}`);
+  lines.push(`- Workset: ${status.sessions.latest?.workset ? `${status.sessions.latest.workset.total} file(s)` : "none"}`);
+  lines.push(`- Memory: ${status.memory.assets.length > 0 ? `${status.memory.assets.length} asset(s)` : "none"}`);
+  lines.push(`- Skills: ${status.skills.ready}/${status.skills.total} ready`);
+  lines.push(`- Model cache: ${readModelCacheLine(status)}`);
+  lines.push(`- Project map: ${status.projectMap ? "ready" : "missing"}`);
+  lines.push(`- Executions: ${status.executions.active.length} active / ${status.executions.total} total`);
+  lines.push(`- Wake signals: ${status.wakeSignals.recent.length}`);
+  if (status.taskLifecycle) {
+    lines.push("");
+    lines.push("Task lifecycle:");
+    lines.push([
+      status.taskLifecycle.stage,
+      status.taskLifecycle.reason ? `reason=${status.taskLifecycle.reason}` : void 0,
+      status.taskLifecycle.updatedAt
+    ].filter(Boolean).join("  "));
+  }
+  if (status.sessions.latest) {
+    lines.push("");
+    lines.push("Latest session:");
+    lines.push([
+      status.sessions.latest.id,
+      status.sessions.latest.title ?? "(untitled)",
+      `messages=${status.sessions.latest.messageCount}`,
+      status.sessions.latest.hasMemory ? "memory=yes" : "memory=no"
+    ].join("  "));
+  }
+  if (status.projectMap) {
+    lines.push("");
+    lines.push("Project map:");
+    lines.push([
+      `dirs=${status.projectMap.topLevelDirectories.slice(0, 6).join(", ") || "none"}`,
+      `scripts=${status.projectMap.packageScripts.slice(0, 6).join(", ") || "none"}`,
+      `tests=${status.projectMap.testDirectories.slice(0, 4).join(", ") || "none"}`,
+      status.projectMap.git.available ? `git=${status.projectMap.git.hasChanges ? "changed" : "clean"}` : "git=unavailable"
+    ].join("  "));
+  }
+  if (status.sessions.latest?.workset?.files.length) {
+    lines.push("");
+    lines.push("Workset:");
+    for (const file of status.sessions.latest.workset.files) {
+      lines.push([
+        file.path,
+        `read=${file.readCount}`,
+        `changed=${file.changedCount}`,
+        `last=${file.lastTool}`,
+        file.lastChangeId ? `change=${file.lastChangeId}` : void 0,
+        file.reason ? `reason=${file.reason}` : void 0
+      ].filter(Boolean).join("  "));
+    }
+  }
+  if (status.sessions.latest?.contextBudget?.promptHotspots.length) {
+    lines.push("");
+    lines.push("Context budget hotspots:");
+    for (const hotspot of status.sessions.latest.contextBudget.promptHotspots.slice(0, 3)) {
+      lines.push([
+        hotspot.layer,
+        hotspot.title,
+        `chars=${hotspot.chars}`,
+        `lines=${hotspot.lines}`
+      ].join("  "));
+    }
+  }
+  if (status.sessions.latest?.contextBudget?.sources.length) {
+    lines.push("");
+    lines.push("Context budget sources:");
+    for (const source of status.sessions.latest.contextBudget.sources) {
+      lines.push([
+        source.name,
+        `chars=${source.chars}`,
+        source.messages === void 0 ? void 0 : `messages=${source.messages}`
+      ].filter(Boolean).join("  "));
+    }
+  }
+  if (status.sessions.latest?.contextBudget?.cacheLayout) {
+    const layout = status.sessions.latest.contextBudget.cacheLayout;
+    const totalChars = layout.stablePrefixChars + layout.volatileTailChars;
+    const stableRatio = totalChars > 0 ? `${Math.round(layout.stablePrefixChars / totalChars * 100)}%` : "unknown";
+    lines.push("");
+    lines.push("Cache layout:");
+    lines.push([
+      `stable=${layout.stablePrefixFingerprint}`,
+      `stableChars=${layout.stablePrefixChars}`,
+      `tail=${layout.volatileTailFingerprint}`,
+      `tailChars=${layout.volatileTailChars}`,
+      `stableRatio=${stableRatio}`
+    ].join("  "));
+    lines.push([
+      `stableSources=${layout.stableSources.join(",") || "none"}`,
+      `volatileSources=${layout.volatileSources.join(",") || "none"}`
+    ].join("  "));
+  }
+  if (status.modelRequests.recent.length > 0) {
+    lines.push("");
+    lines.push("Recent model requests:");
+    for (const request of status.modelRequests.recent.slice(0, 5)) {
+      lines.push([
+        request.model ?? "unknown-model",
+        request.provider ? `provider=${request.provider}` : void 0,
+        request.durationMs === void 0 ? void 0 : `duration=${request.durationMs}ms`,
+        request.usage ? formatUsage(request.usage) : "usage=unavailable"
+      ].filter(Boolean).join("  "));
+    }
+  }
+  if (status.executions.active.length > 0) {
+    lines.push("");
+    lines.push("Active executions:");
+    for (const execution of status.scene.executions) {
+      lines.push([
+        execution.id,
+        execution.kind,
+        execution.status,
+        `risk=${execution.risk}`,
+        `summary=${truncateCliValue(execution.summary, 80)}`,
+        `next=${execution.nextAction}`
+      ].filter(Boolean).join("  "));
+      if (execution.lastOutput) {
+        lines.push(`  lastOutput=${execution.lastOutput}`);
+      }
+    }
+  }
+  if (status.executions.recent.length > 0) {
+    lines.push("");
+    lines.push("Recent executions:");
+    for (const execution of status.executions.recent.slice(0, 5)) {
+      lines.push([
+        execution.id,
+        execution.kind,
+        execution.status,
+        execution.actorName ? `actor=${execution.actorName}` : void 0,
+        execution.summary ? truncateCliValue(execution.summary, 80) : void 0,
+        execution.assignment?.expectedOutput ? `expected=${truncateCliValue(execution.assignment.expectedOutput, 60)}` : void 0
+      ].filter(Boolean).join("  "));
+    }
+  }
+  if (status.memory.assets.length > 0) {
+    lines.push("");
+    lines.push("Memory:");
+    for (const memory of status.memory.assets.slice(0, 5)) {
+      lines.push([
+        memory.id,
+        memory.kind,
+        `bytes=${memory.size}`,
+        memory.evidenceRefs.length > 0 ? `evidence=${memory.evidenceRefs.join(",")}` : void 0,
+        memory.path
+      ].filter(Boolean).join("  "));
+    }
+  }
+  if (status.skills.needsAttention.length > 0) {
+    lines.push("");
+    lines.push("Skills needing attention:");
+    for (const skill of status.skills.needsAttention) {
+      lines.push([
+        skill.name,
+        skill.path,
+        `resources=${skill.resources}`,
+        `dependencies=${skill.dependencies}`,
+        skill.issues.length > 0 ? `issues=${skill.issues.join("; ")}` : void 0
+      ].filter(Boolean).join("  "));
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function readSessionLine(status) {
+  if (!status.sessions.latest) {
+    return "none";
+  }
+  return `${status.sessions.latest.id} (${status.sessions.latest.messageCount} message(s))`;
+}
+function readContextBudgetLine(status) {
+  const budget = status.sessions.latest?.contextBudget;
+  if (!budget) {
+    return "none";
+  }
+  const percent = Math.round(budget.usageRatio * 100);
+  return [
+    `${budget.estimatedChars}/${budget.limitChars} chars`,
+    `${percent}%`,
+    budget.compressed ? `compressed=${budget.compressionMode}` : "compressed=no",
+    `reason=${budget.compressionReason}`
+  ].join("  ");
+}
+function readModelCacheLine(status) {
+  const latest = status.modelRequests.recent[0];
+  if (!latest) {
+    return "none";
+  }
+  if (!latest.usage) {
+    return latest.usageAvailable ? "usage unavailable" : "usage unavailable from provider";
+  }
+  const cacheTokens = latest.usage.cacheHitTokens ?? latest.usage.cacheReadTokens;
+  const missTokens = latest.usage.cacheMissTokens;
+  const rate = latest.usage.cacheHitRate === void 0 ? void 0 : `${Math.round(latest.usage.cacheHitRate * 100)}%`;
+  return [
+    cacheTokens === void 0 ? "cached=unknown" : `cached=${cacheTokens}`,
+    missTokens === void 0 ? void 0 : `miss=${missTokens}`,
+    rate ? `hit=${rate}` : void 0
+  ].filter(Boolean).join("  ");
+}
+function formatUsage(usage) {
+  return [
+    usage.inputTokens === void 0 ? void 0 : `input=${usage.inputTokens}`,
+    usage.outputTokens === void 0 ? void 0 : `output=${usage.outputTokens}`,
+    usage.reasoningTokens === void 0 ? void 0 : `reasoning=${usage.reasoningTokens}`,
+    usage.cacheHitTokens === void 0 ? void 0 : `cacheHit=${usage.cacheHitTokens}`,
+    usage.cacheReadTokens === void 0 ? void 0 : `cacheRead=${usage.cacheReadTokens}`,
+    usage.cacheCreationTokens === void 0 ? void 0 : `cacheWrite=${usage.cacheCreationTokens}`,
+    usage.cacheMissTokens === void 0 ? void 0 : `cacheMiss=${usage.cacheMissTokens}`,
+    usage.cacheHitRate === void 0 ? void 0 : `hit=${Math.round(usage.cacheHitRate * 100)}%`
+  ].filter(Boolean).join(" ");
+}
+
+// src/host/session.ts
+async function createHostSession(sessionStore, cwd) {
+  return sessionStore.create(cwd);
+}
+async function loadLatestSession(sessionStore) {
+  return sessionStore.loadLatest();
+}
+
+// src/cli/commands/sessionPicker.ts
+import readline from "readline/promises";
+import process2 from "process";
+
+// src/session/picker.ts
+function parseSessionPickerChoice(input, sessionCount) {
+  const trimmed = input.trim();
+  if (trimmed === "") {
+    return sessionCount > 0 ? { kind: "existing", index: 0 } : { kind: "new" };
+  }
+  const value = Number.parseInt(trimmed, 10);
+  if (!Number.isInteger(value) || String(value) !== trimmed) {
+    return { kind: "invalid" };
+  }
+  if (value === 0) {
+    return { kind: "new" };
+  }
+  if (value >= 1 && value <= sessionCount) {
+    return { kind: "existing", index: value - 1 };
+  }
+  return { kind: "invalid" };
+}
+function formatRelativeSessionTime(updatedAt, now) {
+  const updatedTime = new Date(updatedAt).getTime();
+  if (!Number.isFinite(updatedTime)) {
+    return updatedAt;
+  }
+  const seconds = Math.max(0, Math.floor((now.getTime() - updatedTime) / 1e3));
+  if (seconds < 60) {
+    return "\u521A\u521A";
+  }
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    return `${minutes} \u5206\u949F\u524D`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    return `${hours} \u5C0F\u65F6\u524D`;
+  }
+  const days = Math.floor(hours / 24);
+  if (days < 7) {
+    return `${days} \u5929\u524D`;
+  }
+  const weeks = Math.floor(days / 7);
+  if (days < 30) {
+    return `${weeks} \u5468\u524D`;
+  }
+  const months = Math.floor(days / 30);
+  if (days < 365) {
+    return `${months} \u4E2A\u6708\u524D`;
+  }
+  return `${Math.floor(days / 365)} \u5E74\u524D`;
+}
+function formatSessionPickerTitle(session) {
+  const title = session.title?.trim();
+  return truncateDisplayTitle(title || `\u672A\u547D\u540D\u4F1A\u8BDD ${session.id}`);
+}
+function truncateDisplayTitle(title) {
+  const chars = Array.from(title);
+  const maxChars = 36;
+  return chars.length > maxChars ? `${chars.slice(0, maxChars).join("")}...` : title;
+}
+
+// src/cli/commands/sessionHelpers.ts
+async function createSessionStore(sessionsDir) {
+  const { SessionStore: SessionStore2 } = await import("./session-XKWJHRVY.mjs");
+  return new SessionStore2(sessionsDir);
+}
+
+// src/cli/commands/events.ts
+async function readSessionEventsForCli(input) {
+  const sessionStore = await createSessionStore(input.paths.sessionsDir);
+  const session = input.sessionId ? await sessionStore.load(input.sessionId) : await loadLatestSession(sessionStore);
+  if (!session) {
+    return {
+      sessionId: null,
+      events: []
+    };
+  }
+  return {
+    sessionId: session.id,
+    events: await new SessionEventStore(input.paths.eventsDir).list(session.id, input.limit)
+  };
+}
+function formatSessionEventsForCli(result) {
+  if (!result.sessionId) {
+    return "No saved sessions yet.";
+  }
+  if (result.events.length === 0) {
+    return `No events recorded for session ${result.sessionId}.`;
+  }
+  return result.events.map(formatSessionEventForCli).join("\n");
+}
+function formatSessionEventForCli(event) {
+  const parts = [
+    event.createdAt,
+    event.type,
+    event.host ? `host=${event.host}` : void 0,
+    event.message ? `message=${formatInline(event.message)}` : void 0,
+    event.details ? `details=${formatInline(JSON.stringify(event.details))}` : void 0
+  ];
+  return parts.filter(Boolean).join("  ");
+}
+function formatInline(value) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > 120 ? `${normalized.slice(0, 117)}...` : normalized;
+}
+
+// src/config/paths.ts
+function getAppPaths(rootDir = process.cwd()) {
+  const statePaths = getProjectStatePaths(rootDir);
+  return {
+    configDir: statePaths.kittyDir,
+    dataDir: statePaths.kittyDir,
+    cacheDir: statePaths.cacheDir,
+    sessionsDir: statePaths.sessionsDir,
+    memoryDir: statePaths.memoryDir,
+    sessionMemoryDir: statePaths.sessionMemoryDir,
+    changesDir: statePaths.changesDir,
+    eventsDir: statePaths.eventsDir
+  };
+}
+
+// src/project/reset.ts
+import fs9 from "fs/promises";
+import path8 from "path";
+
+// src/project/resetSupport.ts
+import fs8 from "fs/promises";
+import path7 from "path";
+async function waitForRemovedPaths(paths, attempts = 20, delayMs = 50) {
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    const remaining = await Promise.all(
+      paths.map(async (entry) => ({
+        entry,
+        exists: await pathExists(entry)
+      }))
+    );
+    if (remaining.every((item) => item.exists === false)) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+}
+async function isSameOrDescendant(targetPath, possibleAncestor) {
+  if (!targetPath.trim() || !possibleAncestor.trim()) {
+    return false;
+  }
+  const resolvedTarget = await canonicalizePathForComparison(targetPath);
+  const resolvedAncestor = await canonicalizePathForComparison(possibleAncestor);
+  const relative = path7.relative(resolvedAncestor, resolvedTarget);
+  return relative === "" || !relative.startsWith("..") && !path7.isAbsolute(relative);
+}
+async function pathExists(targetPath) {
+  try {
+    await fs8.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function canonicalizePathForComparison(targetPath) {
+  let candidate = path7.resolve(targetPath);
+  const tail = [];
+  while (true) {
+    try {
+      const real = await fs8.realpath(candidate);
+      return tail.length > 0 ? path7.join(real, ...tail.reverse()) : real;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        return tail.length > 0 ? path7.join(candidate, ...tail.reverse()) : candidate;
+      }
+    }
+    const parent = path7.dirname(candidate);
+    if (parent === candidate) {
+      return tail.length > 0 ? path7.join(candidate, ...tail.reverse()) : candidate;
+    }
+    tail.push(path7.basename(candidate));
+    candidate = parent;
+  }
+}
+
+// src/project/reset.ts
+var PRESERVED_PROJECT_STATE_ENTRIES = new Set(PRESERVED_PROJECT_STATE_ENTRY_NAMES);
+async function resetProjectRuntime(input) {
+  const roots = await resolveProjectRoots(input.cwd);
+  const statePaths = getProjectStatePaths(roots.stateRootDir);
+  const kittyDir = statePaths.kittyDir;
+  const removedSessionIds = await removeProjectSessions({
+    sessionsDir: input.config.paths.sessionsDir,
+    stateRootDir: roots.stateRootDir,
+    currentSessionId: input.currentSessionId
+  });
+  await waitForRemovedPaths(removedSessionIds.map((sessionId) => path8.join(input.config.paths.sessionsDir, `${sessionId}.json`)));
+  const removedChangeIds = await removeProjectChanges({
+    changesDir: input.config.paths.changesDir,
+    stateRootDir: roots.stateRootDir,
+    removedSessionIds
+  });
+  const { removedEntries, preservedEntries } = await clearProjectKittyDirectory(kittyDir);
+  await waitForRemovedPaths(removedEntries.map((entry) => path8.join(kittyDir, entry)));
+  return {
+    rootDir: roots.rootDir,
+    stateRootDir: roots.stateRootDir,
+    removedSessionIds,
+    removedChangeIds,
+    removedStateEntries: removedEntries,
+    preservedStateEntries: preservedEntries
+  };
+}
+async function removeProjectSessions(input) {
+  const removedIds = [];
+  try {
+    const entries = await fs9.readdir(input.sessionsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) {
+        continue;
+      }
+      const sessionId = path8.basename(entry.name, ".json");
+      const absolutePath = path8.join(input.sessionsDir, entry.name);
+      const removeById = input.currentSessionId === sessionId;
+      let removeByPath = false;
+      if (!removeById) {
+        const raw = await fs9.readFile(absolutePath, "utf8");
+        const parsed = JSON.parse(raw);
+        removeByPath = await isSameOrDescendant(String(parsed.cwd ?? ""), input.stateRootDir);
+      }
+      if (!removeById && !removeByPath) {
+        continue;
+      }
+      await fs9.rm(absolutePath, { force: true });
+      removedIds.push(sessionId);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return removedIds;
+}
+async function removeProjectChanges(input) {
+  const removedIds = [];
+  const removedSessionIds = new Set(input.removedSessionIds);
+  try {
+    const entries = await fs9.readdir(input.changesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) {
+        continue;
+      }
+      const changeId = path8.basename(entry.name, ".json");
+      const metadataPath = path8.join(input.changesDir, entry.name);
+      const raw = await fs9.readFile(metadataPath, "utf8");
+      const parsed = JSON.parse(raw);
+      const remove = typeof parsed.sessionId === "string" && removedSessionIds.has(parsed.sessionId) || await isSameOrDescendant(String(parsed.cwd ?? ""), input.stateRootDir);
+      if (!remove) {
+        continue;
+      }
+      await fs9.rm(metadataPath, { force: true });
+      await fs9.rm(path8.join(input.changesDir, changeId), { recursive: true, force: true }).catch(() => null);
+      removedIds.push(changeId);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return removedIds;
+}
+async function clearProjectKittyDirectory(kittyDir) {
+  const removedEntries = [];
+  const preservedEntries = [];
+  try {
+    const entries = await fs9.readdir(kittyDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = path8.join(kittyDir, entry.name);
+      if (PRESERVED_PROJECT_STATE_ENTRIES.has(entry.name)) {
+        preservedEntries.push(entry.name);
+        continue;
+      }
+      await fs9.rm(absolutePath, { recursive: true, force: true });
+      removedEntries.push(entry.name);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return {
+    removedEntries,
+    preservedEntries
+  };
+}
+
+// src/interaction/localCommandDefinitions.ts
+var LOCAL_COMMAND_DEFINITIONS = [
+  {
+    id: "exit",
+    category: "system",
+    aliases: ["q", "quit", "exit", "/q", "/quit", "/exit"],
+    slashName: "exit",
+    description: "Exit the session",
+    helpLabel: "quit",
+    helpText: "Exit the session",
+    showInIntro: true
+  },
+  {
+    id: "reset",
+    category: "project",
+    aliases: ["reset", "/reset"],
+    slashName: "reset",
+    description: "Clear current project runtime state and exit",
+    helpLabel: "/reset",
+    helpText: "Clear current project runtime state and exit",
+    showInIntro: true
+  },
+  {
+    id: "help",
+    category: "system",
+    aliases: ["/help"],
+    slashName: "help",
+    description: "Show slash commands",
+    helpLabel: "/help",
+    helpText: "Show slash commands",
+    showInIntro: true
+  },
+  {
+    id: "session",
+    category: "session",
+    aliases: ["/session"],
+    slashName: "session",
+    description: "Show current session ID",
+    helpLabel: "/session",
+    helpText: "Show current session ID"
+  },
+  {
+    id: "sessions",
+    category: "session",
+    aliases: ["/sessions", "/resume", "/continue"],
+    slashName: "sessions",
+    description: "List recent sessions",
+    helpLabel: "/sessions",
+    helpText: "List recent sessions"
+  },
+  {
+    id: "config",
+    category: "project",
+    aliases: ["/config"],
+    slashName: "config",
+    description: "Show current runtime config",
+    helpLabel: "/config",
+    helpText: "Show current runtime config"
+  },
+  {
+    id: "status",
+    category: "runtime",
+    aliases: ["/status"],
+    slashName: "status",
+    description: "Show current project scene",
+    helpLabel: "/status",
+    helpText: "Show current project scene"
+  },
+  {
+    id: "background",
+    category: "runtime",
+    aliases: ["/background", "/bg"],
+    slashName: "background",
+    description: "Show background task scene",
+    helpLabel: "/background",
+    helpText: "Show background task scene"
+  },
+  {
+    id: "events",
+    category: "runtime",
+    aliases: ["/events"],
+    slashName: "events",
+    description: "Show recent session events",
+    helpLabel: "/events",
+    helpText: "Show recent session events"
+  },
+  {
+    id: "memory",
+    category: "runtime",
+    aliases: ["/memory"],
+    slashName: "memory",
+    description: "List runtime memory assets",
+    helpLabel: "/memory",
+    helpText: "List runtime memory assets"
+  },
+  {
+    id: "skills",
+    category: "runtime",
+    aliases: ["/skills"],
+    slashName: "skills",
+    description: "List runtime skills",
+    helpLabel: "/skills",
+    helpText: "List runtime skills"
+  },
+  {
+    id: "doctor",
+    category: "project",
+    aliases: ["/doctor"],
+    slashName: "doctor",
+    description: "Run local setup preflight",
+    helpLabel: "/doctor",
+    helpText: "Run local setup preflight"
+  },
+  {
+    id: "copy",
+    category: "session",
+    aliases: ["/copy"],
+    slashName: "copy",
+    description: "Print current session transcript",
+    helpLabel: "/copy",
+    helpText: "Print current session transcript"
+  },
+  {
+    id: "export",
+    category: "session",
+    aliases: ["/export"],
+    slashName: "export",
+    description: "Print current session snapshot JSON",
+    helpLabel: "/export",
+    helpText: "Print current session snapshot JSON"
+  },
+  {
+    id: "clear",
+    category: "session",
+    aliases: ["/clear"],
+    slashName: "clear",
+    description: "Clear the current prompt in UI shells",
+    helpLabel: "/clear",
+    helpText: "Clear the current prompt in UI shells"
+  }
+];
+var ALL_LOCAL_COMMAND_DEFINITIONS = LOCAL_COMMAND_DEFINITIONS;
+var LOCAL_COMMAND_BY_ALIAS = new Map(
+  ALL_LOCAL_COMMAND_DEFINITIONS.flatMap(
+    (definition) => definition.aliases.map((alias) => [alias, definition.id])
+  )
+);
+function normalizeLocalCommand(input) {
+  return LOCAL_COMMAND_BY_ALIAS.get(input.trim().toLowerCase());
+}
+function getLocalCommandDefinition(id) {
+  const definition = ALL_LOCAL_COMMAND_DEFINITIONS.find((item) => item.id === id);
+  if (!definition) {
+    throw new Error(`Unknown local command: ${id}`);
+  }
+  return definition;
+}
+function formatLocalCommandHelpLine(id) {
+  const definition = getLocalCommandDefinition(id);
+  return `${definition.helpLabel.padEnd(12)} ${definition.helpText}`;
+}
+function formatLocalCommandHelp() {
+  return [
+    "Slash commands:",
+    ...ALL_LOCAL_COMMAND_DEFINITIONS.map((definition) => formatLocalCommandHelpLine(definition.id)),
+    "",
+    "Any other input is sent directly to kitty."
+  ].join("\n");
+}
+function listIntroLocalCommands() {
+  return ALL_LOCAL_COMMAND_DEFINITIONS.filter((definition) => definition.showInIntro);
+}
+
+// src/interaction/localCommands.ts
+async function handleLocalCommand(input, context, output) {
+  if (!input.trim()) {
+    return "handled";
+  }
+  const command = normalizeLocalCommand(input);
+  if (command === "exit") {
+    return "quit";
+  }
+  if (command === "reset") {
+    await resetProjectRuntime({
+      cwd: context.cwd,
+      config: context.config,
+      currentSessionId: context.session.id
+    });
+    output.warn("Project runtime reset. Session closed.");
+    return "quit";
+  }
+  if (command === "help") {
+    output.plain(formatLocalCommandHelp());
+    return "handled";
+  }
+  if (command === "session") {
+    output.info(`Current session: ${context.session.id}`);
+    return "handled";
+  }
+  if (command === "config") {
+    output.info(`model=${context.config.model} baseUrl=${context.config.baseUrl}`);
+    return "handled";
+  }
+  if (command === "status") {
+    output.plain(formatRuntimeStatusText(await buildRuntimeStatus(await resolveLocalStateRootDir(context))).trimEnd());
+    return "handled";
+  }
+  if (command === "background") {
+    output.plain(await formatBackgroundExecutionsForLocalCommand(context));
+    return "handled";
+  }
+  if (command === "memory") {
+    output.plain(formatMemoryListForCli(await readMemoryListForCli(await resolveLocalStateRootDir(context))));
+    return "handled";
+  }
+  if (command === "skills") {
+    output.plain(formatSkillsForLocalCommand(await buildRuntimeStatus(await resolveLocalStateRootDir(context))));
+    return "handled";
+  }
+  if (command === "events") {
+    const stateRootDir = await resolveLocalStateRootDir(context);
+    output.plain(formatSessionEventsForCli(await readSessionEventsForCli({
+      cwd: stateRootDir,
+      paths: getAppPaths(stateRootDir),
+      sessionId: context.session.id,
+      limit: 20
+    })));
+    return "handled";
+  }
+  if (command === "doctor") {
+    output.plain(formatConfigPreflightReport(await inspectConfigPreflight(context.cwd)).join("\n"));
+    return "handled";
+  }
+  if (command === "sessions") {
+    output.plain(await formatSessionsForLocalCommand(context));
+    return "handled";
+  }
+  if (command === "copy") {
+    output.plain(formatSessionTranscript(context.session));
+    return "handled";
+  }
+  if (command === "export") {
+    output.plain(JSON.stringify(context.session, null, 2));
+    return "handled";
+  }
+  if (command === "clear") {
+    output.info("Current prompt cleared.");
+    return "handled";
+  }
+  return "continue";
+}
+async function formatBackgroundExecutionsForLocalCommand(context) {
+  const stateRootDir = await resolveLocalStateRootDir(context);
+  const store = new BackgroundExecutionStore(stateRootDir);
+  const executions = store.listAll().map(summarizeExecution).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+  if (executions.length === 0) {
+    return "No background executions recorded.";
+  }
+  return executions.map(formatBackgroundExecution).join("\n");
+}
+async function resolveLocalStateRootDir(context) {
+  return context.stateRootDir ?? (await resolveProjectRoots(context.cwd)).stateRootDir;
+}
+function formatSkillsForLocalCommand(status) {
+  if (status.skills.total === 0) {
+    return "No runtime skills discovered.";
+  }
+  return [
+    `skills: ${status.skills.ready}/${status.skills.total} ready`,
+    ...status.skills.needsAttention.map((skill) => `${skill.name}  status=${skill.status}  issues=${skill.issues.join("; ") || "none"}`)
+  ].join("\n");
+}
+async function formatSessionsForLocalCommand(context) {
+  const sessions = await (context.sessionStore?.list(10) ?? []);
+  if (sessions.length === 0) {
+    return "No saved sessions yet.";
+  }
+  return sessions.map((session) => [
+    session.id === context.session.id ? "*" : " ",
+    session.id,
+    session.updatedAt,
+    session.title ?? "(untitled)",
+    `messages=${session.messageCount}`
+  ].join("  ")).join("\n");
+}
+function formatSessionTranscript(session) {
+  if (session.messages.length === 0) {
+    return "Current session has no messages yet.";
+  }
+  return session.messages.map((message) => `${message.role}: ${message.content}`).join("\n\n");
+}
+
+// src/interaction/sessionDriver.ts
+var InteractiveSessionDriver = class {
+  constructor(options) {
+    this.options = options;
+    this.session = options.session;
+  }
+  session;
+  turnInFlight = false;
+  turnAbortController = null;
+  lastInterruptNoticeAt = 0;
+  exitRequested = false;
+  terminationInProgress = false;
+  async run() {
+    const releaseInterrupt = this.options.shell.input.bindInterrupt(() => {
+      this.handleInterrupt();
+    });
+    const releaseProcessTermination = this.bindProcessTerminationCleanup();
+    try {
+      while (true) {
+        const prompt = await this.options.shell.input.readInput("> ");
+        if (prompt.kind === "closed") {
+          await this.terminateRunningProcessesForForcedExit("Input closed. Stopping running processes before exit.");
+          return this.session;
+        }
+        const input = prompt.value.trim();
+        if (!input) {
+          continue;
+        }
+        const decision = await this.handleInput(input);
+        if (decision === "quit") {
+          return this.session;
+        }
+        if (this.exitRequested) {
+          return this.session;
+        }
+      }
+    } finally {
+      releaseProcessTermination();
+      releaseInterrupt();
+    }
+  }
+  async handleInput(input) {
+    let localCommandResult;
+    try {
+      localCommandResult = await (this.options.localCommandHandler ?? handleLocalCommand)(
+        input,
+        {
+          cwd: this.options.cwd,
+          session: this.session,
+          config: this.options.config,
+          sessionStore: this.options.sessionStore
+        },
+        this.options.shell.output
+      );
+    } catch (error) {
+      this.options.shell.output.error(getErrorMessage(error));
+      return "handled";
+    }
+    if (localCommandResult === "continue") {
+      await this.runTurn(input);
+    } else if (localCommandResult === "quit") {
+      return this.handleQuitRequest();
+    }
+    return localCommandResult;
+  }
+  async handleQuitRequest() {
+    const exitGuard = this.options.exitGuard ?? defaultInteractiveExitGuard;
+    let runningProcesses;
+    try {
+      runningProcesses = await exitGuard.collectRunningProcesses(this.options.cwd);
+    } catch (error) {
+      this.options.shell.output.error(`Failed to inspect running background processes: ${getErrorMessage(error)}`);
+      return "handled";
+    }
+    if (runningProcesses.length === 0) {
+      this.options.shell.output.info("Session saved.");
+      return "quit";
+    }
+    this.options.shell.output.warn("Running processes detected. Exiting now will kill them all.");
+    this.options.shell.output.plain(runningProcesses.map((process4) => process4.summary).join("\n"));
+    const confirmation = await this.options.shell.input.readInput(
+      "Kill all running processes and exit? [y/N] "
+    );
+    if (confirmation.kind !== "submit" || !isYes(confirmation.value)) {
+      this.options.shell.output.info("Exit cancelled. Background processes will keep running.");
+      return "handled";
+    }
+    try {
+      const result = await exitGuard.terminateProcesses(runningProcesses, this.options.cwd);
+      if (result.failedPids.length > 0) {
+        this.options.shell.output.error(
+          `Could not stop all background processes. Still running: ${result.failedPids.join(", ")}. Exit cancelled.`
+        );
+        return "handled";
+      }
+      this.options.shell.output.warn(`Stopped ${result.terminatedPids.length} background process(es).`);
+      this.options.shell.output.info("Session saved.");
+      return "quit";
+    } catch (error) {
+      this.options.shell.output.error(`Failed to stop background processes: ${getErrorMessage(error)}`);
+      return "handled";
+    }
+  }
+  handleInterrupt() {
+    if (this.turnInFlight && this.turnAbortController && !this.turnAbortController.signal.aborted) {
+      this.turnAbortController.abort();
+      this.showInterruptNotice("Interrupted the current turn. You can continue typing.");
+      return;
+    }
+    this.showInterruptNotice("This session will not exit automatically. Type quit or q to exit.");
+  }
+  showInterruptNotice(message) {
+    const now = Date.now();
+    if (now - this.lastInterruptNoticeAt < 150) {
+      return;
+    }
+    this.lastInterruptNoticeAt = now;
+    this.options.shell.output.interrupt(message);
+  }
+  bindProcessTerminationCleanup() {
+    const signals = ["SIGHUP", "SIGTERM", "SIGBREAK"];
+    const handler = (signal) => {
+      void this.terminateRunningProcessesForForcedExit(
+        `Received ${signal}. Stopping running processes before exit.`
+      ).finally(() => {
+        process3.exit(0);
+      });
+    };
+    for (const signal of signals) {
+      process3.once(signal, handler);
+    }
+    return () => {
+      for (const signal of signals) {
+        process3.off(signal, handler);
+      }
+    };
+  }
+  async terminateRunningProcessesForForcedExit(reason) {
+    if (this.terminationInProgress) {
+      return;
+    }
+    this.terminationInProgress = true;
+    this.exitRequested = true;
+    if (this.turnAbortController && !this.turnAbortController.signal.aborted) {
+      this.turnAbortController.abort();
+    }
+    const exitGuard = this.options.exitGuard ?? defaultInteractiveExitGuard;
+    try {
+      const runningProcesses = await exitGuard.collectRunningProcesses(this.options.cwd);
+      if (runningProcesses.length === 0) {
+        this.options.shell.output.info("Session saved.");
+        return;
+      }
+      this.options.shell.output.warn(reason);
+      this.options.shell.output.plain(runningProcesses.map((processInfo) => processInfo.summary).join("\n"));
+      const result = await exitGuard.terminateProcesses(runningProcesses, this.options.cwd);
+      if (result.failedPids.length > 0) {
+        this.options.shell.output.error(`Could not stop all running processes. Still running: ${result.failedPids.join(", ")}.`);
+        return;
+      }
+      this.options.shell.output.warn(`Stopped ${result.terminatedPids.length} running process(es).`);
+      this.options.shell.output.info("Session saved.");
+    } catch (error) {
+      this.options.shell.output.error(`Failed to stop running processes: ${getErrorMessage(error)}`);
+    }
+  }
+  async runTurn(input) {
+    this.options.shell.output.plain(formatSubmittedInput(input));
+    this.turnInFlight = true;
+    const controller = new AbortController();
+    this.turnAbortController = controller;
+    const turnDisplay = this.options.shell.createTurnDisplay({
+      cwd: this.options.cwd,
+      config: this.options.config,
+      abortSignal: controller.signal
+    });
+    try {
+      const turnContext = await this.options.turnContextProvider?.(this.session, input);
+      const outcome = await runHostTurn({
+        host: "interactive",
+        input,
+        cwd: turnContext?.cwd ?? this.options.cwd,
+        stateRootDir: turnContext?.stateRootDir,
+        config: this.options.config,
+        session: this.session,
+        sessionStore: this.options.sessionStore,
+        builtinToolFilter: turnContext?.builtinToolFilter,
+        extraTools: turnContext?.extraTools,
+        runtimePromptState: turnContext?.runtimePromptState,
+        abortSignal: controller.signal,
+        callbacks: turnDisplay.callbacks
+      }, {
+        runTurn: this.options.runTurn
+      });
+      this.session = outcome.session;
+      this.options.onSessionUpdated?.(this.session);
+      if (outcome.status === "aborted") {
+        turnDisplay.flush();
+        this.options.shell.output.warn(outcome.errorMessage ?? "Turn interrupted. You can keep chatting.");
+        return;
+      }
+      if (outcome.status === "failed") {
+        turnDisplay.flush();
+        this.options.shell.output.error(outcome.errorMessage ?? "The request failed.");
+        this.options.shell.output.info("The request failed, but the session is still alive. You can keep chatting.");
+      }
+    } catch (error) {
+      turnDisplay.flush();
+      this.options.shell.output.error(getErrorMessage(error));
+      this.options.shell.output.info("The request failed, but the session is still alive. You can keep chatting.");
+    } finally {
+      turnDisplay.dispose();
+      this.turnInFlight = false;
+      this.turnAbortController = null;
+    }
+  }
+};
+function isYes(value) {
+  const normalized = value.trim().toLowerCase();
+  return normalized === "y" || normalized === "yes";
+}
+function formatSubmittedInput(input) {
+  return input.split("\n").map((line, index) => `${index === 0 ? "> " : "\u2026 "}${line}`).join("\n");
+}
+
+// src/shell/banner.ts
+import figlet from "figlet";
+var KITTY_WORDMARK_FONT = "ANSI Shadow";
+function renderKittyBanner() {
+  return figlet.textSync("kitty agent", {
+    font: KITTY_WORDMARK_FONT,
+    horizontalLayout: "default",
+    verticalLayout: "default",
+    width: 120,
+    whitespaceBreak: false
+  }).trimEnd();
+}
+
+export {
+  ui,
+  createHostSession,
+  parseSessionPickerChoice,
+  formatRelativeSessionTime,
+  formatSessionPickerTitle,
+  createTerminalLogWriter,
+  mirrorProcessOutputToTerminalLog,
+  mirrorInteractionShellToTerminalLog,
+  formatLocalCommandHelpLine,
+  listIntroLocalCommands,
+  renderKittyBanner,
+  InteractiveSessionDriver
+};