@jun133/kitty 0.0.8 → 0.0.9

package/dist/cli.js

@@ -40,7 +40,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@jun133/kitty",
-      version: "0.0.8",
+      version: "0.0.9",
       description: "Agent",
       license: "MIT",
       keywords: [
@@ -64,7 +64,7 @@ var init_package = __esm({
         node: ">=20.0.0"
       },
       scripts: {
-        build: "tsup src/cli.ts --format cjs --platform node --target node20 --outDir dist --clean --sourcemap",
+        build: "tsup src/cli.ts --format cjs --platform node --target node20 --outDir dist --clean --sourcemap && tsup src/tui.ts --format esm --platform node --target node20 --outDir dist --clean=false --external typescript",
         check: "npm run typecheck && npm run build",
         dev: "tsx src/cli.ts",
         "test:build": `node -e "require('node:fs').rmSync('.test-build', { recursive: true, force: true })" && tsc -p tsconfig.tests.json`,
@@ -83,12 +83,18 @@ var init_package = __esm({
         execa: "^9.6.0",
         "fast-glob": "^3.3.3",
         figlet: "^1.11.0",
+        ink: "^7.1.0",
+        marked: "^15.0.7",
         openai: "^6.4.0",
+        react: "^19.2.7",
+        "string-width": "^8.2.1",
+        "wrap-ansi": "^10.0.0",
         ws: "^8.21.0"
       },
       devDependencies: {
         "@types/better-sqlite3": "^7.6.13",
         "@types/node": "^24.5.2",
+        "@types/react": "^19.2.17",
         "@types/ws": "^8.18.1",
         tsup: "^8.5.0",
         tsx: "^4.20.5",
@@ -1128,6 +1134,13 @@ var init_wakeSignals = __esm({
 });
 
 // src/control/ledger.ts
+var ledger_exports = {};
+__export(ledger_exports, {
+  ControlPlaneLedger: () => ControlPlaneLedger,
+  ExecutionLedgerRepo: () => ExecutionLedgerRepo,
+  TaskLifecycleLedgerRepo: () => TaskLifecycleLedgerRepo,
+  WakeSignalLedgerRepo: () => WakeSignalLedgerRepo
+});
 var import_better_sqlite3, import_node_fs2, ControlPlaneLedger;
 var init_ledger = __esm({
   "src/control/ledger.ts"() {
@@ -5911,6 +5924,12 @@ var init_envKeys = __esm({
 });
 
 // src/agent/prompt/format.ts
+var format_exports = {};
+__export(format_exports, {
+  formatPromptBlock: () => formatPromptBlock,
+  joinBlocks: () => joinBlocks,
+  renderPromptLayers: () => renderPromptLayers
+});
 function formatPromptBlock(title, content) {
   return `${title}:
 ${content}`;
@@ -8682,7 +8701,22 @@ function readContextBudget(value, sessionPath) {
     compressionMode,
     compressionReason: readRequiredString(record, "compressionReason", sessionPath, "contextBudget"),
     sources: readContextBudgetSources(record.sources, sessionPath),
-    promptHotspots: readContextBudgetHotspots(record.promptHotspots, sessionPath)
+    promptHotspots: readContextBudgetHotspots(record.promptHotspots, sessionPath),
+    cacheLayout: readContextCacheLayout(record.cacheLayout, sessionPath)
+  };
+}
+function readContextCacheLayout(value, sessionPath) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const record = expectRecord(value, sessionPath, "contextBudget.cacheLayout");
+  return {
+    stablePrefixFingerprint: readRequiredString(record, "stablePrefixFingerprint", sessionPath, "contextBudget.cacheLayout"),
+    volatileTailFingerprint: readRequiredString(record, "volatileTailFingerprint", sessionPath, "contextBudget.cacheLayout"),
+    stablePrefixChars: readRequiredNumber(record, "stablePrefixChars", sessionPath, "contextBudget.cacheLayout"),
+    volatileTailChars: readRequiredNumber(record, "volatileTailChars", sessionPath, "contextBudget.cacheLayout"),
+    stableSources: readStringArray(record.stableSources, sessionPath, "contextBudget.cacheLayout.stableSources"),
+    volatileSources: readStringArray(record.volatileSources, sessionPath, "contextBudget.cacheLayout.volatileSources")
   };
 }
 function readContextBudgetSources(value, sessionPath) {
@@ -8724,6 +8758,17 @@ function readContextBudgetHotspots(value, sessionPath) {
     };
   });
 }
+function readStringArray(value, sessionPath, scope) {
+  if (!Array.isArray(value)) {
+    throw createSessionCorruptError(sessionPath, `${scope} must be an array`);
+  }
+  return value.map((entry, index) => {
+    if (typeof entry !== "string") {
+      throw createSessionCorruptError(sessionPath, `${scope}[${index}] must be a string`);
+    }
+    return entry;
+  });
+}
 function readMessage(value, index, sessionPath) {
   const record = expectRecord(value, sessionPath, `messages[${index}]`);
   const role = readRequiredString(record, "role", sessionPath, `messages[${index}]`);
@@ -9881,6 +9926,222 @@ var init_projectContext = __esm({
   }
 });
 
+// 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 ? truncateText2(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 truncateText2(focus, 120);
+  }
+  const title = status.sessions.latest?.title;
+  if (title) {
+    return truncateText2(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 truncateText2(execution.assignment.objective, 120);
+  }
+  if (execution.summary) {
+    return truncateText2(execution.summary, 120);
+  }
+  if (execution.command) {
+    return truncateText2(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 truncateText2(value, maxChars) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxChars) {
+    return normalized;
+  }
+  return `${normalized.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+var init_scene = __esm({
+  "src/runtime/scene.ts"() {
+    "use strict";
+  }
+});
+
 // src/runtime/status.ts
 var status_exports = {};
 __export(status_exports, {
@@ -9901,7 +10162,7 @@ async function buildRuntimeStatus(rootDir) {
   ]);
   const sessions = sessionRead.sessions.map(summarizeSession);
   const taskLifecycle = sessions[0] ? readTaskLifecycleStatus(paths.rootDir, sessions[0].id) : void 0;
-  return {
+  const statusWithoutScene = {
     rootDir: paths.rootDir,
     stateDir: paths.kittyDir,
     sessions: {
@@ -9922,6 +10183,10 @@ async function buildRuntimeStatus(rootDir) {
     executions: control.executions,
     wakeSignals: control.wakeSignals
   };
+  return {
+    ...statusWithoutScene,
+    scene: buildRuntimeScene(statusWithoutScene)
+  };
 }
 function summarizeProjectMap2(projectMap) {
   return {
@@ -10101,6 +10366,7 @@ var init_status = __esm({
     init_memory2();
     init_projectContext();
     init_executionSummary();
+    init_scene();
     init_store3();
     DEFAULT_RECENT_LIMIT = 10;
   }
@@ -12157,6 +12423,252 @@ var init_initialConfig = __esm({
   }
 });
 
+// src/cli/commands/runtimeStatusPresenter.ts
+var runtimeStatusPresenter_exports = {};
+__export(runtimeStatusPresenter_exports, {
+  formatRuntimeStatusText: () => formatRuntimeStatusText
+});
+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(" ");
+}
+var init_runtimeStatusPresenter = __esm({
+  "src/cli/commands/runtimeStatusPresenter.ts"() {
+    "use strict";
+    init_cliValues();
+  }
+});
+
 // src/agent/turn/persistence.ts
 async function initializeTurnSession(session, input, sessionStore, source = "external") {
   const appended = await sessionStore.appendMessages(session, [
@@ -226726,14 +227238,6 @@ function createWebInputPort(wss) {
         pendingResolve = resolve;
       });
     },
-    readMultiline(_promptLabel) {
-      return this.readInput(_promptLabel).then((result) => {
-        if (result.kind === "submit") {
-          return { kind: "submit", value: result.value };
-        }
-        return { kind: "cancel" };
-      });
-    },
     bindInterrupt(handler) {
       interruptHandlers.add(handler);
       return () => {
@@ -227231,6 +227735,9 @@ var init_lifecycle2 = __esm({
 function listEvaluationChecks() {
   return [...EVALUATION_CHECK_IDS];
 }
+function listEvaluationScenarios() {
+  return [...EVALUATION_SCENARIOS];
+}
 async function runEvaluationCheck(id, rootDir) {
   try {
     switch (id) {
@@ -227267,6 +227774,9 @@ async function runEvaluationCheck(id, rootDir) {
       case "cache-economy-ready": {
         return await runCacheEconomyCheck(id);
       }
+      case "production-scene-ready": {
+        return await runProductionSceneCheck(id, rootDir);
+      }
       case "host-turn-boundary-runs": {
         return await runHostTurnBoundaryCheck(id, rootDir);
       }
@@ -227291,6 +227801,7 @@ async function runCacheEconomyCheck(id) {
   const { resolveProviderCachePolicy: resolveProviderCachePolicy2 } = await Promise.resolve().then(() => (init_cachePolicy(), cachePolicy_exports));
   const { buildCompressedContextRequest: buildCompressedContextRequest2 } = await Promise.resolve().then(() => (init_builder(), builder_exports));
   const { buildContextRuntimePromptLayers: buildContextRuntimePromptLayers2 } = await Promise.resolve().then(() => (init_prompt3(), prompt_exports));
+  const { renderPromptLayers: renderPromptLayers2 } = await Promise.resolve().then(() => (init_format(), format_exports));
   const { getInitialRuntimeConfig: getInitialRuntimeConfig2 } = await Promise.resolve().then(() => (init_initialConfig(), initialConfig_exports));
   const { getAppPaths: getAppPaths2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
   const { resolveTelegramRuntimeConfig: resolveTelegramRuntimeConfig2 } = await Promise.resolve().then(() => (init_hosts(), hosts_exports));
@@ -227326,7 +227837,7 @@ async function runCacheEconomyCheck(id) {
     instructionText: "",
     instructionTruncated: false,
     ignoreRules: [],
-    skills: []
+    skills: [buildCostSkillFixture()]
   };
   const firstPrompt = buildContextRuntimePromptLayers2({
     cwd: process.cwd(),
@@ -227382,18 +227893,37 @@ async function runCacheEconomyCheck(id) {
   };
   const first = buildCompressedContextRequest2(
     firstPrompt,
-    [{ role: "user", content: "first", createdAt: "2026-06-16T00:00:00.000Z" }],
+    [
+      { role: "user", content: "first", createdAt: "2026-06-16T00:00:00.000Z" },
+      { role: "tool", name: "bash", content: `large output ${"x".repeat(2e4)}`, createdAt: "2026-06-16T00:00:01.000Z" }
+    ],
     requestConfig
   );
   const second = buildCompressedContextRequest2(
     secondPrompt,
     [
       { role: "user", content: "first", createdAt: "2026-06-16T00:00:00.000Z" },
+      { role: "tool", name: "bash", content: `large output ${"x".repeat(2e4)}`, createdAt: "2026-06-16T00:00:01.000Z" },
       { role: "user", content: "second", createdAt: "2026-06-16T00:01:00.000Z" }
     ],
     requestConfig
   );
-  if (deepSeek?.cacheHitRate !== 0.8 || openai?.cacheReadTokens !== 960 || !policy.promptCacheKey || first.cacheLayout?.stablePrefixFingerprint !== second.cacheLayout?.stablePrefixFingerprint || first.cacheLayout?.volatileTailFingerprint === second.cacheLayout?.volatileTailFingerprint) {
+  const compactedLargeOutput = buildCompressedContextRequest2(
+    firstPrompt,
+    [
+      { role: "user", content: "large output", createdAt: "2026-06-16T00:00:00.000Z" },
+      { role: "tool", name: "bash", content: `large output ${"x".repeat(2e4)}`, createdAt: "2026-06-16T00:00:01.000Z" },
+      { role: "user", content: "continue", createdAt: "2026-06-16T00:00:02.000Z" }
+    ],
+    {
+      contextWindowMessages: 3,
+      model: "gpt-5.5",
+      maxContextChars: 8e3,
+      contextSummaryChars: 600
+    }
+  );
+  const renderedPrompt = renderPromptLayers2(firstPrompt);
+  if (deepSeek?.cacheHitRate !== 0.8 || openai?.cacheReadTokens !== 960 || !policy.promptCacheKey || first.cacheLayout?.stablePrefixFingerprint !== second.cacheLayout?.stablePrefixFingerprint || first.cacheLayout?.volatileTailFingerprint === second.cacheLayout?.volatileTailFingerprint || renderedPrompt.includes("FULL_SKILL_BODY_MUST_NOT_ENTER_DEFAULT_CONTEXT") || !renderedPrompt.includes("cost-skill") || (compactedLargeOutput.cacheLayout?.volatileTailChars ?? Number.POSITIVE_INFINITY) >= 2e4) {
     return {
       id,
       status: "failed",
@@ -227402,9 +227932,141 @@ async function runCacheEconomyCheck(id) {
   }
   return passed(
     id,
-    `cache economy ready: deepseekHit=${deepSeek?.cacheHitRate}, openaiCached=${openai?.cacheReadTokens}, stablePrefix=${first.cacheLayout?.stablePrefixFingerprint ?? "unknown"}`
+    `cache economy ready: deepseekHit=${deepSeek?.cacheHitRate}, openaiCached=${openai?.cacheReadTokens}, stablePrefix=${first.cacheLayout?.stablePrefixFingerprint ?? "unknown"}, stableChars=${first.cacheLayout?.stablePrefixChars ?? 0}, compactedTailChars=${compactedLargeOutput.cacheLayout?.volatileTailChars ?? 0}, skillIndex=only`
   );
 }
+async function runProductionSceneCheck(id, rootDir) {
+  const { buildRuntimeStatus: buildRuntimeStatus2 } = await Promise.resolve().then(() => (init_status(), status_exports));
+  const { formatRuntimeStatusText: formatRuntimeStatusText2 } = await Promise.resolve().then(() => (init_runtimeStatusPresenter(), runtimeStatusPresenter_exports));
+  const { ControlPlaneLedger: ControlPlaneLedger2 } = await Promise.resolve().then(() => (init_ledger(), ledger_exports));
+  const { SessionStore: SessionStore2 } = await Promise.resolve().then(() => (init_store3(), store_exports2));
+  const workspace = await prepareCheckWorkspace(rootDir, "production-scene");
+  await import_promises33.default.mkdir(import_node_path46.default.join(workspace, "skills", "scene-skill"), { recursive: true });
+  await import_promises33.default.writeFile(
+    import_node_path46.default.join(workspace, "skills", "scene-skill", "SKILL.md"),
+    [
+      "---",
+      "name: scene-skill",
+      "description: Checks production scene readiness.",
+      "requires: node",
+      "---",
+      "Use when validating production runtime scene."
+    ].join("\n"),
+    "utf8"
+  );
+  const sessionStore = new SessionStore2(import_node_path46.default.join(workspace, ".kitty", "sessions"), {
+    memorySessionsDir: import_node_path46.default.join(workspace, ".kitty", "memory", "sessions")
+  });
+  const session = await sessionStore.save({
+    ...await sessionStore.create(workspace),
+    title: "Production scene check",
+    sessionMemory: {
+      version: 1,
+      summary: "User needs production runtime visibility.",
+      updatedAt: "2026-06-18T00:00:00.000Z"
+    },
+    contextBudget: {
+      version: 1,
+      limitChars: 1e5,
+      estimatedChars: 5e4,
+      remainingChars: 5e4,
+      usageRatio: 0.5,
+      compressed: false,
+      compressionMode: "none",
+      compressionReason: "within_budget",
+      sources: [{ name: "nearFieldConversation", chars: 2e4, messages: 4 }],
+      promptHotspots: [],
+      cacheLayout: {
+        stablePrefixFingerprint: "scene-stable",
+        volatileTailFingerprint: "scene-tail",
+        stablePrefixChars: 3e4,
+        volatileTailChars: 2e4,
+        stableSources: ["staticPrompt"],
+        volatileSources: ["runtimeFacts", "nearFieldConversation"]
+      }
+    }
+  });
+  const eventsDir = import_node_path46.default.join(workspace, ".kitty", "observability", "events");
+  await import_promises33.default.mkdir(eventsDir, { recursive: true });
+  await import_promises33.default.writeFile(
+    import_node_path46.default.join(eventsDir, "2026-06-18.jsonl"),
+    JSON.stringify({
+      version: 1,
+      timestamp: "2026-06-18T00:00:00.000Z",
+      event: "model.request",
+      status: "completed",
+      model: "gpt-5.5",
+      durationMs: 123,
+      details: {
+        provider: "openai",
+        usageAvailable: true,
+        usage: {
+          totalTokens: 1e3,
+          cacheReadTokens: 700,
+          cacheMissTokens: 300,
+          cacheHitRate: 0.7
+        }
+      }
+    }) + "\n",
+    "utf8"
+  );
+  const ledger = new ControlPlaneLedger2(workspace);
+  try {
+    ledger.executions.create({
+      kind: "background",
+      status: "running",
+      command: "long production task",
+      cwd: workspace,
+      requestedBy: "lead",
+      pid: process.pid,
+      sessionId: session.id
+    });
+  } finally {
+    ledger.close();
+  }
+  const status = await buildRuntimeStatus2(workspace);
+  const text = formatRuntimeStatusText2(status);
+  if (status.scene.background.active !== 1 || status.scene.background.blocked !== 1 || !status.scene.cost.includes("1000 tokens") || !status.scene.cost.includes("700 cached") || status.scene.skills.ready < 1 || status.scene.memory.assets < 1 || !status.scene.memory.latestSessionMemory || status.skills.ready < 1 || status.memory.assets.length < 1 || !text.includes("Scene:") || !text.includes("Background next:") || !text.includes("Cost:")) {
+    return {
+      id,
+      status: "failed",
+      fact: `production scene incomplete: background=${status.scene.background.active}/${status.scene.background.blocked}, skills=${status.skills.ready}/${status.skills.total}, memory=${status.memory.assets.length}, cost=${status.scene.cost}`
+    };
+  }
+  return passed(
+    id,
+    `production scene ready: background=${status.scene.background.active}/${status.scene.background.blocked}, skills=${status.skills.ready}/${status.skills.total}, memory=${status.memory.assets.length}, cost=${status.scene.cost}`
+  );
+}
+function buildCostSkillFixture() {
+  return {
+    name: "cost-skill",
+    description: "Loaded only when needed.",
+    path: "skills/cost-skill/SKILL.md",
+    absolutePath: "skills/cost-skill/SKILL.md",
+    body: "FULL_SKILL_BODY_MUST_NOT_ENTER_DEFAULT_CONTEXT",
+    dependencies: [],
+    resources: [{
+      path: "references/cost.md",
+      size: 1e5,
+      kind: "references"
+    }],
+    health: {
+      status: "ready",
+      bodyPresent: true,
+      resourceCount: 1,
+      dependencyCount: 0,
+      resourceGroups: {
+        references: 1,
+        scripts: 0,
+        examples: 0,
+        assets: 0,
+        other: 0
+      },
+      issues: []
+    }
+  };
+}
 async function runHostTurnBoundaryCheck(id, rootDir) {
   const { runHostTurn: runHostTurn2 } = await Promise.resolve().then(() => (init_turn2(), turn_exports));
   const { SessionEventStore: SessionEventStore2 } = await Promise.resolve().then(() => (init_events(), events_exports));
@@ -227602,7 +228264,7 @@ async function closeWebSocketServer(wss) {
     });
   });
 }
-var import_promises33, import_node_path46, import_node_events, import_ws, EVALUATION_CHECK_IDS;
+var import_promises33, import_node_path46, import_node_events, import_ws, EVALUATION_CHECK_IDS, EVALUATION_SCENARIOS;
 var init_checks = __esm({
   "src/evaluation/checks.ts"() {
     "use strict";
@@ -227619,10 +228281,79 @@ var init_checks = __esm({
       "skill-packages-readable",
       "config-preflight-readable",
       "cache-economy-ready",
+      "production-scene-ready",
       "host-turn-boundary-runs",
       "remote-entrypoints-available",
       "recovery-drills-pass"
     ];
+    EVALUATION_SCENARIOS = [
+      {
+        id: "runtime-status-builds",
+        title: "\u5F53\u524D\u73B0\u573A\u53EF\u5BA1\u9605",
+        userPath: "\u7528\u6237\u8FD0\u884C `kitty status` \u65F6\uFF0C\u53EF\u4EE5\u770B\u5230 session\u3001context\u3001memory\u3001skills\u3001execution \u548C cache \u7684\u5F53\u524D\u4E8B\u5B9E\u3002",
+        evidence: "\u6784\u5EFA runtime status\uFF0C\u5E76\u786E\u8BA4 sessions / executions \u7B49\u73B0\u573A\u6458\u8981\u53EF\u7528\u3002"
+      },
+      {
+        id: "project-map-builds",
+        title: "\u8FDB\u5165\u4ED3\u5E93\u80FD\u5FEB\u901F\u5B9A\u5411",
+        userPath: "\u7528\u6237\u628A Kitty \u6253\u5F00\u5728\u4E00\u4E2A\u4ED3\u5E93\u91CC\uFF0C\u6A21\u578B\u80FD\u770B\u5230\u76EE\u5F55\u3001\u5165\u53E3\u3001\u811A\u672C\u3001\u6D4B\u8BD5\u3001\u9879\u76EE\u6587\u6863\u548C git \u4E8B\u5B9E\u3002",
+        evidence: "\u6784\u5EFA project map\uFF0C\u5E76\u786E\u8BA4\u76EE\u5F55\u3001\u811A\u672C\u548C\u4ED3\u5E93\u4E8B\u5B9E\u53EF\u8BFB\u3002"
+      },
+      {
+        id: "memory-assets-readable",
+        title: "\u8BB0\u5FC6\u8D44\u4EA7\u53EF\u5BA1\u9605",
+        userPath: "\u7528\u6237\u53EF\u4EE5\u67E5\u770B session/project/user/evidence memory\uFF0C\u4E0D\u9760\u9690\u85CF\u4E0A\u4E0B\u6587\u731C\u5386\u53F2\u3002",
+        evidence: "\u679A\u4E3E runtime memory assets\uFF0C\u5E76\u786E\u8BA4\u8D44\u4EA7\u7D22\u5F15\u53EF\u8BFB\u3002"
+      },
+      {
+        id: "extension-surface-current",
+        title: "\u5DE5\u5177\u9762\u53EA\u66B4\u9732\u5F53\u524D\u80FD\u529B",
+        userPath: "\u9ED8\u8BA4 agent \u6253\u5F00\u5F53\u524D\u771F\u5B9E extensions\uFF0C\u4E0D\u590D\u6D3B\u5DF2\u5220\u9664\u80FD\u529B\u3002",
+        evidence: "\u8BFB\u53D6 extension registry\uFF0C\u5E76\u786E\u8BA4\u9ED8\u8BA4\u542F\u7528\u9762\u6765\u81EA\u5F53\u524D\u5B9A\u4E49\u3002"
+      },
+      {
+        id: "skill-packages-readable",
+        title: "\u65B9\u6CD5\u5305\u6309\u9700\u53EF\u7528",
+        userPath: "\u6A21\u578B\u80FD\u5148\u770B\u5230 skill \u7D22\u5F15\uFF0C\u5FC5\u8981\u65F6\u518D\u52A0\u8F7D\u6B63\u6587\u3001\u8D44\u6E90\u6216\u811A\u672C\u3002",
+        evidence: "\u52A0\u8F7D project context\uFF0C\u5E76\u786E\u8BA4 runtime skills \u53EF\u53D1\u73B0\u3002"
+      },
+      {
+        id: "config-preflight-readable",
+        title: "\u9996\u6B21\u914D\u7F6E\u8DEF\u5F84\u6E05\u695A",
+        userPath: "\u7528\u6237\u8FD0\u884C `kitty init` / `kitty doctor` \u540E\uFF0C\u80FD\u77E5\u9053 `.kitty/.env` \u662F\u5426\u5B8C\u6574\u3001\u4E0B\u4E00\u6B65\u8865\u4EC0\u4E48\u3002",
+        evidence: "\u6267\u884C config preflight\uFF0C\u5E76\u786E\u8BA4\u672C\u5730\u6A21\u677F\u548C env contract \u53EF\u68C0\u67E5\u3002"
+      },
+      {
+        id: "cache-economy-ready",
+        title: "\u6210\u672C\u4E8B\u5B9E\u53EF\u5BA1\u9605",
+        userPath: "\u7528\u6237\u80FD\u770B\u5230 provider usage\u3001cache hit/miss\u3001\u7A33\u5B9A\u524D\u7F00\u548C\u6309\u9700 skill \u8FB9\u754C\uFF0C\u800C\u4E0D\u662F\u53EA\u770B\u5230 token \u603B\u6570\u3002",
+        evidence: "\u9A8C\u8BC1 usage \u5F52\u4E00\u5316\u3001provider cache policy\u3001stable/volatile prompt fingerprint\u3001skill index boundary \u548C\u5927\u8F93\u51FA\u538B\u7F29\u3002"
+      },
+      {
+        id: "production-scene-ready",
+        title: "\u751F\u4EA7\u73B0\u573A\u4E00\u773C\u53EF\u8BFB",
+        userPath: "\u7528\u6237\u8FD0\u884C `kitty status` \u6216 `kitty background` \u65F6\uFF0C\u80FD\u770B\u5230\u5F53\u524D\u73B0\u573A\u3001\u540E\u53F0\u98CE\u9669\u3001\u4E0B\u4E00\u6B65\u3001\u6062\u590D\u72B6\u6001\u3001\u6210\u672C\u3001skill \u548C memory \u53EF\u5BA1\u9605\u6027\u3002",
+        evidence: "\u6784\u5EFA\u5E26 session\u3001memory\u3001cache\u3001skill\u3001background \u548C provider usage \u7684 runtime scene\uFF0C\u5E76\u786E\u8BA4 scene \u4E0E CLI \u6587\u672C\u90FD\u66B4\u9732\u5173\u952E\u4E8B\u5B9E\u3002"
+      },
+      {
+        id: "host-turn-boundary-runs",
+        title: "\u4E00\u6B21 agent turn \u6709\u660E\u786E\u8FB9\u754C",
+        userPath: "\u7528\u6237\u53D1\u8D77\u4E00\u6B21\u4EFB\u52A1\u540E\uFF0Chost \u80FD\u8BB0\u5F55 turn \u5F00\u59CB\u3001\u5B8C\u6210\u3001\u5931\u8D25\u6216\u4E2D\u65AD\uFF0C\u4E0D\u628A\u5185\u90E8\u4E8B\u5B9E\u5199\u6210\u7528\u6237\u610F\u56FE\u3002",
+        evidence: "\u7528\u5047 turn \u8DD1 host boundary\uFF0C\u5E76\u786E\u8BA4 session events \u95ED\u73AF\u3002"
+      },
+      {
+        id: "remote-entrypoints-available",
+        title: "\u8FDC\u7A0B\u5165\u53E3\u590D\u7528\u540C\u4E00\u4E3B\u5E72",
+        userPath: "Web / Telegram \u5165\u53E3\u80FD\u63A5\u5165\u540C\u4E00 turn \u8F93\u5165\uFF0C\u4E0D\u5206\u88C2\u6210\u53E6\u4E00\u5957 agent\u3002",
+        evidence: "\u9A8C\u8BC1 web input port\u3001HTML shell \u548C Telegram file turn input \u53EF\u7528\u3002"
+      },
+      {
+        id: "recovery-drills-pass",
+        title: "\u540E\u53F0\u548C\u5B50\u6267\u884C\u53EF\u6062\u590D",
+        userPath: "background \u6216 subagent \u5361\u4F4F\u3001\u6D88\u5931\u3001\u8D85\u65F6\u540E\uFF0CKitty \u80FD reconcile\u3001\u6682\u505C\u7B49\u5F85\u6216\u7EC8\u6B62\u73B0\u573A\u3002",
+        evidence: "\u6F14\u7EC3 stale background\u3001expired lead-wait subagent\u3001running process termination \u548C runtime status\u3002"
+      }
+    ];
   }
 });
 
@@ -227645,22 +228376,25 @@ var init_harness = __esm({
 
 // src/cli/commands/evaluation.ts
 function registerEvaluationCommand(program, options = {}) {
-  program.command("eval").description("List or run machine-verifiable evaluation checks.").option("--json", "Print structured JSON.").option("--run", "Run all local evaluation checks.").action(async (commandOptions) => {
-    const checks = listEvaluationChecks();
+  program.command("eval").description("List or run product acceptance scenarios.").option("--json", "Print structured JSON.").option("--run", "Run all local evaluation checks.").action(async (commandOptions) => {
+    const scenarios = listEvaluationScenarios();
     const result = commandOptions.run ? await runEvaluationChecks(options.getCwd?.() ?? process.cwd()) : void 0;
     if (commandOptions.json) {
-      writeStdoutLine(JSON.stringify({ checks, result }, null, 2));
+      writeStdoutLine(JSON.stringify({ scenarios, result }, null, 2));
       return;
     }
-    writeStdoutLine(commandOptions.run ? "Evaluation checks run:" : "Evaluation checks:");
-    for (const check of checks) {
-      writeStdoutLine(`- ${check}`);
+    writeStdoutLine(commandOptions.run ? "Evaluation scenarios run:" : "Evaluation scenarios:");
+    for (const scenario of scenarios) {
+      writeStdoutLine(`- ${scenario.id}: ${scenario.title}`);
+      writeStdoutLine(`  \u7528\u6237\u8DEF\u5F84: ${scenario.userPath}`);
+      writeStdoutLine(`  \u673A\u5668\u8BC1\u636E: ${scenario.evidence}`);
     }
     if (result) {
       writeStdoutLine("");
       writeStdoutLine(`Status: ${result.status}`);
       for (const check of result.checks) {
-        writeStdoutLine(`${check.status} ${check.id}: ${check.fact}${check.error ? ` (${check.error})` : ""}`);
+        const scenario = scenarios.find((item) => item.id === check.id);
+        writeStdoutLine(`${check.status} ${check.id}${scenario ? ` ${scenario.title}` : ""}: ${check.fact}${check.error ? ` (${check.error})` : ""}`);
       }
     }
   });
@@ -227734,57 +228468,7 @@ var init_session2 = __esm({
   }
 });
 
-// src/cli/commands/sessionPicker.ts
-async function selectCliSession(options) {
-  const sessions = await options.sessionStore.list(options.limit ?? DEFAULT_SESSION_PICKER_LIMIT);
-  if (sessions.length === 0) {
-    return {
-      session: await createHostSession(options.sessionStore, options.cwd),
-      cwd: options.cwd
-    };
-  }
-  const io = resolveSessionPickerIo(options.io);
-  renderSessionPicker({
-    sessions,
-    io,
-    now: io.now()
-  });
-  while (true) {
-    const answer = await io.readChoice("\u9009\u62E9\u4F1A\u8BDD\uFF08\u8F93\u5165\u7F16\u53F7\uFF0C0 \u65B0\u5EFA\uFF09: ");
-    if (answer === null) {
-      return null;
-    }
-    const selected = parseSessionPickerChoice(answer, sessions.length);
-    if (selected.kind === "new") {
-      return {
-        session: await createHostSession(options.sessionStore, options.cwd),
-        cwd: options.cwd
-      };
-    }
-    if (selected.kind === "existing") {
-      const session = sessions[selected.index];
-      if (!session) {
-        io.writeLine("\u65E0\u6548\u9009\u62E9\uFF0C\u8BF7\u91CD\u65B0\u8F93\u5165\u3002");
-        continue;
-      }
-      return {
-        session,
-        cwd: options.cwdOverridden ? options.cwd : session.cwd
-      };
-    }
-    io.writeLine("\u65E0\u6548\u9009\u62E9\uFF0C\u8BF7\u8F93\u5165\u5217\u8868\u7F16\u53F7\uFF0C\u6216\u8F93\u5165 0 \u65B0\u5EFA\u4F1A\u8BDD\u3002");
-  }
-}
-function renderSessionPicker(options) {
-  options.io.writeLine("\u6700\u8FD1\u4F1A\u8BDD");
-  options.io.writeLine("0. \u65B0\u5EFA\u4F1A\u8BDD");
-  options.sessions.forEach((session, index) => {
-    options.io.writeLine(
-      `${index + 1}. ${formatSessionPickerTitle(session)}  ${formatRelativeSessionTime(session.updatedAt, options.now)}`
-    );
-  });
-  options.io.writeLine();
-}
+// src/session/picker.ts
 function parseSessionPickerChoice(input, sessionCount) {
   const trimmed = input.trim();
   if (trimmed === "") {
@@ -227842,6 +228526,63 @@ function truncateDisplayTitle(title) {
   const maxChars = 36;
   return chars.length > maxChars ? `${chars.slice(0, maxChars).join("")}...` : title;
 }
+var init_picker = __esm({
+  "src/session/picker.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/commands/sessionPicker.ts
+async function selectCliSession(options) {
+  const sessions = await options.sessionStore.list(options.limit ?? DEFAULT_SESSION_PICKER_LIMIT);
+  if (sessions.length === 0) {
+    return {
+      session: await createHostSession(options.sessionStore, options.cwd),
+      cwd: options.cwd
+    };
+  }
+  const io = resolveSessionPickerIo(options.io);
+  renderSessionPicker({
+    sessions,
+    io,
+    now: io.now()
+  });
+  while (true) {
+    const answer = await io.readChoice("\u9009\u62E9\u4F1A\u8BDD\uFF08\u8F93\u5165\u7F16\u53F7\uFF0C0 \u65B0\u5EFA\uFF09: ");
+    if (answer === null) {
+      return null;
+    }
+    const selected = parseSessionPickerChoice(answer, sessions.length);
+    if (selected.kind === "new") {
+      return {
+        session: await createHostSession(options.sessionStore, options.cwd),
+        cwd: options.cwd
+      };
+    }
+    if (selected.kind === "existing") {
+      const session = sessions[selected.index];
+      if (!session) {
+        io.writeLine("\u65E0\u6548\u9009\u62E9\uFF0C\u8BF7\u91CD\u65B0\u8F93\u5165\u3002");
+        continue;
+      }
+      return {
+        session,
+        cwd: options.cwdOverridden ? options.cwd : session.cwd
+      };
+    }
+    io.writeLine("\u65E0\u6548\u9009\u62E9\uFF0C\u8BF7\u8F93\u5165\u5217\u8868\u7F16\u53F7\uFF0C\u6216\u8F93\u5165 0 \u65B0\u5EFA\u4F1A\u8BDD\u3002");
+  }
+}
+function renderSessionPicker(options) {
+  options.io.writeLine("\u6700\u8FD1\u4F1A\u8BDD");
+  options.io.writeLine("0. \u65B0\u5EFA\u4F1A\u8BDD");
+  options.sessions.forEach((session, index) => {
+    options.io.writeLine(
+      `${index + 1}. ${formatSessionPickerTitle(session)}  ${formatRelativeSessionTime(session.updatedAt, options.now)}`
+    );
+  });
+  options.io.writeLine();
+}
 function resolveSessionPickerIo(io) {
   return {
     writeLine: io?.writeLine ?? ((text = "") => writeStdoutLine(text)),
@@ -227873,6 +228614,8 @@ var init_sessionPicker = __esm({
     import_node_process2 = __toESM(require("process"));
     init_stdio();
     init_session2();
+    init_picker();
+    init_picker();
     DEFAULT_SESSION_PICKER_LIMIT = 10;
   }
 });
@@ -227944,6 +228687,218 @@ var init_exitGuard = __esm({
   }
 });
 
+// src/cli/commands/background.ts
+function registerBackgroundCommand(program, options) {
+  const command = program.command("background").description("Inspect, wait for, or stop background executions.");
+  command.argument("[action]", "Optional action: list, wait, stop").argument("[id]", "Background execution id for wait or stop").option("--json", "Print structured JSON.").option("--timeout-ms <ms>", "Wait timeout in milliseconds.", (value) => Number.parseInt(value, 10), 6e4).action(async (action, id, commandOptions) => {
+    const runtime = await options.resolveRuntime(options.getCliOverrides());
+    const normalizedAction = action ?? "list";
+    if (normalizedAction === "list") {
+      const executions = new BackgroundExecutionStore(runtime.stateRootDir).listAll().map(summarizeExecution).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+      printBackgroundExecutions(executions, Boolean(commandOptions.json));
+      return;
+    }
+    if (!id) {
+      throw new Error(`background ${normalizedAction} requires an execution id.`);
+    }
+    if (normalizedAction === "wait") {
+      const execution = summarizeExecution(await waitForBackgroundExecution({
+        rootDir: runtime.stateRootDir,
+        id,
+        timeoutMs: commandOptions.timeoutMs
+      }));
+      printBackgroundExecutions([execution], Boolean(commandOptions.json));
+      return;
+    }
+    if (normalizedAction === "stop") {
+      const execution = terminateBackgroundExecution(runtime.stateRootDir, id);
+      await waitForRegisteredBackgroundProcess(id);
+      printBackgroundExecutions([summarizeExecution(execution)], Boolean(commandOptions.json));
+      return;
+    }
+    throw new Error(`Unknown background action: ${normalizedAction}. Use list, wait, or stop.`);
+  });
+}
+function printBackgroundExecutions(executions, json) {
+  if (json) {
+    writeStdoutLine(JSON.stringify({ executions }, null, 2));
+    return;
+  }
+  if (executions.length === 0) {
+    ui.info("No background executions recorded.");
+    return;
+  }
+  for (const execution of executions) {
+    writeStdoutLine(formatBackgroundExecution(execution));
+  }
+}
+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("  ");
+}
+var init_background3 = __esm({
+  "src/cli/commands/background.ts"() {
+    "use strict";
+    init_background();
+    init_executionSummary();
+    init_scene();
+    init_console();
+    init_stdio();
+    init_cliValues();
+  }
+});
+
+// src/cli/commands/memory.ts
+function registerMemoryCommand(program, options) {
+  program.command("memory").description("List readable runtime memory assets.").argument("[memoryId]", "Optional runtime memory asset id to read.").option("--delete", "Delete the selected runtime memory asset.").option("--append-to-skill <skillName>", "Append the selected memory asset to a runtime skill references/ file.").option("--create <kind>", "Create a project, user, or evidence memory asset.").option("--title <title>", "Title for --create.").option("--content <content>", "Content for --create.").option("--evidence <refs>", "Comma-separated evidence refs for --create.").option("--scope <scope>", "Scope metadata for --create.").option("--tags <tags>", "Comma-separated tags for --create.").option("--file <fileName>", "Target file name for --append-to-skill.").option("-q, --query <query>", "Search runtime memory assets.").option("--json", "Print structured JSON.").action(async (memoryId, commandOptions) => {
+    const runtime = await options.resolveRuntime(options.getCliOverrides());
+    if (commandOptions.create) {
+      await handleMemoryCreate(runtime.cwd, commandOptions);
+      return;
+    }
+    if (memoryId) {
+      await handleSelectedMemory(runtime.cwd, memoryId, commandOptions);
+      return;
+    }
+    if (commandOptions.query) {
+      await handleMemorySearch(runtime.cwd, commandOptions.query, commandOptions.json === true);
+      return;
+    }
+    await handleMemoryList(runtime.cwd, commandOptions.json === true);
+  });
+}
+async function handleMemoryCreate(cwd, options) {
+  const kind = parseWritableMemoryKind(options.create);
+  if (!options.title?.trim()) {
+    throw new Error("--title is required when creating a memory asset.");
+  }
+  if (!options.content?.trim()) {
+    throw new Error("--content is required when creating a memory asset.");
+  }
+  const created = await createRuntimeMemoryAsset({
+    rootDir: cwd,
+    kind,
+    title: options.title,
+    content: options.content,
+    evidenceRefs: parseCsvOption(options.evidence),
+    scope: options.scope,
+    tags: parseCsvOption(options.tags),
+    fileName: options.file
+  });
+  if (options.json) {
+    writeStdoutLine(JSON.stringify({ created }, null, 2));
+    return;
+  }
+  ui.success(`Created memory asset ${created.id}`);
+  writeStdoutLine(created.path);
+}
+async function handleSelectedMemory(cwd, memoryId, options) {
+  if (options.appendToSkill) {
+    const appended = await appendRuntimeMemoryAssetToSkillReference({
+      rootDir: cwd,
+      memoryId,
+      skillName: options.appendToSkill,
+      fileName: options.file
+    });
+    if (options.json) {
+      writeStdoutLine(JSON.stringify({ appended }, null, 2));
+      return;
+    }
+    ui.success(`Appended memory asset ${memoryId} to skill ${options.appendToSkill}`);
+    writeStdoutLine(appended.path);
+    return;
+  }
+  if (options.delete) {
+    const deleted = await deleteRuntimeMemoryAsset(cwd, memoryId);
+    if (options.json) {
+      writeStdoutLine(JSON.stringify({ deleted }, null, 2));
+      return;
+    }
+    ui.success(`Deleted memory asset ${deleted.id}`);
+    writeStdoutLine(deleted.path);
+    return;
+  }
+  const memory = await readRuntimeMemoryAsset(cwd, memoryId);
+  if (options.json) {
+    writeStdoutLine(JSON.stringify(memory, null, 2));
+    return;
+  }
+  writeStdoutLine(memory.content.trimEnd());
+}
+async function handleMemorySearch(cwd, query, json) {
+  const results = await searchRuntimeMemoryAssets(cwd, query);
+  if (json) {
+    writeStdoutLine(JSON.stringify({ query, results }, null, 2));
+    return;
+  }
+  if (results.length === 0) {
+    ui.info("No matching runtime memory assets.");
+    return;
+  }
+  for (const result of results) {
+    writeStdoutLine(`${result.id}  score=${result.score}  ${result.path}`);
+    for (const match of result.matches) {
+      writeStdoutLine(`  ${match}`);
+    }
+  }
+}
+function parseWritableMemoryKind(value) {
+  if (value === "project" || value === "user" || value === "evidence") {
+    return value;
+  }
+  throw new Error("--create must be one of: project, user, evidence.");
+}
+function parseCsvOption(value) {
+  return (value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+}
+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");
+}
+async function handleMemoryList(cwd, json) {
+  const memory = await readMemoryListForCli(cwd);
+  if (json) {
+    writeStdoutLine(JSON.stringify(memory, null, 2));
+    return;
+  }
+  if (memory.assets.length === 0) {
+    ui.info("No runtime memory assets yet.");
+    return;
+  }
+  writeStdoutLine(formatMemoryListForCli(memory));
+}
+var init_memory3 = __esm({
+  "src/cli/commands/memory.ts"() {
+    "use strict";
+    init_status();
+    init_memory2();
+    init_console();
+    init_stdio();
+  }
+});
+
 // src/project/resetSupport.ts
 async function waitForRemovedPaths(paths, attempts = 20, delayMs = 50) {
   for (let attempt = 0; attempt < attempts; attempt += 1) {
@@ -228132,7 +229087,7 @@ function normalizeLocalCommand(input) {
   return LOCAL_COMMAND_BY_ALIAS.get(input.trim().toLowerCase());
 }
 function getLocalCommandDefinition(id) {
-  const definition = LOCAL_COMMAND_DEFINITIONS.find((item) => item.id === id);
+  const definition = ALL_LOCAL_COMMAND_DEFINITIONS.find((item) => item.id === id);
   if (!definition) {
     throw new Error(`Unknown local command: ${id}`);
   }
@@ -228142,50 +229097,164 @@ function formatLocalCommandHelpLine(id) {
   const definition = getLocalCommandDefinition(id);
   return `${definition.helpLabel.padEnd(12)} ${definition.helpText}`;
 }
-var LOCAL_COMMAND_DEFINITIONS, LOCAL_COMMAND_BY_ALIAS;
+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);
+}
+var LOCAL_COMMAND_DEFINITIONS, ALL_LOCAL_COMMAND_DEFINITIONS, LOCAL_COMMAND_BY_ALIAS;
 var init_localCommandDefinitions = __esm({
   "src/interaction/localCommandDefinitions.ts"() {
     "use strict";
     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"
+        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"
+        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 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: "multiline",
-        aliases: ["/multi"],
-        helpLabel: "/multi",
-        helpText: "Enter multiline input; use ::end to submit and ::cancel to cancel"
+        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"
       }
     ];
+    ALL_LOCAL_COMMAND_DEFINITIONS = LOCAL_COMMAND_DEFINITIONS;
     LOCAL_COMMAND_BY_ALIAS = new Map(
-      LOCAL_COMMAND_DEFINITIONS.flatMap(
+      ALL_LOCAL_COMMAND_DEFINITIONS.flatMap(
         (definition) => definition.aliases.map((alias) => [alias, definition.id])
       )
     );
@@ -228211,23 +229280,9 @@ async function handleLocalCommand(input, context, output) {
     return "quit";
   }
   if (command === "help") {
-    output.plain(
-      [
-        formatLocalCommandHelpLine("help"),
-        formatLocalCommandHelpLine("session"),
-        formatLocalCommandHelpLine("config"),
-        formatLocalCommandHelpLine("multiline"),
-        formatLocalCommandHelpLine("reset"),
-        formatLocalCommandHelpLine("exit"),
-        "",
-        "Any other input is sent directly to kitty."
-      ].join("\n")
-    );
+    output.plain(formatLocalCommandHelp());
     return "handled";
   }
-  if (command === "multiline") {
-    return "multiline";
-  }
   if (command === "session") {
     output.info(`Current session: ${context.session.id}`);
     return "handled";
@@ -228236,12 +229291,108 @@ async function handleLocalCommand(input, context, output) {
     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");
+}
 var init_localCommands = __esm({
   "src/interaction/localCommands.ts"() {
     "use strict";
+    init_background();
+    init_background3();
+    init_preflight();
+    init_memory3();
+    init_runtimeStatusPresenter();
+    init_events3();
+    init_paths();
+    init_repoRoots();
     init_reset();
+    init_status();
+    init_executionSummary();
     init_localCommandDefinitions();
   }
 });
@@ -228311,7 +229462,8 @@ var init_sessionDriver = __esm({
             {
               cwd: this.options.cwd,
               session: this.session,
-              config: this.options.config
+              config: this.options.config,
+              sessionStore: this.options.sessionStore
             },
             this.options.shell.output
           );
@@ -228323,8 +229475,6 @@ var init_sessionDriver = __esm({
           await this.runTurn(input);
         } else if (localCommandResult === "quit") {
           return this.handleQuitRequest();
-        } else if (localCommandResult === "multiline") {
-          await this.handleMultilineInput();
         }
         return localCommandResult;
       }
@@ -228366,25 +229516,6 @@ var init_sessionDriver = __esm({
           return "handled";
         }
       }
-      async handleMultilineInput() {
-        this.options.shell.output.info("Entered multiline mode. Use ::end to submit or ::cancel to cancel.\n");
-        const multiline = await this.options.shell.input.readMultiline("\u2026 ");
-        if (multiline.kind === "cancel") {
-          this.options.shell.output.warn("Cancelled multiline input.\n");
-          return;
-        }
-        if (multiline.kind === "closed") {
-          await this.terminateRunningProcessesForForcedExit("Input closed during multiline mode. Stopping running processes before exit.");
-          this.exitRequested = true;
-          return;
-        }
-        const value = multiline.value.trim();
-        if (!value) {
-          this.options.shell.output.warn("Multiline input was empty, nothing was sent.\n");
-          return;
-        }
-        await this.runTurn(value);
-      }
       handleInterrupt() {
         if (this.turnInFlight && this.turnAbortController && !this.turnAbortController.signal.aborted) {
           this.turnAbortController.abort();
@@ -228477,6 +229608,7 @@ var init_sessionDriver = __esm({
             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.");
@@ -229334,17 +230466,6 @@ function mirrorInput(input, writer) {
       const result = await input.readInput(promptLabel);
       if (result.kind === "submit") {
         writer.write(`${promptLabel ?? "> "}${result.value}
-`);
-      }
-      return result;
-    },
-    async readMultiline(promptLabel) {
-      const result = await input.readMultiline(promptLabel);
-      if (result.kind === "submit") {
-        writer.write(`${promptLabel ?? "... "}${result.value}
-`);
-      } else if (result.kind === "cancel") {
-        writer.write(`${promptLabel ?? "... "}::cancel
 `);
       }
       return result;
@@ -229392,7 +230513,7 @@ var init_terminalLog = __esm({
   }
 });
 
-// src/shell/cli/intro.ts
+// src/shell/banner.ts
 function renderKittyBanner() {
   return import_figlet.default.textSync("kitty agent", {
     font: KITTY_WORDMARK_FONT,
@@ -229402,6 +230523,16 @@ function renderKittyBanner() {
     whitespaceBreak: false
   }).trimEnd();
 }
+var import_figlet, KITTY_WORDMARK_FONT;
+var init_banner = __esm({
+  "src/shell/banner.ts"() {
+    "use strict";
+    import_figlet = __toESM(require("figlet"));
+    KITTY_WORDMARK_FONT = "ANSI Shadow";
+  }
+});
+
+// src/shell/cli/intro.ts
 function writeCliInteractiveIntro(options) {
   options.output.plain(import_chalk4.default.bold(import_chalk4.default.greenBright(renderKittyBanner())));
   options.output.dim(`session: ${options.session.id}`);
@@ -229410,21 +230541,18 @@ function writeCliInteractiveIntro(options) {
     options.output.dim(`Tools: ${options.toolsLabel}`);
   }
   options.output.dim("Commands:");
-  options.output.dim(formatLocalCommandHelpLine("help"));
-  options.output.dim(formatLocalCommandHelpLine("multiline"));
-  options.output.dim(formatLocalCommandHelpLine("reset"));
-  options.output.dim(formatLocalCommandHelpLine("exit"));
-  options.output.dim("::end        Submit multiline input");
-  options.output.dim("::cancel     Cancel multiline input\n");
-}
-var import_chalk4, import_figlet, KITTY_WORDMARK_FONT;
+  for (const command of listIntroLocalCommands()) {
+    options.output.dim(formatLocalCommandHelpLine(command.id));
+  }
+  options.output.dim("");
+}
+var import_chalk4;
 var init_intro = __esm({
   "src/shell/cli/intro.ts"() {
     "use strict";
     import_chalk4 = __toESM(require("chalk"));
-    import_figlet = __toESM(require("figlet"));
     init_localCommandDefinitions();
-    KITTY_WORDMARK_FONT = "ANSI Shadow";
+    init_banner();
   }
 });
 
@@ -229499,58 +230627,6 @@ async function readPersistentInput(promptLabel, onInterrupt) {
     rl.prompt();
   });
 }
-async function readMultilineInput(onInterrupt, promptLabel = "\u2026 ") {
-  return new Promise((resolve) => {
-    const rl = import_node_readline.default.createInterface({
-      input: import_node_process4.default.stdin,
-      output: import_node_process4.default.stdout,
-      terminal: true
-    });
-    const lines = [];
-    let settled = false;
-    const cleanup = () => {
-      rl.removeAllListeners("line");
-      rl.removeAllListeners("close");
-      rl.removeAllListeners("SIGINT");
-    };
-    const finish = (value) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanup();
-      rl.close();
-      resolve(value);
-    };
-    rl.on("line", (line) => {
-      const trimmed = line.trim();
-      if (trimmed === "::end") {
-        finish({ kind: "submit", value: lines.join("\n") });
-        return;
-      }
-      if (trimmed === "::cancel") {
-        finish({ kind: "cancel" });
-        return;
-      }
-      lines.push(line);
-      rl.prompt();
-    });
-    rl.on("SIGINT", () => {
-      onInterrupt();
-      rl.prompt();
-    });
-    rl.on("close", () => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanup();
-      resolve({ kind: "eof" });
-    });
-    rl.setPrompt(promptLabel);
-    rl.prompt();
-  });
-}
 function createReadlineInputPort() {
   const listeners = /* @__PURE__ */ new Set();
   let releaseProcessInterrupt = null;
@@ -229583,13 +230659,6 @@ function createReadlineInputPort() {
       const value = await readPersistentInput(promptLabel, notifyInterrupt);
       return value === null ? { kind: "closed" } : { kind: "submit", value };
     },
-    async readMultiline(promptLabel = "\u2026 ") {
-      const result = await readMultilineInput(notifyInterrupt, promptLabel);
-      if (result.kind === "eof") {
-        return { kind: "closed" };
-      }
-      return result;
-    },
     bindInterrupt(handler) {
       listeners.add(handler);
       ensureProcessInterruptBinding();
@@ -230081,7 +231150,7 @@ function registerEventsCommand(program, options) {
       return;
     }
     for (const event of result.events) {
-      writeStdoutLine(formatSessionEvent(event));
+      writeStdoutLine(formatSessionEventForCli(event));
     }
   });
 }
@@ -230099,7 +231168,16 @@ async function readSessionEventsForCli(input) {
     events: await new SessionEventStore(input.paths.eventsDir).list(session.id, input.limit)
   };
 }
-function formatSessionEvent(event) {
+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,
@@ -230124,382 +231202,6 @@ var init_events3 = __esm({
   }
 });
 
-// src/cli/commands/memory.ts
-function registerMemoryCommand(program, options) {
-  program.command("memory").description("List readable runtime memory assets.").argument("[memoryId]", "Optional runtime memory asset id to read.").option("--delete", "Delete the selected runtime memory asset.").option("--append-to-skill <skillName>", "Append the selected memory asset to a runtime skill references/ file.").option("--create <kind>", "Create a project, user, or evidence memory asset.").option("--title <title>", "Title for --create.").option("--content <content>", "Content for --create.").option("--evidence <refs>", "Comma-separated evidence refs for --create.").option("--scope <scope>", "Scope metadata for --create.").option("--tags <tags>", "Comma-separated tags for --create.").option("--file <fileName>", "Target file name for --append-to-skill.").option("-q, --query <query>", "Search runtime memory assets.").option("--json", "Print structured JSON.").action(async (memoryId, commandOptions) => {
-    const runtime = await options.resolveRuntime(options.getCliOverrides());
-    if (commandOptions.create) {
-      await handleMemoryCreate(runtime.cwd, commandOptions);
-      return;
-    }
-    if (memoryId) {
-      await handleSelectedMemory(runtime.cwd, memoryId, commandOptions);
-      return;
-    }
-    if (commandOptions.query) {
-      await handleMemorySearch(runtime.cwd, commandOptions.query, commandOptions.json === true);
-      return;
-    }
-    await handleMemoryList(runtime.cwd, commandOptions.json === true);
-  });
-}
-async function handleMemoryCreate(cwd, options) {
-  const kind = parseWritableMemoryKind(options.create);
-  if (!options.title?.trim()) {
-    throw new Error("--title is required when creating a memory asset.");
-  }
-  if (!options.content?.trim()) {
-    throw new Error("--content is required when creating a memory asset.");
-  }
-  const created = await createRuntimeMemoryAsset({
-    rootDir: cwd,
-    kind,
-    title: options.title,
-    content: options.content,
-    evidenceRefs: parseCsvOption(options.evidence),
-    scope: options.scope,
-    tags: parseCsvOption(options.tags),
-    fileName: options.file
-  });
-  if (options.json) {
-    writeStdoutLine(JSON.stringify({ created }, null, 2));
-    return;
-  }
-  ui.success(`Created memory asset ${created.id}`);
-  writeStdoutLine(created.path);
-}
-async function handleSelectedMemory(cwd, memoryId, options) {
-  if (options.appendToSkill) {
-    const appended = await appendRuntimeMemoryAssetToSkillReference({
-      rootDir: cwd,
-      memoryId,
-      skillName: options.appendToSkill,
-      fileName: options.file
-    });
-    if (options.json) {
-      writeStdoutLine(JSON.stringify({ appended }, null, 2));
-      return;
-    }
-    ui.success(`Appended memory asset ${memoryId} to skill ${options.appendToSkill}`);
-    writeStdoutLine(appended.path);
-    return;
-  }
-  if (options.delete) {
-    const deleted = await deleteRuntimeMemoryAsset(cwd, memoryId);
-    if (options.json) {
-      writeStdoutLine(JSON.stringify({ deleted }, null, 2));
-      return;
-    }
-    ui.success(`Deleted memory asset ${deleted.id}`);
-    writeStdoutLine(deleted.path);
-    return;
-  }
-  const memory = await readRuntimeMemoryAsset(cwd, memoryId);
-  if (options.json) {
-    writeStdoutLine(JSON.stringify(memory, null, 2));
-    return;
-  }
-  writeStdoutLine(memory.content.trimEnd());
-}
-async function handleMemorySearch(cwd, query, json) {
-  const results = await searchRuntimeMemoryAssets(cwd, query);
-  if (json) {
-    writeStdoutLine(JSON.stringify({ query, results }, null, 2));
-    return;
-  }
-  if (results.length === 0) {
-    ui.info("No matching runtime memory assets.");
-    return;
-  }
-  for (const result of results) {
-    writeStdoutLine(`${result.id}  score=${result.score}  ${result.path}`);
-    for (const match of result.matches) {
-      writeStdoutLine(`  ${match}`);
-    }
-  }
-}
-function parseWritableMemoryKind(value) {
-  if (value === "project" || value === "user" || value === "evidence") {
-    return value;
-  }
-  throw new Error("--create must be one of: project, user, evidence.");
-}
-function parseCsvOption(value) {
-  return (value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
-}
-async function handleMemoryList(cwd, json) {
-  const status = await buildRuntimeStatus(cwd);
-  if (json) {
-    writeStdoutLine(JSON.stringify(status.memory, null, 2));
-    return;
-  }
-  if (status.memory.assets.length === 0) {
-    ui.info("No runtime memory assets yet.");
-    return;
-  }
-  for (const memory of status.memory.assets) {
-    writeStdoutLine([
-      memory.id,
-      memory.kind,
-      memory.updatedAt ?? "",
-      `bytes=${memory.size}`,
-      memory.evidenceRefs.length > 0 ? `evidence=${memory.evidenceRefs.join(",")}` : void 0,
-      memory.path
-    ].filter(Boolean).join("  "));
-  }
-}
-var init_memory3 = __esm({
-  "src/cli/commands/memory.ts"() {
-    "use strict";
-    init_status();
-    init_memory2();
-    init_console();
-    init_stdio();
-  }
-});
-
-// src/cli/commands/runtimeStatusPresenter.ts
-function formatRuntimeStatusText(status) {
-  const lines = [];
-  lines.push(`Project: ${status.rootDir}`);
-  lines.push(`State: ${status.stateDir}`);
-  lines.push("");
-  lines.push("Current workspace:");
-  lines.push(`- Focus: ${readFocus(status)}`);
-  lines.push(`- Session: ${readSessionLine(status)}`);
-  lines.push(`- Next: ${readNextStep(status)}`);
-  lines.push(`- Blocked: ${readBlockedLine(status)}`);
-  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;
-    lines.push("");
-    lines.push("Cache layout:");
-    lines.push([
-      `stable=${layout.stablePrefixFingerprint}`,
-      `stableChars=${layout.stablePrefixChars}`,
-      `tail=${layout.volatileTailFingerprint}`,
-      `tailChars=${layout.volatileTailChars}`
-    ].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.executions.active) {
-      lines.push([
-        execution.id,
-        execution.kind,
-        execution.status,
-        execution.actorName ? `actor=${execution.actorName}` : void 0,
-        execution.waitPolicy ? `wait=${execution.waitPolicy}` : void 0,
-        execution.health ? `health=${execution.health.state}` : void 0,
-        execution.deadlineAt ? `deadline=${execution.deadlineAt}` : void 0,
-        execution.assignment?.objective ? `objective=${truncateCliValue(execution.assignment.objective, 60)}` : void 0
-      ].filter(Boolean).join("  "));
-    }
-  }
-  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 readFocus(status) {
-  const focus = status.sessions.latest?.focus;
-  return focus ? truncateCliValue(focus, 100) : "none";
-}
-function readSessionLine(status) {
-  if (!status.sessions.latest) {
-    return "none";
-  }
-  return `${status.sessions.latest.id} (${status.sessions.latest.messageCount} message(s))`;
-}
-function readNextStep(status) {
-  if (status.executions.active.length > 0) {
-    return "Wait for active execution results or inspect them with status/tools.";
-  }
-  if (!status.sessions.latest) {
-    return "Start a session with `kitty` or run a prompt.";
-  }
-  return "Continue from the current session focus.";
-}
-function readBlockedLine(status) {
-  const unhealthy = status.executions.active.find(
-    (execution) => execution.health?.state === "stale" || execution.health?.state === "deadline_passed"
-  );
-  if (unhealthy) {
-    return `${unhealthy.kind} ${unhealthy.id}: ${unhealthy.health?.message}`;
-  }
-  return "no";
-}
-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 "usage unavailable";
-  }
-  const cacheTokens = latest.usage.cacheHitTokens ?? latest.usage.cacheReadTokens;
-  const rate = latest.usage.cacheHitRate === void 0 ? void 0 : `${Math.round(latest.usage.cacheHitRate * 100)}%`;
-  return [
-    cacheTokens === void 0 ? "cached=unknown" : `cached=${cacheTokens}`,
-    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(" ");
-}
-var init_runtimeStatusPresenter = __esm({
-  "src/cli/commands/runtimeStatusPresenter.ts"() {
-    "use strict";
-    init_cliValues();
-  }
-});
-
 // src/cli/commands/runtimeStatus.ts
 function registerRuntimeStatusCommand(program, options) {
   program.command("status").description("Show the current project runtime status.").option("--json", "Print structured JSON.").action(async (commandOptions) => {
@@ -230814,74 +231516,6 @@ var init_agent = __esm({
   }
 });
 
-// src/cli/commands/background.ts
-function registerBackgroundCommand(program, options) {
-  const command = program.command("background").description("Inspect, wait for, or stop background executions.");
-  command.argument("[action]", "Optional action: list, wait, stop").argument("[id]", "Background execution id for wait or stop").option("--json", "Print structured JSON.").option("--timeout-ms <ms>", "Wait timeout in milliseconds.", (value) => Number.parseInt(value, 10), 6e4).action(async (action, id, commandOptions) => {
-    const runtime = await options.resolveRuntime(options.getCliOverrides());
-    const normalizedAction = action ?? "list";
-    if (normalizedAction === "list") {
-      const executions = new BackgroundExecutionStore(runtime.stateRootDir).listAll().map(summarizeExecution).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-      printBackgroundExecutions(executions, Boolean(commandOptions.json));
-      return;
-    }
-    if (!id) {
-      throw new Error(`background ${normalizedAction} requires an execution id.`);
-    }
-    if (normalizedAction === "wait") {
-      const execution = summarizeExecution(await waitForBackgroundExecution({
-        rootDir: runtime.stateRootDir,
-        id,
-        timeoutMs: commandOptions.timeoutMs
-      }));
-      printBackgroundExecutions([execution], Boolean(commandOptions.json));
-      return;
-    }
-    if (normalizedAction === "stop") {
-      const execution = terminateBackgroundExecution(runtime.stateRootDir, id);
-      await waitForRegisteredBackgroundProcess(id);
-      printBackgroundExecutions([summarizeExecution(execution)], Boolean(commandOptions.json));
-      return;
-    }
-    throw new Error(`Unknown background action: ${normalizedAction}. Use list, wait, or stop.`);
-  });
-}
-function printBackgroundExecutions(executions, json) {
-  if (json) {
-    writeStdoutLine(JSON.stringify({ executions }, null, 2));
-    return;
-  }
-  if (executions.length === 0) {
-    ui.info("No background executions recorded.");
-    return;
-  }
-  for (const execution of executions) {
-    writeStdoutLine(formatBackgroundExecution(execution));
-  }
-}
-function formatBackgroundExecution(execution) {
-  return [
-    execution.id,
-    execution.status,
-    execution.pid === void 0 ? void 0 : `pid=${execution.pid}`,
-    execution.health ? `health=${execution.health.state}` : void 0,
-    execution.deadlineAt ? `deadline=${execution.deadlineAt}` : void 0,
-    execution.command ? `cmd=${truncateCliValue(execution.command, 70)}` : void 0,
-    execution.summary ? `summary=${truncateCliValue(execution.summary, 90)}` : void 0,
-    execution.outputPreview ? `output=${truncateCliValue(execution.outputPreview, 120)}` : void 0
-  ].filter(Boolean).join("  ");
-}
-var init_background3 = __esm({
-  "src/cli/commands/background.ts"() {
-    "use strict";
-    init_background();
-    init_executionSummary();
-    init_console();
-    init_stdio();
-    init_cliValues();
-  }
-});
-
 // src/cli/commands/session.ts
 function registerSessionCommands(program, options) {
   program.argument("[prompt...]", "Start a new session with a one-shot prompt. Without a prompt, opens interactive chat.").action(async (promptParts) => {
@@ -231839,7 +232473,6 @@ var init_helpText_zh = __esm({
       "/stop            Stop the current Telegram task without shutting down the bot service",
       "/session         Show the session ID bound to this Telegram chat",
       "/config          Show current runtime configuration",
-      "/multi           Telegram does not support interactive multiline mode; send the full message directly",
       "",
       "File usage:",
       "- Send files directly to the private chat. Kitty downloads them and attaches them to the current session.",
@@ -232286,11 +232919,6 @@ async function runTelegramTurn(options) {
         options.markQueuedTurnStarted(options.message.peerKey);
         return;
       }
-      if (localCommandResult === "multiline") {
-        options.markQueuedTurnStarted(options.message.peerKey);
-        output.warn("Telegram does not support interactive multiline mode. Send the full message directly.");
-        return;
-      }
     }
     const display = new TelegramTurnDisplay({
       chatId: options.message.chatId,
@@ -233417,6 +234045,39 @@ var init_web2 = __esm({
   }
 });
 
+// src/cli/commands/tui.ts
+function registerTuiCommand(program, dependencies) {
+  program.command("tui").description("Start the Ink terminal UI.").action(async () => {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      throw new Error("kitty tui requires an interactive TTY.");
+    }
+    const runtime = await dependencies.resolveRuntime(dependencies.getCliOverrides());
+    const sessionStore = await createSessionStore(runtime.paths.sessionsDir);
+    const { startTuiChat } = await loadTuiEntrypoint();
+    await startTuiChat({
+      cwd: runtime.cwd,
+      cwdOverridden: Boolean(runtime.overrides.cwd),
+      config: runtime.config,
+      sessionStore
+    });
+  });
+}
+async function loadTuiEntrypoint() {
+  try {
+    return await import(new URL("./tui.mjs", (0, import_node_url.pathToFileURL)(__filename)).href);
+  } catch (error) {
+    throw new Error(`TUI entrypoint is unavailable. Run npm.cmd run build and try again. Cause: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+var import_node_url;
+var init_tui = __esm({
+  "src/cli/commands/tui.ts"() {
+    "use strict";
+    import_node_url = require("url");
+    init_sessionHelpers();
+  }
+});
+
 // src/cli/program.ts
 var program_exports = {};
 __export(program_exports, {
@@ -233491,6 +234152,10 @@ function buildCliProgram(dependencies = {}) {
     getCliOverrides,
     resolveRuntime
   });
+  registerTuiCommand(program, {
+    getCliOverrides,
+    resolveRuntime
+  });
   return program;
 }
 var import_commander;
@@ -233513,6 +234178,7 @@ var init_program = __esm({
     init_stdio();
     init_cli();
     init_web2();
+    init_tui();
   }
 });