@wrongstack/tui 0.309.1 → 0.310.0

package/dist/components/context-panel.d.ts

@@ -14,10 +14,19 @@ export interface ContextPanelData {
      * Surfaced in the panel so `/context` answers "how much of my spend
      * is hitting the cache" without asking the user to chase the CLI
      * `/context cache` subcommand.
+     *
+     * `savedUsd` is the gross read-discount USD figure computed by the
+     * counter (cache-read tokens × (input price − cache-read price)).
+     * `cacheWrite5m` / `cacheWrite1h` are present when the upstream exposed
+     * an Anthropic-style TTL split (Anthropic family, including MiniMax
+     * routed through the Anthropic Messages surface); OpenAI-family
+     * gateways emit only the aggregate and leave them undefined.
      */
     cacheStats?: {
         readTokens: number;
         writeTokens: number;
+        cacheWrite5m?: number | undefined;
+        cacheWrite1h?: number | undefined;
         hitRatio: number;
         savedUsd: number;
     } | undefined;
@@ -27,6 +36,16 @@ export interface ContextPanelData {
      * exact extent of the cache, not just a percentage.
      */
     cacheCoverageTokens?: number | undefined;
+    /** Session cache telemetry split by provider, including fallback/model switches. */
+    providerCacheStats?: Array<{
+        provider: string;
+        input: number;
+        cacheRead: number;
+        cacheWrite: number;
+        cacheWrite5m?: number | undefined;
+        cacheWrite1h?: number | undefined;
+        hitRatio: number;
+    }> | undefined;
     /**
      * Real, measured per-category token accounting for the live request. When
      * present the Composition tab shows honest numbers; when absent (no request

package/dist/index.js

@@ -5439,6 +5439,7 @@ function MetricsSection({ data }) {
 function CacheSection({ data }) {
   const cs = data.cacheStats ?? { readTokens: 0, writeTokens: 0, hitRatio: 0, savedUsd: 0 };
   const hasCache = cs.readTokens > 0 || cs.writeTokens > 0;
+  const hasTtlSplit = cs.cacheWrite5m !== void 0 && cs.cacheWrite1h !== void 0;
   const coverage = Math.max(0, data.cacheCoverageTokens ?? 0);
   const max = data.ctxMaxTokens ?? 0;
   const covBarLen = 30;
@@ -5455,8 +5456,58 @@ function CacheSection({ data }) {
       /* @__PURE__ */ jsx10(Text, { color: theme.textMuted, children: " \xB7 read " }),
       /* @__PURE__ */ jsx10(Text, { color: theme.textPrimary, children: cs.readTokens.toLocaleString("en-US") }),
       /* @__PURE__ */ jsx10(Text, { color: theme.textMuted, children: " \xB7 write " }),
-      /* @__PURE__ */ jsx10(Text, { color: theme.textSecondary, children: cs.writeTokens.toLocaleString("en-US") })
+      /* @__PURE__ */ jsx10(Text, { color: theme.textSecondary, children: cs.writeTokens.toLocaleString("en-US") }),
+      cs.savedUsd > 0 ? /* @__PURE__ */ jsxs9(Fragment4, { children: [
+        /* @__PURE__ */ jsx10(Text, { color: theme.textMuted, children: " \xB7 saved " }),
+        /* @__PURE__ */ jsxs9(Text, { color: theme.success, children: [
+          "~$",
+          cs.savedUsd.toFixed(2)
+        ] })
+      ] }) : null
     ] }),
