@wrongstack/tui 1.0.26 → 1.0.27

package/dist/index.js

@@ -24887,378 +24887,1014 @@ var require_jsx_runtime = __commonJS({
   }
 });
 
-// src/connections-health.ts
-var connections_health_exports = {};
-__export(connections_health_exports, {
-  collectConnectionsHealth: () => collectConnectionsHealth
+// src/connection-actions.ts
+var connection_actions_exports = {};
+__export(connection_actions_exports, {
+  RESTARTABLE_SERVICES: () => RESTARTABLE_SERVICES,
+  executeConnectionAction: () => executeConnectionAction,
+  isEndpointAlive: () => isEndpointAlive,
+  isRestartableService: () => isRestartableService,
+  killChronicleServer: () => killChronicleServer,
+  killCodebaseIndexServer: () => killCodebaseIndexServer,
+  killKanbanServer: () => killKanbanServer,
+  killMailboxServer: () => killMailboxServer,
+  killSageServer: () => killSageServer,
+  killSessionCatalogServer: () => killSessionCatalogServer,
+  restartAllConnectionServices: () => restartAllConnectionServices,
+  waitForShutdown: () => waitForShutdown
 });
-import { createChronicleProjectAccess as createChronicleProjectAccess2 } from "@wrongstack/core/chronicle";
+import * as net from "node:net";
 import {
-  isMailboxProjectServerAvailable as isMailboxProjectServerAvailable2,
-  MailboxProjectServerConnection as MailboxProjectServerConnection2
+  ChronicleProjectServerClient,
+  createChronicleProjectAccess,
+  resolveChronicleProjectServerOptions
+} from "@wrongstack/core/chronicle";
+import {
+  isMailboxProjectServerAvailable,
+  MailboxProjectServerConnection
 } from "@wrongstack/core/coordination";
-import { SessionCatalogProjectClient as SessionCatalogProjectClient2 } from "@wrongstack/core/session-catalog";
-import { resolveWstackPaths as resolveWstackPaths3 } from "@wrongstack/core/utils";
-import { getKanbanServerConnection as getKanbanServerConnection2 } from "@wrongstack/kanban";
-import { readGovernanceDaemonOperatorStatus } from "@wrongstack/runtime/governance-bootstrap";
-import { isSageProjectServerAvailable as isSageProjectServerAvailable2, SageProjectServerConnection as SageProjectServerConnection2 } from "@wrongstack/sage";
+import { SessionCatalogProjectClient } from "@wrongstack/core/session-catalog";
 import {
-  checkCodebaseIndexServerHealth as checkCodebaseIndexServerHealth2,
-  getIndexState,
-  resolveProjectIndexDaemonAvailability
+  assertDaemonRuntimeVersion,
+  resolveWstackPaths as resolveWstackPaths2,
+  toErrorMessage
+} from "@wrongstack/core/utils";
+import {
+  closeKanbanServerConnections,
+  getKanbanServerConnection,
+  isKanbanServerAvailable
+} from "@wrongstack/kanban";
+import { isSageProjectServerAvailable, SageProjectServerConnection } from "@wrongstack/sage";
+import {
+  checkCodebaseIndexServerHealth,
+  ensureCodebaseIndexServer,
+  shutdownCodebaseIndexServer
 } from "@wrongstack/tools";
-async function collectConnectionsHealth(projectRoot) {
-  const services = await Promise.all([
-    sessionCatalogHealth(projectRoot),
-    chronicleHealth(projectRoot),
-    codebaseIndexHealth(projectRoot),
-    sageHealth(projectRoot),
-    kanbanHealth(projectRoot),
-    mailboxHealth(projectRoot),
-    governanceHealth(projectRoot)
-  ]);
-  const required = services.filter((s2) => s2.required);
-  const overall = required.some((s2) => s2.status === "error") ? "error" : required.some((s2) => s2.status !== "healthy") ? "degraded" : "healthy";
-  return { checkedAt: Date.now(), overall, services };
+function isRestartableService(serviceId) {
+  return RESTARTABLE_SERVICES.includes(serviceId);
 }
-async function sessionCatalogHealth(projectRoot) {
-  const startedAt = Date.now();
-  try {
-    const paths = resolveWstackPaths3({ projectRoot });
-    const client = new SessionCatalogProjectClient2({
-      projectDir: paths.projectDir,
-      projectRoot
+function isEndpointAlive(endpoint) {
+  return new Promise((resolve) => {
+    const sock = net.createConnection(endpoint);
+    const timer = setTimeout(() => {
+      sock.destroy();
+      resolve(false);
+    }, 500);
+    timer.unref?.();
+    sock.once("connect", () => {
+      clearTimeout(timer);
+      sock.destroy();
+      resolve(true);
+    });
+    sock.once("error", () => {
+      clearTimeout(timer);
+      sock.destroy();
+      resolve(false);
     });
+  });
+}
+async function waitForShutdown(probe) {
+  const pollIntervalMs = 250;
+  if (!probe) {
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    return;
+  }
+  const deadline = Date.now() + 3e3;
+  while (Date.now() < deadline) {
     try {
-      const health2 = await client.callExisting("ping", {}, { timeoutMs: 3e3 });
+      const stillUp = await probe();
+      if (!stillUp) return;
+    } catch {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  throw new Error("Daemon did not stop before the restart deadline; restart was not verified.");
+}
+async function executeConnectionAction(serviceId, action, projectRoot, indexDir) {
+  switch (serviceId) {
+    case "session-catalog":
+      return killSessionCatalogServer(projectRoot, action);
+    case "kanban":
+      return killKanbanServer(projectRoot, action);
+    case "sage":
+      return killSageServer(projectRoot, action);
+    case "chronicle":
+      return killChronicleServer(projectRoot, action);
+    case "codebase-index":
+      return killCodebaseIndexServer(projectRoot, indexDir, action);
+    case "mailbox":
+      return killMailboxServer(projectRoot, action);
+    case "governance":
       return {
-        id: "session-catalog",
-        label: "Session Catalog",
-        status: health2.damagedRows > 0 ? "degraded" : "healthy",
-        required: true,
-        mode: "project-daemon",
-        detail: health2.damagedRows > 0 ? `${health2.damagedRows} damaged catalog row(s); rebuild is required.` : `${health2.catalogRows} catalog session(s), ${health2.liveLeases} live lease(s), ${health2.reservations} reservation(s).`,
-        ownerPid: health2.pid,
-        endpoint: health2.endpoint,
-        storage: health2.databasePath,
-        uptimeMs: health2.uptimeMs,
-        latencyMs: Date.now() - startedAt,
-        clients: health2.clients,
-        activeRequests: health2.activeRequests,
-        queuedWork: health2.reservations + health2.maintenanceLeases
+        serviceId: "governance",
+        action,
+        success: false,
+        message: "Governance control plane is read-only; daemon restart is not supported."
+      };
+    default:
+      return {
+        serviceId,
+        action,
+        success: false,
+        message: `Unknown service: ${serviceId}`
+      };
+  }
+}
+async function restartAllConnectionServices(projectRoot, indexDir) {
+  const results = [];
+  for (const id of RESTARTABLE_SERVICES) {
+    try {
+      results.push(await executeConnectionAction(id, "restart", projectRoot, indexDir));
+    } catch (error) {
+      results.push({
+        serviceId: id,
+        action: "restart",
+        success: false,
+        message: toErrorMessage(error)
+      });
+    }
+  }
+  return results;
+}
+async function killSessionCatalogServer(projectRoot, action) {
+  const paths = resolveWstackPaths2({ projectRoot });
+  const client = new SessionCatalogProjectClient({
+    projectDir: paths.projectDir,
+    projectRoot
+  });
+  try {
+    const previousPid = action === "restart" ? await client.callExisting("ping", {}, { timeoutMs: 1e3 }).then(
+      (health2) => health2.pid,
+      () => void 0
+    ) : void 0;
+    const result = await client.shutdown(`TUI request: ${action}`);
+    if (!result.stopped && action === "shutdown") {
+      return {
+        serviceId: "session-catalog",
+        action,
+        success: false,
+        message: "Session Catalog IPC daemon is not running"
       };
-    } finally {
-      await client.close().catch(() => void 0);
     }
+    if (action === "restart") return await restartSessionCatalogServer(projectRoot, previousPid);
+    return {
+      serviceId: "session-catalog",
+      action,
+      success: true,
+      message: "Session Catalog IPC daemon shutdown requested"
+    };
   } catch (error) {
-    const offline = isOfflineConnectionError(error);
     return {
-      id: "session-catalog",
-      label: "Session Catalog",
-      status: offline ? "offline" : "error",
-      required: !offline,
-      mode: offline ? "on-demand project-daemon" : "project-daemon",
-      detail: offline ? "Not running for this project; it starts on demand when a session is used." : "Project-scoped session ownership and catalog are unavailable.",
-      latencyMs: Date.now() - startedAt,
-      lastError: error instanceof Error ? error.message : String(error)
+      serviceId: "session-catalog",
+      action,
+      success: false,
+      message: toErrorMessage(error)
     };
+  } finally {
+    await client.close().catch(() => void 0);
   }
 }
-async function chronicleHealth(projectRoot) {
-  const startedAt = Date.now();
-  let access;
+async function restartSessionCatalogServer(projectRoot, previousPid) {
+  const paths = resolveWstackPaths2({ projectRoot });
+  const probe = () => {
+    const client = new SessionCatalogProjectClient({
+      projectDir: paths.projectDir,
+      projectRoot
+    });
+    return client.callExisting("ping", {}, { timeoutMs: 1e3 }).then(
+      () => true,
+      () => false
+    ).finally(() => client.close().catch(() => void 0));
+  };
+  await waitForShutdown(probe);
+  const verify = new SessionCatalogProjectClient({
+    projectDir: paths.projectDir,
+    projectRoot
+  });
   try {
-    access = createChronicleProjectAccess2({ projectRoot });
-    const health2 = await access.call("ping", {}, { timeoutMs: 5e3 });
-    const quarantined = health2.quarantinedFamilies ?? [];
+    const health2 = await verify.ping();
+    assertDaemonRuntimeVersion(health2.runtimeVersion);
+    if (previousPid !== void 0 && health2.pid === previousPid) {
+      return {
+        serviceId: "session-catalog",
+        action: "restart",
+        success: false,
+        message: `Session Catalog IPC daemon did not restart (owner PID is still ${previousPid})`
+      };
+    }
     return {
-      id: "chronicle",
-      label: "Chronicle telemetry",
-      status: quarantined.length > 0 ? "degraded" : access.mode === "server" ? "healthy" : "degraded",
-      required: true,
-      mode: access.mode,
-      detail: quarantined.length > 0 ? `Serving, but ${quarantined.length} day(s) were quarantined for a broken chain: ${quarantined.map((family) => family.day).join(", ")}.` : access.mode === "server" ? "One project owner collects, processes, stores, and serves telemetry." : "Inline fallback is active; ownership is not shared across clients.",
-      ownerPid: health2.pid,
-      endpoint: health2.endpoint,
-      storage: health2.chronicleDirectory,
-      uptimeMs: health2.uptimeMs,
-      latencyMs: Date.now() - startedAt,
-      clients: health2.clients,
-      activeRequests: health2.activeRequests,
-      queuedWork: health2.journal.pendingEvents,
-      watcher: { active: health2.watcher.active, watchedFiles: health2.watcher.watchedFiles },
-      ...quarantined[0] ? { lastError: quarantined[0].reason } : health2.watcher.lastError ? { lastError: health2.watcher.lastError } : {}
+      serviceId: "session-catalog",
+      action: "restart",
+      success: true,
+      message: "Session Catalog IPC daemon restarted successfully"
     };
   } catch (error) {
-    return failureService(
-      "chronicle",
-      "Chronicle telemetry",
-      true,
-      access?.mode ?? "unavailable",
-      error,
-      Date.now() - startedAt
-    );
+    return {
+      serviceId: "session-catalog",
+      action: "restart",
+      success: false,
+      message: `Session Catalog IPC daemon restarted but verification failed: ${toErrorMessage(error)}`
+    };
   } finally {
-    await access?.close();
+    await verify.close().catch(() => void 0);
   }
 }
-async function codebaseIndexHealth(projectRoot) {
-  const startedAt = Date.now();
-  const availability = resolveProjectIndexDaemonAvailability(projectRoot);
-  if (availability.kind === "endpoint-invalid") {
+async function killKanbanServer(projectRoot, action) {
+  if (process.env["WRONGSTACK_KANBAN_SERVER"] === "0") {
     return {
-      id: "codebase-index",
-      label: "Codebase index",
-      status: "unavailable",
-      required: false,
-      mode: "endpoint-invalid",
-      detail: `Socket path is ${availability.byteLength} bytes \u2014 over this platform's ${availability.maxBytes}-byte sun_path limit. Queries fall back to a process-local index. Set a shorter TMPDIR to restore the shared daemon.`,
-      endpoint: availability.endpoint,
-      latencyMs: Date.now() - startedAt
+      serviceId: "kanban",
+      action,
+      success: false,
+      message: "Kanban IPC daemon is disabled via WRONGSTACK_KANBAN_SERVER=0"
     };
   }
+  let connection;
   try {
-    const health2 = await checkCodebaseIndexServerHealth2(projectRoot, void 0, {
-      timeoutMs: 2e3
-    });
-    const connection = getIndexState().server;
+    connection = await getKanbanServerConnection(projectRoot);
+  } catch (error) {
     return {
-      id: "codebase-index",
-      label: "Codebase index",
-      status: health2.status === "unresponsive" ? "error" : health2.status,
-      required: false,
-      mode: "project-server",
-      detail: health2.server?.activity.indexing ? `Indexing ${health2.server.activity.currentFile}/${health2.server.activity.totalFiles}.` : "Shared symbol index is ready for project queries.",
-      ownerPid: connection.pid,
-      endpoint: connection.endpoint,
-      storage: connection.indexDir ?? resolveWstackPaths3({ projectRoot }).projectCodebaseIndex,
-      uptimeMs: health2.server?.uptimeMs,
-      latencyMs: health2.latencyMs ?? Date.now() - startedAt,
-      clients: health2.server?.clients,
-      activeRequests: health2.server?.activeRequests,
-      queuedWork: health2.server?.queuedWrites,
-      watcher: health2.server ? { active: health2.server.watchingExternal, watchedFiles: health2.server.watchingClients } : void 0
+      serviceId: "kanban",
+      action,
+      success: false,
+      message: toErrorMessage(error)
     };
-  } catch (error) {
-    if (isOfflineConnectionError(error)) {
-      return {
-        ...failureService(
-          "codebase-index",
-          "Codebase index",
-          false,
-          "on-demand project-server",
-          error,
-          Date.now() - startedAt
-        ),
-        status: "offline",
-        detail: "Not running for this project; it starts on demand when indexing is used."
-      };
-    }
-    return failureService(
-      "codebase-index",
-      "Codebase index",
-      false,
-      "project-server",
-      error,
-      Date.now() - startedAt
-    );
   }
-}
-async function sageHealth(projectRoot) {
-  const startedAt = Date.now();
-  if (!isSageProjectServerAvailable2()) {
+  if (!connection) {
     return {
-      id: "sage",
-      label: "SAGE memory",
-      status: "unavailable",
-      required: false,
-      mode: "unavailable",
-      detail: "The packaged SAGE project server is unavailable in this runtime."
+      serviceId: "kanban",
+      action,
+      success: false,
+      message: "Kanban IPC daemon is not running"
     };
   }
-  const connection = new SageProjectServerConnection2(projectRoot);
   try {
-    const status = await connection.status();
-    if (!status) {
+    const result = await connection.request("shutdown", {
+      reason: `TUI request: ${action}`
+    });
+    if (!result.stopping) {
       return {
-        id: "sage",
-        label: "SAGE memory",
-        status: "offline",
-        required: false,
-        mode: "on-demand project-server",
-        detail: "Not running for this project; it starts on demand when memory is used.",
-        endpoint: connection.getState().endpoint,
-        latencyMs: Date.now() - startedAt
+        serviceId: "kanban",
+        action,
+        success: false,
+        message: "Kanban IPC daemon shutdown failed (not confirmed)"
       };
     }
-    const healthStatus = status.health.status === "ready" ? "healthy" : status.health.status === "degraded" ? "degraded" : "error";
+    if (action === "restart") {
+      closeKanbanServerConnections();
+      return await restartKanbanServer(projectRoot);
+    }
     return {
-      id: "sage",
-      label: "SAGE memory",
-      status: healthStatus,
-      required: false,
-      mode: "project-server",
-      detail: `Persistent project memory backend: ${status.health.backend}.`,
-      ownerPid: status.pid,
-      endpoint: status.endpoint,
-      storage: status.storageRoot,
-      latencyMs: Date.now() - startedAt,
-      clients: status.clients,
-      activeRequests: status.pendingRequests
+      serviceId: "kanban",
+      action,
+      success: true,
+      message: "Kanban IPC daemon shutdown requested"
     };
   } catch (error) {
-    return failureService(
-      "sage",
-      "SAGE memory",
-      false,
-      "project-server",
-      error,
-      Date.now() - startedAt
-    );
-  } finally {
-    connection.close();
-  }
-}
-async function kanbanHealth(projectRoot) {
-  const startedAt = Date.now();
-  if (process.env["WRONGSTACK_KANBAN_SERVER"] === "0") {
     return {
-      id: "kanban",
-      label: "Kanban IPC",
-      status: "unavailable",
-      required: false,
-      mode: "disabled",
-      detail: "Kanban IPC daemon is disabled via WRONGSTACK_KANBAN_SERVER=0."
+      serviceId: "kanban",
+      action,
+      success: false,
+      message: toErrorMessage(error)
     };
   }
-  let connection;
+}
+async function restartKanbanServer(projectRoot) {
+  await waitForShutdown(() => isKanbanServerAvailable(projectRoot));
   try {
-    connection = await getKanbanServerConnection2(projectRoot);
-  } catch (error) {
-    return failureService(
-      "kanban",
-      "Kanban IPC",
-      false,
-      "project-server",
-      error,
-      Date.now() - startedAt
-    );
-  }
-  if (!connection) {
+    const connection = await getKanbanServerConnection(projectRoot);
+    if (!connection) {
+      return {
+        serviceId: "kanban",
+        action: "restart",
+        success: false,
+        message: "Kanban IPC daemon failed to restart (no connection after re-init)"
+      };
+    }
+    const health2 = await connection.request("ping", {}, { timeoutMs: 1e4 });
+    assertDaemonRuntimeVersion(health2.runtimeVersion);
     return {
-      id: "kanban",
-      label: "Kanban IPC",
-      status: "unavailable",
-      required: false,
-      mode: "disabled",
-      detail: "Kanban IPC daemon is disabled in this runtime."
+      serviceId: "kanban",
+      action: "restart",
+      success: true,
+      message: "Kanban IPC daemon restarted successfully"
     };
-  }
-  try {
-    const status = await connection.request("ping", {}, { timeoutMs: 5e3 });
+  } catch (error) {
     return {
-      id: "kanban",
-      label: "Kanban IPC",
-      status: "healthy",
-      required: true,
-      mode: "project-server",
-      detail: `Single shared project-server owns kanban state (v${status.protocolVersion}).`,
-      ownerPid: status.pid,
-      endpoint: status.endpoint,
-      storage: status.databasePath,
-      latencyMs: Date.now() - startedAt,
-      clients: status.clients,
-      activeRequests: status.pendingRequests,
-      uptimeMs: Date.now() - new Date(status.startedAt).getTime()
+      serviceId: "kanban",
+      action: "restart",
+      success: false,
+      message: `Kanban IPC daemon restarted but verification failed: ${toErrorMessage(error)}`
     };
-  } catch (error) {
-    return failureService(
-      "kanban",
-      "Kanban IPC",
-      true,
-      "project-server",
-      error,
-      Date.now() - startedAt
-    );
   }
 }
-async function mailboxHealth(projectRoot) {
-  const startedAt = Date.now();
-  if (!isMailboxProjectServerAvailable2()) {
+async function killSageServer(projectRoot, action) {
+  if (!isSageProjectServerAvailable()) {
     return {
-      id: "mailbox",
-      label: "Mailbox IPC",
-      status: "unavailable",
-      required: false,
-      mode: "unavailable",
-      detail: "The packaged mailbox project server is unavailable in this runtime."
+      serviceId: "sage",
+      action,
+      success: false,
+      message: "SAGE project server is unavailable in this runtime"
     };
   }
-  const connection = new MailboxProjectServerConnection2(
-    resolveWstackPaths3({ projectRoot }).projectDir
-  );
+  const connection = new SageProjectServerConnection(projectRoot);
   try {
-    const status = await connection.probeStatus();
-    if (!status) {
+    const result = await connection.shutdown(`TUI request: ${action}`);
+    if (!result.stopped) {
+      if (action === "restart" && result.reason === "not-running") {
+        return await restartSageServer(projectRoot);
+      }
       return {
-        id: "mailbox",
-        label: "Mailbox IPC",
-        status: "offline",
-        required: false,
-        mode: "on-demand project-server",
-        detail: "Not running for this project; it starts on demand when mailbox is used.",
-        endpoint: connection.getState().endpoint,
-        latencyMs: Date.now() - startedAt
+        serviceId: "sage",
+        action,
+        success: false,
+        message: `SAGE memory server shutdown failed: ${result.reason ?? "unknown"}`
       };
     }
+    if (action === "restart") {
+      return await restartSageServer(projectRoot);
+    }
     return {
-      id: "mailbox",
-      label: "Mailbox IPC",
-      status: "healthy",
-      required: true,
-      mode: "project-server",
-      detail: `Single shared project-server owns inter-agent mailbox state (v${status.protocolVersion}).`,
-      ownerPid: status.pid,
-      endpoint: status.endpoint,
-      storage: status.databasePath,
-      latencyMs: Date.now() - startedAt,
-      clients: status.clients,
-      activeRequests: status.pendingRequests,
-      uptimeMs: Date.now() - new Date(status.startedAt).getTime()
+      serviceId: "sage",
+      action,
+      success: true,
+      message: "SAGE memory server shutdown requested"
     };
   } catch (error) {
-    return failureService(
-      "mailbox",
-      "Mailbox IPC",
-      true,
-      "project-server",
-      error,
-      Date.now() - startedAt
-    );
+    return {
+      serviceId: "sage",
+      action,
+      success: false,
+      message: toErrorMessage(error)
+    };
   } finally {
     connection.close();
   }
 }
-async function governanceHealth(projectRoot) {
-  const startedAt = Date.now();
-  const result = await readGovernanceDaemonOperatorStatus(projectRoot);
-  if (!result.available) {
-    const missing = result.code === "broker_missing";
+async function restartSageServer(projectRoot) {
+  await waitForShutdown(async () => {
+    const probe = new SageProjectServerConnection(projectRoot);
+    try {
+      return await probe.status() !== null;
+    } finally {
+      probe.close();
+    }
+  });
+  const verifyConn = new SageProjectServerConnection(projectRoot);
+  try {
+    const health2 = await verifyConn.call(
+      "ping",
+      {},
+      { timeoutMs: 1e4, meta: { clientId: `sage-restart-${process.pid}` } }
+    );
+    assertDaemonRuntimeVersion(health2.runtimeVersion);
     return {
-      id: "governance",
-      label: "Governance control plane",
-      status: missing ? "offline" : "error",
-      required: false,
-      mode: missing ? "compatibility-default-off" : "project-daemon",
-      detail: missing ? "Not active for this project. Existing agent and model execution remains unchanged." : `Read-only governance status is unavailable: ${result.message}`,
-      latencyMs: Date.now() - startedAt,
-      control: "none",
-      ...missing ? {} : { lastError: result.message }
+      serviceId: "sage",
+      action: "restart",
+      success: true,
+      message: "SAGE memory server restarted successfully"
     };
-  }
-  const { status } = result;
-  return {
-    id: "governance",
+  } catch (error) {
+    return {
+      serviceId: "sage",
+      action: "restart",
+      success: false,
+      message: `SAGE memory server restarted but verification failed: ${toErrorMessage(error)}`
+    };
+  } finally {
+    verifyConn.close();
+  }
+}
+async function killChronicleServer(projectRoot, action) {
+  const options = resolveChronicleProjectServerOptions({ projectRoot });
+  const client = new ChronicleProjectServerClient(options);
+  try {
+    const result = await client.shutdown(`TUI request: ${action}`);
+    if (!result.stopped) {
+      if (action === "restart" && result.reason === "offline") {
+        return await restartChronicleServer(projectRoot);
+      }
+      return {
+        serviceId: "chronicle",
+        action,
+        success: false,
+        message: `Chronicle telemetry server shutdown failed: ${result.reason ?? "unknown"}`
+      };
+    }
+    if (action === "restart") {
+      return await restartChronicleServer(projectRoot);
+    }
+    return {
+      serviceId: "chronicle",
+      action,
+      success: true,
+      message: "Chronicle telemetry server shutdown requested"
+    };
+  } catch (error) {
+    return {
+      serviceId: "chronicle",
+      action,
+      success: false,
+      message: toErrorMessage(error)
+    };
+  } finally {
+    client.close();
+  }
+}
+async function restartChronicleServer(projectRoot) {
+  const options = resolveChronicleProjectServerOptions({ projectRoot });
+  const endpoint = new ChronicleProjectServerClient(options).endpoint;
+  await waitForShutdown(async () => isEndpointAlive(endpoint));
+  let access;
+  try {
+    access = createChronicleProjectAccess({ projectRoot });
+    const health2 = await access.call("ping", {}, { timeoutMs: 1e4 });
+    if (access.mode !== "server") {
+      return {
+        serviceId: "chronicle",
+        action: "restart",
+        success: false,
+        message: `Chronicle telemetry server restarted but running in ${access.mode} mode (expected server)`
+      };
+    }
+    assertDaemonRuntimeVersion(health2.runtimeVersion);
+    return {
+      serviceId: "chronicle",
+      action: "restart",
+      success: true,
+      message: "Chronicle telemetry server restarted successfully"
+    };
+  } catch (error) {
+    return {
+      serviceId: "chronicle",
+      action: "restart",
+      success: false,
+      message: `Chronicle telemetry server restarted but verification failed: ${toErrorMessage(error)}`
+    };
+  } finally {
+    await access?.close();
+  }
+}
+async function killCodebaseIndexServer(projectRoot, indexDir, action) {
+  try {
+    const result = await shutdownCodebaseIndexServer(
+      projectRoot,
+      indexDir,
+      `tui-request:${action}`
+    );
+    if (!result.stopped) {
+      if (action === "restart" && result.reason === "not-running") {
+        return await restartCodebaseIndexServer(projectRoot, indexDir);
+      }
+      return {
+        serviceId: "codebase-index",
+        action,
+        success: false,
+        message: `Codebase index server shutdown failed: ${result.reason ?? "unknown"}`
+      };
+    }
+    if (action === "restart") {
+      return await restartCodebaseIndexServer(projectRoot, indexDir);
+    }
+    return {
+      serviceId: "codebase-index",
+      action,
+      success: true,
+      message: "Codebase index server shutdown requested"
+    };
+  } catch (error) {
+    return {
+      serviceId: "codebase-index",
+      action,
+      success: false,
+      message: toErrorMessage(error)
+    };
+  }
+}
+async function restartCodebaseIndexServer(projectRoot, indexDir) {
+  await waitForShutdown(async () => {
+    try {
+      await checkCodebaseIndexServerHealth(projectRoot, indexDir, {
+        timeoutMs: 1e3
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  try {
+    await ensureCodebaseIndexServer({ projectRoot, indexDir });
+    const health2 = await checkCodebaseIndexServerHealth(projectRoot, indexDir, {
+      timeoutMs: 1e4
+    });
+    if (health2.status !== "healthy") {
+      return {
+        serviceId: "codebase-index",
+        action: "restart",
+        success: false,
+        message: `Codebase index server restart verification failed: ${health2.status}`
+      };
+    }
+    assertDaemonRuntimeVersion(health2.server?.runtimeVersion);
+    return {
+      serviceId: "codebase-index",
+      action: "restart",
+      success: true,
+      message: "Codebase index server restarted successfully"
+    };
+  } catch (error) {
+    return {
+      serviceId: "codebase-index",
+      action: "restart",
+      success: false,
+      message: `Codebase index server restarted but verification failed: ${toErrorMessage(error)}`
+    };
+  }
+}
+async function killMailboxServer(projectRoot, action) {
+  if (!isMailboxProjectServerAvailable()) {
+    return {
+      serviceId: "mailbox",
+      action,
+      success: false,
+      message: "Mailbox project server is unavailable in this runtime"
+    };
+  }
+  const connection = new MailboxProjectServerConnection(
+    resolveWstackPaths2({ projectRoot }).projectDir
+  );
+  try {
+    const result = await connection.shutdown(`TUI request: ${action}`);
+    if (!result.stopped) {
+      if (action === "restart" && result.reason === "offline") {
+        return await restartMailboxServer(projectRoot);
+      }
+      return {
+        serviceId: "mailbox",
+        action,
+        success: false,
+        message: `Mailbox IPC server shutdown failed: ${result.reason ?? "unknown"}`
+      };
+    }
+    if (action === "restart") {
+      return await restartMailboxServer(projectRoot);
+    }
+    return {
+      serviceId: "mailbox",
+      action,
+      success: true,
+      message: "Mailbox IPC server shutdown requested"
+    };
+  } catch (error) {
+    return {
+      serviceId: "mailbox",
+      action,
+      success: false,
+      message: toErrorMessage(error)
+    };
+  } finally {
+    connection.close();
+  }
+}
+async function restartMailboxServer(projectRoot) {
+  await waitForShutdown(async () => {
+    const probe = new MailboxProjectServerConnection(
+      resolveWstackPaths2({ projectRoot }).projectDir
+    );
+    try {
+      return await probe.probeStatus() !== null;
+    } finally {
+      probe.close();
+    }
+  });
+  const verifyConn = new MailboxProjectServerConnection(
+    resolveWstackPaths2({ projectRoot }).projectDir
+  );
+  try {
+    const health2 = await verifyConn.call("ping", {}, { timeoutMs: 1e4 });
+    assertDaemonRuntimeVersion(health2.runtimeVersion);
+    return {
+      serviceId: "mailbox",
+      action: "restart",
+      success: true,
+      message: "Mailbox IPC server restarted successfully"
+    };
+  } catch (error) {
+    return {
+      serviceId: "mailbox",
+      action: "restart",
+      success: false,
+      message: `Mailbox IPC server restarted but verification failed: ${toErrorMessage(error)}`
+    };
+  } finally {
+    verifyConn.close();
+  }
+}
+var RESTARTABLE_SERVICES;
+var init_connection_actions = __esm({
+  "src/connection-actions.ts"() {
+    "use strict";
+    RESTARTABLE_SERVICES = [
+      "session-catalog",
+      "chronicle",
+      "codebase-index",
+      "sage",
+      "kanban",
+      "mailbox"
+    ];
+  }
+});
+
+// src/connections-health.ts
+var connections_health_exports = {};
+__export(connections_health_exports, {
+  collectConnectionsHealth: () => collectConnectionsHealth
+});
+import { createChronicleProjectAccess as createChronicleProjectAccess2 } from "@wrongstack/core/chronicle";
+import {
+  isMailboxProjectServerAvailable as isMailboxProjectServerAvailable2,
+  MailboxProjectServerConnection as MailboxProjectServerConnection2
+} from "@wrongstack/core/coordination";
+import { SessionCatalogProjectClient as SessionCatalogProjectClient2 } from "@wrongstack/core/session-catalog";
+import { resolveWstackPaths as resolveWstackPaths3, withDaemonVersion } from "@wrongstack/core/utils";
+import { getKanbanServerConnection as getKanbanServerConnection2 } from "@wrongstack/kanban";
+import { readGovernanceDaemonOperatorStatus } from "@wrongstack/runtime/governance-bootstrap";
+import { isSageProjectServerAvailable as isSageProjectServerAvailable2, SageProjectServerConnection as SageProjectServerConnection2 } from "@wrongstack/sage";
+import {
+  checkCodebaseIndexServerHealth as checkCodebaseIndexServerHealth2,
+  getIndexState,
+  resolveProjectIndexDaemonAvailability
+} from "@wrongstack/tools";
+async function collectConnectionsHealth(projectRoot) {
+  const services = await Promise.all([
+    sessionCatalogHealth(projectRoot),
+    chronicleHealth(projectRoot),
+    codebaseIndexHealth(projectRoot),
+    sageHealth(projectRoot),
+    kanbanHealth(projectRoot),
+    mailboxHealth(projectRoot),
+    governanceHealth(projectRoot)
+  ]);
+  const required = services.filter((s2) => s2.required);
+  const overall = required.some((s2) => s2.status === "error") ? "error" : services.some((s2) => s2.versionMismatch) || required.some((s2) => s2.status !== "healthy") ? "degraded" : "healthy";
+  return { checkedAt: Date.now(), overall, services };
+}
+async function sessionCatalogHealth(projectRoot) {
+  const startedAt = Date.now();
+  try {
+    const paths = resolveWstackPaths3({ projectRoot });
+    const client = new SessionCatalogProjectClient2({
+      projectDir: paths.projectDir,
+      projectRoot
+    });
+    try {
+      const health2 = await client.callExisting("ping", {}, { timeoutMs: 3e3 });
+      return withDaemonVersion(
+        {
+          id: "session-catalog",
+          label: "Session Catalog",
+          status: health2.damagedRows > 0 ? "degraded" : "healthy",
+          required: true,
+          mode: "project-daemon",
+          detail: health2.damagedRows > 0 ? `${health2.damagedRows} damaged catalog row(s); rebuild is required.` : `${health2.catalogRows} catalog session(s), ${health2.liveLeases} live lease(s), ${health2.reservations} reservation(s).`,
+          ownerPid: health2.pid,
+          endpoint: health2.endpoint,
+          storage: health2.databasePath,
+          uptimeMs: health2.uptimeMs,
+          latencyMs: Date.now() - startedAt,
+          clients: health2.clients,
+          activeRequests: health2.activeRequests,
+          queuedWork: health2.reservations + health2.maintenanceLeases
+        },
+        health2?.runtimeVersion
+      );
+    } finally {
+      await client.close().catch(() => void 0);
+    }
+  } catch (error) {
+    const offline = isOfflineConnectionError(error);
+    return {
+      id: "session-catalog",
+      label: "Session Catalog",
+      status: offline ? "offline" : "error",
+      required: !offline,
+      mode: offline ? "on-demand project-daemon" : "project-daemon",
+      detail: offline ? "Not running for this project; it starts on demand when a session is used." : "Project-scoped session ownership and catalog are unavailable.",
+      latencyMs: Date.now() - startedAt,
+      lastError: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function chronicleHealth(projectRoot) {
+  const startedAt = Date.now();
+  let access;
+  try {
+    access = createChronicleProjectAccess2({ projectRoot });
+    const health2 = await access.call("ping", {}, { timeoutMs: 5e3 });
+    const quarantined = health2.quarantinedFamilies ?? [];
+    return withDaemonVersion(
+      {
+        id: "chronicle",
+        label: "Chronicle telemetry",
+        status: quarantined.length > 0 ? "degraded" : access.mode === "server" ? "healthy" : "degraded",
+        required: true,
+        mode: access.mode,
+        detail: quarantined.length > 0 ? `Serving, but ${quarantined.length} day(s) were quarantined for a broken chain: ${quarantined.map((family) => family.day).join(", ")}.` : access.mode === "server" ? "One project owner collects, processes, stores, and serves telemetry." : "Inline fallback is active; ownership is not shared across clients.",
+        ownerPid: health2.pid,
+        endpoint: health2.endpoint,
+        storage: health2.chronicleDirectory,
+        uptimeMs: health2.uptimeMs,
+        latencyMs: Date.now() - startedAt,
+        clients: health2.clients,
+        activeRequests: health2.activeRequests,
+        queuedWork: health2.journal.pendingEvents,
+        watcher: { active: health2.watcher.active, watchedFiles: health2.watcher.watchedFiles },
+        ...quarantined[0] ? { lastError: quarantined[0].reason } : health2.watcher.lastError ? { lastError: health2.watcher.lastError } : {}
+      },
+      health2?.runtimeVersion
+    );
+  } catch (error) {
+    return failureService(
+      "chronicle",
+      "Chronicle telemetry",
+      true,
+      access?.mode ?? "unavailable",
+      error,
+      Date.now() - startedAt
+    );
+  } finally {
+    await access?.close();
+  }
+}
+async function codebaseIndexHealth(projectRoot) {
+  const startedAt = Date.now();
+  const availability = resolveProjectIndexDaemonAvailability(projectRoot);
+  if (availability.kind === "endpoint-invalid") {
+    return {
+      id: "codebase-index",
+      label: "Codebase index",
+      status: "unavailable",
+      required: false,
+      mode: "endpoint-invalid",
+      detail: `Socket path is ${availability.byteLength} bytes \u2014 over this platform's ${availability.maxBytes}-byte sun_path limit. Queries fall back to a process-local index. Set a shorter TMPDIR to restore the shared daemon.`,
+      endpoint: availability.endpoint,
+      latencyMs: Date.now() - startedAt
+    };
+  }
+  try {
+    const health2 = await checkCodebaseIndexServerHealth2(projectRoot, void 0, {
+      timeoutMs: 2e3
+    });
+    const connection = getIndexState().server;
+    return withDaemonVersion(
+      {
+        id: "codebase-index",
+        label: "Codebase index",
+        status: health2.status === "unresponsive" ? "error" : health2.status,
+        required: false,
+        mode: "project-server",
+        detail: health2.server?.activity.indexing ? `Indexing ${health2.server.activity.currentFile}/${health2.server.activity.totalFiles}.` : "Shared symbol index is ready for project queries.",
+        ownerPid: connection.pid,
+        endpoint: connection.endpoint,
+        storage: connection.indexDir ?? resolveWstackPaths3({ projectRoot }).projectCodebaseIndex,
+        uptimeMs: health2.server?.uptimeMs,
+        latencyMs: health2.latencyMs ?? Date.now() - startedAt,
+        clients: health2.server?.clients,
+        activeRequests: health2.server?.activeRequests,
+        queuedWork: health2.server?.queuedWrites,
+        watcher: health2.server ? { active: health2.server.watchingExternal, watchedFiles: health2.server.watchingClients } : void 0
+      },
+      health2.server?.runtimeVersion
+    );
+  } catch (error) {
+    if (isOfflineConnectionError(error)) {
+      return {
+        ...failureService(
+          "codebase-index",
+          "Codebase index",
+          false,
+          "on-demand project-server",
+          error,
+          Date.now() - startedAt
+        ),
+        status: "offline",
+        detail: "Not running for this project; it starts on demand when indexing is used."
+      };
+    }
+    return failureService(
+      "codebase-index",
+      "Codebase index",
+      false,
+      "project-server",
+      error,
+      Date.now() - startedAt
+    );
+  }
+}
+async function sageHealth(projectRoot) {
+  const startedAt = Date.now();
+  if (!isSageProjectServerAvailable2()) {
+    return {
+      id: "sage",
+      label: "SAGE memory",
+      status: "unavailable",
+      required: false,
+      mode: "unavailable",
+      detail: "The packaged SAGE project server is unavailable in this runtime."
+    };
+  }
+  const connection = new SageProjectServerConnection2(projectRoot);
+  try {
+    const status = await connection.status();
+    if (!status) {
+      return {
+        id: "sage",
+        label: "SAGE memory",
+        status: "offline",
+        required: false,
+        mode: "on-demand project-server",
+        detail: "Not running for this project; it starts on demand when memory is used.",
+        endpoint: connection.getState().endpoint,
+        latencyMs: Date.now() - startedAt
+      };
+    }
+    const healthStatus = status.health.status === "ready" ? "healthy" : status.health.status === "degraded" ? "degraded" : "error";
+    return withDaemonVersion(
+      {
+        id: "sage",
+        label: "SAGE memory",
+        status: healthStatus,
+        required: false,
+        mode: "project-server",
+        detail: `Persistent project memory backend: ${status.health.backend}.`,
+        ownerPid: status.pid,
+        endpoint: status.endpoint,
+        storage: status.storageRoot,
+        latencyMs: Date.now() - startedAt,
+        clients: status.clients,
+        activeRequests: status.pendingRequests
+      },
+      status?.runtimeVersion
+    );
+  } catch (error) {
+    return failureService(
+      "sage",
+      "SAGE memory",
+      false,
+      "project-server",
+      error,
+      Date.now() - startedAt
+    );
+  } finally {
+    connection.close();
+  }
+}
+async function kanbanHealth(projectRoot) {
+  const startedAt = Date.now();
+  if (process.env["WRONGSTACK_KANBAN_SERVER"] === "0") {
+    return {
+      id: "kanban",
+      label: "Kanban IPC",
+      status: "unavailable",
+      required: false,
+      mode: "disabled",
+      detail: "Kanban IPC daemon is disabled via WRONGSTACK_KANBAN_SERVER=0."
+    };
+  }
+  let connection;
+  try {
+    connection = await getKanbanServerConnection2(projectRoot);
+  } catch (error) {
+    return failureService(
+      "kanban",
+      "Kanban IPC",
+      false,
+      "project-server",
+      error,
+      Date.now() - startedAt
+    );
+  }
+  if (!connection) {
+    return {
+      id: "kanban",
+      label: "Kanban IPC",
+      status: "unavailable",
+      required: false,
+      mode: "disabled",
+      detail: "Kanban IPC daemon is disabled in this runtime."
+    };
+  }
+  try {
+    const status = await connection.request("ping", {}, { timeoutMs: 5e3 });
+    return withDaemonVersion(
+      {
+        id: "kanban",
+        label: "Kanban IPC",
+        status: "healthy",
+        required: true,
+        mode: "project-server",
+        detail: `Single shared project-server owns kanban state (v${status.protocolVersion}).`,
+        ownerPid: status.pid,
+        endpoint: status.endpoint,
+        storage: status.databasePath,
+        latencyMs: Date.now() - startedAt,
+        clients: status.clients,
+        activeRequests: status.pendingRequests,
+        uptimeMs: Date.now() - new Date(status.startedAt).getTime()
+      },
+      status?.runtimeVersion
+    );
+  } catch (error) {
+    return failureService(
+      "kanban",
+      "Kanban IPC",
+      true,
+      "project-server",
+      error,
+      Date.now() - startedAt
+    );
+  }
+}
+async function mailboxHealth(projectRoot) {
+  const startedAt = Date.now();
+  if (!isMailboxProjectServerAvailable2()) {
+    return {
+      id: "mailbox",
+      label: "Mailbox IPC",
+      status: "unavailable",
+      required: false,
+      mode: "unavailable",
+      detail: "The packaged mailbox project server is unavailable in this runtime."
+    };
+  }
+  const connection = new MailboxProjectServerConnection2(
+    resolveWstackPaths3({ projectRoot }).projectDir
+  );
+  try {
+    const status = await connection.probeStatus();
+    if (!status) {
+      return {
+        id: "mailbox",
+        label: "Mailbox IPC",
+        status: "offline",
+        required: false,
+        mode: "on-demand project-server",
+        detail: "Not running for this project; it starts on demand when mailbox is used.",
+        endpoint: connection.getState().endpoint,
+        latencyMs: Date.now() - startedAt
+      };
+    }
+    return withDaemonVersion(
+      {
+        id: "mailbox",
+        label: "Mailbox IPC",
+        status: "healthy",
+        required: true,
+        mode: "project-server",
+        detail: `Single shared project-server owns inter-agent mailbox state (v${status.protocolVersion}).`,
+        ownerPid: status.pid,
+        endpoint: status.endpoint,
+        storage: status.databasePath,
+        latencyMs: Date.now() - startedAt,
+        clients: status.clients,
+        activeRequests: status.pendingRequests,
+        uptimeMs: Date.now() - new Date(status.startedAt).getTime()
+      },
+      status?.runtimeVersion
+    );
+  } catch (error) {
+    return failureService(
+      "mailbox",
+      "Mailbox IPC",
+      true,
+      "project-server",
+      error,
+      Date.now() - startedAt
+    );
+  } finally {
+    connection.close();
+  }
+}
+async function governanceHealth(projectRoot) {
+  const startedAt = Date.now();
+  const result = await readGovernanceDaemonOperatorStatus(projectRoot);
+  if (!result.available) {
+    const missing = result.code === "broker_missing";
+    return {
+      id: "governance",
+      label: "Governance control plane",
+      status: missing ? "offline" : "error",
+      required: false,
+      mode: missing ? "compatibility-default-off" : "project-daemon",
+      detail: missing ? "Not active for this project. Existing agent and model execution remains unchanged." : `Read-only governance status is unavailable: ${result.message}`,
+      latencyMs: Date.now() - startedAt,
+      control: "none",
+      ...missing ? {} : { lastError: result.message }
+    };
+  }
+  const { status } = result;
+  return {
+    id: "governance",
     label: "Governance control plane",
     status: status.signal.level === "healthy" ? "healthy" : "degraded",
     required: false,
@@ -34210,6 +34846,23 @@ function parseHexColor(hex) {
   const n = Number.parseInt(raw, 16);
   return [n >> 16 & 255, n >> 8 & 255, n & 255];
 }
+function relativeLuminance(hex) {
+  const rgb = parseHexColor(hex);
+  if (!rgb) return null;
+  const [r, g, b] = rgb.map((channel) => {
+    const s2 = channel / 255;
+    return s2 <= 0.03928 ? s2 / 12.92 : ((s2 + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function contrastRatio(foreground, background) {
+  const a = relativeLuminance(foreground);
+  const b = relativeLuminance(background);
+  if (a === null || b === null) return 1;
+  const lighter = Math.max(a, b);
+  const darker = Math.min(a, b);
+  return Math.round((lighter + 0.05) / (darker + 0.05) * 10) / 10;
+}
 function detectSupportsBackground(env3 = process.env, isTTY = process.stdout.isTTY ?? false) {
   if (!isTTY) return false;
   if (typeof env3["NO_COLOR"] === "string" && env3["NO_COLOR"] !== "") return false;
@@ -35647,296 +36300,26 @@ var nightfoxPresets = {
 };
 
 // src/theme-presets/options.ts
-var THEME_OPTIONS = [
-  {
-    id: "catppuccin",
-    name: "Catppuccin Mocha",
-    description: "Warm pastel \u2014 the original WrongStack default"
-  },
-  {
-    id: "tokyo-night",
-    name: "Tokyo Night",
-    description: "Cool blue-purple, calm low-contrast coding palette"
-  },
-  { id: "nord", name: "Nord", description: "Arctic, muted blues and greens \u2014 easy on the eyes" },
-  {
-    id: "cyberpunk",
-    name: "Cyberpunk",
-    description: "Hot pink + neon cyan, high-contrast night mode"
-  },
-  { id: "dracula", name: "Dracula", description: "Classic purple-on-black, vivid accents" },
-  {
-    id: "gruvbox-dark",
-    name: "Gruvbox Dark",
-    description: "Warm earthy retro palette \u2014 orange, olive and muted aqua"
-  },
-  {
-    id: "solarized-dark",
-    name: "Solarized Dark",
-    description: "Precision contrast, base16 classic with teal undertones"
-  },
-  {
-    id: "one-dark",
-    name: "One Dark",
-    description: "Atom's iconic dark palette \u2014 blue-led with warm accents"
-  },
-  {
-    id: "monokai",
-    name: "Monokai",
-    description: "Sublime Text classic \u2014 vivid magenta, cyan and lime"
-  },
-  {
-    id: "rose-pine",
-    name: "Ros\xE9 Pine",
-    description: "Aesthetic pine & foam \u2014 soft pastel evening tones"
-  },
-  { id: "kanagawa", name: "Kanagawa", description: "Hokusai-inspired waves \u2014 sumi ink on washi" },
-  {
-    id: "ayu-dark",
-    name: "Ayu Dark",
-    description: "Simple, pleasant dark \u2014 warm orange + cool blue mix"
-  },
-  {
-    id: "everforest",
-    name: "Everforest",
-    description: "Green-based comfort palette \u2014 forest greens and warm tans"
-  },
-  {
-    id: "night-owl",
-    name: "Night Owl",
-    description: "Sarah Drasner's night theme \u2014 deep navy with bold accents"
-  },
-  {
-    id: "synthwave",
-    name: "Synthwave '84",
-    description: "Hot pink + neon cyan on deep purple \u2014 80s retro glow"
-  },
-  {
-    id: "github-dark",
-    name: "GitHub Dark",
-    description: "GitHub's default dark \u2014 crisp blue on near-black"
-  },
-  {
-    id: "material-ocean",
-    name: "Material Ocean",
-    description: "Deepest Material variant \u2014 ink blue with pastel accents"
-  },
-  { id: "nightfox", name: "Nightfox", description: "Balanced slate blue with muted sage and rose" },
-  {
-    id: "oxocarbon",
-    name: "Oxocarbon",
-    description: "IBM Carbon-derived \u2014 neutral greys, electric blue & pink"
-  },
-  {
-    id: "catppuccin-macchiato",
-    name: "Catppuccin Macchiato",
-    description: "Warmer, one shade lighter than Mocha"
-  },
-  {
-    id: "catppuccin-frappe",
-    name: "Catppuccin Frapp\xE9",
-    description: "The lightest Catppuccin dark \u2014 gentle midday contrast"
-  },
-  {
-    id: "gruvbox-material",
-    name: "Gruvbox Material",
-    description: "Softened Gruvbox \u2014 same warmth, lower eye strain"
-  },
-  {
-    id: "tokyo-night-storm",
-    name: "Tokyo Night Storm",
-    description: "Tokyo Night on a lifted blue-grey base"
-  },
-  {
-    id: "rose-pine-moon",
-    name: "Ros\xE9 Pine Moon",
-    description: "Ros\xE9 Pine at dusk \u2014 deeper base, same soft accents"
-  },
-  {
-    id: "zenburn",
-    name: "Zenburn",
-    description: "The classic low-contrast grey \u2014 desaturated and calm"
-  },
-  {
-    id: "palenight",
-    name: "Palenight",
-    description: "Material Palenight \u2014 indigo base, candy accents"
-  },
-  {
-    id: "horizon",
-    name: "Horizon",
-    description: "Warm coral and mint on charcoal \u2014 sunset gradient"
-  },
-  {
-    id: "sonokai",
-    name: "Sonokai",
-    description: "Monokai Pro descendant \u2014 punchy on warm graphite"
-  },
-  {
-    id: "edge-dark",
-    name: "Edge Dark",
-    description: "Clean, evenly-weighted palette on desaturated navy"
-  },
-  {
-    id: "moonfly",
-    name: "Moonfly",
-    description: "Near-black base with high-chroma accents \u2014 maximum contrast"
-  },
-  {
-    id: "melange",
-    name: "Melange",
-    description: "Warm sepia and clay \u2014 the least blue dark theme here"
-  },
-  {
-    id: "poimandres",
-    name: "Poimandres",
-    description: "Teal-forward, low-saturation \u2014 mint on deep indigo"
-  },
-  {
-    id: "vitesse-dark",
-    name: "Vitesse Dark",
-    description: "Anthony Fu's minimal palette \u2014 muted, print-like"
-  },
-  {
-    id: "aura",
-    name: "Aura Dark",
-    description: "Vivid purple and spring green on near-black violet"
-  },
-  {
-    id: "dark-plus",
-    name: "VS Code Dark+",
-    description: "Visual Studio Code's default \u2014 familiar blue/orange/teal"
-  },
-  { id: "monochrome", name: "Monochrome", description: "Pure grayscale \u2014 no hue, only luminance" },
-  {
-    id: "matrix",
-    name: "Matrix Green",
-    description: "Phosphor green CRT terminal \u2014 digital rain aesthetic"
-  },
-  {
-    id: "amber",
-    name: "Amber CRT",
-    description: "Warm phosphor CRT terminal \u2014 glowing vintage amber"
-  },
-  {
-    id: "cyber-noir",
-    name: "Cyber Noir",
-    description: "Stark white and slate on jet black \u2014 minimalist high contrast"
-  },
-  {
-    id: "cobalt-mono",
-    name: "Cobalt Monochrome",
-    description: "Luminous cyan on deep abyss blue \u2014 oceanic blueprint"
-  },
-  {
-    id: "blood-moon",
-    name: "Blood Moon",
-    description: "Crimson & scarlet on obsidian \u2014 brooding dark mode"
-  },
-  {
-    id: "cobalt2",
-    name: "Cobalt2",
-    description: "Wes Bos' signature theme \u2014 deep navy with golden yellow & cyan"
-  },
-  {
-    id: "shades-of-purple",
-    name: "Shades of Purple",
-    description: "Ahmad Awais' bold purple palette with neon yellow & magenta"
-  },
-  {
-    id: "flexoki-dark",
-    name: "Flexoki Dark",
-    description: "Steph Ango's inky warm paper palette \u2014 natural earthy accents"
-  },
-  {
-    id: "laserwave",
-    name: "LaserWave",
-    description: "80s retrowave \u2014 neon flamingo and turquoise on violet"
-  },
-  {
-    id: "andromeda",
-    name: "Andromeda",
-    description: "Deep interstellar dark with vibrant neon teal and pink"
-  },
-  {
-    id: "github-dark-dimmed",
-    name: "GitHub Dark Dimmed",
-    description: "GitHub's softer slate dark theme \u2014 gentle blues and pastels"
-  },
-  {
-    id: "snazzy",
-    name: "Hyper Snazzy",
-    description: "Sindre Sorhus' elegant saturated terminal palette"
-  },
-  {
-    id: "tokyo-night-moon",
-    name: "Tokyo Night Moon",
-    description: "Tokyo Night on balanced deep indigo \u2014 vibrant accents"
-  },
-  {
-    id: "gruvbox-dark-hard",
-    name: "Gruvbox Dark Hard",
-    description: "Maximum contrast Gruvbox on deep pitch charcoal"
-  },
-  {
-    id: "oceanic-next",
-    name: "Oceanic Next",
-    description: "Teal-and-slate classic \u2014 calm blue, warm coral"
-  },
-  {
-    id: "one-half-dark",
-    name: "One Half Dark",
-    description: "Atom's One Half \u2014 One Dark with cleaner contrast"
-  },
-  { id: "ayu-mirage", name: "Ayu Mirage", description: "Dusk-slate Ayu, between Dark and Light" },
-  { id: "seti", name: "Seti", description: "Long-running VS Code classic \u2014 charcoal, gold, cyan" },
-  { id: "paraiso-dark", name: "Paraiso Dark", description: "Base16 plum \u2014 warm, muted, low-glare" },
-  {
-    id: "darcula",
-    name: "Darcula",
-    description: "JetBrains' default dark \u2014 grey-green with amber"
-  },
-  {
-    id: "slack-dark",
-    name: "Slack Aubergine",
-    description: "Deep aubergine with sky blue and lime"
-  },
-  {
-    id: "vitesse-black",
-    name: "Vitesse Black",
-    description: "Vitesse on true black \u2014 least glare here"
-  },
-  {
-    id: "atom-dark",
-    name: "Atom Dark",
-    description: "The original Atom grey \u2014 neutral, low-chroma"
-  },
-  {
-    id: "github-dark-high-contrast",
-    name: "GitHub Dark High Contrast",
-    description: "Accessible GitHub \u2014 boosted text and borders"
-  },
-  {
-    id: "contrast-max",
-    name: "Maximum Contrast",
-    description: "Original \u2014 pure black, AAA-targeted text and borders"
-  },
-  {
-    id: "colorblind-safe",
-    name: "Colorblind Safe",
-    description: "Original \u2014 blue/orange coding, no red-vs-green reliance"
-  },
-  {
-    id: "sandstone",
-    name: "Sandstone",
-    description: "Original \u2014 warm stone neutrals with sage and clay"
-  },
-  {
-    id: "everforest-hard",
-    name: "Everforest Hard",
-    description: "Everforest on its deepest base \u2014 more depth, same greens"
-  }
-];
+import { THEME_PRESET_IDS, THEME_PRESET_META } from "@wrongstack/core/types";
+var THEME_OPTIONS = THEME_PRESET_IDS.map((id) => ({
+  id,
+  name: THEME_PRESET_META[id].name,
+  description: THEME_PRESET_META[id].description,
+  family: THEME_PRESET_META[id].family
+})).sort(
+  // Group by family, keeping canonical order WITHIN each family.
+  //
+  // `THEME_PRESET_IDS` is not family-ordered — the Catppuccin variants sit
+  // ~15 rows apart, and the three `misc-N` buckets scatter single palettes
+  // across the whole list. Sorting here (rather than in the picker) is what
+  // makes the grouping usable: the reducer, the Enter handler and the rendered
+  // window all index into THIS array, so reordering it in one place keeps
+  // `selected` meaning the same thing everywhere.
+  //
+  // `Array.prototype.sort` is stable, so sorting only on `family` preserves
+  // canonical order inside each group without a second comparison.
+  (a, b) => a.family.localeCompare(b.family)
+);
 
 // src/theme-presets/rose-pine.ts
 var rosePinePresets = {
@@ -35953,7 +36336,7 @@ var rosePinePresets = {
     user: "#f6c177",
     assistant: "#c4a7e7",
     tool: "#9ccfd8",
-    success: "#31748f",
+    success: "#3e8fb0",
     warn: "#f6c177",
     error: "#eb6f92",
     borderDefault: "#524f67",
@@ -37060,7 +37443,7 @@ var PANEL_IDS = Object.freeze([
   "connections"
   // Ctrl+N
 ]);
-var TOTAL_SETTINGS_FIELD_COUNT = PANEL_POSITION_FIELD_START + PANEL_IDS.length + 4;
+var TOTAL_SETTINGS_FIELD_COUNT = PANEL_POSITION_FIELD_START + PANEL_IDS.length + 5;
 var DEFAULT_PANEL_POSITIONS = Object.freeze({
   projectPicker: "bottom",
   fleet: "bottom",
@@ -42671,6 +43054,7 @@ import {
   formatQuotaResetIn,
   getAllProviderQuota,
   onProviderQuota,
+  quotaExhaustionInMs,
   quotaResetInMs,
   quotaWindowLabel,
   worstProviderQuotaWindow
@@ -42679,11 +43063,15 @@ function readWorst() {
   const worst = worstProviderQuotaWindow(getAllProviderQuota());
   if (!worst) return void 0;
   const resetIn = formatQuotaResetIn(quotaResetInMs(worst.window));
+  const exhaustsIn = formatQuotaResetIn(
+    quotaExhaustionInMs(worst.snapshot.providerId, worst.snapshot.meterId, worst.window)
+  );
   return {
     providerId: worst.snapshot.providerId,
     windowLabel: quotaWindowLabel(worst.window),
     usedPercent: worst.window.usedPercent,
     ...resetIn !== void 0 ? { resetIn } : {},
+    ...exhaustsIn !== void 0 ? { exhaustsIn } : {},
     reached: worst.snapshot.reachedWindowId === worst.window.id
   };
 }
@@ -43702,6 +44090,7 @@ function buildSafetyWorkEntries(p) {
         isNoColor
       );
       const reset = quota.resetIn ? ` ${glyphs.clock}${quota.resetIn}` : "";
+      const pace = quota.exhaustsIn ? ` \u2192100% ~${quota.exhaustsIn}` : "";
       return entry("quota", "quota", p, [
         /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(Text2, { color, children: [
           icon(STATUSLINE_ICONS.quota, isNoColor),
@@ -43709,7 +44098,8 @@ function buildSafetyWorkEntries(p) {
           " ",
           pct,
           "%",
-          reset
+          reset,
+          pace
         ] }),
         /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(Text2, { color, children: [
           icon(STATUSLINE_ICONS.quota, isNoColor),
@@ -44145,6 +44535,11 @@ function buildMinimumChips(p) {
       stateLabel
     ] }) : null,
     yolo && showChip("yolo") ? /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(Text2, { color: chipColor(theme.error, isNoColor), bold: true, children: isNoColor ? "YOLO" : `${STATUSLINE_ICONS.yolo} YOLO` }) : null,
+    // No effort suffix here: minimum mode is the DEFAULT statusline and its
+    // chips are single-level elements the fitter can only DROP, never degrade,
+    // so a qualifier on this chip could never shed — it would evict trailing
+    // chips at moderate widths instead. Same reason the minimum context chip
+    // omits its `[strategy]`, which the detailed full level does render.
     showChip("model") ? /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)(Text2, { color: chipColor(theme.monitor.agents, isNoColor), children: [
       provider ? `${provider}/` : "",
       model
@@ -44372,6 +44767,7 @@ var STATUSLINE_SIDE_INSET = 1;
 var StatusBar = (0, import_react51.memo)(function StatusBar2({
   model,
   provider,
+  effort,
   version,
   latestVersion,
   updateAvailable,
@@ -44510,14 +44906,19 @@ var StatusBar = (0, import_react51.memo)(function StatusBar2({
     stateLabel
   ] }) : null;
   const modelColor = isNoColor ? void 0 : theme.monitor.agents;
+  const effortSuffix = effort ? /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(Text2, { dimColor: !isNoColor, children: ` \xB7 ${effort}` }) : null;
   const modelStatusChip = showChip("model") ? /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(Text2, { color: modelColor, children: [
     provider ? /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(Text2, { dimColor: !isNoColor, children: [
       provider,
       "/"
     ] }) : null,
-    model
+    model,
+    effortSuffix
+  ] }) : null;
+  const modelShortChip = showChip("model") ? /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(Text2, { color: modelColor, children: [
+    model,
+    effortSuffix
   ] }) : null;
-  const modelShortChip = showChip("model") ? /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(Text2, { color: modelColor, children: model }) : null;
   const modelMicroChip = showChip("model") ? /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(Text2, { color: modelColor, children: truncateChip(model, 10) }) : null;
   const indexStatusChip = buildIndexStatusChip(indexState, showChip, isNoColor);
   const quota = useProviderQuota();
@@ -45907,7 +46308,7 @@ function TodosMonitor({ todos }) {
       setSelected((value) => Math.min(Math.max(0, ordered.length - 1), value + 1));
     }
   });
-  const renderRow4 = (t, idx) => {
+  const renderRow5 = (t, idx) => {
     const isSelected = window2.start + idx === selected;
     const marker = isSelected ? "\u203A " : "  ";
     const num = String(todos.indexOf(t) + 1).padStart(2);
@@ -46003,9 +46404,9 @@ function TodosMonitor({ todos }) {
             accent: theme.warn
           }
         ) : twoCols ? /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)(Box2, { flexDirection: "row", gap: 3, marginTop: 1, children: [
-          /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(Box2, { flexDirection: "column", width: colWidth, children: visible.slice(0, mid).map((t, i) => renderRow4(t, i)) }),
-          /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(Box2, { flexDirection: "column", width: colWidth, children: visible.slice(mid).map((t, i) => renderRow4(t, mid + i)) })
-        ] }) : /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(Box2, { flexDirection: "column", marginTop: 1, children: visible.map(renderRow4) })
+          /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(Box2, { flexDirection: "column", width: colWidth, children: visible.slice(0, mid).map((t, i) => renderRow5(t, i)) }),
+          /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(Box2, { flexDirection: "column", width: colWidth, children: visible.slice(mid).map((t, i) => renderRow5(t, mid + i)) })
+        ] }) : /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(Box2, { flexDirection: "column", marginTop: 1, children: visible.map(renderRow5) })
       ]
     }
   );
@@ -46439,6 +46840,7 @@ function AppStatusRegion({
       {
         provider: liveProvider,
         model: liveModel,
+        effort: getSettings ? state.settingsPicker.open ? state.settingsPicker.reasoningEffort : getSettings().reasoningEffort : void 0,
         version: appVersion,
         latestVersion,
         updateAvailable,
@@ -51072,1249 +51474,678 @@ function collectMultiFileDiffItems(toolName, output, _input) {
       diffText = trimmed;
     }
     if (!diffText?.trim()) return void 0;
-    const blocks = splitGitStyleDiff(diffText);
-    if (blocks.length === 0) {
-      const path13 = explicitFiles[0] ?? extractPatchHeaderPath(diffText);
-      return [{ path: path13, diff: diffText }];
-    }
-    return blocks.map((block, idx) => ({
-      path: explicitFiles[idx] ?? block.path,
-      diff: block.diff
-    }));
-  }
-  return void 0;
-}
-function extractUnifiedDiffText(text) {
-  const lines = text.split("\n");
-  const start = lines.findIndex(
-    (line) => (
-      // Real unified-diff `--- ` headers carry a file path, not a label like
-      // `--- SAGE: ...`; reject uppercase-label patterns that hook notices
-      // append to tool output after a blank-line separator.
-      line.startsWith("--- ") && !/^--- [A-Z]{2,}:/.test(line) || line.startsWith("diff --git") || line.startsWith("@@")
-    )
-  );
-  if (start === -1) return void 0;
-  let end = lines.length;
-  for (let i = start + 1; i < lines.length; i++) {
-    if (lines[i]?.length === 0) {
-      end = i;
-      break;
-    }
-  }
-  return lines.slice(start, end).join("\n");
-}
-function newFileDiffFromWriteInput(output, input) {
-  if (!input || typeof input !== "object") return void 0;
-  const obj = input;
-  const content = stringOf(obj["content"]);
-  if (content === void 0) return void 0;
-  const path13 = stringOf(output["path"]) ?? stringOf(obj["path"]) ?? "new file";
-  const lines = content === "" ? [] : content.replace(/\n$/, "").split("\n");
-  const header = [`+++ ${path13}`, `@@ -0,0 +1,${lines.length} @@`];
-  return [...header, ...lines.map((line) => `+${line}`)].join("\n");
-}
-function splitGitStyleDiff(diff2) {
-  const lines = diff2.split("\n");
-  const blocks = [];
-  let current = null;
-  const flush = () => {
-    if (!current) return;
-    const text = current.body.join("\n").trim();
-    if (text) blocks.push({ path: current.path, diff: text });
-    current = null;
-  };
-  for (const line of lines) {
-    if (line.startsWith("diff --git ")) {
-      flush();
-      current = { path: parseDiffGitPath(line), body: [line], hasGitHeader: true };
-      continue;
-    }
-    if (current) {
-      current.body.push(line);
-      if (!current.hasGitHeader && line.startsWith("--- a/") && current.body.length > 2) {
-        const carriedBody = current.body.slice(0, -1);
-        const carriedPath = current.path;
-        const text = carriedBody.join("\n").trim();
-        if (text) blocks.push({ path: carriedPath, diff: text });
-        current = {
-          path: line.slice("--- a/".length).trim(),
-          body: [line],
-          hasGitHeader: false
-        };
-      }
-    } else if (line.startsWith("--- a/")) {
-      current = { path: line.slice("--- a/".length).trim(), body: [line], hasGitHeader: false };
-    } else if (line.startsWith("+++ b/")) {
-      current = { body: [line], hasGitHeader: false };
-    }
-  }
-  flush();
-  if (blocks.length === 1 && !blocks[0].path) {
-    const path13 = extractPatchHeaderPath(blocks[0].diff);
-    if (path13) blocks[0] = { path: path13, diff: blocks[0].diff };
-  }
-  return blocks;
-}
-function parseDiffGitPath(line) {
-  const rest = line.slice("diff --git ".length).trim();
-  if (!rest) return void 0;
-  const sep = rest.lastIndexOf(" b/");
-  if (sep > 0 && sep > rest.length - sep - 3) {
-    return rest.slice(sep + 3);
-  }
-  const spaceIdx = rest.lastIndexOf(" ");
-  if (spaceIdx > 0) {
-    const rhs = rest.slice(spaceIdx + 1);
-    return rhs.startsWith("b/") ? rhs.slice(2) : rhs;
-  }
-  return void 0;
-}
-function extractPatchHeaderPath(diffText) {
-  for (const line of diffText.split("\n")) {
-    if (line.startsWith("+++ ")) {
-      const path13 = line.slice(4).trim();
-      const cleaned = path13.replace(/^b\//, "").split("	")[0].trim();
-      return cleaned || void 0;
-    }
-  }
-  return void 0;
-}
-
-// src/components/history/diff-model.ts
-var DIFF_MAX_LINES = 200;
-var MULTI_DIFF_MAX_FILES = 20;
-var MULTI_DIFF_MAX_ROWS = 400;
-var MULTI_DIFF_SUMMARY_THRESHOLD = 5;
-function summarizeMultiFileDiffs(items) {
-  let added = 0;
-  let removed = 0;
-  let hiddenAdded = 0;
-  let hiddenRemoved = 0;
-  let truncatedFiles = 0;
-  for (const item of items) {
-    added += item.preview.added;
-    removed += item.preview.removed;
-    hiddenAdded += item.preview.hiddenAdded;
-    hiddenRemoved += item.preview.hiddenRemoved;
-    if (item.preview.hidden > 0) truncatedFiles += 1;
-  }
-  const omitted = items.omitted;
-  if (omitted) {
-    added += omitted.added;
-    removed += omitted.removed;
-  }
-  return {
-    fileCount: items.length + (omitted?.fileCount ?? 0),
-    added,
-    removed,
-    hiddenAdded,
-    hiddenRemoved,
-    truncatedFiles,
-    omittedFiles: omitted?.fileCount ?? 0
-  };
-}
-function formatMultiDiffSummary(summary, threshold = MULTI_DIFF_SUMMARY_THRESHOLD) {
-  if (threshold === 0) return null;
-  const effectiveThreshold = threshold < 0 ? MULTI_DIFF_SUMMARY_THRESHOLD : threshold;
-  if (summary.fileCount < effectiveThreshold) return null;
-  const parts = [`${summary.fileCount} files`];
-  if (summary.added > 0) parts.push(`+${summary.added}`);
-  if (summary.removed > 0) parts.push(`-${summary.removed}`);
-  if (summary.hiddenAdded > 0 || summary.hiddenRemoved > 0) {
-    const hiddenParts = [];
-    if (summary.hiddenAdded > 0) hiddenParts.push(`+${summary.hiddenAdded}`);
-    if (summary.hiddenRemoved > 0) hiddenParts.push(`-${summary.hiddenRemoved}`);
-    parts.push(
-      `\u2026 ${hiddenParts.join(" ")} hidden across ${summary.truncatedFiles} file${summary.truncatedFiles === 1 ? "" : "s"}`
-    );
-  }
-  const omittedFiles = summary.omittedFiles ?? 0;
-  if (omittedFiles > 0) {
-    parts.push(`${omittedFiles} more file${omittedFiles === 1 ? "" : "s"} not rendered`);
-  }
-  return parts.join(" \xB7 ");
-}
-function formatDiffStats(added, removed) {
-  const parts = [];
-  if (added > 0) parts.push(`added ${added} line${added === 1 ? "" : "s"}`);
-  if (removed > 0) parts.push(`removed ${removed} line${removed === 1 ? "" : "s"}`);
-  if (parts.length === 0) return null;
-  const joined = parts.join(", ");
-  return joined.charAt(0).toUpperCase() + joined.slice(1);
-}
-function parseUnifiedDiff(diff2, maxLines) {
-  return parseUnifiedDiffPreview(diff2, maxLines);
-}
-function extractDiffPreview(toolName, output, input) {
-  if (!output) return void 0;
-  const text = output.trim();
-  if (!text) return void 0;
-  let diff2;
-  if (toolName === "edit" || toolName === "diff" || toolName === "write") {
-    const parsed = tryParseJson(text);
-    if (parsed && typeof parsed === "object") {
-      const obj = parsed;
-      diff2 = toolName === "write" && obj["created"] === true ? newFileDiffFromWriteInput(obj, input) ?? stringOf(obj["diff"]) : stringOf(obj["diff"]);
-    } else {
-      diff2 = extractUnifiedDiffText(text);
-    }
-  } else if (toolName === "patch") {
-    const parsed = tryParseJson(text);
-    if (parsed && typeof parsed === "object") {
-      diff2 = stringOf(parsed["diff"]) ?? stringOf(parsed["stdout"]);
-    } else if (text.includes("@@") || text.startsWith("---")) {
-      diff2 = text;
-    }
-  } else if (toolName === "replace") {
-    const parsed = tryParseJson(text);
-    if (parsed && typeof parsed === "object") {
-      diff2 = joinReplaceDiffs(parsed);
-    }
-  }
-  if (!diff2?.trim() || diff2.startsWith("(no-op")) return void 0;
-  const preview = parseUnifiedDiff(diff2, DIFF_MAX_LINES);
-  return preview.rows.length > 0 ? preview : void 0;
-}
-function extractMultiFileDiffs(toolName, output, input) {
-  if (!output) return void 0;
-  const items = collectMultiFileDiffItems(toolName, output, input);
-  if (items === void 0) return void 0;
-  if (items.length === 0) return void 0;
-  const previews = [];
-  const candidateItems = items.slice(0, MULTI_DIFF_MAX_FILES);
-  let remainingRows = MULTI_DIFF_MAX_ROWS;
-  let visited = 0;
-  for (const item of candidateItems) {
-    if (remainingRows <= 0) break;
-    visited++;
-    const preview = parseUnifiedDiff(item.diff, Math.min(DIFF_MAX_LINES, remainingRows));
-    if (preview.rows.length === 0) continue;
-    previews.push({ path: item.path ?? "unknown file", preview });
-    remainingRows -= preview.rows.length;
-  }
-  const omittedItems = items.slice(visited);
-  if (omittedItems.length > 0) {
-    let added = 0;
-    let removed = 0;
-    for (const item of omittedItems) {
-      const summary = countUnifiedDiffChanges(item.diff);
-      added += summary.added;
-      removed += summary.removed;
-    }
-    previews.omitted = { fileCount: omittedItems.length, added, removed };
-  }
-  return previews.length > 0 ? previews : void 0;
-}
-
-// src/components/history/code-block.tsx
-var import_jsx_runtime49 = __toESM(require_jsx_runtime(), 1);
-var MAX_CODE_LINES = 80;
-var DIFF_FALLBACK_WRAP_WIDTH = 100;
-var HARD_TAB_WIDTH = 8;
-function expandTabs(text, tabWidth = HARD_TAB_WIDTH) {
-  if (!text.includes("	")) return text;
-  let out = "";
-  let col = 0;
-  for (const ch of text) {
-    if (ch === "	") {
-      const advance = tabWidth - col % tabWidth;
-      out += " ".repeat(advance);
-      col += advance;
-    } else {
-      out += ch;
-      col += 1;
-    }
-  }
-  return out;
-}
-function CodeBlockImpl({
-  code,
-  lang,
-  contentWidth
-}) {
-  useActiveTheme();
-  let lines = sanitizeTerminalText(code, HARD_TAB_WIDTH).replace(/\n+$/, "").split("\n");
-  const hidden = Math.max(0, lines.length - MAX_CODE_LINES);
-  if (hidden > 0) lines = lines.slice(0, MAX_CODE_LINES);
-  const gutterW = String(lines.length).length;
-  const maxW = Math.max(1, Math.min(contentWidth - 4 - gutterW - 1, 120));
-  let carry = {};
-  const rows = lines.map((raw) => {
-    const expanded = expandTabs(raw);
-    const display = truncateDisplay(expanded, maxW);
-    const r = highlightLine(display, lang, carry);
-    carry = r.carry;
-    return r.tokens;
-  });
-  return /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(HistoryRail, { color: theme.borderDefault, children: [
-    lang !== "plain" ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: lang }) : null,
-    rows.map((tokens, i) => /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Text2, { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: `${String(i + 1).padStart(gutterW, " ")} ` }),
-      tokens.length === 0 ? " " : tokens.map((t, j) => /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(
-        Text2,
-        {
-          dimColor: Boolean(t.dim),
-          bold: Boolean(t.bold),
-          ...t.color ? { color: t.color } : {},
-          children: t.text
-        },
-        j
-      ))
-    ] }, i)),
-    hidden > 0 ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, italic: true, children: `\u2026 +${hidden} more line${hidden === 1 ? "" : "s"}` }) : null
-  ] });
-}
-function DiffFileBlock({
-  path: path13,
-  preview,
-  useColor = true,
-  contentWidth
-}) {
-  return /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Box2, { flexDirection: "column", marginTop: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Box2, { flexDirection: "row", marginBottom: 0, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { bold: true, color: theme.accent, children: `\u25B8 ${path13}` }),
-      preview.added > 0 || preview.removed > 0 ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: `  (${preview.added > 0 ? `+${preview.added}` : ""}${preview.added > 0 && preview.removed > 0 ? " " : ""}${preview.removed > 0 ? `-${preview.removed}` : ""})` }) : null
-    ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(
-      DiffBlock,
-      {
-        rows: preview.rows,
-        hidden: preview.hidden,
-        added: preview.added,
-        removed: preview.removed,
-        hiddenAdded: preview.hiddenAdded,
-        hiddenRemoved: preview.hiddenRemoved,
-        useColor,
-        lang: langFromPath(path13),
-        showStats: false,
-        contentWidth
-      }
-    )
-  ] });
-}
-function applyWashTokens(tokens, onWash) {
-  if (!onWash) return tokens;
-  return tokens.map((t) => {
-    if (t.color !== "syntax.comment") return t;
-    return { ...t, color: "syntax.commentOnWash", dim: false };
-  });
-}
-function renderTokens(tokens, onWash = false) {
-  const effective = applyWashTokens(tokens, onWash);
-  if (effective.length === 0) return " ";
-  return effective.map((t, j) => /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(
-    Text2,
-    {
-      dimColor: Boolean(t.dim),
-      bold: Boolean(t.bold),
-      ...t.color ? { color: t.color } : {},
-      children: t.text
-    },
-    j
-  ));
-}
-function wrapTokens(tokens, width) {
-  if (width <= 0) return [tokens];
-  const segments = [];
-  let current = [];
-  let currentWidth = 0;
-  for (const t of tokens) {
-    let text = t.text;
-    while (text.length > 0) {
-      const room = width - currentWidth;
-      if (room <= 0) {
-        segments.push(current);
-        current = [];
-        currentWidth = 0;
-        continue;
-      }
-      const [piece, rest] = splitDisplay(text, room);
-      if (!piece) {
-        segments.push(current);
-        current = [];
-        currentWidth = 0;
-        continue;
-      }
-      current.push({ ...t, text: piece });
-      currentWidth += displayWidth(piece);
-      text = rest;
-    }
-  }
-  if (current.length > 0 || segments.length === 0) segments.push(current);
-  return segments;
-}
-function DiffBlock({
-  rows,
-  hidden,
-  added = 0,
-  removed = 0,
-  hiddenAdded = 0,
-  hiddenRemoved = 0,
-  useColor = true,
-  lang = "plain",
-  showStats = true,
-  contentWidth
-}) {
-  const lineNoOf = (row) => row.kind === "del" ? row.oldLine : row.newLine ?? row.oldLine;
-  let gutterWidth = 1;
-  for (const r of rows) {
-    const n = lineNoOf(r);
-    if (typeof n === "number" && String(n).length > gutterWidth) gutterWidth = String(n).length;
-  }
-  const blank = " ".repeat(gutterWidth);
-  const markerFor = (kind) => {
-    if (kind === "add") return "+";
-    if (kind === "del") return "-";
-    return " ";
-  };
-  const textForDisplay = (row) => {
-    if ((row.kind === "add" || row.kind === "del" || row.kind === "ctx") && row.text.length > 0) {
-      return sanitizeTerminalText(expandTabs(row.text.slice(1)), HARD_TAB_WIDTH) || " ";
-    }
-    return sanitizeTerminalText(expandTabs(row.text), HARD_TAB_WIDTH) || " ";
-  };
-  const stats = showStats ? formatDiffStats(added, removed) : null;
-  const terminalWrapGuard = typeof contentWidth === "number" ? 1 : 0;
-  const bodyBudget = typeof contentWidth === "number" ? Math.max(1, contentWidth - (2 + 3 + gutterWidth + 3 + terminalWrapGuard)) : DIFF_FALLBACK_WRAP_WIDTH;
-  const hasWidth = typeof contentWidth === "number";
-  const padBody = (seg) => {
-    if (!hasWidth) return 0;
-    const len = seg.reduce((n, t) => n + displayWidth(t.text), 0);
-    return Math.max(0, bodyBudget - len);
-  };
-  const contPrefix = `   ${blank}   `;
-  const hiddenStats = [];
-  if (hiddenAdded > 0) hiddenStats.push(`+${hiddenAdded}`);
-  if (hiddenRemoved > 0) hiddenStats.push(`-${hiddenRemoved}`);
-  return /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Box2, { flexDirection: "column", marginLeft: 2, marginTop: 0, children: [
-    stats ? /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Text2, { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: "\u23BF  " }),
-      /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { children: stats })
-    ] }) : null,
-    rows.map((row, i) => {
-      const key2 = i;
-      if (row.kind === "hunk") {
-        if (i === 0) return null;
-        return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: `   ${blank} \u22EF` }, key2);
-      }
-      if (row.kind === "meta") {
-        return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: `   ${blank}   ${sanitizeTerminalText(row.text)}` }, key2);
-      }
-      const n = lineNoOf(row);
-      const ln = typeof n === "number" ? String(n).padStart(gutterWidth, " ") : blank;
-      const body = textForDisplay(row);
-      const tokens = highlightLine(body, lang).tokens;
-      const segments = wrapTokens(tokens, bodyBudget);
-      if (row.kind === "ctx") {
-        return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Box2, { flexDirection: "column", children: segments.map((seg, si) => /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Text2, { children: [
-          /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: si === 0 ? `   ${ln}   ` : contPrefix }),
-          renderTokens(seg)
-        ] }, si)) }, key2);
-      }
-      const marker = markerFor(row.kind);
-      const markerColor = row.kind === "add" ? theme.success : theme.error;
-      if (useColor) {
-        const bg = row.kind === "add" ? theme.diffAddBg : theme.diffDelBg;
-        return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Box2, { flexDirection: "column", children: segments.map((seg, si) => {
-          const pad = padBody(seg);
-          return /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Text2, { backgroundColor: bg, children: [
-            si === 0 ? /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(import_jsx_runtime49.Fragment, { children: [
-              /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: `   ${ln} ` }),
-              /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { color: markerColor, bold: true, children: marker }),
-              /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { children: " " })
-            ] }) : /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: contPrefix }),
-            renderTokens(seg, true),
-            pad > 0 ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { children: " ".repeat(pad) }) : null
-          ] }, si);
-        }) }, key2);
-      }
-      return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Box2, { flexDirection: "column", children: segments.map((seg, si) => /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Text2, { children: [
-        si === 0 ? /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(import_jsx_runtime49.Fragment, { children: [
-          /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: `   ${ln} ` }),
-          /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { color: markerColor, bold: true, children: marker }),
-          /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { children: " " })
-        ] }) : /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: contPrefix }),
-        renderTokens(seg)
-      ] }, si)) }, key2);
-    }),
-    hidden > 0 ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, italic: true, children: `   ${blank}  \u2026 ${hidden} more line${hidden === 1 ? "" : "s"}${hiddenStats.length > 0 ? ` (${hiddenStats.join(" ")} hidden)` : ""}` }) : null
-  ] });
-}
-var CodeBlock = (0, import_react62.memo)(CodeBlockImpl);
-
-// src/components/confirm-prompt.tsx
-var import_jsx_runtime50 = __toESM(require_jsx_runtime(), 1);
-var BUTTON_COLOR = {
-  yes: "green",
-  no: "red",
-  always: "cyan",
-  "always-exact": "cyan",
-  "always-command": "cyan",
-  "always-tool": "yellow",
-  deny: "red"
-};
-function buttonLabels(_suggestedPattern, toolName = "exec") {
-  return [
-    { decision: "yes", bracket: "[y]", rest: "es " },
-    { decision: "no", bracket: "[n]", rest: "o " },
-    { decision: "always-exact", bracket: "[a]", rest: " same args " },
-    ...toolName === "exec" ? [{ decision: "always-command", bracket: "[c]", rest: " command " }] : [],
-    { decision: "always-tool", bracket: "[t]", rest: " tool " },
-    { decision: "deny", bracket: "[d]", rest: "eny" }
-  ];
-}
-function stringifyInput(input) {
-  if (!input || typeof input !== "object") return "";
-  const obj = input;
-  return Object.entries(obj).filter(([k]) => k !== "content" && k !== "new_string" && k !== "diff").map(([k, v]) => `${k}: ${truncate(JSON.stringify(v), 80)}`).join("  ");
+    const blocks = splitGitStyleDiff(diffText);
+    if (blocks.length === 0) {
+      const path13 = explicitFiles[0] ?? extractPatchHeaderPath(diffText);
+      return [{ path: path13, diff: diffText }];
+    }
+    return blocks.map((block, idx) => ({
+      path: explicitFiles[idx] ?? block.path,
+      diff: block.diff
+    }));
+  }
+  return void 0;
 }