+    hasTtlSplit ? /* @__PURE__ */ jsxs9(Box, { children: [
+      /* @__PURE__ */ jsx10(Text, { color: theme.textMuted, children: "Write TTL " }),
+      /* @__PURE__ */ jsxs9(Text, { color: theme.textPrimary, children: [
+        "5m ",
+        (cs.cacheWrite5m ?? 0).toLocaleString("en-US")
+      ] }),
+      /* @__PURE__ */ jsx10(Text, { color: theme.textMuted, children: " \xB7 " }),
+      /* @__PURE__ */ jsxs9(Text, { color: theme.textSecondary, children: [
+        "1h ",
+        (cs.cacheWrite1h ?? 0).toLocaleString("en-US")
+      ] })
+    ] }) : null,
+    (data.providerCacheStats?.length ?? 0) > 0 ? /* @__PURE__ */ jsxs9(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx10(Text, { color: theme.textMuted, children: "Providers" }),
+      data.providerCacheStats?.map((provider) => /* @__PURE__ */ jsxs9(Text, { children: [
+        /* @__PURE__ */ jsxs9(Text, { color: theme.textPrimary, children: [
+          " ",
+          provider.provider
+        ] }),
+        /* @__PURE__ */ jsx10(Text, { color: theme.textMuted, children: " \xB7 " }),
+        /* @__PURE__ */ jsxs9(Text, { color: provider.cacheRead > 0 ? theme.success : theme.textMuted, children: [
+          (provider.hitRatio * 100).toFixed(1),
+          "%"
+        ] }),
+        /* @__PURE__ */ jsx10(Text, { color: theme.textMuted, children: " \xB7 read " }),
+        /* @__PURE__ */ jsx10(Text, { color: theme.textPrimary, children: provider.cacheRead.toLocaleString("en-US") }),
+        /* @__PURE__ */ jsx10(Text, { color: theme.textMuted, children: " \xB7 write " }),
+        /* @__PURE__ */ jsx10(Text, { color: theme.textSecondary, children: provider.cacheWrite.toLocaleString("en-US") }),
+        provider.cacheWrite5m !== void 0 && provider.cacheWrite1h !== void 0 ? /* @__PURE__ */ jsxs9(Fragment4, { children: [
+          /* @__PURE__ */ jsx10(Text, { color: theme.textMuted, children: " (" }),
+          /* @__PURE__ */ jsxs9(Text, { color: theme.textPrimary, children: [
+            "5m ",
+            provider.cacheWrite5m.toLocaleString("en-US")
+          ] }),
+          /* @__PURE__ */ jsx10(Text, { color: theme.textMuted, children: ", " }),
+          /* @__PURE__ */ jsxs9(Text, { color: theme.textSecondary, children: [
+            "1h ",
+            provider.cacheWrite1h.toLocaleString("en-US")
+          ] }),
+          /* @__PURE__ */ jsx10(Text, { color: theme.textMuted, children: ")" })
+        ] }) : null
+      ] }, provider.provider))
+    ] }) : null,
     coverage > 0 && max > 0 ? /* @__PURE__ */ jsxs9(Fragment4, { children: [
       /* @__PURE__ */ jsxs9(Box, { marginTop: 1, children: [
         /* @__PURE__ */ jsx10(Text, { color: theme.textMuted, children: "Coverage " }),
@@ -10316,6 +10367,7 @@ function AppStatusRegion({
             })(),
             cacheStats: cacheStats ?? { readTokens: 0, writeTokens: 0, hitRatio: 0, savedUsd: 0 },
             cacheCoverageTokens: cacheCoverageTokens ?? 0,
+            providerCacheStats: cacheStats?.providers ?? [],
             fleetEntries: Object.values(state.fleet).map((e) => ({
               name: e.name,
               status: e.status,
@@ -20901,6 +20953,7 @@ function SidebarContent({
   const cs = cacheStats ?? { readTokens: 0, writeTokens: 0, hitRatio: 0, savedUsd: 0 };
   const hasCacheActivity = cs.readTokens > 0 || cs.writeTokens > 0;
   const cacheHitPct = Math.round(cs.hitRatio * 100);
+  const activeProviderCache = cs.providers?.find((entry) => entry.provider === provider);
   const cacheCoveragePct = contextWindow && contextWindow.max > 0 ? Math.min(100, Math.round(cacheCoverageTokens / contextWindow.max * 100)) : 0;
   const MAX_SIDEBAR_AGENTS = 12;
   const allEntries = Object.values(entries);
@@ -21065,6 +21118,16 @@ function SidebarContent({
             )
           ) })
         ] }),
+        /* @__PURE__ */ jsx78(
+          SidebarStatRow,
+          {
+            label: `${activeProviderCache?.provider ?? provider ?? "provider"} hit`,
+            value: activeProviderCache ? `${(activeProviderCache.hitRatio * 100).toFixed(1)}%` : `${cacheHitPct}%`,
+            color: theme.success,
+            accent: theme.success,
+            innerWidth: bodyWidth
+          }
+        ),
         /* @__PURE__ */ jsx78(
           SidebarStatRow,
           {
@@ -46254,6 +46317,50 @@ function createRunTuiClientRegistration(opts) {
   return { register, unregister };
 }
 
+// src/run-tui-teardown.ts
+var DEFAULT_CLOSE_BUDGET_MS = 1500;
+function createDurableTeardown(opts) {
+  const closeBudgetMs = opts.closeBudgetMs ?? DEFAULT_CLOSE_BUDGET_MS;
+  const salvageSync = () => {
+    try {
+      opts.getSession()?.flushSync?.();
+    } catch {
+    }
+  };
+  const awaitCloseBounded = async () => {
+    await Promise.race([
+      (async () => {
+        try {
+          await opts.getSession()?.close();
+        } catch {
+        }
+      })(),
+      new Promise((resolve) => {
+        const t = setTimeout(resolve, closeBudgetMs);
+        t.unref();
+      })
+    ]);
+  };
+  const awaitDurableClose = async () => {
+    salvageSync();
+    try {
+      opts.cleanup();
+    } catch {
+    }
+    await awaitCloseBounded();
+    salvageSync();
+  };
+  const shutdownViaSignal = async (exitCode) => {
+    try {
+      opts.killChildren?.();
+    } catch {
+    }
+    await awaitDurableClose();
+    opts.exit(exitCode);
+  };
+  return { shutdownViaSignal, awaitDurableClose, salvageSync };
+}
+
 // src/run-tui-title-controller.ts
 import * as path11 from "node:path";
 
@@ -46508,6 +46615,24 @@ async function runTui(opts) {
       unsilenceTerminal();
     }
   };
+  let resolveRun;
+  let runExitCode = 0;
+  const finishRun = (code) => {
+    detachListeners();
+    if (!resolveRun) return;
+    const resolve = resolveRun;
+    resolveRun = void 0;
+    resolve(code);
+  };
+  const durableTeardown = createDurableTeardown({
+    getSession: () => opts.agent.ctx.session,
+    killChildren: () => getProcessRegistry10().killAll({ force: true, preserveBackground: true }),
+    cleanup,
+    // Resolve the host instead of process.exit so CLI teardown (plugin
+    // stop, Telegram lock.release, vector-memory close) still runs.
+    // Rapid Ctrl+C and the hung-unmount timer still hard-exit.
+    exit: (code) => finishRun(code)
+  });
   const RAPID_EXIT_WINDOW_MS = 2e3;
   const RAPID_EXIT_THRESHOLD = 2;
   let ctrlCPressTimestamps = [];
@@ -46518,21 +46643,20 @@ async function runTui(opts) {
       getProcessRegistry10().killAll({ force: true, preserveBackground: true });
     } catch {
     }
-    try {
-      opts.agent.ctx.session.flushSync?.();
-    } catch {
-    }
+    durableTeardown.salvageSync();
     cleanup();
     process.exit(130);
   };
   const signals = ["SIGTERM", "SIGHUP", "SIGINT"];
   const signalHandler = () => {
+    runExitCode = 143;
     inkInstance?.unmount();
+    void durableTeardown.shutdownViaSignal(143);
+  };
+  const exitHandler = () => {
+    durableTeardown.salvageSync();
     cleanup();
-    const sig = setTimeout(() => process.exit(143), 5e3);
-    sig.unref();
   };
-  const exitHandler = () => cleanup();
   const sigintHandler = () => {
     const now = Date.now();
     ctrlCPressTimestamps = ctrlCPressTimestamps.filter((t) => now - t < RAPID_EXIT_WINDOW_MS);
@@ -46542,10 +46666,9 @@ async function runTui(opts) {
       forceExitViaRapidCtrlC();
       return;
     }
+    runExitCode = 130;
     inkInstance?.unmount();
-    cleanup();
-    const sig = setTimeout(() => process.exit(130), 5e3);
-    sig.unref();
+    void durableTeardown.shutdownViaSignal(130);
   };
   process.on("SIGINT", sigintHandler);
   for (const s2 of ["SIGTERM", "SIGHUP", "SIGBREAK"]) {
@@ -46584,24 +46707,32 @@ async function runTui(opts) {
   };
   void tuiClientRegistration.register();
   return new Promise((resolve) => {
-    let exitCode = 0;
+    resolveRun = resolve;
     let hardExitTimer = null;
     const onExit = (code) => {
-      exitCode = code;
+      runExitCode = code;
     };
     const settle = (code) => {
       if (hardExitTimer) {
         clearTimeout(hardExitTimer);
         hardExitTimer = null;
       }
-      cleanup();
-      detachListeners();
-      resolve(code);
+      void durableTeardown.awaitDurableClose().then(
+        () => finishRun(code),
+        () => finishRun(code)
+      );
     };
     const requestExit = (code) => {
       onExit(code);
       inkInstance?.unmount();
-      hardExitTimer = setTimeout(() => process.exit(code), 5e3);
+      hardExitTimer = setTimeout(() => {
+        durableTeardown.salvageSync();
+        try {
+          getProcessRegistry10().killAll({ force: true, preserveBackground: true });
+        } catch {
+        }
+        process.exit(code);
+      }, 5e3);
       hardExitTimer.unref();
     };
     opts.requestExit = requestExit;
@@ -46772,7 +46903,7 @@ async function runTui(opts) {
     detachResize = () => stdout.off("resize", onResize2);
     instance.waitUntilExit().then(() => {
       detachResize?.();
-      settle(exitCode);
+      settle(runExitCode);
     }).catch(() => {
       detachResize?.();
       settle(1);

package/dist/run-tui-teardown.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Durable teardown primitives for the TUI host.
+ *
+ * Extracted from run-tui.ts so the kill-safety semantics are unit-testable
+ * without an Ink render loop.
+ *
+ * Why both a sync and an async step exist:
+ *   - `flushSync()` drains the writer's in-memory buffer with blocking
+ *     writes. That data survives ANY concurrent hard exit (the host's
+ *     500ms exit-grace timer, a second Ctrl+C, a supervisor SIGKILL racing
+ *     us) because by the time it returns, the bytes are already handed to
+ *     the OS.
+ *   - `close()` additionally drains the async write chain, `datasync()`s
+ *     the handle, and writes the `.summary.json` sidecar + `_index.jsonl`
+ *     row. That work is async, cannot be forced synchronous, and therefore
+ *     gets a bounded budget instead of being trusted to outlive the loop.
+ *
+ * Ordering contract of `shutdownViaSignal`:
+ *   1. killChildren   — stop tool subprocesses from producing new events.
+ *   2. salvageSync    — buffered events are durably on disk from here on.
+ *   3. cleanup        — terminal restore; also kicks off close() (idempotent).
+ *   4. await close    — bounded by closeBudgetMs; never hangs shutdown.
+ *   5. salvageSync    — catch anything close() re-buffered while failing.
+ *   6. exit           — caller-supplied exit function.
+ */
+/** Structural subset of SessionWriter the teardown needs. */
+export interface TeardownSession {
+    /** Durable drain: buffer → disk → datasync → sidecar/index. Idempotent. */
+    close(): Promise<void>;
+    /** Last-gasp synchronous drain of whatever is still in memory. */
+    flushSync?(): void;
+}
+export interface DurableTeardownOptions {
+    /** Reads the CURRENT writer so swaps (e.g. /resume) stay covered. */
+    getSession: () => TeardownSession | undefined;
+    /** Foreground child cleanup (process registry killAll). Best-effort. */
+    killChildren?: (() => void) | undefined;
+    /** Terminal restore + client unregister. Idempotent. */
+    cleanup: () => void;
+    /** Hard ceiling for awaiting close(). Default 1500ms. */
+    closeBudgetMs?: number;
+    /** Exit function — injectable so tests don't need process.exit. */
+    exit: (code: number) => void;
+}
+export interface DurableTeardown {
+    /**
+     * Signal-driven shutdown (SIGTERM/SIGHUP/Ctrl+C): full ordered sequence,
+     * ends by calling exit(). Safe to fire concurrently from several handlers
+     * — every step is idempotent and exit wins once.
+     */
+    shutdownViaSignal(exitCode: number): Promise<void>;
+    /**
+     * Awaited close WITHOUT exiting — used by the natural exit path (settle)
+     * so the host continues only after durability, and project-switch respawns
+     * keep working.
+     */
+    awaitDurableClose(): Promise<void>;
+    /** Sync-only last-chance drain for 'exit' listeners / process.exit contexts. */
+    salvageSync(): void;
+}
+export declare function createDurableTeardown(opts: DurableTeardownOptions): DurableTeardown;
+//# sourceMappingURL=run-tui-teardown.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/tui",
-  "version": "0.309.1",
+  "version": "0.310.0",
   "license": "MIT",
   "description": "WrongStack terminal UI: Ink-based interactive renderer with history, pickers, and slash menus.",
   "repository": {
@@ -29,12 +29,12 @@
     "ink": "7.1.1",
     "react": "^19.2.8",
     "string-width": "8.2.2",
-    "@wrongstack/core": "0.309.1",
-    "@wrongstack/sage": "0.309.1",
-    "@wrongstack/runtime": "0.309.1",
-    "@wrongstack/kanban": "0.309.1",
-    "@wrongstack/sdd": "0.309.1",
-    "@wrongstack/tools": "0.309.1"
+    "@wrongstack/core": "0.310.0",
+    "@wrongstack/kanban": "0.310.0",
+    "@wrongstack/runtime": "0.310.0",
+    "@wrongstack/sage": "0.310.0",
+    "@wrongstack/sdd": "0.310.0",
+    "@wrongstack/tools": "0.310.0"
   },
   "devDependencies": {
     "@testing-library/dom": "^10.4.1",