-function truncate(s2, max) {
-  return s2.length <= max ? s2 : `${s2.slice(0, max - 1)}\u2026`;
+function extractUnifiedDiffText(text) {
+  const lines = text.split("\n");
+  const start = lines.findIndex(
+    (line) => (
+      // Real unified-diff `--- ` headers carry a file path, not a label like
+      // `--- SAGE: ...`; reject uppercase-label patterns that hook notices
+      // append to tool output after a blank-line separator.
+      line.startsWith("--- ") && !/^--- [A-Z]{2,}:/.test(line) || line.startsWith("diff --git") || line.startsWith("@@")
+    )
+  );
+  if (start === -1) return void 0;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (lines[i]?.length === 0) {
+      end = i;
+      break;
+    }
+  }
+  return lines.slice(start, end).join("\n");
 }
-function payloadDiff(input) {
-  if (!input || typeof input !== "object") return "";
+function newFileDiffFromWriteInput(output, input) {
+  if (!input || typeof input !== "object") return void 0;
   const obj = input;
-  const filePath = typeof obj["path"] === "string" ? obj["path"] : "file";
-  if (typeof obj["diff"] === "string" && obj["diff"]) return obj["diff"];
-  const newString = obj["new_string"];
-  if (typeof newString === "string") {
-    const oldString = typeof obj["old_string"] === "string" ? obj["old_string"] : "";
-    return unifiedDiff(oldString, newString, { fromFile: filePath, toFile: filePath, context: 2 });
+  const content = stringOf(obj["content"]);
+  if (content === void 0) return void 0;
+  const path13 = stringOf(output["path"]) ?? stringOf(obj["path"]) ?? "new file";
+  const lines = content === "" ? [] : content.replace(/\n$/, "").split("\n");
+  const header = [`+++ ${path13}`, `@@ -0,0 +1,${lines.length} @@`];
+  return [...header, ...lines.map((line) => `+${line}`)].join("\n");
+}
+function splitGitStyleDiff(diff2) {
+  const lines = diff2.split("\n");
+  const blocks = [];
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    const text = current.body.join("\n").trim();
+    if (text) blocks.push({ path: current.path, diff: text });
+    current = null;
+  };
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      flush();
+      current = { path: parseDiffGitPath(line), body: [line], hasGitHeader: true };
+      continue;
+    }
+    if (current) {
+      current.body.push(line);
+      if (!current.hasGitHeader && line.startsWith("--- a/") && current.body.length > 2) {
+        const carriedBody = current.body.slice(0, -1);
+        const carriedPath = current.path;
+        const text = carriedBody.join("\n").trim();
+        if (text) blocks.push({ path: carriedPath, diff: text });
+        current = {
+          path: line.slice("--- a/".length).trim(),
+          body: [line],
+          hasGitHeader: false
+        };
+      }
+    } else if (line.startsWith("--- a/")) {
+      current = { path: line.slice("--- a/".length).trim(), body: [line], hasGitHeader: false };
+    } else if (line.startsWith("+++ b/")) {
+      current = { body: [line], hasGitHeader: false };
+    }
   }
-  const content = obj["content"];
-  if (typeof content === "string" && content) {
-    return unifiedDiff("", content, { fromFile: "/dev/null", toFile: filePath, context: 0 });
+  flush();
+  if (blocks.length === 1 && !blocks[0].path) {
+    const path13 = extractPatchHeaderPath(blocks[0].diff);
+    if (path13) blocks[0] = { path: path13, diff: blocks[0].diff };
   }
-  return "";
-}
-var CONFIRM_DIFF_MAX_LINES = 20;
-function renderDiffLine(line) {
-  const prefix = line.startsWith("+") ? "green" : line.startsWith("-") ? "red" : line.startsWith("@@") ? "cyan" : void 0;
-  return /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(Text2, { ...prefix ? { color: prefix } : {}, children: [
-    line,
-    "\n"
-  ] }, line);
+  return blocks;
 }
-function renderDiff(diff2, path13) {
-  const preview = parseUnifiedDiff(diff2, CONFIRM_DIFF_MAX_LINES);
-  if (preview.rows.length > 0) {
-    return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(
-      DiffBlock,
-      {
-        rows: preview.rows,
-        hidden: preview.hidden,
-        added: preview.added,
-        removed: preview.removed,
-        hiddenAdded: preview.hiddenAdded,
-        hiddenRemoved: preview.hiddenRemoved,
-        useColor: theme.supportsBackground,
-        lang: langFromPath(path13 ?? "")
-      }
-    );
+function parseDiffGitPath(line) {
+  const rest = line.slice("diff --git ".length).trim();
+  if (!rest) return void 0;
+  const sep = rest.lastIndexOf(" b/");
+  if (sep > 0 && sep > rest.length - sep - 3) {
+    return rest.slice(sep + 3);
   }
-  const lines = diff2.split("\n").filter((l) => l.length > 0).slice(0, CONFIRM_DIFF_MAX_LINES);
-  return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Box2, { flexDirection: "column", paddingX: 2, children: lines.map((l) => renderDiffLine(l)) });
+  const spaceIdx = rest.lastIndexOf(" ");
+  if (spaceIdx > 0) {
+    const rhs = rest.slice(spaceIdx + 1);
+    return rhs.startsWith("b/") ? rhs.slice(2) : rhs;
+  }
+  return void 0;
 }
-function ConfirmPrompt({
-  toolName,
-  input,
-  suggestedPattern,
-  onDecision,
-  onEnableYolo,
-  destructive,
-  boundaryReason,
-  writeTargets,
-  maxRows
-}) {
-  const size = useTerminalSize();
-  const rowBudget = maxRows ?? size.rows;
-  const buttons = import_react63.default.useRef(/* @__PURE__ */ new Map());
-  const partialMouse = import_react63.default.useRef("");
-  const decided = import_react63.default.useRef(false);
-  const decide = (decision) => {
-    if (decided.current) return;
-    decided.current = true;
-    onDecision(decision);
-  };
-  const { stdin } = use_stdin_default();
-  import_react63.default.useEffect(() => {
-    if (!stdin) return;
-    const onData = (data) => {
-      const chunk = splitTrailingMousePartial(partialMouse.current + data.toString());
-      partialMouse.current = chunk.pending;
-      for (const event of parseMouseEvents(chunk.consumed)) {
-        if (event.kind !== "press" || event.button !== "left") continue;
-        for (const [decision, node] of buttons.current) {
-          const rect = measure_element_default(node);
-          if (event.x > rect.x && event.x <= rect.x + rect.width && event.y > rect.y && event.y <= rect.y + rect.height) {
-            decide(decision);
-            break;
-          }
-        }
-      }
-    };
-    stdin.on("data", onData);
-    return () => {
-      stdin.off("data", onData);
-    };
-  }, [stdin, decide]);
-  import_react63.default.useEffect(() => {
-    writeOut("\x07");
-  }, []);
-  use_input_default((input2, key2) => {
-    if (key2.ctrl || key2.meta || decided.current) return;
-    if (!input2 || input2 === "\r" || input2 === "\n") return;
-    if (input2 === "Y" && !boundaryReason) {
-      onEnableYolo();
-      return;
-    }
-    const ch = input2.toLowerCase();
-    if (ch === "y") {
-      decide("yes");
-    } else if (ch === "n") {
-      decide("no");
-    } else if (ch === "a") {
-      decide("always-exact");
-    } else if (ch === "c" && toolName === "exec") {
-      decide("always-command");
-    } else if (ch === "t") {
-      decide("always-tool");
-    } else if (ch === "d") {
-      decide("deny");
-    }
-  });
-  const inputSummary = stringifyInput(input);
-  const inp = input;
-  const diff2 = payloadDiff(input);
-  const diffPath = typeof inp?.path === "string" ? inp.path : void 0;
-  return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(PanelInputProvider, { value: true, children: /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(MonitorViewportProvider, { value: { columns: size.columns, rows: rowBudget }, children: /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(
-    MonitorShell,
-    {
-      accent: "yellow",
-      icon: "\u26A0",
-      title: `APPROVAL REQUIRED \xB7 ${toolName}`,
-      footer: /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Box2, { flexDirection: "row", flexWrap: "wrap", children: buttonLabels(suggestedPattern, toolName).map((label) => /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(
-        Box2,
-        {
-          flexShrink: 0,
-          ref: (node) => {
-            if (node) buttons.current.set(label.decision, node);
-            else buttons.current.delete(label.decision);
-          },
-          children: /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(Text2, { children: [
-            /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Text2, { bold: true, color: BUTTON_COLOR[label.decision], children: label.bracket }),
-            /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Text2, { dimColor: true, children: label.rest })
-          ] })
-        },
-        label.decision
-      )) }),
-      children: [
-        inputSummary ? /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Text2, { dimColor: true, children: inputSummary }) : null,
-        boundaryReason ? /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(Text2, { color: "yellow", children: [
-          "KANBAN BOUNDARY: ",
-          boundaryReason
-        ] }) : null,
-        writeTargets && writeTargets.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(Text2, { color: "yellow", children: [
-          "WRITES: ",
-          writeTargets.slice(0, 5).join(", "),
-          writeTargets.length > 5 ? ` (+${writeTargets.length - 5} more)` : ""
-        ] }) : null,
-        diff2 ? /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Box2, { flexDirection: "column", marginY: 1, children: renderDiff(diff2, diffPath) }) : null,
-        /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(Text2, { dimColor: true, children: [
-          "Remember: [a] this input; ",
-          toolName === "exec" ? "[c] executable, any args; " : "",
-          "[t] tool, any input. Destructive calls still prompt."
-        ] }),
-        !boundaryReason ? /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Box2, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(Text2, { dimColor: true, children: [
-          " ",
-          "Tip: press",
-          " ",
-          /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Text2, { bold: true, color: "yellow", children: "Y" }),
-          " ",
-          "to enable YOLO mode",
-          destructive ? " (this destructive approval remains)" : " (skips future routine approvals)",
-          "."
-        ] }) }) : null
-      ]
+function extractPatchHeaderPath(diffText) {
+  for (const line of diffText.split("\n")) {
+    if (line.startsWith("+++ ")) {
+      const path13 = line.slice(4).trim();
+      const cleaned = path13.replace(/^b\//, "").split("	")[0].trim();
+      return cleaned || void 0;
     }
-  ) }) });
+  }
+  return void 0;
 }
 
-// src/components/connections-panel.tsx
-var import_react64 = __toESM(require_react(), 1);
-
-// src/connection-actions.ts
-import * as net from "node:net";
-import {
-  ChronicleProjectServerClient,
-  createChronicleProjectAccess,
-  resolveChronicleProjectServerOptions
-} from "@wrongstack/core/chronicle";
-import {
-  isMailboxProjectServerAvailable,
-  MailboxProjectServerConnection
-} from "@wrongstack/core/coordination";
-import { SessionCatalogProjectClient } from "@wrongstack/core/session-catalog";
-import { resolveWstackPaths as resolveWstackPaths2, toErrorMessage } from "@wrongstack/core/utils";
-import {
-  closeKanbanServerConnections,
-  getKanbanServerConnection,
-  isKanbanServerAvailable
-} from "@wrongstack/kanban";
-import { isSageProjectServerAvailable, SageProjectServerConnection } from "@wrongstack/sage";
-import {
-  checkCodebaseIndexServerHealth,
-  ensureCodebaseIndexServer,
-  shutdownCodebaseIndexServer
-} from "@wrongstack/tools";
-var RESTARTABLE_SERVICES = [
-  "session-catalog",
-  "chronicle",
-  "codebase-index",
-  "sage",
-  "kanban",
-  "mailbox"
-];
-function isRestartableService(serviceId) {
-  return RESTARTABLE_SERVICES.includes(serviceId);
-}
-function isEndpointAlive(endpoint) {
-  return new Promise((resolve) => {
-    const sock = net.createConnection(endpoint);
-    const timer = setTimeout(() => {
-      sock.destroy();
-      resolve(false);
-    }, 500);
-    timer.unref?.();
-    sock.once("connect", () => {
-      clearTimeout(timer);
-      sock.destroy();
-      resolve(true);
-    });
-    sock.once("error", () => {
-      clearTimeout(timer);
-      sock.destroy();
-      resolve(false);
-    });
-  });
-}
-async function waitForShutdown(probe) {
-  const pollIntervalMs = 250;
-  if (!probe) {
-    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-    return;
+// src/components/history/diff-model.ts
+var DIFF_MAX_LINES = 200;
+var MULTI_DIFF_MAX_FILES = 20;
+var MULTI_DIFF_MAX_ROWS = 400;
+var MULTI_DIFF_SUMMARY_THRESHOLD = 5;
+function summarizeMultiFileDiffs(items) {
+  let added = 0;
+  let removed = 0;
+  let hiddenAdded = 0;
+  let hiddenRemoved = 0;
+  let truncatedFiles = 0;
+  for (const item of items) {
+    added += item.preview.added;
+    removed += item.preview.removed;
+    hiddenAdded += item.preview.hiddenAdded;
+    hiddenRemoved += item.preview.hiddenRemoved;
+    if (item.preview.hidden > 0) truncatedFiles += 1;
   }
-  const deadline = Date.now() + 3e3;
-  while (Date.now() < deadline) {
-    try {
-      const stillUp = await probe();
-      if (!stillUp) return;
-    } catch {
-      return;
-    }
-    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  const omitted = items.omitted;
+  if (omitted) {
+    added += omitted.added;
+    removed += omitted.removed;
   }
+  return {
+    fileCount: items.length + (omitted?.fileCount ?? 0),
+    added,
+    removed,
+    hiddenAdded,
+    hiddenRemoved,
+    truncatedFiles,
+    omittedFiles: omitted?.fileCount ?? 0
+  };
 }
-async function executeConnectionAction(serviceId, action, projectRoot, indexDir) {
-  switch (serviceId) {
-    case "session-catalog":
-      return killSessionCatalogServer(projectRoot, action);
-    case "kanban":
-      return killKanbanServer(projectRoot, action);
-    case "sage":
-      return killSageServer(projectRoot, action);
-    case "chronicle":
-      return killChronicleServer(projectRoot, action);
-    case "codebase-index":
-      return killCodebaseIndexServer(projectRoot, indexDir, action);
-    case "mailbox":
-      return killMailboxServer(projectRoot, action);
-    case "governance":
-      return {
-        serviceId: "governance",
-        action,
-        success: false,
-        message: "Governance control plane is read-only; daemon restart is not supported."
-      };
-    default:
-      return {
-        serviceId,
-        action,
-        success: false,
-        message: `Unknown service: ${serviceId}`
-      };
+function formatMultiDiffSummary(summary, threshold = MULTI_DIFF_SUMMARY_THRESHOLD) {
+  if (threshold === 0) return null;
+  const effectiveThreshold = threshold < 0 ? MULTI_DIFF_SUMMARY_THRESHOLD : threshold;
+  if (summary.fileCount < effectiveThreshold) return null;
+  const parts = [`${summary.fileCount} files`];
+  if (summary.added > 0) parts.push(`+${summary.added}`);
+  if (summary.removed > 0) parts.push(`-${summary.removed}`);
+  if (summary.hiddenAdded > 0 || summary.hiddenRemoved > 0) {
+    const hiddenParts = [];
+    if (summary.hiddenAdded > 0) hiddenParts.push(`+${summary.hiddenAdded}`);
+    if (summary.hiddenRemoved > 0) hiddenParts.push(`-${summary.hiddenRemoved}`);
+    parts.push(
+      `\u2026 ${hiddenParts.join(" ")} hidden across ${summary.truncatedFiles} file${summary.truncatedFiles === 1 ? "" : "s"}`
+    );
   }
-}
-async function killSessionCatalogServer(projectRoot, action) {
-  const paths = resolveWstackPaths2({ projectRoot });
-  const client = new SessionCatalogProjectClient({
-    projectDir: paths.projectDir,
-    projectRoot
-  });
-  try {
-    const previousPid = action === "restart" ? await client.callExisting("ping", {}, { timeoutMs: 1e3 }).then(
-      (health2) => health2.pid,
-      () => void 0
-    ) : void 0;
-    const result = await client.shutdown(`TUI request: ${action}`);
-    if (!result.stopped && action === "shutdown") {
-      return {
-        serviceId: "session-catalog",
-        action,
-        success: false,
-        message: "Session Catalog IPC daemon is not running"
-      };
-    }
-    if (action === "restart") return await restartSessionCatalogServer(projectRoot, previousPid);
-    return {
-      serviceId: "session-catalog",
-      action,
-      success: true,
-      message: "Session Catalog IPC daemon shutdown requested"
-    };
-  } catch (error) {
-    return {
-      serviceId: "session-catalog",
-      action,
-      success: false,
-      message: toErrorMessage(error)
-    };
-  } finally {
-    await client.close().catch(() => void 0);
+  const omittedFiles = summary.omittedFiles ?? 0;
+  if (omittedFiles > 0) {
+    parts.push(`${omittedFiles} more file${omittedFiles === 1 ? "" : "s"} not rendered`);
   }
+  return parts.join(" \xB7 ");
 }
-async function restartSessionCatalogServer(projectRoot, previousPid) {
-  const paths = resolveWstackPaths2({ projectRoot });
-  const probe = () => {
-    const client = new SessionCatalogProjectClient({
-      projectDir: paths.projectDir,
-      projectRoot
-    });
-    return client.callExisting("ping", {}, { timeoutMs: 1e3 }).then(
-      () => true,
-      () => false
-    ).finally(() => client.close().catch(() => void 0));
-  };
-  await waitForShutdown(probe);
-  const verify = new SessionCatalogProjectClient({
-    projectDir: paths.projectDir,
-    projectRoot
-  });
-  try {
-    const health2 = await verify.ping();
-    if (previousPid !== void 0 && health2.pid === previousPid) {
-      return {
-        serviceId: "session-catalog",
-        action: "restart",
-        success: false,
-        message: `Session Catalog IPC daemon did not restart (owner PID is still ${previousPid})`
-      };
+function formatDiffStats(added, removed) {
+  const parts = [];
+  if (added > 0) parts.push(`added ${added} line${added === 1 ? "" : "s"}`);
+  if (removed > 0) parts.push(`removed ${removed} line${removed === 1 ? "" : "s"}`);
+  if (parts.length === 0) return null;
+  const joined = parts.join(", ");
+  return joined.charAt(0).toUpperCase() + joined.slice(1);
+}
+function parseUnifiedDiff(diff2, maxLines) {
+  return parseUnifiedDiffPreview(diff2, maxLines);
+}
+function extractDiffPreview(toolName, output, input) {
+  if (!output) return void 0;
+  const text = output.trim();
+  if (!text) return void 0;
+  let diff2;
+  if (toolName === "edit" || toolName === "diff" || toolName === "write") {
+    const parsed = tryParseJson(text);
+    if (parsed && typeof parsed === "object") {
+      const obj = parsed;
+      diff2 = toolName === "write" && obj["created"] === true ? newFileDiffFromWriteInput(obj, input) ?? stringOf(obj["diff"]) : stringOf(obj["diff"]);
+    } else {
+      diff2 = extractUnifiedDiffText(text);
+    }
+  } else if (toolName === "patch") {
+    const parsed = tryParseJson(text);
+    if (parsed && typeof parsed === "object") {
+      diff2 = stringOf(parsed["diff"]) ?? stringOf(parsed["stdout"]);
+    } else if (text.includes("@@") || text.startsWith("---")) {
+      diff2 = text;
+    }
+  } else if (toolName === "replace") {
+    const parsed = tryParseJson(text);
+    if (parsed && typeof parsed === "object") {
+      diff2 = joinReplaceDiffs(parsed);
     }
-    return {
-      serviceId: "session-catalog",
-      action: "restart",
-      success: true,
-      message: "Session Catalog IPC daemon restarted successfully"
-    };
-  } catch (error) {
-    return {
-      serviceId: "session-catalog",
-      action: "restart",
-      success: false,
-      message: `Session Catalog IPC daemon restarted but verification failed: ${toErrorMessage(error)}`
-    };
-  } finally {
-    await verify.close().catch(() => void 0);
   }
+  if (!diff2?.trim() || diff2.startsWith("(no-op")) return void 0;
+  const preview = parseUnifiedDiff(diff2, DIFF_MAX_LINES);
+  return preview.rows.length > 0 ? preview : void 0;
 }
-async function killKanbanServer(projectRoot, action) {
-  if (process.env["WRONGSTACK_KANBAN_SERVER"] === "0") {
-    return {
-      serviceId: "kanban",
-      action,
-      success: false,
-      message: "Kanban IPC daemon is disabled via WRONGSTACK_KANBAN_SERVER=0"
-    };
-  }
-  let connection;
-  try {
-    connection = await getKanbanServerConnection(projectRoot);
-  } catch (error) {
-    return {
-      serviceId: "kanban",
-      action,
-      success: false,
-      message: toErrorMessage(error)
-    };
-  }
-  if (!connection) {
-    return {
-      serviceId: "kanban",
-      action,
-      success: false,
-      message: "Kanban IPC daemon is not running"
-    };
+function extractMultiFileDiffs(toolName, output, input) {
+  if (!output) return void 0;
+  const items = collectMultiFileDiffItems(toolName, output, input);
+  if (items === void 0) return void 0;
+  if (items.length === 0) return void 0;
+  const previews = [];
+  const candidateItems = items.slice(0, MULTI_DIFF_MAX_FILES);
+  let remainingRows = MULTI_DIFF_MAX_ROWS;
+  let visited = 0;
+  for (const item of candidateItems) {
+    if (remainingRows <= 0) break;
+    visited++;
+    const preview = parseUnifiedDiff(item.diff, Math.min(DIFF_MAX_LINES, remainingRows));
+    if (preview.rows.length === 0) continue;
+    previews.push({ path: item.path ?? "unknown file", preview });
+    remainingRows -= preview.rows.length;
   }
-  try {
-    const result = await connection.request("shutdown", {
-      reason: `TUI request: ${action}`
-    });
-    if (!result.stopping) {
-      return {
-        serviceId: "kanban",
-        action,
-        success: false,
-        message: "Kanban IPC daemon shutdown failed (not confirmed)"
-      };
-    }
-    if (action === "restart") {
-      closeKanbanServerConnections();
-      return await restartKanbanServer(projectRoot);
+  const omittedItems = items.slice(visited);
+  if (omittedItems.length > 0) {
+    let added = 0;
+    let removed = 0;
+    for (const item of omittedItems) {
+      const summary = countUnifiedDiffChanges(item.diff);
+      added += summary.added;
+      removed += summary.removed;
     }
-    return {
-      serviceId: "kanban",
-      action,
-      success: true,
-      message: "Kanban IPC daemon shutdown requested"
-    };
-  } catch (error) {
-    return {
-      serviceId: "kanban",
-      action,
-      success: false,
-      message: toErrorMessage(error)
-    };
+    previews.omitted = { fileCount: omittedItems.length, added, removed };
   }
+  return previews.length > 0 ? previews : void 0;
 }
-async function restartKanbanServer(projectRoot) {
-  await waitForShutdown(() => isKanbanServerAvailable(projectRoot));
-  try {
-    const connection = await getKanbanServerConnection(projectRoot);
-    if (!connection) {
-      return {
-        serviceId: "kanban",
-        action: "restart",
-        success: false,
-        message: "Kanban IPC daemon failed to restart (no connection after re-init)"
-      };
+
+// src/components/history/code-block.tsx
+var import_jsx_runtime49 = __toESM(require_jsx_runtime(), 1);
+var MAX_CODE_LINES = 80;
+var DIFF_FALLBACK_WRAP_WIDTH = 100;
+var HARD_TAB_WIDTH = 8;
+function expandTabs(text, tabWidth = HARD_TAB_WIDTH) {
+  if (!text.includes("	")) return text;
+  let out = "";
+  let col = 0;
+  for (const ch of text) {
+    if (ch === "	") {
+      const advance = tabWidth - col % tabWidth;
+      out += " ".repeat(advance);
+      col += advance;
+    } else {
+      out += ch;
+      col += 1;
     }
-    await connection.request("ping", {}, { timeoutMs: 1e4 });
-    return {
-      serviceId: "kanban",
-      action: "restart",
-      success: true,
-      message: "Kanban IPC daemon restarted successfully"
-    };
-  } catch (error) {
-    return {
-      serviceId: "kanban",
-      action: "restart",
-      success: false,
-      message: `Kanban IPC daemon restarted but verification failed: ${toErrorMessage(error)}`
-    };
   }
+  return out;
 }
-async function killSageServer(projectRoot, action) {
-  if (!isSageProjectServerAvailable()) {
-    return {
-      serviceId: "sage",
-      action,
-      success: false,
-      message: "SAGE project server is unavailable in this runtime"
-    };
-  }
-  const connection = new SageProjectServerConnection(projectRoot);
-  try {
-    const result = await connection.shutdown(`TUI request: ${action}`);
-    if (!result.stopped) {
-      if (action === "restart" && result.reason === "not-running") {
-        return await restartSageServer(projectRoot);
+function CodeBlockImpl({
+  code,
+  lang,
+  contentWidth
+}) {
+  useActiveTheme();
+  let lines = sanitizeTerminalText(code, HARD_TAB_WIDTH).replace(/\n+$/, "").split("\n");
+  const hidden = Math.max(0, lines.length - MAX_CODE_LINES);
+  if (hidden > 0) lines = lines.slice(0, MAX_CODE_LINES);
+  const gutterW = String(lines.length).length;
+  const maxW = Math.max(1, Math.min(contentWidth - 4 - gutterW - 1, 120));
+  let carry = {};
+  const rows = lines.map((raw) => {
+    const expanded = expandTabs(raw);
+    const display = truncateDisplay(expanded, maxW);
+    const r = highlightLine(display, lang, carry);
+    carry = r.carry;
+    return r.tokens;
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(HistoryRail, { color: theme.borderDefault, children: [
+    lang !== "plain" ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: lang }) : null,
+    rows.map((tokens, i) => /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Text2, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: `${String(i + 1).padStart(gutterW, " ")} ` }),
+      tokens.length === 0 ? " " : tokens.map((t, j) => /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(
+        Text2,
+        {
+          dimColor: Boolean(t.dim),
+          bold: Boolean(t.bold),
+          ...t.color ? { color: t.color } : {},
+          children: t.text
+        },
+        j
+      ))
+    ] }, i)),
+    hidden > 0 ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, italic: true, children: `\u2026 +${hidden} more line${hidden === 1 ? "" : "s"}` }) : null
+  ] });
+}
+function DiffFileBlock({
+  path: path13,
+  preview,
+  useColor = true,
+  contentWidth
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Box2, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Box2, { flexDirection: "row", marginBottom: 0, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { bold: true, color: theme.accent, children: `\u25B8 ${path13}` }),
+      preview.added > 0 || preview.removed > 0 ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: `  (${preview.added > 0 ? `+${preview.added}` : ""}${preview.added > 0 && preview.removed > 0 ? " " : ""}${preview.removed > 0 ? `-${preview.removed}` : ""})` }) : null
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(
+      DiffBlock,
+      {
+        rows: preview.rows,
+        hidden: preview.hidden,
+        added: preview.added,
+        removed: preview.removed,
+        hiddenAdded: preview.hiddenAdded,
+        hiddenRemoved: preview.hiddenRemoved,
+        useColor,
+        lang: langFromPath(path13),
+        showStats: false,
+        contentWidth
       }
-      return {
-        serviceId: "sage",
-        action,
-        success: false,
-        message: `SAGE memory server shutdown failed: ${result.reason ?? "unknown"}`
-      };
-    }
-    if (action === "restart") {
-      return await restartSageServer(projectRoot);
-    }
-    return {
-      serviceId: "sage",
-      action,
-      success: true,
-      message: "SAGE memory server shutdown requested"
-    };
-  } catch (error) {
-    return {
-      serviceId: "sage",
-      action,
-      success: false,
-      message: toErrorMessage(error)
-    };
-  } finally {
-    connection.close();
-  }
+    )
+  ] });
 }
-async function restartSageServer(projectRoot) {
-  await waitForShutdown(async () => {
-    const probe = new SageProjectServerConnection(projectRoot);
-    try {
-      return await probe.status() !== null;
-    } finally {
-      probe.close();
-    }
+function applyWashTokens(tokens, onWash) {
+  if (!onWash) return tokens;
+  return tokens.map((t) => {
+    if (t.color !== "syntax.comment") return t;
+    return { ...t, color: "syntax.commentOnWash", dim: false };
   });
-  const verifyConn = new SageProjectServerConnection(projectRoot);
-  try {
-    await verifyConn.call(
-      "ping",
-      {},
-      { timeoutMs: 1e4, meta: { clientId: `sage-restart-${process.pid}` } }
-    );
-    return {
-      serviceId: "sage",
-      action: "restart",
-      success: true,
-      message: "SAGE memory server restarted successfully"
-    };
-  } catch (error) {
-    return {
-      serviceId: "sage",
-      action: "restart",
-      success: false,
-      message: `SAGE memory server restarted but verification failed: ${toErrorMessage(error)}`
-    };
-  } finally {
-    verifyConn.close();
-  }
 }
-async function killChronicleServer(projectRoot, action) {
-  const options = resolveChronicleProjectServerOptions({ projectRoot });
-  const client = new ChronicleProjectServerClient(options);
-  try {
-    const result = await client.shutdown(`TUI request: ${action}`);
-    if (!result.stopped) {
-      if (action === "restart" && result.reason === "offline") {
-        return await restartChronicleServer(projectRoot);
+function renderTokens(tokens, onWash = false) {
+  const effective = applyWashTokens(tokens, onWash);
+  if (effective.length === 0) return " ";
+  return effective.map((t, j) => /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(
+    Text2,
+    {
+      dimColor: Boolean(t.dim),
+      bold: Boolean(t.bold),
+      ...t.color ? { color: t.color } : {},
+      children: t.text
+    },
+    j
+  ));
+}
+function wrapTokens(tokens, width) {
+  if (width <= 0) return [tokens];
+  const segments = [];
+  let current = [];
+  let currentWidth = 0;
+  for (const t of tokens) {
+    let text = t.text;
+    while (text.length > 0) {
+      const room = width - currentWidth;
+      if (room <= 0) {
+        segments.push(current);
+        current = [];
+        currentWidth = 0;
+        continue;
       }
-      return {
-        serviceId: "chronicle",
-        action,
-        success: false,
-        message: `Chronicle telemetry server shutdown failed: ${result.reason ?? "unknown"}`
-      };
-    }
-    if (action === "restart") {
-      return await restartChronicleServer(projectRoot);
+      const [piece, rest] = splitDisplay(text, room);
+      if (!piece) {
+        segments.push(current);
+        current = [];
+        currentWidth = 0;
+        continue;
+      }
+      current.push({ ...t, text: piece });
+      currentWidth += displayWidth(piece);
+      text = rest;
     }
-    return {
-      serviceId: "chronicle",
-      action,
-      success: true,
-      message: "Chronicle telemetry server shutdown requested"
-    };
-  } catch (error) {
-    return {
-      serviceId: "chronicle",
-      action,
-      success: false,
-      message: toErrorMessage(error)
-    };
-  } finally {
-    client.close();
   }
+  if (current.length > 0 || segments.length === 0) segments.push(current);
+  return segments;
 }
-async function restartChronicleServer(projectRoot) {
-  const options = resolveChronicleProjectServerOptions({ projectRoot });
-  const endpoint = new ChronicleProjectServerClient(options).endpoint;
-  await waitForShutdown(async () => isEndpointAlive(endpoint));
-  let access;
-  try {
-    access = createChronicleProjectAccess({ projectRoot });
-    await access.call("ping", {}, { timeoutMs: 1e4 });
-    if (access.mode !== "server") {
-      return {
-        serviceId: "chronicle",
-        action: "restart",
-        success: false,
-        message: `Chronicle telemetry server restarted but running in ${access.mode} mode (expected server)`
-      };
-    }
-    return {
-      serviceId: "chronicle",
-      action: "restart",
-      success: true,
-      message: "Chronicle telemetry server restarted successfully"
-    };
-  } catch (error) {
-    return {
-      serviceId: "chronicle",
-      action: "restart",
-      success: false,
-      message: `Chronicle telemetry server restarted but verification failed: ${toErrorMessage(error)}`
-    };
-  } finally {
-    await access?.close();
+function DiffBlock({
+  rows,
+  hidden,
+  added = 0,
+  removed = 0,
+  hiddenAdded = 0,
+  hiddenRemoved = 0,
+  useColor = true,
+  lang = "plain",
+  showStats = true,
+  contentWidth
+}) {
+  const lineNoOf = (row) => row.kind === "del" ? row.oldLine : row.newLine ?? row.oldLine;
+  let gutterWidth = 1;
+  for (const r of rows) {
+    const n = lineNoOf(r);
+    if (typeof n === "number" && String(n).length > gutterWidth) gutterWidth = String(n).length;
   }
-}
-async function killCodebaseIndexServer(projectRoot, indexDir, action) {
-  try {
-    const result = await shutdownCodebaseIndexServer(
-      projectRoot,
-      indexDir,
-      `tui-request:${action}`
-    );
-    if (!result.stopped) {
-      if (action === "restart" && result.reason === "not-running") {
-        return await restartCodebaseIndexServer(projectRoot, indexDir);
-      }
-      return {
-        serviceId: "codebase-index",
-        action,
-        success: false,
-        message: `Codebase index server shutdown failed: ${result.reason ?? "unknown"}`
-      };
-    }
-    if (action === "restart") {
-      return await restartCodebaseIndexServer(projectRoot, indexDir);
+  const blank = " ".repeat(gutterWidth);
+  const markerFor = (kind) => {
+    if (kind === "add") return "+";
+    if (kind === "del") return "-";
+    return " ";
+  };
+  const textForDisplay = (row) => {
+    if ((row.kind === "add" || row.kind === "del" || row.kind === "ctx") && row.text.length > 0) {
+      return sanitizeTerminalText(expandTabs(row.text.slice(1)), HARD_TAB_WIDTH) || " ";
     }
-    return {
-      serviceId: "codebase-index",
-      action,
-      success: true,
-      message: "Codebase index server shutdown requested"
-    };
-  } catch (error) {
-    return {
-      serviceId: "codebase-index",
-      action,
-      success: false,
-      message: toErrorMessage(error)
-    };
-  }
+    return sanitizeTerminalText(expandTabs(row.text), HARD_TAB_WIDTH) || " ";
+  };
+  const stats = showStats ? formatDiffStats(added, removed) : null;
+  const terminalWrapGuard = typeof contentWidth === "number" ? 1 : 0;
+  const bodyBudget = typeof contentWidth === "number" ? Math.max(1, contentWidth - (2 + 3 + gutterWidth + 3 + terminalWrapGuard)) : DIFF_FALLBACK_WRAP_WIDTH;
+  const hasWidth = typeof contentWidth === "number";
+  const padBody = (seg) => {
+    if (!hasWidth) return 0;
+    const len = seg.reduce((n, t) => n + displayWidth(t.text), 0);
+    return Math.max(0, bodyBudget - len);
+  };
+  const contPrefix = `   ${blank}   `;
+  const hiddenStats = [];
+  if (hiddenAdded > 0) hiddenStats.push(`+${hiddenAdded}`);
+  if (hiddenRemoved > 0) hiddenStats.push(`-${hiddenRemoved}`);
+  return /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Box2, { flexDirection: "column", marginLeft: 2, marginTop: 0, children: [
+    stats ? /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Text2, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: "\u23BF  " }),
+      /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { children: stats })
+    ] }) : null,
+    rows.map((row, i) => {
+      const key2 = i;
+      if (row.kind === "hunk") {
+        if (i === 0) return null;
+        return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: `   ${blank} \u22EF` }, key2);
+      }
+      if (row.kind === "meta") {
+        return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: `   ${blank}   ${sanitizeTerminalText(row.text)}` }, key2);
+      }
+      const n = lineNoOf(row);
+      const ln = typeof n === "number" ? String(n).padStart(gutterWidth, " ") : blank;
+      const body = textForDisplay(row);
+      const tokens = highlightLine(body, lang).tokens;
+      const segments = wrapTokens(tokens, bodyBudget);
+      if (row.kind === "ctx") {
+        return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Box2, { flexDirection: "column", children: segments.map((seg, si) => /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Text2, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: si === 0 ? `   ${ln}   ` : contPrefix }),
+          renderTokens(seg)
+        ] }, si)) }, key2);
+      }
+      const marker = markerFor(row.kind);
+      const markerColor = row.kind === "add" ? theme.success : theme.error;
+      if (useColor) {
+        const bg = row.kind === "add" ? theme.diffAddBg : theme.diffDelBg;
+        return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Box2, { flexDirection: "column", children: segments.map((seg, si) => {
+          const pad = padBody(seg);
+          return /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Text2, { backgroundColor: bg, children: [
+            si === 0 ? /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(import_jsx_runtime49.Fragment, { children: [
+              /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: `   ${ln} ` }),
+              /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { color: markerColor, bold: true, children: marker }),
+              /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { children: " " })
+            ] }) : /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: contPrefix }),
+            renderTokens(seg, true),
+            pad > 0 ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { children: " ".repeat(pad) }) : null
+          ] }, si);
+        }) }, key2);
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Box2, { flexDirection: "column", children: segments.map((seg, si) => /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Text2, { children: [
+        si === 0 ? /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(import_jsx_runtime49.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: `   ${ln} ` }),
+          /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { color: markerColor, bold: true, children: marker }),
+          /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { children: " " })
+        ] }) : /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, children: contPrefix }),
+        renderTokens(seg)
+      ] }, si)) }, key2);
+    }),
+    hidden > 0 ? /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(Text2, { dimColor: true, italic: true, children: `   ${blank}  \u2026 ${hidden} more line${hidden === 1 ? "" : "s"}${hiddenStats.length > 0 ? ` (${hiddenStats.join(" ")} hidden)` : ""}` }) : null
+  ] });
+}
+var CodeBlock = (0, import_react62.memo)(CodeBlockImpl);
+
+// src/components/confirm-prompt.tsx
+var import_jsx_runtime50 = __toESM(require_jsx_runtime(), 1);
+var BUTTON_COLOR = {
+  yes: "green",
+  no: "red",
+  always: "cyan",
+  "always-exact": "cyan",
+  "always-command": "cyan",
+  "always-tool": "yellow",
+  deny: "red"
+};
+function buttonLabels(_suggestedPattern, toolName = "exec") {
+  return [
+    { decision: "yes", bracket: "[y]", rest: "es " },
+    { decision: "no", bracket: "[n]", rest: "o " },
+    { decision: "always-exact", bracket: "[a]", rest: " same args " },
+    ...toolName === "exec" ? [{ decision: "always-command", bracket: "[c]", rest: " command " }] : [],
+    { decision: "always-tool", bracket: "[t]", rest: " tool " },
+    { decision: "deny", bracket: "[d]", rest: "eny" }
+  ];
 }
-async function restartCodebaseIndexServer(projectRoot, indexDir) {
-  await waitForShutdown(async () => {
-    try {
-      await checkCodebaseIndexServerHealth(projectRoot, indexDir, {
-        timeoutMs: 1e3
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  });
-  try {
-    await ensureCodebaseIndexServer({ projectRoot, indexDir });
-    const health2 = await checkCodebaseIndexServerHealth(projectRoot, indexDir, {
-      timeoutMs: 1e4
-    });
-    if (health2.status === "unresponsive") {
-      return {
-        serviceId: "codebase-index",
-        action: "restart",
-        success: false,
-        message: "Codebase index server restarted but is unresponsive"
-      };
-    }
-    return {
-      serviceId: "codebase-index",
-      action: "restart",
-      success: true,
-      message: "Codebase index server restarted successfully"
-    };
-  } catch (error) {
-    return {
-      serviceId: "codebase-index",
-      action: "restart",
-      success: false,
-      message: `Codebase index server restarted but verification failed: ${toErrorMessage(error)}`
-    };
+function stringifyInput(input) {
+  if (!input || typeof input !== "object") return "";
+  const obj = input;
+  return Object.entries(obj).filter(([k]) => k !== "content" && k !== "new_string" && k !== "diff").map(([k, v]) => `${k}: ${truncate(JSON.stringify(v), 80)}`).join("  ");
+}
+function truncate(s2, max) {
+  return s2.length <= max ? s2 : `${s2.slice(0, max - 1)}\u2026`;
+}
+function payloadDiff(input) {
+  if (!input || typeof input !== "object") return "";
+  const obj = input;
+  const filePath = typeof obj["path"] === "string" ? obj["path"] : "file";
+  if (typeof obj["diff"] === "string" && obj["diff"]) return obj["diff"];
+  const newString = obj["new_string"];
+  if (typeof newString === "string") {
+    const oldString = typeof obj["old_string"] === "string" ? obj["old_string"] : "";
+    return unifiedDiff(oldString, newString, { fromFile: filePath, toFile: filePath, context: 2 });
+  }
+  const content = obj["content"];
+  if (typeof content === "string" && content) {
+    return unifiedDiff("", content, { fromFile: "/dev/null", toFile: filePath, context: 0 });
   }
+  return "";
 }
-async function killMailboxServer(projectRoot, action) {
-  if (!isMailboxProjectServerAvailable()) {
-    return {
-      serviceId: "mailbox",
-      action,
-      success: false,
-      message: "Mailbox project server is unavailable in this runtime"
-    };
+var CONFIRM_DIFF_MAX_LINES = 20;
+function renderDiffLine(line) {
+  const prefix = line.startsWith("+") ? "green" : line.startsWith("-") ? "red" : line.startsWith("@@") ? "cyan" : void 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(Text2, { ...prefix ? { color: prefix } : {}, children: [
+    line,
+    "\n"
+  ] }, line);
+}
+function renderDiff(diff2, path13) {
+  const preview = parseUnifiedDiff(diff2, CONFIRM_DIFF_MAX_LINES);
+  if (preview.rows.length > 0) {
+    return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(
+      DiffBlock,
+      {
+        rows: preview.rows,
+        hidden: preview.hidden,
+        added: preview.added,
+        removed: preview.removed,
+        hiddenAdded: preview.hiddenAdded,
+        hiddenRemoved: preview.hiddenRemoved,
+        useColor: theme.supportsBackground,
+        lang: langFromPath(path13 ?? "")
+      }
+    );
   }
-  const connection = new MailboxProjectServerConnection(
-    resolveWstackPaths2({ projectRoot }).projectDir
-  );
-  try {
-    const result = await connection.shutdown(`TUI request: ${action}`);
-    if (!result.stopped) {
-      if (action === "restart" && result.reason === "offline") {
-        return await restartMailboxServer(projectRoot);
+  const lines = diff2.split("\n").filter((l) => l.length > 0).slice(0, CONFIRM_DIFF_MAX_LINES);
+  return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Box2, { flexDirection: "column", paddingX: 2, children: lines.map((l) => renderDiffLine(l)) });
+}
+function ConfirmPrompt({
+  toolName,
+  input,
+  suggestedPattern,
+  onDecision,
+  onEnableYolo,
+  destructive,
+  boundaryReason,
+  writeTargets,
+  maxRows
+}) {
+  const size = useTerminalSize();
+  const rowBudget = maxRows ?? size.rows;
+  const buttons = import_react63.default.useRef(/* @__PURE__ */ new Map());
+  const partialMouse = import_react63.default.useRef("");
+  const decided = import_react63.default.useRef(false);
+  const decide = (decision) => {
+    if (decided.current) return;
+    decided.current = true;
+    onDecision(decision);
+  };
+  const { stdin } = use_stdin_default();
+  import_react63.default.useEffect(() => {
+    if (!stdin) return;
+    const onData = (data) => {
+      const chunk = splitTrailingMousePartial(partialMouse.current + data.toString());
+      partialMouse.current = chunk.pending;
+      for (const event of parseMouseEvents(chunk.consumed)) {
+        if (event.kind !== "press" || event.button !== "left") continue;
+        for (const [decision, node] of buttons.current) {
+          const rect = measure_element_default(node);
+          if (event.x > rect.x && event.x <= rect.x + rect.width && event.y > rect.y && event.y <= rect.y + rect.height) {
+            decide(decision);
+            break;
+          }
+        }
       }
-      return {
-        serviceId: "mailbox",
-        action,
-        success: false,
-        message: `Mailbox IPC server shutdown failed: ${result.reason ?? "unknown"}`
-      };
-    }
-    if (action === "restart") {
-      return await restartMailboxServer(projectRoot);
-    }
-    return {
-      serviceId: "mailbox",
-      action,
-      success: true,
-      message: "Mailbox IPC server shutdown requested"
     };
-  } catch (error) {
-    return {
-      serviceId: "mailbox",
-      action,
-      success: false,
-      message: toErrorMessage(error)
+    stdin.on("data", onData);
+    return () => {
+      stdin.off("data", onData);
     };
-  } finally {
-    connection.close();
-  }
-}
-async function restartMailboxServer(projectRoot) {
-  await waitForShutdown(async () => {
-    const probe = new MailboxProjectServerConnection(
-      resolveWstackPaths2({ projectRoot }).projectDir
-    );
-    try {
-      return await probe.probeStatus() !== null;
-    } finally {
-      probe.close();
+  }, [stdin, decide]);
+  import_react63.default.useEffect(() => {
+    writeOut("\x07");
+  }, []);
+  use_input_default((input2, key2) => {
+    if (key2.ctrl || key2.meta || decided.current) return;
+    if (!input2 || input2 === "\r" || input2 === "\n") return;
+    if (input2 === "Y" && !boundaryReason) {
+      onEnableYolo();
+      return;
+    }
+    const ch = input2.toLowerCase();
+    if (ch === "y") {
+      decide("yes");
+    } else if (ch === "n") {
+      decide("no");
+    } else if (ch === "a") {
+      decide("always-exact");
+    } else if (ch === "c" && toolName === "exec") {
+      decide("always-command");
+    } else if (ch === "t") {
+      decide("always-tool");
+    } else if (ch === "d") {
+      decide("deny");
     }
   });
-  const verifyConn = new MailboxProjectServerConnection(
-    resolveWstackPaths2({ projectRoot }).projectDir
-  );
-  try {
-    await verifyConn.call("ping", {}, { timeoutMs: 1e4 });
-    return {
-      serviceId: "mailbox",
-      action: "restart",
-      success: true,
-      message: "Mailbox IPC server restarted successfully"
-    };
-  } catch (error) {
-    return {
-      serviceId: "mailbox",
-      action: "restart",
-      success: false,
-      message: `Mailbox IPC server restarted but verification failed: ${toErrorMessage(error)}`
-    };
-  } finally {
-    verifyConn.close();
-  }
+  const inputSummary = stringifyInput(input);
+  const inp = input;
+  const diff2 = payloadDiff(input);
+  const diffPath = typeof inp?.path === "string" ? inp.path : void 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(PanelInputProvider, { value: true, children: /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(MonitorViewportProvider, { value: { columns: size.columns, rows: rowBudget }, children: /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(
+    MonitorShell,
+    {
+      accent: "yellow",
+      icon: "\u26A0",
+      title: `APPROVAL REQUIRED \xB7 ${toolName}`,
+      footer: /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Box2, { flexDirection: "row", flexWrap: "wrap", children: buttonLabels(suggestedPattern, toolName).map((label) => /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(
+        Box2,
+        {
+          flexShrink: 0,
+          ref: (node) => {
+            if (node) buttons.current.set(label.decision, node);
+            else buttons.current.delete(label.decision);
+          },
+          children: /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(Text2, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Text2, { bold: true, color: BUTTON_COLOR[label.decision], children: label.bracket }),
+            /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Text2, { dimColor: true, children: label.rest })
+          ] })
+        },
+        label.decision
+      )) }),
+      children: [
+        inputSummary ? /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Text2, { dimColor: true, children: inputSummary }) : null,
+        boundaryReason ? /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(Text2, { color: "yellow", children: [
+          "KANBAN BOUNDARY: ",
+          boundaryReason
+        ] }) : null,
+        writeTargets && writeTargets.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(Text2, { color: "yellow", children: [
+          "WRITES: ",
+          writeTargets.slice(0, 5).join(", "),
+          writeTargets.length > 5 ? ` (+${writeTargets.length - 5} more)` : ""
+        ] }) : null,
+        diff2 ? /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Box2, { flexDirection: "column", marginY: 1, children: renderDiff(diff2, diffPath) }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(Text2, { dimColor: true, children: [
+          "Remember: [a] this input; ",
+          toolName === "exec" ? "[c] executable, any args; " : "",
+          "[t] tool, any input. Destructive calls still prompt."
+        ] }),
+        !boundaryReason ? /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Box2, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)(Text2, { dimColor: true, children: [
+          " ",
+          "Tip: press",
+          " ",
+          /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(Text2, { bold: true, color: "yellow", children: "Y" }),
+          " ",
+          "to enable YOLO mode",
+          destructive ? " (this destructive approval remains)" : " (skips future routine approvals)",
+          "."
+        ] }) }) : null
+      ]
+    }
+  ) }) });
 }
 
 // src/components/connections-panel.tsx
+var import_react64 = __toESM(require_react(), 1);
+init_connection_actions();
 init_connections_health();
 var import_jsx_runtime51 = __toESM(require_jsx_runtime(), 1);
 var REFRESH_MS = 8e3;
@@ -54184,8 +54015,10 @@ var SETTINGS_FIELD_LABELS = [
   // 60
   "Right sidebar",
   // 61
-  "Tool result view"
+  "Tool result view",
   // 62
+  "Tool Coach"
+  // 63
 ];
 
 // src/components/model-picker-effort.ts
@@ -55878,6 +55711,7 @@ function resolveSettingsFieldValue(field, input) {
     [10, "featureMemory"],
     [11, "featureSkills"],
     [12, "featureModelsRegistry"],
+    [63, "featureToolCoach"],
     [14, "allowOutsideProjectRoot"],
     [18, "enhanceEnabled"],
     [20, "indexOnStart"],
@@ -56087,6 +55921,7 @@ function getSettingsFieldValue(values, field) {
     [10, "featureMemory"],
     [11, "featureSkills"],
     [12, "featureModelsRegistry"],
+    [63, "featureToolCoach"],
     [14, "allowOutsideProjectRoot"],
     [18, "enhanceEnabled"],
     [20, "indexOnStart"],
@@ -56176,6 +56011,10 @@ var SETTINGS_SECTIONS = [
     name: "Features",
     fields: [8, 9, 10, 11, 12, 13, 14]
   },
+  {
+    name: "Agent guidance",
+    fields: [63]
+  },
   {
     name: "Tools",
     fields: [15, 16, 17, 18, 19, 20, 21, 22, 42, 45]
@@ -56264,6 +56103,7 @@ var SETTINGS_DEFAULTS = Object.freeze({
   featureMemory: true,
   featureSkills: true,
   featureModelsRegistry: true,
+  featureToolCoach: true,
   tokenSavingTier: "off",
   allowOutsideProjectRoot: true,
   contextAutoCompact: true,
@@ -56331,6 +56171,7 @@ function buildResetPatch(field) {
     [10, "featureMemory"],
     [11, "featureSkills"],
     [12, "featureModelsRegistry"],
+    [63, "featureToolCoach"],
     [13, "tokenSavingTier"],
     [14, "allowOutsideProjectRoot"],
     [15, "maxIterations"],
@@ -56525,6 +56366,7 @@ function SettingsPicker({
   featureMemory,
   featureSkills,
   featureModelsRegistry,
+  featureToolCoach,
   tokenSavingTier,
   allowOutsideProjectRoot,
   maxIterations,
@@ -56875,7 +56717,13 @@ function SettingsPicker({
       value: `${boolVal(showSidebar ?? true)}${sidebarPinned ? " \xB7 pinned" : ""}`,
       detail: sidebarPinned ? "A panel is routed to the sidebar \u2014 set that panel to bottom to unlock hiding" : "Show or hide the right sidebar in the TUI (chat history takes full width when off)"
     },
-    toolResultViewSettingRow(toolResultViewMode)
+    toolResultViewSettingRow(toolResultViewMode),
+    { section: "Agent guidance" },
+    {
+      label: "Tool Coach",
+      value: boolVal(featureToolCoach),
+      detail: "Suggest enabled tools and guide recovery after tool errors (default on)"
+    }
   ];
   const fieldRowIndex = [];
   for (let i = 0; i < rows.length; i++) {
@@ -57460,8 +57308,86 @@ function SubagentModelsPanel({
   ] });
 }
 
+// src/theme-picker-rows.ts
+function filterThemeOptions(options, query) {
+  const terms = query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+  if (terms.length === 0) return options;
+  return options.filter((opt) => {
+    const haystack = `${opt.name} ${opt.id} ${opt.description}`.toLowerCase();
+    return terms.every((term) => haystack.includes(term));
+  });
+}
+function buildThemeRows(options) {
+  const rows = [];
+  let lastFamily;
+  for (const [index, option] of options.entries()) {
+    if (option.family !== lastFamily) {
+      rows.push({ kind: "header", family: option.family });
+      lastFamily = option.family;
+    }
+    rows.push({ kind: "option", option, index });
+  }
+  return rows;
+}
+function windowThemeRows(rows, selected, budget) {
+  if (rows.length === 0) return { rows: [], hasAbove: false, hasBelow: false };
+  const focusPos = Math.max(
+    0,
+    rows.findIndex((r) => r.kind === "option" && r.index === selected)
+  );
+  let headerPos = focusPos;
+  for (let i = focusPos; i >= 0; i -= 1) {
+    if (rows[i].kind === "header") {
+      headerPos = i;
+      break;
+    }
+  }
+  const capacity = Math.max(2, budget);
+  let start = focusPos + 1 - headerPos <= capacity ? headerPos : focusPos;
+  let end = focusPos + 1;
+  let used = end - start;
+  while (used < capacity && end < rows.length) {
+    const cost = needsHeaderAbove(rows, end) ? 2 : 1;
+    if (used + cost > capacity) break;
+    end += cost;
+    used += cost;
+  }
+  while (used < capacity && start > 0) {
+    start -= 1;
+    used += 1;
+  }
+  return {
+    rows: rows.slice(start, end),
+    hasAbove: start > 0,
+    hasBelow: end < rows.length
+  };
+}
+function needsHeaderAbove(rows, pos) {
+  const row = rows[pos];
+  if (row === void 0) return false;
+  return row.kind === "header" || rows[pos - 1]?.kind === "header";
+}
+
 // src/components/theme-preview.tsx
 var import_jsx_runtime81 = __toESM(require_jsx_runtime(), 1);
+var CONTRAST_FLOOR = 3;
+function ContrastRow({
+  fg,
+  bg,
+  label
+}) {
+  const ratio = contrastRatio(fg, bg);
+  const weak = ratio < CONTRAST_FLOOR;
+  return /* @__PURE__ */ (0, import_jsx_runtime81.jsxs)(Text2, { children: [
+    "  ",
+    /* @__PURE__ */ (0, import_jsx_runtime81.jsx)(Text2, { dimColor: true, children: label.padEnd(5) }),
+    /* @__PURE__ */ (0, import_jsx_runtime81.jsx)(Text2, { color: weak ? "yellow" : void 0, children: weak ? "\u25B2" : "\xB7" }),
+    /* @__PURE__ */ (0, import_jsx_runtime81.jsxs)(Text2, { color: weak ? "yellow" : void 0, bold: weak, children: [
+      ratio.toFixed(1),
+      ":1"
+    ] })
+  ] });
+}
 function ThemePreview({
   presetId,
   active,
@@ -57567,6 +57493,21 @@ function ThemePreview({
           /* @__PURE__ */ (0, import_jsx_runtime81.jsx)(Text2, { backgroundColor: preset.diffDelBg, children: " " })
         ] })
       ] })
+    },
+    {
+      // Placed LAST so the existing trim-from-bottom order is untouched: a
+      // short terminal drops contrast before it drops the sample/diff the user
+      // actually judges the palette by.
+      key: "contrast",
+      // Label + three readings = 4 physical rows. The cost must match the real
+      // height or the trim loop lets the preview overrun the picker's budget.
+      cost: 4,
+      render: /* @__PURE__ */ (0, import_jsx_runtime81.jsxs)(Box2, { flexDirection: "column", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime81.jsx)(Text2, { dimColor: true, children: "contrast" }),
+        /* @__PURE__ */ (0, import_jsx_runtime81.jsx)(ContrastRow, { fg: preset.textPrimary, bg: preset.surface, label: "text" }),
+        /* @__PURE__ */ (0, import_jsx_runtime81.jsx)(ContrastRow, { fg: preset.success, bg: preset.diffAddBg, label: "+add" }),
+        /* @__PURE__ */ (0, import_jsx_runtime81.jsx)(ContrastRow, { fg: preset.error, bg: preset.diffDelBg, label: "-del" })
+      ] })
     }
   ];
   let used = 0;
@@ -57595,21 +57536,21 @@ function ThemePicker({
   activeId,
   hint,
   columns = 0,
-  maxRows
+  maxRows,
+  filter = ""
 }) {
   const split = columns >= SPLIT_MIN_COLUMNS && options.length > 0 && (maxRows === void 0 || maxRows >= PREVIEW_MIN_ROWS);
   const listMaxRows = split && maxRows !== void 0 ? Math.min(maxRows, PREVIEW_FULL_ROWS) : maxRows;
-  const { start, end, hasAbove, hasBelow } = useWindowedPicker({
-    total: options.length,
-    selected,
-    chromeRows: 4,
-    // 2 marker slots + 1 conditional hint slot — reserve the worst case so
-    // the window never overflows whether or not those rows actually render.
-    markerRows: 3,
-    maxRows: listMaxRows
-  });
-  const visibleOptions = options.slice(start, end);
-  const selectedOption = options[Math.max(0, Math.min(selected, options.length - 1))];
+  const visibleOptions = filterThemeOptions(options, filter);
+  const rows = buildThemeRows(visibleOptions);
+  const { rows: rows_terminal } = useTerminalSize();
+  const chromeRows = 4;
+  const markerRows = 4;
+  const listBudget = listMaxRows === void 0 ? Math.max(1, rows_terminal - chromeRows - markerRows - SHELL_RESERVED_ROWS) : Math.max(1, listMaxRows - chromeRows - markerRows);
+  const safeSelected = Math.max(0, Math.min(selected, Math.max(0, visibleOptions.length - 1)));
+  const window2 = windowThemeRows(rows, safeSelected, listBudget);
+  const selectedOption = visibleOptions[safeSelected];
+  const innerWidth = (split ? LIST_COLUMN_WIDTH : Math.max(0, columns)) - LIST_CHROME_COLUMNS;
   const list = /* @__PURE__ */ (0, import_jsx_runtime82.jsxs)(
     Box2,
     {
@@ -57620,40 +57561,19 @@ function ThemePicker({
       ...split ? { width: LIST_COLUMN_WIDTH, flexShrink: 0 } : {},
       children: [
         /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(Text2, { color: "cyan", bold: true, children: "\u2501\u2501 TUI Theme \u2501\u2501" }),
-        /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(Text2, { dimColor: true, wrap: "truncate-end", children: "\u2191\u2193 \xB7 Enter apply \xB7 Esc cancel" }),
-        hasAbove ? /* @__PURE__ */ (0, import_jsx_runtime82.jsxs)(Text2, { dimColor: true, children: [
-          " \u2026 ",
-          start,
-          " more above"
-        ] }) : null,
-        visibleOptions.map((opt, j) => {
-          const i = start + j;
-          const isActive = opt.id === activeId;
-          const isSelected = i === selected;
-          return /* @__PURE__ */ (0, import_jsx_runtime82.jsxs)(
-            Text2,
-            {
-              wrap: "truncate-end",
-              inverse: isSelected,
-              ...isSelected ? { color: "cyan" } : {},
-              children: [
-                isSelected ? "\u203A " : "  ",
-                /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(Text2, { bold: true, children: opt.name.padEnd(21) }),
-                isActive ? /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(Text2, { color: "green", children: " [active]" }) : null,
-                split ? null : /* @__PURE__ */ (0, import_jsx_runtime82.jsxs)(Text2, { dimColor: true, children: [
-                  " ",
-                  opt.description
-                ] })
-              ]
-            },
-            opt.id
-          );
-        }),
-        hasBelow ? /* @__PURE__ */ (0, import_jsx_runtime82.jsxs)(Text2, { dimColor: true, children: [
-          " \u2026 ",
-          options.length - end,
-          " more below"
+        /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(Text2, { dimColor: true, wrap: "truncate-end", children: "\u2191\u2193 Enter apply \xB7 / \xB7 u undo \xB7 Esc" }),
+        filter ? /* @__PURE__ */ (0, import_jsx_runtime82.jsxs)(Text2, { color: "yellow", wrap: "truncate-end", children: [
+          "/",
+          filter,
+          visibleOptions.length,
+          " match",
+          visibleOptions.length === 1 ? "" : "es"
         ] }) : null,
+        window2.hasAbove ? /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(Text2, { dimColor: true, children: " \u2026 more above" }) : null,
+        window2.rows.map(
+          (row) => renderRow2(row, keyFor(row), activeId, safeSelected, split, innerWidth)
+        ),
+        window2.hasBelow ? /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(Text2, { dimColor: true, children: " \u2026 more below" }) : null,
         hint ? /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(Text2, { color: "yellow", wrap: "truncate-end", children: hint }) : null
       ]
     }
@@ -57674,8 +57594,67 @@ function ThemePicker({
     )
   ] });
 }
-var LIST_COLUMN_WIDTH = 36;
-var SPLIT_MIN_COLUMNS = 88;
+function keyFor(row) {
+  return row.kind === "header" ? `h:${row.family}` : `o:${row.option.id}`;
+}
+function renderRow2(row, key2, activeId, selected, split, innerWidth) {
+  if (row.kind === "header") {
+    return /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(Text2, { color: "blue", bold: true, dimColor: true, wrap: "truncate-end", children: row.family }, key2);
+  }
+  const opt = row.option;
+  const isActive = opt.id === activeId;
+  const isSelected = row.index === selected;
+  const fixed = ROW_BASE_COLUMNS + (isActive ? ACTIVE_MARKER_COLUMNS : 0);
+  const showSwatches = !split && innerWidth - fixed >= SWATCH_COLUMNS;
+  const showDescription = !split && innerWidth - fixed - (showSwatches ? SWATCH_COLUMNS : 0) >= MIN_DESCRIPTION_COLUMNS;
+  return (
+    // The cursor/name/marker run and the swatches are SIBLINGS, not nested.
+    // Ink propagates a parent's `inverse` to nested children, so keeping
+    // <Swatches/> inside the inverted <Text> inverted every chip — each swatch
+    // would render in the complement of its own colour, which defeats the
+    // point of sampling the palette.
+    /* @__PURE__ */ (0, import_jsx_runtime82.jsxs)(Box2, { flexDirection: "row", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime82.jsxs)(Text2, { inverse: isSelected, ...isSelected ? { color: "cyan" } : {}, children: [
+        isSelected ? "\u203A " : "  ",
+        /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(Text2, { bold: true, children: fitName(opt.name) }),
+        isActive ? /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(Text2, { color: "green", children: " [active]" }) : null
+      ] }),
+      showSwatches ? /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(Swatches, { optionId: opt.id }) : null,
+      showDescription ? /* @__PURE__ */ (0, import_jsx_runtime82.jsxs)(Text2, { dimColor: true, wrap: "truncate-end", children: [
+        " ",
+        opt.description
+      ] }) : null
+    ] }, key2)
+  );
+}
+var NAME_COLUMNS = 21;
+function fitName(name) {
+  return name.length > NAME_COLUMNS ? `${name.slice(0, NAME_COLUMNS - 1)}\u2026` : name.padEnd(NAME_COLUMNS);
+}
+var SWATCH_COLUMNS = 7;
+var ROW_BASE_COLUMNS = 2 + NAME_COLUMNS;
+var ACTIVE_MARKER_COLUMNS = 9;
+var MIN_DESCRIPTION_COLUMNS = 12;
+var LIST_CHROME_COLUMNS = 4;
+function Swatches({ optionId }) {
+  const preset = themePresets[optionId];
+  if (!preset) return null;
+  const chips = [
+    preset.accent,
+    preset.brandPrimary,
+    preset.user,
+    preset.success,
+    preset.error,
+    preset.surfaceRaised
+  ];
+  return /* @__PURE__ */ (0, import_jsx_runtime82.jsxs)(Text2, { children: [
+    " ",
+    chips.map((color, i) => /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(Text2, { backgroundColor: color, children: " " }, `${optionId}-${i}`))
+  ] });
+}
+var SHELL_RESERVED_ROWS = 6;
+var LIST_COLUMN_WIDTH = 43;
+var SPLIT_MIN_COLUMNS = 92;
 var PREVIEW_MIN_ROWS = 12;
 var PREVIEW_FULL_ROWS = 18;
 
@@ -58094,6 +58073,7 @@ function AppViewPickers({
           selected: state.themePicker.selected,
           activeId: getActiveThemeName(),
           hint: state.themePicker.hint,
+          filter: state.themePicker.filter,
           columns: mainColumnWidth,
           maxRows: pickerMaxRows
         }
@@ -58177,6 +58157,7 @@ function AppViewPickers({
           featureMemory: state.settingsPicker.featureMemory,
           featureSkills: state.settingsPicker.featureSkills,
           featureModelsRegistry: state.settingsPicker.featureModelsRegistry,
+          featureToolCoach: state.settingsPicker.featureToolCoach,
           tokenSavingTier: state.settingsPicker.tokenSavingTier,
           allowOutsideProjectRoot: state.settingsPicker.allowOutsideProjectRoot,
           contextAutoCompact: state.settingsPicker.contextAutoCompact,
@@ -62072,7 +62053,7 @@ function ComposerTopRail({
 function inputContentWidth(termColumns) {
   return Math.max(8, termColumns - 4);
 }
-function renderRow2(cells, rowKey, promptColor) {
+function renderRow3(cells, rowKey, promptColor) {
   const out = [];
   let run = "";
   let runStart = 0;
@@ -62401,7 +62382,7 @@ var Input = (0, import_react78.memo)(function Input2({
       const padding = " ".repeat(Math.max(0, contentWidth - rowWidth));
       return /* @__PURE__ */ (0, import_jsx_runtime104.jsxs)(Text2, { children: [
         /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(Text2, { color: disabled ? theme.error : accent ?? theme.brandPrimary, children: "\u2502 " }),
-        row.length === 0 ? null : renderRow2(row, `r${i}`, promptColor),
+        row.length === 0 ? null : renderRow3(row, `r${i}`, promptColor),
         /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(Text2, { children: padding }),
         /* @__PURE__ */ (0, import_jsx_runtime104.jsx)(Text2, { color: disabled ? theme.error : accent ?? theme.brandPrimary, children: " \u2502" })
       ] }, i);
@@ -62902,7 +62883,7 @@ var EntryHeightCache = class {
 };
 
 // src/hit-test.ts
-var SCROLLBAR_HIT_WIDTH = 5;
+var SCROLLBAR_HIT_WIDTH = 8;
 function historyViewportRows(termRows, bottomHeight) {
   return Math.max(1, Math.floor(termRows) - Math.max(0, Math.floor(bottomHeight)));
 }
@@ -63702,10 +63683,10 @@ function renderTable(tableLines, maxWidth) {
   const widths = computeWidths([header, ...dataRows], cols, maxWidth, sepWidths);
   const lines = [];
   lines.push(border("\u250C", "\u252C", "\u2510", widths));
-  lines.push(...renderRow3(header, widths, aligns));
+  lines.push(...renderRow4(header, widths, aligns));
   lines.push(border("\u251C", "\u253C", "\u2524", widths));
   for (const row of dataRows) {
-    lines.push(...renderRow3(row, widths, aligns));
+    lines.push(...renderRow4(row, widths, aligns));
   }
   lines.push(border("\u2514", "\u2534", "\u2518", widths));
   return lines.join("\n");
@@ -63771,9 +63752,12 @@ function border(left, mid, right, widths) {
   return left + widths.map((w) => "\u2500".repeat(w + 2)).join(mid) + right;
 }
 function stripInlineMarkers(text) {
-  return text.replace(/\*\*(.+?)\*\*/g, "$1").replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "$1").replace(/`(.+?)`/g, "$1").replace(/~~(.+?)~~/g, "$1");
+  return text.split(/(`.+?`)/).map((part, i) => i % 2 === 1 ? part.slice(1, -1) : stripEmphasis(part)).join("");
 }
-function renderRow3(cells, widths, aligns) {
+function stripEmphasis(text) {
+  return text.replace(/\*\*(?!\s)(.+?)(?<!\s)\*\*/g, "$1").replace(/(?<!\*)\*(?![\s*])(.+?)(?<![\s*])\*(?!\*)/g, "$1").replace(/~~(.+?)~~/g, "$1");
+}
+function renderRow4(cells, widths, aligns) {
   const safe = cells.map((cell) => breakLigatures(stripInlineMarkers(cell)));
   const wrapped = safe.map((c, i) => wrapCell(c, widths[i] ?? MIN_COL_WIDTH));
   const height = Math.max(1, ...wrapped.map((w) => w.length));
@@ -63804,7 +63788,7 @@ function wrapCell(text, width) {
       continue;
     }
     if (cur) {
-      out.push(padVisual(cur, width));
+      out.push(clipVisual(cur.trimEnd(), width));
       cur = "";
       curWidth = 0;
     }
@@ -63814,7 +63798,7 @@ function wrapCell(text, width) {
       while (restWidth > width) {
         const [collected, remaining] = splitDisplay(rest, width);
         if (collected === "") break;
-        out.push(padVisual(collected, width));
+        out.push(clipVisual(collected, width));
         rest = remaining;
         restWidth = strWidth(rest);
       }
@@ -63825,13 +63809,11 @@ function wrapCell(text, width) {
       curWidth = wordWidth;
     }
   }
-  if (cur) out.push(padVisual(cur, width));
+  if (cur) out.push(clipVisual(cur.trimEnd(), width));
   return out.length === 0 ? [""] : out;
 }
-function padVisual(text, targetWidth) {
-  const w = strWidth(text);
-  if (w >= targetWidth) return truncateDisplay(text, targetWidth, "");
-  return text + " ".repeat(targetWidth - w);
+function clipVisual(text, targetWidth) {
+  return strWidth(text) > targetWidth ? truncateDisplay(text, targetWidth, "") : text;
 }
 function padCell(text, width, align) {
   const visualLen = strWidth(text);
@@ -65764,6 +65746,7 @@ var Scrollbar = (0, import_react88.memo)(function Scrollbar2({
       ),
       /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(Text2, { children: " " }),
       /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(Text2, { color: copyHit?.inspectCol !== void 0 ? theme.accent : void 0, children: copyHit?.inspectCol !== void 0 ? INSPECT_ICON : " " }),
+      /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(Text2, { children: "   " }),
       /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(Text2, { ...inBand || row === markedRow ? { color: theme.accent } : {}, children: isHead ? "\u2588" : inBand ? "\u258C" : row === markedRow ? "\u25C0" : " " }),
       /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(
         Text2,
@@ -66529,7 +66512,10 @@ function closePanels(state) {
     sddBoard: state.sddBoard ? { ...state.sddBoard, monitorOpen: false } : state.sddBoard,
     worktreeMonitorOpen: false,
     coordinator: { ...state.coordinator, monitorOpen: false },
-    themePicker: { ...state.themePicker, open: false },
+    // `preview` is explicitly cleared: the spread would carry a live-preview
+    // flag into the next `/theme` open, so arrows would start applying themes
+    // with no keypress opting in.
+    themePicker: { ...state.themePicker, open: false, preview: false },
     skillPicker: { ...state.skillPicker, open: false },
     resourceMenu: { ...state.resourceMenu, open: false, pendingAction: void 0 }
   };
@@ -68286,6 +68272,7 @@ function useSettingsAutoSave(state, saveSettings, dispatch) {
       featureMemory: sp.featureMemory,
       featureSkills: sp.featureSkills,
       featureModelsRegistry: sp.featureModelsRegistry,
+      featureToolCoach: sp.featureToolCoach,
       featureTokenSaving: sp.tokenSavingTier,
       allowOutsideProjectRoot: sp.allowOutsideProjectRoot,
       contextAutoCompact: sp.contextAutoCompact,
@@ -68353,6 +68340,7 @@ function useSettingsAutoSave(state, saveSettings, dispatch) {
     state.settingsPicker.featureMemory,
     state.settingsPicker.featureSkills,
     state.settingsPicker.featureModelsRegistry,
+    state.settingsPicker.featureToolCoach,
     state.settingsPicker.tokenSavingTier,
     state.settingsPicker.allowOutsideProjectRoot,
     state.settingsPicker.contextAutoCompact,
@@ -68570,6 +68558,7 @@ function useStreamChipExpiration({
 
 // src/hooks/use-theme-state.ts
 var import_react102 = __toESM(require_react(), 1);
+import { THEME_RANDOM_ID } from "@wrongstack/core/types";
 function useThemeState({ configStore }) {
   (0, import_react102.useEffect)(() => {
     let randomMode = false;
@@ -68589,7 +68578,7 @@ function useThemeState({ configStore }) {
       }, RANDOM_THEME_ROTATION_MS);
     };
     const syncTheme = (preset) => {
-      if (!preset) {
+      if (!preset || preset === THEME_RANDOM_ID) {
         startRandomMode();
         return;
       }
@@ -70140,6 +70129,7 @@ function createInitialState(options) {
       featureMemory: true,
       featureSkills: true,
       featureModelsRegistry: true,
+      featureToolCoach: true,
       tokenSavingTier: "off",
       allowOutsideProjectRoot: true,
       contextAutoCompact: true,
@@ -70735,6 +70725,11 @@ var composerActionTypes = [
   "themePickerClose",
   "themePickerMove",
   "themePickerHint",
+  "themePickerFilter",
+  "themePickerFilterMode",
+  "themePickerPreview",
+  "themePickerUndo",
+  "themePickerSwapPrevious",
   "modePickerOpen",
   "modePickerClose",
   "modePickerMove",
@@ -70926,7 +70921,14 @@ function reduceComposerPickers(state, action) {
       return {
         ...state,
         ...closePanels(state),
-        themePicker: { open: true, selected, hint: void 0 }
+        themePicker: {
+          open: true,
+          selected,
+          hint: void 0,
+          filter: "",
+          filtering: false,
+          previous: getActiveThemeName()
+        }
       };
     }
     case "themePickerClose":
@@ -70935,7 +70937,9 @@ function reduceComposerPickers(state, action) {
         themePicker: { open: false, selected: 0 }
       };
     case "themePickerMove": {
-      const n = THEME_OPTIONS.length;
+      const visible = filterThemeOptions(THEME_OPTIONS, state.themePicker.filter ?? "");
+      const n = visible.length;
+      if (n === 0) return state;
       const next = (state.themePicker.selected + action.delta + n) % n;
       if (next === state.themePicker.selected) return state;
       return {
@@ -70948,6 +70952,57 @@ function reduceComposerPickers(state, action) {
         ...state,
         themePicker: { ...state.themePicker, hint: action.text }
       };
+    case "themePickerPreview":
+      return {
+        ...state,
+        themePicker: {
+          ...state.themePicker,
+          preview: action.on,
+          // Entering preview re-baselines `previous` to whatever is live RIGHT
+          // NOW, so Esc restores the palette that was in effect when preview
+          // began — not the one from when the picker was first opened.
+          ...action.on ? { previous: getActiveThemeName() } : {}
+        }
+      };
+    case "themePickerFilterMode":
+      return {
+        ...state,
+        themePicker: {
+          ...state.themePicker,
+          filtering: action.on,
+          // Leaving filter mode with `/` also drops the query, so the mode
+          // flag and the visible list can never disagree about what is shown.
+          filter: action.on ? state.themePicker.filter : ""
+        }
+      };
+    case "themePickerFilter": {
+      const previousId = filterThemeOptions(THEME_OPTIONS, state.themePicker.filter ?? "")[state.themePicker.selected]?.id;
+      const visible = filterThemeOptions(THEME_OPTIONS, action.text);
+      const retained = visible.findIndex((o) => o.id === previousId);
+      return {
+        ...state,
+        themePicker: {
+          ...state.themePicker,
+          filter: action.text,
+          selected: retained >= 0 ? retained : 0,
+          hint: void 0
+        }
+      };
+    }
+    case "themePickerUndo":
+      return state;
+    case "themePickerSwapPrevious": {
+      const visible = filterThemeOptions(THEME_OPTIONS, state.themePicker.filter ?? "");
+      const activeIndex = visible.findIndex((o) => o.id === getActiveThemeName());
+      return {
+        ...state,
+        themePicker: {
+          ...state.themePicker,
+          previous: getActiveThemeName(),
+          ...activeIndex >= 0 ? { selected: activeIndex } : {}
+        }
+      };
+    }
     case "modePickerOpen":
       return {
         ...state,
@@ -71357,6 +71412,11 @@ function reduceComposer(state, action) {
     case "themePickerClose":
     case "themePickerMove":
     case "themePickerHint":
+    case "themePickerFilter":
+    case "themePickerFilterMode":
+    case "themePickerPreview":
+    case "themePickerUndo":
+    case "themePickerSwapPrevious":
     case "modePickerOpen":
     case "modePickerClose":
     case "modePickerMove":
@@ -73257,6 +73317,7 @@ function reduceSettingsPanel(state, action) {
           featureMemory: action.featureMemory,
           featureSkills: action.featureSkills,
           featureModelsRegistry: action.featureModelsRegistry,
+          featureToolCoach: action.featureToolCoach,
           tokenSavingTier: action.tokenSavingTier,
           allowOutsideProjectRoot: action.allowOutsideProjectRoot,
           contextAutoCompact: action.contextAutoCompact,
@@ -73851,6 +73912,11 @@ function reduceSettingsValues(state, action) {
             hint: void 0
           }
         };
+      if (f === 63)
+        return {
+          ...state,
+          settingsPicker: { ...sp, featureToolCoach: !sp.featureToolCoach, hint: void 0 }
+        };
       if (f >= PANEL_POSITION_FIELD_START && f - PANEL_POSITION_FIELD_START < PANEL_IDS.length) {
         const PANEL_POSITION_CYCLE = ["bottom", "sidebar"];
         const panelId = PANEL_IDS[f - PANEL_POSITION_FIELD_START];
@@ -75564,18 +75630,50 @@ function createChatSearchSlashCommand(deps) {
 
 // src/connections-slash.ts
 function createConnectionsSlashCommand(deps) {
+  let restarting = false;
   return {
     name: "connections",
     aliases: ["conn", "conns"],
     description: "Show service connection health and restart daemons \u2014 Session Catalog, Chronicle, Codebase Index, SAGE, Kanban, Mailbox, Governance.",
-    argsHint: "[open]",
+    argsHint: "[open|restart]",
     category: "Inspect",
-    help: "Usage:\n  /connections         \u2014 open the interactive service health and restart panel\n  /connections open    \u2014 same as above\n",
-    async run(args) {
+    help: "Usage:\n  /connections         \u2014 open the interactive service health and restart panel\n  /connections open    \u2014 same as above\n  /connections restart \u2014 restart all six supported project daemons without opening the panel\nGovernance is read-only and is excluded from restart.\n",
+    async run(args, ctx) {
       const trimmed = args.trim().toLowerCase();
+      if (trimmed === "restart") {
+        if (!ctx?.projectRoot) return { message: "No active project; cannot restart daemons." };
+        if (restarting) return { message: "Connection daemon restart is already in progress." };
+        restarting = true;
+        try {
+          const { executeConnectionAction: executeConnectionAction2, RESTARTABLE_SERVICES: RESTARTABLE_SERVICES2 } = await Promise.resolve().then(() => (init_connection_actions(), connection_actions_exports));
+          const projectRoot = ctx.projectRoot;
+          const lines = [];
+          let succeeded = 0;
+          for (const serviceId of RESTARTABLE_SERVICES2) {
+            try {
+              const result = await executeConnectionAction2(serviceId, "restart", projectRoot);
+              if (result.success) succeeded++;
+              lines.push(`${result.success ? "OK" : "FAILED"} ${serviceId}: ${result.message}`);
+            } catch (error) {
+              lines.push(
+                `FAILED ${serviceId}: ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+          }
+          return {
+            message: [
+              `Restarted ${succeeded}/${RESTARTABLE_SERVICES2.length} project daemons.`,
+              ...lines,
+              "Governance skipped: read-only service."
+            ].join("\n")
+          };
+        } finally {
+          restarting = false;
+        }
+      }
       const panelRequest = trimmed === "" || trimmed === "open" || trimmed === "--open";
       if (!panelRequest) {
-        return { message: "Usage: /connections [open]" };
+        return { message: "Usage: /connections [open|restart]" };
       }
       const opened = deps.onPanelOpen?.current?.("toggleConnectionsPanel") ?? false;
       if (opened) return { message: "" };
@@ -79586,6 +79684,50 @@ import {
   matchTodoIdFromPrompt
 } from "@wrongstack/tools/auto-proceed-loop-guard";
 import { todoTool } from "@wrongstack/tools/todo";
+
+// src/hooks/failed-run-tracker.ts
+var FAILED_RUN_CONTINUE_PROMPT = "The previous run stopped on an API error (the provider failed after its retries), not on a decision of mine. Continue from where it stopped; do not redo work that is already done. If you cannot tell how far it got, say so and stop.";
+function createFailedRunTracker(events, leaderSessionId) {
+  let providerFailure = null;
+  let pendingFailure = false;
+  const isLeader = (sessionId) => {
+    const leader = leaderSessionId();
+    return sessionId === void 0 || leader === void 0 || sessionId === leader;
+  };
+  const offs = [
+    events.on("agent.run.started", (e) => {
+      if (!isLeader(e.sessionId)) return;
+      providerFailure = null;
+      pendingFailure = false;
+    }),
+    events.on("provider.error", (e) => {
+      if (!isLeader(e.sessionId)) return;
+      providerFailure = { retryable: e.retryable };
+    }),
+    events.on("provider.response", (e) => {
+      if (!isLeader(e.sessionId)) return;
+      providerFailure = null;
+    }),
+    events.on("agent.run.completed", (e) => {
+      if (!isLeader(e.sessionId)) return;
+      pendingFailure = e.status === "failed" && providerFailure?.retryable === true;
+      providerFailure = null;
+    })
+  ];
+  return {
+    pending: () => pendingFailure,
+    consume() {
+      const had = pendingFailure;
+      pendingFailure = false;
+      return had;
+    },
+    dispose() {
+      for (const off of offs) off();
+    }
+  };
+}
+
+// src/hooks/use-next-steps-auto-submit.ts
 async function commitTodoTransition(agent, todos) {
   if (!agent?.ctx?.state) return null;
   try {
@@ -79600,7 +79742,8 @@ function selectAutoProceedCandidate({
   suggestions = [],
   autoSuggestions = [],
   yolo = false,
-  autonomyNextPrompt
+  autonomyNextPrompt,
+  failedRun = false
 }) {
   const todo = resolveContinuation({ todos, suggestions: [] });
   if (todo.source === "todo") {
@@ -79612,7 +79755,12 @@ function selectAutoProceedCandidate({
     return { source: "auto-suggestion", prompt, label: automatic };
   }
   const suggestion = suggestions.find((item) => item.trim().length > 0)?.trim();
-  return suggestion ? { source: "suggestion", prompt: suggestion, label: suggestion } : null;
+  if (suggestion) return { source: "suggestion", prompt: suggestion, label: suggestion };
+  return failedRun ? {
+    source: "failed-run",
+    prompt: FAILED_RUN_CONTINUE_PROMPT,
+    label: "resume after the API error"
+  } : null;
 }
 function useNextStepsAutoSubmit({
   state,
@@ -79646,6 +79794,17 @@ function useNextStepsAutoSubmit({
   const autoSubmitLoopGuardRef = (0, import_react135.useRef)(createAutoProceedLoopGuard());
   const continuationAttemptTrackerRef = (0, import_react135.useRef)(createContinuationAttemptTracker());
   const [nextStepsRecheck, setNextStepsRecheck] = (0, import_react135.useState)(0);
+  const failedRunTrackerRef = (0, import_react135.useRef)(null);
+  (0, import_react135.useEffect)(() => {
+    const events = agent?.events;
+    if (!events) return;
+    const tracker = createFailedRunTracker(events, () => agent?.ctx?.session?.id);
+    failedRunTrackerRef.current = tracker;
+    return () => {
+      tracker.dispose();
+      failedRunTrackerRef.current = null;
+    };
+  }, [agent]);
   (0, import_react135.useEffect)(() => {
     autoSubmitStreakRef.current = 0;
     autoSubmitCapWarnedRef.current = false;
@@ -79665,7 +79824,7 @@ function useNextStepsAutoSubmit({
       nextStepsAutoSubmitTodoIdRef.current = null;
       return;
     }
-    if (state.autoProceedHold) {
+    if (state.autoProceedHold || state.steeringPending) {
       clearInterval(nextStepsAutoSubmitTimerRef.current);
       nextStepsAutoSubmitTimerRef.current = void 0;
       setNextStepsAutoSubmitCountdown(null);
@@ -79691,7 +79850,8 @@ function useNextStepsAutoSubmit({
       suggestions,
       autoSuggestions: isYolo ? getAutoSuggestions?.() ?? [] : [],
       yolo: isYolo,
-      autonomyNextPrompt
+      autonomyNextPrompt,
+      failedRun: failedRunTrackerRef.current?.pending() ?? false
     });
     nextStepsAutoSubmitTodosRef.current = allTodos;
     if (!candidate) {
@@ -79742,6 +79902,7 @@ function useNextStepsAutoSubmit({
         nextStepsAutoSubmitSuggestionRef.current = null;
         nextStepsAutoSubmitSourceRef.current = null;
         nextStepsAutoSubmitTodoIdRef.current = null;
+        if (source === "failed-run") failedRunTrackerRef.current?.consume();
         if (suggestion) {
           if (source === "todo" && todoId) {
             if (agent?.ctx?.state) {
@@ -79835,7 +79996,7 @@ function useNextStepsAutoSubmit({
             }
             setSuggestions?.([]);
             const truncatedForMessage = suggestion.length > 100 ? `${suggestion.slice(0, 97)}\u2026` : suggestion;
-            const reason = source === "todo" ? stalledMatchFailed ? "the stalled prompt could not be matched to any todo on the board" : "No more open todos to advance to" : `the same prompt was fed ${repetition.runLength} times in a row`;
+            const reason = source === "failed-run" ? "the run failed on an API error again after one automatic retry" : source === "todo" ? stalledMatchFailed ? "the stalled prompt could not be matched to any todo on the board" : "No more open todos to advance to" : `the same prompt was fed ${repetition.runLength} times in a row`;
             dispatch({
               type: "addEntry",
               entry: {
@@ -79879,6 +80040,7 @@ ${GROUNDED_NO_PROGRESS_STEER}` : suggestion;
   }, [
     state.status,
     state.autoProceedHold,
+    state.steeringPending,
     autonomyLive,
     state.enhance,
     state.enhanceBusy,
@@ -80127,6 +80289,7 @@ function usePanelControllers({
       featureMemory: s2.featureMemory ?? true,
       featureSkills: s2.featureSkills ?? true,
       featureModelsRegistry: s2.featureModelsRegistry ?? true,
+      featureToolCoach: s2.featureToolCoach ?? true,
       tokenSavingTier: s2.featureTokenSaving ?? "off",
       allowOutsideProjectRoot: s2.allowOutsideProjectRoot ?? true,
       contextAutoCompact: s2.contextAutoCompact ?? true,
@@ -82164,36 +82327,51 @@ function useThemePickerHandler({
   configStore,
   saveThemePreset,
   dispatch,
-  selectedIndex: selectedIndex2
+  selectedIndex: selectedIndex2,
+  filter,
+  previous
 }) {
+  const applyPreset = (0, import_react149.useCallback)(
+    (presetName, verb) => {
+      setActiveTheme(presetName);
+      try {
+        configStore?.update({ themePreset: presetName });
+        void saveThemePreset?.(presetName).catch((err) => {
+          dispatch({
+            type: "addEntry",
+            entry: {
+              kind: "warn",
+              text: `Theme applied in-memory but could not persist to disk: ${err instanceof Error ? err.message : String(err)}`
+            }
+          });
+        });
+      } catch {
+      }
+      dispatch({
+        type: "addEntry",
+        entry: {
+          kind: "info",
+          text: `Theme preset ${verb} "${presetName}"${getActiveThemeName() === presetName ? "" : ` (fallback applied: ${getActiveThemeName()})`}.`
+        }
+      });
+    },
+    [configStore, dispatch, saveThemePreset]
+  );
   const onThemePickerEnter = (0, import_react149.useCallback)(() => {
-    const preset = THEME_OPTIONS[Math.max(0, selectedIndex2)];
+    const preset = filterThemeOptions(THEME_OPTIONS, filter ?? "")[Math.max(0, selectedIndex2)];
     const presetName = preset?.id;
     if (!presetName) return;
-    setActiveTheme(presetName);
-    try {
-      configStore?.update({ themePreset: presetName });
-      void saveThemePreset?.(presetName).catch((err) => {
-        dispatch({
-          type: "addEntry",
-          entry: {
-            kind: "warn",
-            text: `Theme applied in-memory but could not persist to disk: ${err instanceof Error ? err.message : String(err)}`
-          }
-        });
-      });
-    } catch {
-    }
-    dispatch({
-      type: "addEntry",
-      entry: {
-        kind: "info",
-        text: `Theme preset switched to "${presetName}"${getActiveThemeName() === presetName ? "" : ` (fallback applied: ${getActiveThemeName()})`}.`
-      }
-    });
+    applyPreset(presetName, "switched to");
     dispatch({ type: "themePickerClose" });
-  }, [configStore, dispatch, saveThemePreset, selectedIndex2]);
-  return { onThemePickerEnter };
+  }, [applyPreset, dispatch, filter, selectedIndex2]);
+  const onThemePickerUndo = (0, import_react149.useCallback)(() => {
+    if (previous === void 0 || previous === getActiveThemeName()) return;
+    const current = getActiveThemeName();
+    applyPreset(previous, "restored to");
+    dispatch({ type: "themePickerHint", text: `Undid \u2192 ${previous} (was ${current})` });
+    dispatch({ type: "themePickerSwapPrevious" });
+  }, [applyPreset, dispatch, previous]);
+  return { onThemePickerEnter, onThemePickerUndo };
 }
 
 // src/hooks/use-tui-controllers.ts
@@ -83598,7 +83776,8 @@ function useSettingsSlashCommands(deps, part) {
     state,
     hiddenItemsRef,
     setHiddenItems,
-    openStatuslinePicker
+    openStatuslinePicker,
+    applyThemePreset
   } = deps;
   (0, import_react158.useEffect)(() => {
     if (part !== "core") return;
@@ -83870,10 +84049,11 @@ Available chords:
               message: `Unknown theme preset "${arg}". Available: ${names}`
             };
           }
-          dispatch({
-            type: "themePickerOpen",
-            selected: presetIdx
-          });
+          if (applyThemePreset) {
+            applyThemePreset(THEME_OPTIONS[presetIdx].id);
+            return { message: void 0 };
+          }
+          dispatch({ type: "themePickerOpen", selected: presetIdx });
           return { message: void 0 };
         }
         dispatch({ type: "themePickerOpen" });
@@ -83909,7 +84089,10 @@ function useTuiSlashCommands({
   setMailboxPanelOpen,
   switchAutonomy,
   listSessions,
-  openPromptPicker
+  openPromptPicker,
+  configStore,
+  saveThemePreset,
+  applyThemePreset
 }) {
   const sliceDeps = {
     slashRegistry,
@@ -83932,7 +84115,10 @@ function useTuiSlashCommands({
     setMailboxPanelOpen,
     switchAutonomy,
     listSessions,
-    openPromptPicker
+    openPromptPicker,
+    configStore,
+    saveThemePreset,
+    applyThemePreset
   };
   useSessionSlashCommands(sliceDeps, "head");
   useProviderSlashCommands(sliceDeps);
@@ -84271,6 +84457,7 @@ function routeSettingsOverlayKey(host, input, key2, isEnter) {
     featureMemory: config.featureMemory ?? true,
     featureSkills: config.featureSkills ?? true,
     featureModelsRegistry: config.featureModelsRegistry ?? true,
+    featureToolCoach: config.featureToolCoach ?? true,
     tokenSavingTier: config.featureTokenSaving ?? "off",
     allowOutsideProjectRoot: config.allowOutsideProjectRoot ?? true,
     contextAutoCompact: config.contextAutoCompact ?? true,
@@ -87190,19 +87377,33 @@ function tryAuthModelPickerKeys(host, input, key2, isEnter, debouncedEnter2) {
   if (state.themePicker.open) {
     if (key2.ctrl || key2.meta) return true;
     if (key2.escape) {
+      if (state.themePicker.preview) {
+        if (state.themePicker.previous) setActiveTheme(state.themePicker.previous);
+        dispatch({ type: "themePickerPreview", on: false });
+        dispatch({ type: "themePickerClose" });
+        return true;
+      }
+      if (state.themePicker.filtering || state.themePicker.filter) {
+        dispatch({ type: "themePickerFilterMode", on: false });
+        return true;
+      }
       dispatch({ type: "themePickerClose" });
       return true;
     }
-    if (key2.mouse?.kind === "wheel") {
-      dispatch({ type: "themePickerMove", delta: key2.mouse.wheel > 0 ? -1 : 1 });
-      return true;
-    }
-    if (key2.upArrow) {
-      dispatch({ type: "themePickerMove", delta: -1 });
+    if (!state.themePicker.filtering && input === "p") {
+      dispatch({ type: "themePickerPreview", on: !state.themePicker.preview });
       return true;
     }
-    if (key2.downArrow) {
-      dispatch({ type: "themePickerMove", delta: 1 });
+    const previewed = state.themePicker.preview;
+    const moveBy = key2.mouse?.kind === "wheel" ? key2.mouse.wheel > 0 ? -1 : 1 : 0;
+    if (key2.upArrow || key2.downArrow || moveBy !== 0) {
+      const delta = key2.upArrow ? -1 : key2.downArrow ? 1 : moveBy;
+      const next = (state.themePicker.selected + delta + filterThemeOptions(THEME_OPTIONS, state.themePicker.filter ?? "").length) % filterThemeOptions(THEME_OPTIONS, state.themePicker.filter ?? "").length;
+      if (previewed) {
+        const focused = filterThemeOptions(THEME_OPTIONS, state.themePicker.filter ?? "")[next];
+        if (focused) setActiveTheme(focused.id);
+      }
+      dispatch({ type: "themePickerMove", delta });
       return true;
     }
     if (isEnter) {
@@ -87215,6 +87416,30 @@ function tryAuthModelPickerKeys(host, input, key2, isEnter, debouncedEnter2) {
       }
       return true;
     }
+    const query = state.themePicker.filter ?? "";
+    if (!key2.ctrl && input === "/") {
+      dispatch({ type: "themePickerFilterMode", on: !state.themePicker.filtering });
+      return true;
+    }
+    if (state.themePicker.filtering) {
+      if (key2.delete || input === "\x7F" || key2.backspace) {
+        dispatch({ type: "themePickerFilter", text: query.slice(0, -1) });
+        return true;
+      }
+      if (input && !key2.ctrl && !key2.meta && input.length === 1 && input >= " ") {
+        dispatch({ type: "themePickerFilter", text: query + input });
+        return true;
+      }
+    }
+    if (!state.themePicker.filtering && input === "u") {
+      host.inputGateRef.current = true;
+      try {
+        host.onThemePickerUndo?.();
+      } finally {
+        host.inputGateRef.current = false;
+      }
+      return true;
+    }
     return true;
   }
   if (state.skillPicker.open) {
@@ -88148,6 +88373,7 @@ function useAppPickerKeys({
   statuslineHiddenForPicker,
   onPickerEnter,
   onThemePickerEnter,
+  onThemePickerUndo,
   setPromptFavorite
 }) {
   const {
@@ -88646,7 +88872,8 @@ function useAppPickerKeys({
       if (action) dispatch(action);
     },
     onPickerEnter,
-    onThemePickerEnter
+    onThemePickerEnter,
+    onThemePickerUndo
   });
 }
 
@@ -89187,6 +89414,7 @@ function useControllerKeyPipeline({
   statuslineHiddenForPicker,
   onPickerEnter,
   onThemePickerEnter,
+  onThemePickerUndo,
   setPromptFavorite,
   stateRef,
   exitRequestedRef,
@@ -89306,6 +89534,7 @@ function useControllerKeyPipeline({
     statuslineHiddenForPicker,
     onPickerEnter,
     onThemePickerEnter,
+    onThemePickerUndo,
     setPromptFavorite
   });
   const { interruptsSyncRef, runInterruptLadder } = useInterruptLadder({
@@ -89926,6 +90155,30 @@ function useAppController(props) {
     clearDraft,
     runBlocksRef
   });
+  const applyThemePreset = (0, import_react163.useCallback)(
+    (preset) => {
+      setActiveTheme(preset);
+      const warnPersist = (err) => dispatch({
+        type: "addEntry",
+        entry: {
+          kind: "warn",
+          text: `Theme applied in-memory but could not persist to disk: ${err instanceof Error ? err.message : String(err)}`
+        }
+      });
+      try {
+        configStore?.update({ themePreset: preset });
+      } catch (err) {
+        warnPersist(err);
+        return;
+      }
+      try {
+        void props.saveThemePreset?.(preset).catch(warnPersist);
+      } catch (err) {
+        warnPersist(err);
+      }
+    },
+    [configStore, dispatch, props.saveThemePreset]
+  );
   useTuiSlashCommands({
     slashRegistry,
     skillLoader: props.skillLoader,
@@ -89947,7 +90200,9 @@ function useAppController(props) {
     setMailboxPanelOpen,
     switchAutonomy,
     listSessions,
-    openPromptPicker
+    openPromptPicker,
+    configStore,
+    applyThemePreset
   });
   useProviderEventBridge({
     events,
@@ -90067,11 +90322,13 @@ function useAppController(props) {
     setDraft,
     tokenPreviewsRef
   });
-  const { onThemePickerEnter } = useThemePickerHandler({
+  const { onThemePickerEnter, onThemePickerUndo } = useThemePickerHandler({
     configStore,
     saveThemePreset: props.saveThemePreset,
     dispatch,
-    selectedIndex: state.themePicker.selected
+    selectedIndex: state.themePicker.selected,
+    filter: state.themePicker.filter,
+    previous: state.themePicker.previous
   });
   const { runInterruptLadder, stableOnKey } = useControllerKeyPipeline({
     sessionGenerationRef,
@@ -90098,6 +90355,7 @@ function useAppController(props) {
     statuslineHiddenForPicker,
     onPickerEnter,
     onThemePickerEnter,
+    onThemePickerUndo,
     setPromptFavorite,
     stateRef,
     exitRequestedRef,