claudish 7.46.0 → 7.47.0

package/dist/index.js

@@ -729,7 +729,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.46.0";
+var VERSION = "7.47.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -29217,6 +29217,11 @@ function removeUriFormat(schema) {
   }
   return result;
 }
+function stripBillingHeader(text) {
+  if (!text || !text.includes("x-anthropic-billing-header"))
+    return text;
+  return text.replace(BILLING_HEADER_RE, "");
+}
 function transformOpenAIToClaude(claudeRequestInput) {
   const req = JSON.parse(JSON.stringify(claudeRequestInput));
   const isO3Model = typeof req.model === "string" && (req.model.includes("o3") || req.model.includes("o1"));
@@ -29240,9 +29245,11 @@ function transformOpenAIToClaude(claudeRequestInput) {
         }
       }
       return JSON.stringify(item);
-    }).filter((text) => text && text.trim() !== "").join(`
+    }).map((text) => stripBillingHeader(text)).filter((text) => text && text.trim() !== "").join(`
 
 `);
+  } else if (typeof req.system === "string") {
+    req.system = stripBillingHeader(req.system);
   }
   if (!Array.isArray(req.messages)) {
     if (req.messages == null)
@@ -29264,7 +29271,10 @@ function transformOpenAIToClaude(claudeRequestInput) {
     isO3Model
   };
 }
-var init_transform = () => {};
+var BILLING_HEADER_RE;
+var init_transform = __esm(() => {
+  BILLING_HEADER_RE = /x-anthropic-billing-header:[^\n]*\n?/gi;
+});
 
 // src/handlers/shared/format/openai-tools.ts
 function emptyParamsSchema() {
@@ -33137,6 +33147,13 @@ function createStreamingResponseHandler(c, response, adapter, target, middleware
     async start(controller) {
       const send = (e, d) => {
         if (!isClosed) {
+          if (e === "content_block_start" && d?.content_block?.type === "tool_use") {
+            try {
+              behavior?.onToolCallObserved?.(String(d.content_block.name ?? ""));
+            } catch (err) {
+              log(`[Streaming] onToolCallObserved threw: ${err}`);
+            }
+          }
           controller.enqueue(encoder.encode(`event: ${e}
 data: ${JSON.stringify(d)}
 
@@ -33164,54 +33181,98 @@ data: ${JSON.stringify(d)}
           send("ping", { type: "ping" });
         }
       }, 1000);
+      const teardown = () => {
+        if (!isClosed) {
+          try {
+            controller.enqueue(encoder.encode(`data: [DONE]
+
+
+`));
+          } catch {}
+          try {
+            controller.close();
+          } catch {}
+          isClosed = true;
+        }
+        if (ping) {
+          clearInterval(ping);
+          ping = null;
+        }
+      };
       const finalize = async (reason, err) => {
-        if (state.finalized)
+        if (state.finalized) {
+          teardown();
           return;
+        }
         state.finalized = true;
-        if (state.accumulatedText.length > 0) {
-          const preview = state.accumulatedText.slice(0, 500).replace(/\n/g, "\\n");
-          log(`[Streaming] Accumulated text (${state.accumulatedText.length} chars): ${preview}...`);
-        }
-        const textToolCalls = extractToolCallsFromText(state.accumulatedText);
-        log(`[Streaming] Text-based tool calls found: ${textToolCalls.length}`);
-        if (textToolCalls.length > 0) {
-          log(`[Streaming] Found ${textToolCalls.length} text-based tool call(s), converting to structured format`);
+        try {
+          if (state.accumulatedText.length > 0) {
+            const preview = state.accumulatedText.slice(0, 500).replace(/\n/g, "\\n");
+            log(`[Streaming] Accumulated text (${state.accumulatedText.length} chars): ${preview}...`);
+          }
+          const textToolCalls = extractToolCallsFromText(state.accumulatedText);
+          log(`[Streaming] Text-based tool calls found: ${textToolCalls.length}`);
+          if (textToolCalls.length > 0) {
+            log(`[Streaming] Found ${textToolCalls.length} text-based tool call(s), converting to structured format`);
+            if (state.textStarted) {
+              send("content_block_stop", { type: "content_block_stop", index: state.textIdx });
+              state.textStarted = false;
+            }
+            for (const tc of textToolCalls) {
+              const toolIdx = state.curIdx++;
+              const toolId = `tool_${Date.now()}_${toolIdx}`;
+              send("content_block_start", {
+                type: "content_block_start",
+                index: toolIdx,
+                content_block: { type: "tool_use", id: toolId, name: tc.name }
+              });
+              send("content_block_delta", {
+                type: "content_block_delta",
+                index: toolIdx,
+                delta: {
+                  type: "input_json_delta",
+                  partial_json: repairArgs(tc.name, JSON.stringify(tc.arguments))
+                }
+              });
+              send("content_block_stop", { type: "content_block_stop", index: toolIdx });
+            }
+          }
+          if (state.reasoningStarted) {
+            send("content_block_stop", { type: "content_block_stop", index: state.reasoningIdx });
+          }
           if (state.textStarted) {
             send("content_block_stop", { type: "content_block_stop", index: state.textIdx });
-            state.textStarted = false;
           }
-          for (const tc of textToolCalls) {
-            const toolIdx = state.curIdx++;
-            const toolId = `tool_${Date.now()}_${toolIdx}`;
-            send("content_block_start", {
-              type: "content_block_start",
-              index: toolIdx,
-              content_block: { type: "tool_use", id: toolId, name: tc.name }
-            });
-            send("content_block_delta", {
-              type: "content_block_delta",
-              index: toolIdx,
-              delta: {
-                type: "input_json_delta",
-                partial_json: repairArgs(tc.name, JSON.stringify(tc.arguments))
-              }
-            });
-            send("content_block_stop", { type: "content_block_stop", index: toolIdx });
-          }
-        }
-        if (state.reasoningStarted) {
-          send("content_block_stop", { type: "content_block_stop", index: state.reasoningIdx });
-        }
-        if (state.textStarted) {
-          send("content_block_stop", { type: "content_block_stop", index: state.textIdx });
-        }
-        for (const t of Array.from(state.tools.values())) {
-          if (!t.closed && t.buffered && !t.started) {
-            if (toolSchemas && toolSchemas.length > 0) {
-              const validation = validateToolArguments(t.name, t.arguments, toolSchemas, state.accumulatedText);
-              if (validation.valid || validation.repaired && validation.repairedArgs) {
-                const argsJson = repairArgs(t.name, JSON.stringify(validation.repaired ? validation.repairedArgs : validation.parsedArgs));
-                log(`[Streaming] Sending buffered tool call (finish_reason!=tool_calls): ${t.name} with args: ${argsJson}`);
+          for (const t of Array.from(state.tools.values())) {
+            if (!t.closed && t.buffered && !t.started) {
+              if (toolSchemas && toolSchemas.length > 0) {
+                const validation = validateToolArguments(t.name, t.arguments, toolSchemas, state.accumulatedText);
+                if (validation.valid || validation.repaired && validation.repairedArgs) {
+                  const argsJson = repairArgs(t.name, JSON.stringify(validation.repaired ? validation.repairedArgs : validation.parsedArgs));
+                  log(`[Streaming] Sending buffered tool call (finish_reason!=tool_calls): ${t.name} with args: ${argsJson}`);
+                  send("content_block_start", {
+                    type: "content_block_start",
+                    index: t.blockIndex,
+                    content_block: { type: "tool_use", id: t.id, name: t.name }
+                  });
+                  send("content_block_delta", {
+                    type: "content_block_delta",
+                    index: t.blockIndex,
+                    delta: { type: "input_json_delta", partial_json: argsJson }
+                  });
+                  send("content_block_stop", {
+                    type: "content_block_stop",
+                    index: t.blockIndex
+                  });
+                  t.started = true;
+                  t.closed = true;
+                } else {
+                  log(`[Streaming] Buffered tool call ${t.name} failed validation, skipping: ${validation.missingParams.join(", ")}`);
+                  t.closed = true;
+                }
+              } else {
+                const argsJson = repairArgs(t.name, t.arguments || "{}");
+                log(`[Streaming] Sending buffered tool call (no validation): ${t.name} with args: ${argsJson}`);
                 send("content_block_start", {
                   type: "content_block_start",
                   index: t.blockIndex,
@@ -33228,83 +33289,51 @@ data: ${JSON.stringify(d)}
                 });
                 t.started = true;
                 t.closed = true;
-              } else {
-                log(`[Streaming] Buffered tool call ${t.name} failed validation, skipping: ${validation.missingParams.join(", ")}`);
-                t.closed = true;
               }
-            } else {
-              const argsJson = repairArgs(t.name, t.arguments || "{}");
-              log(`[Streaming] Sending buffered tool call (no validation): ${t.name} with args: ${argsJson}`);
-              send("content_block_start", {
-                type: "content_block_start",
-                index: t.blockIndex,
-                content_block: { type: "tool_use", id: t.id, name: t.name }
-              });
-              send("content_block_delta", {
-                type: "content_block_delta",
-                index: t.blockIndex,
-                delta: { type: "input_json_delta", partial_json: argsJson }
-              });
-              send("content_block_stop", {
-                type: "content_block_stop",
-                index: t.blockIndex
-              });
-              t.started = true;
+            }
+          }
+          for (const t of Array.from(state.tools.values())) {
+            if (t.started && !t.closed) {
+              send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
               t.closed = true;
             }
           }
-        }
-        for (const t of Array.from(state.tools.values())) {
-          if (t.started && !t.closed) {
-            send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
-            t.closed = true;
+          if (middlewareManager) {
+            await middlewareManager.afterStreamComplete(target, streamMetadata);
           }
-        }
-        if (middlewareManager) {
-          await middlewareManager.afterStreamComplete(target, streamMetadata);
-        }
-        if (reason === "error") {
-          send("error", { type: "error", error: { type: "api_error", message: err } });
-        } else {
-          const hasStructuredTools = Array.from(state.tools.values()).some((t) => t.started);
-          const truncated = state.finishReason === "length";
-          const refused = state.finishReason === "content_filter";
-          const stopReason = refused ? "refusal" : truncated ? "max_tokens" : textToolCalls.length > 0 || hasStructuredTools ? "tool_use" : "end_turn";
-          if (truncated || refused) {
-            log(`[Streaming] Upstream finish_reason=${state.finishReason} \u2192 stop_reason=${stopReason} (${state.accumulatedText.length} chars produced)`);
+          if (reason === "error") {
+            send("error", { type: "error", error: { type: "api_error", message: err } });
+          } else {
+            const hasStructuredTools = Array.from(state.tools.values()).some((t) => t.started);
+            const truncated = state.finishReason === "length";
+            const refused = state.finishReason === "content_filter";
+            const stopReason = refused ? "refusal" : truncated ? "max_tokens" : textToolCalls.length > 0 || hasStructuredTools ? "tool_use" : "end_turn";
+            if (truncated || refused) {
+              log(`[Streaming] Upstream finish_reason=${state.finishReason} \u2192 stop_reason=${stopReason} (${state.accumulatedText.length} chars produced)`);
+            }
+            send("message_delta", {
+              type: "message_delta",
+              delta: { stop_reason: stopReason, stop_sequence: null },
+              usage: {
+                ...state.usage?.prompt_tokens ? { input_tokens: state.usage.prompt_tokens } : {},
+                output_tokens: state.usage?.completion_tokens || 0
+              }
+            });
+            behavior?.onTurnEnd?.();
+            send("message_stop", { type: "message_stop" });
           }
-          send("message_delta", {
-            type: "message_delta",
-            delta: { stop_reason: stopReason, stop_sequence: null },
-            usage: {
-              ...state.usage?.prompt_tokens ? { input_tokens: state.usage.prompt_tokens } : {},
-              output_tokens: state.usage?.completion_tokens || 0
+          if (onTokenUpdate) {
+            if (state.usage) {
+              log(`[Streaming] Final usage: prompt=${state.usage.prompt_tokens || 0}, completion=${state.usage.completion_tokens || 0}`);
+              onTokenUpdate(state.usage.prompt_tokens || 0, state.usage.completion_tokens || 0);
+            } else {
+              const estimatedOutputTokens = Math.ceil(state.accumulatedText.length / 4);
+              log(`[Streaming] No usage data from provider, estimating: ~${estimatedOutputTokens} output tokens`);
+              onTokenUpdate(priorInputTokens || 100, estimatedOutputTokens);
             }
-          });
-          behavior?.onTurnEnd?.();
-          send("message_stop", { type: "message_stop" });
-        }
-        if (onTokenUpdate) {
-          if (state.usage) {
-            log(`[Streaming] Final usage: prompt=${state.usage.prompt_tokens || 0}, completion=${state.usage.completion_tokens || 0}`);
-            onTokenUpdate(state.usage.prompt_tokens || 0, state.usage.completion_tokens || 0);
-          } else {
-            const estimatedOutputTokens = Math.ceil(state.accumulatedText.length / 4);
-            log(`[Streaming] No usage data from provider, estimating: ~${estimatedOutputTokens} output tokens`);
-            onTokenUpdate(priorInputTokens || 100, estimatedOutputTokens);
           }
-        }
-        if (!isClosed) {
-          try {
-            controller.enqueue(encoder.encode(`data: [DONE]
-
-
-`));
-          } catch (e) {}
-          controller.close();
-          isClosed = true;
-          if (ping)
-            clearInterval(ping);
+        } finally {
+          teardown();
         }
       };
       try {
@@ -39184,62 +39213,70 @@ data: ${JSON.stringify(data)}
           send("ping", { type: "ping" });
         }
       }, 1000);
+      const teardown = () => {
+        if (!isClosed) {
+          isClosed = true;
+          try {
+            controller.close();
+          } catch {}
+        }
+        if (pingInterval) {
+          clearInterval(pingInterval);
+          pingInterval = null;
+        }
+      };
       const finalize = async (reason, err) => {
-        if (finalized2)
+        if (finalized2) {
+          teardown();
           return;
-        finalized2 = true;
-        if (thinkingStarted) {
-          send("content_block_stop", { type: "content_block_stop", index: thinkingIdx });
         }
-        if (textStarted) {
-          send("content_block_stop", { type: "content_block_stop", index: textIdx });
-        }
-        for (const t of toolCalls.values()) {
-          if (t.started && !t.closed) {
-            send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
-            t.closed = true;
+        finalized2 = true;
+        try {
+          if (thinkingStarted) {
+            send("content_block_stop", { type: "content_block_stop", index: thinkingIdx });
           }
-        }
-        if (opts.middlewareManager) {
-          await opts.middlewareManager.afterStreamComplete(opts.modelName, new Map);
-        }
-        const inputTokens = usage?.promptTokenCount || 0;
-        const outputTokens = usage?.candidatesTokenCount || 0;
-        if (usage) {
-          log(`[GeminiSSE] Usage: prompt=${inputTokens}, completion=${outputTokens}`);
-        }
-        if (opts.onTokenUpdate) {
-          opts.onTokenUpdate(inputTokens, outputTokens);
-        }
-        if (reason === "error") {
-          log(`[GeminiSSE] Stream error: ${err}`);
-          send("error", { type: "error", error: { type: "api_error", message: err } });
-        } else {
-          const hasToolCalls = toolCalls.size > 0;
-          const stopReason = truncated ? "max_tokens" : hasToolCalls ? "tool_use" : "end_turn";
-          if (truncated) {
-            log("[GeminiSSE] finishReason=MAX_TOKENS \u2192 stop_reason=max_tokens");
+          if (textStarted) {
+            send("content_block_stop", { type: "content_block_stop", index: textIdx });
           }
-          send("message_delta", {
-            type: "message_delta",
-            delta: { stop_reason: stopReason, stop_sequence: null },
-            usage: {
-              ...inputTokens > 0 ? { input_tokens: inputTokens } : {},
-              output_tokens: outputTokens
+          for (const t of toolCalls.values()) {
+            if (t.started && !t.closed) {
+              send("content_block_stop", { type: "content_block_stop", index: t.blockIndex });
+              t.closed = true;
             }
-          });
-          opts.onTurnEnd?.();
-          send("message_stop", { type: "message_stop" });
-        }
-        if (!isClosed) {
-          isClosed = true;
-          if (pingInterval) {
-            clearInterval(pingInterval);
-            pingInterval = null;
           }
-          try {
-            controller.close();
-          } catch {}
+          if (opts.middlewareManager) {
+            await opts.middlewareManager.afterStreamComplete(opts.modelName, new Map);
+          }
+          const inputTokens = usage?.promptTokenCount || 0;
+          const outputTokens = usage?.candidatesTokenCount || 0;
+          if (usage) {
+            log(`[GeminiSSE] Usage: prompt=${inputTokens}, completion=${outputTokens}`);
+          }
+          if (opts.onTokenUpdate) {
+            opts.onTokenUpdate(inputTokens, outputTokens);
+          }
+          if (reason === "error") {
+            log(`[GeminiSSE] Stream error: ${err}`);
+            send("error", { type: "error", error: { type: "api_error", message: err } });
+          } else {
+            const hasToolCalls = toolCalls.size > 0;
+            const stopReason = truncated ? "max_tokens" : hasToolCalls ? "tool_use" : "end_turn";
+            if (truncated) {
+              log("[GeminiSSE] finishReason=MAX_TOKENS \u2192 stop_reason=max_tokens");
+            }
+            send("message_delta", {
+              type: "message_delta",
+              delta: { stop_reason: stopReason, stop_sequence: null },
+              usage: {
+                ...inputTokens > 0 ? { input_tokens: inputTokens } : {},
+                output_tokens: outputTokens
+              }
+            });
+            opts.onTurnEnd?.();
+            send("message_stop", { type: "message_stop" });
+          }
+        } finally {
+          teardown();
         }
       };
       try {
@@ -39457,38 +39494,48 @@ data: ${JSON.stringify(data)}
           send("ping", { type: "ping" });
         }
       }, 1000);
-      const finalize = (reason, err) => {
-        if (isClosed)
-          return;
-        if (textStarted) {
-          send("content_block_stop", { type: "content_block_stop", index: 0 });
-        }
-        if (reason === "error") {
-          send("error", { type: "error", error: { type: "api_error", message: err } });
-        } else {
-          send("message_delta", {
-            type: "message_delta",
-            delta: { stop_reason: "end_turn", stop_sequence: null },
-            usage: {
-              ...promptTokens > 0 ? { input_tokens: promptTokens } : {},
-              output_tokens: completionTokens
-            }
-          });
-          send("message_stop", { type: "message_stop" });
-        }
-        if (opts.onTokenUpdate) {
-          opts.onTokenUpdate(promptTokens, completionTokens);
-        }
+      let finalized2 = false;
+      const teardown = () => {
         if (!isClosed) {
           isClosed = true;
-          if (pingInterval) {
-            clearInterval(pingInterval);
-            pingInterval = null;
-          }
           try {
             controller.close();
           } catch {}
         }
+        if (pingInterval) {
+          clearInterval(pingInterval);
+          pingInterval = null;
+        }
+      };
+      const finalize = (reason, err) => {
+        if (finalized2) {
+          teardown();
+          return;
+        }
+        finalized2 = true;
+        try {
+          if (textStarted) {
+            send("content_block_stop", { type: "content_block_stop", index: 0 });
+          }
+          if (reason === "error") {
+            send("error", { type: "error", error: { type: "api_error", message: err } });
+          } else {
+            send("message_delta", {
+              type: "message_delta",
+              delta: { stop_reason: "end_turn", stop_sequence: null },
+              usage: {
+                ...promptTokens > 0 ? { input_tokens: promptTokens } : {},
+                output_tokens: completionTokens
+              }
+            });
+            send("message_stop", { type: "message_stop" });
+          }
+          if (opts.onTokenUpdate) {
+            opts.onTokenUpdate(promptTokens, completionTokens);
+          }
+        } finally {
+          teardown();
+        }
       };
       try {
         const reader = response.body.getReader();
@@ -39975,10 +40022,26 @@ class TokenTracker {
   modelNameOverride;
   planUsage;
   lastPlanSerialized = "";
+  toolCallsByName = new Map;
+  startedAt = Date.now();
+  sessionBilledInputTokens = 0;
   constructor(port, config2) {
     this.port = port;
     this.config = config2;
   }
+  recordToolUse(name) {
+    const key = name.trim() || "unknown";
+    this.toolCallsByName.set(key, (this.toolCallsByName.get(key) ?? 0) + 1);
+  }
+  getToolCallCount() {
+    let n = 0;
+    for (const v of this.toolCallsByName.values())
+      n += v;
+    return n;
+  }
+  getToolCalls() {
+    return [...this.toolCallsByName].map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+  }
   setActiveModelName(name) {
     this.modelNameOverride = name;
   }
@@ -40000,6 +40063,7 @@ class TokenTracker {
     this.sessionInputTokens = inputTokens;
     this.lastInputTokens = inputTokens;
     this.sessionOutputTokens += outputTokens;
+    this.sessionBilledInputTokens += inputTokens;
     const pricing = this.getPricing();
     const cost = inputTokens / 1e6 * pricing.inputCostPer1M + outputTokens / 1e6 * pricing.outputCostPer1M;
     this.sessionTotalCost += cost;
@@ -40012,6 +40076,7 @@ class TokenTracker {
     const pricing = this.getPricing();
     const cost = this.sessionInputTokens / 1e6 * pricing.inputCostPer1M + this.sessionOutputTokens / 1e6 * pricing.outputCostPer1M;
     this.sessionTotalCost = cost;
+    this.sessionBilledInputTokens = this.sessionInputTokens;
     this.writeFile(this.sessionInputTokens, this.sessionOutputTokens, pricing.isEstimate);
   }
   updateWithDelta(inputTokens, outputTokens) {
@@ -40030,6 +40095,7 @@ class TokenTracker {
     }
     this.sessionOutputTokens += outputTokens;
     const pricing = this.getPricing();
+    this.sessionBilledInputTokens += incrementalInputTokens;
     const cost = incrementalInputTokens / 1e6 * pricing.inputCostPer1M + outputTokens / 1e6 * pricing.outputCostPer1M;
     this.sessionTotalCost += cost;
     this.writeFile(inputTokens, this.sessionOutputTokens, pricing.isEstimate);
@@ -40038,6 +40104,7 @@ class TokenTracker {
     this.sessionInputTokens = inputTokens;
     this.lastInputTokens = inputTokens;
     this.sessionOutputTokens += outputTokens;
+    this.sessionBilledInputTokens += inputTokens;
     if (typeof actualCost === "number" && actualCost > 0) {
       this.sessionTotalCost += actualCost;
       log(`[TokenTracker] Actual cost from API: $${actualCost.toFixed(6)}`);
@@ -40055,6 +40122,7 @@ class TokenTracker {
       this.lastInputTokens = inputTokens;
     }
     this.sessionOutputTokens += outputTokens;
+    this.sessionBilledInputTokens += inputTokens;
     this.writeFile(this.sessionInputTokens, this.sessionOutputTokens);
   }
   setContextWindow(contextWindow) {
@@ -40107,7 +40175,12 @@ class TokenTracker {
         provider_name: this.getDisplayName(),
         updated_at: Date.now(),
         is_free: isFreeModel,
-        is_estimated: isEstimate || false
+        is_estimated: isEstimate || false,
+        started_at: this.startedAt,
+        tool_calls: this.getToolCalls(),
+        billed_input_tokens: this.sessionBilledInputTokens,
+        input_per_m: pricing.inputCostPer1M,
+        output_per_m: pricing.outputCostPer1M
       };
       const displayModel = stripProviderPrefix(this.modelNameOverride || this.config.modelName || "");
       if (displayModel) {
@@ -40813,14 +40886,18 @@ class ComposedHandler {
     };
     const streamFormat = this.resolveStreamFormat();
     const priorInputTokens = this.tokenTracker.getLastInputTokens();
+    const observeToolCall = (name) => {
+      this.tokenTracker.recordToolUse(name);
+      behaviorSession?.observeToolCall(name);
+    };
     switch (streamFormat) {
       case "openai-sse":
-        return createStreamingResponseHandler(c, response, adapter, this.bareModelName, this.middlewareManager, onTokenUpdate, claudeRequest.tools, toolNameMap, priorInputTokens, behaviorSession && {
-          shouldBufferTool: (name) => behaviorSession.interceptsTool(name),
-          onToolCall: (name, argsJson) => behaviorSession.repairToolCall(name, argsJson),
-          onAssistantText: (text, kind) => behaviorSession.observeText(text, kind),
-          onToolCallObserved: (name) => behaviorSession.observeToolCall(name),
-          onTurnEnd: () => behaviorSession.finishTurn()
+        return createStreamingResponseHandler(c, response, adapter, this.bareModelName, this.middlewareManager, onTokenUpdate, claudeRequest.tools, toolNameMap, priorInputTokens, {
+          shouldBufferTool: (name) => behaviorSession?.interceptsTool(name) ?? false,
+          onToolCall: (name, argsJson) => behaviorSession?.repairToolCall(name, argsJson) ?? null,
+          onAssistantText: (text, kind) => behaviorSession?.observeText(text, kind),
+          onToolCallObserved: observeToolCall,
+          onTurnEnd: () => behaviorSession?.finishTurn()
         });
       case "openai-responses-sse":
         return createResponsesStreamHandler(c, response, {
@@ -40834,7 +40911,7 @@ class ComposedHandler {
           shouldBufferTool: (name) => behaviorSession?.interceptsTool(name) ?? false,
           onToolCall: (name, argsJson) => behaviorSession?.repairToolCall(name, argsJson) ?? null,
           onAssistantText: (text, kind) => behaviorSession?.observeText(text, kind),
-          onToolCallObserved: (name) => behaviorSession?.observeToolCall(name),
+          onToolCallObserved: observeToolCall,
           onTurnEnd: () => behaviorSession?.finishTurn()
         });
       case "anthropic-sse":
@@ -40845,7 +40922,7 @@ class ComposedHandler {
           shouldBufferTool: (name) => behaviorSession?.interceptsTool(name) ?? false,
           repairToolArgs: (name, argsJson) => behaviorSession?.repairToolCall(name, argsJson) ?? null,
           onAssistantText: (text, kind) => behaviorSession?.observeText(text, kind),
-          onToolCallObserved: (name) => behaviorSession?.observeToolCall(name),
+          onToolCallObserved: observeToolCall,
           onTurnEnd: () => behaviorSession?.finishTurn()
         });
       case "gemini-sse": {
@@ -40862,7 +40939,7 @@ class ComposedHandler {
           onToolCall,
           repairToolArgs: (name, argsJson) => behaviorSession?.repairToolCall(name, argsJson) ?? null,
           onAssistantText: (text, kind) => behaviorSession?.observeText(text, kind),
-          onToolCallObserved: (name) => behaviorSession?.observeToolCall(name),
+          onToolCallObserved: observeToolCall,
           onTurnEnd: () => behaviorSession?.finishTurn(),
           unwrapResponse: this.options.unwrapGeminiResponse,
           priorInputTokens
@@ -40882,7 +40959,7 @@ class ComposedHandler {
           repairToolArgs: (name, argsJson) => behaviorSession?.repairToolCall(name, argsJson) ?? null,
           shouldBufferTool: (name) => behaviorSession?.interceptsTool(name) ?? false,
           onAssistantText: (text, kind) => behaviorSession?.observeText(text, kind),
-          onToolCallObserved: (name) => behaviorSession?.observeToolCall(name),
+          onToolCallObserved: observeToolCall,
           onTurnEnd: () => behaviorSession?.finishTurn()
         });
       case "ollama-jsonl":
@@ -42891,6 +42968,9 @@ async function routeBare(model, nativeProvider, rules, defaultProvider, cachePat
   const [primary, ...fallbacks] = credentialed;
   return { kind: "ok", primary, fallbacks };
 }
+function normalizeGlmSlug(model) {
+  return model.replace(/^glm-(\d+)-(\d+)(-.*)?$/i, (_m, major, minor, suffix) => `glm-${major}.${minor}${suffix ?? ""}`);
+}
 async function route(modelSpec, rulesOverride, defaultProviderOverride, cachePath) {
   const parsed = parseModelSpec(modelSpec);
   if (parsed.isExplicitProvider) {
@@ -42898,7 +42978,7 @@ async function route(modelSpec, rulesOverride, defaultProviderOverride, cachePat
   }
   const rules = rulesOverride ?? loadRoutingRules();
   const defaultProvider = defaultProviderOverride !== undefined ? defaultProviderOverride : rulesOverride !== undefined ? undefined : loadConfig().defaultProvider;
-  return routeBare(parsed.model, parsed.provider, rules, defaultProvider, cachePath);
+  return routeBare(normalizeGlmSlug(parsed.model), parsed.provider, rules, defaultProvider, cachePath);
 }
 var init_routing_rules = __esm(() => {
   init_model_catalog();
@@ -68509,6 +68589,8 @@ Usage:  claudish --models --provider <slug>`);
       if (rest.length > 0)
         config3._hasPositionalPrompt = true;
       break;
+    } else if (arg === "--resume" && (i + 1 >= args.length || args[i + 1].startsWith("-"))) {
+      config3._resumePicker = true;
     } else if (arg.startsWith("-")) {
       config3.claudeArgs.push(arg);
       if (arg === "-p" || arg === "--print") {
@@ -78411,12 +78493,2864 @@ var init_team_grid = __esm(() => {
   ];
 });
 
+// src/tui/viz/text.ts
+function columns(n, fn, arg = "width") {
+  if (!Number.isFinite(n))
+    throw new RangeError(`${fn}: ${arg} must be a finite number, got ${n}`);
+  return Math.max(0, Math.floor(n));
+}
+function isWide2(cp) {
+  let lo = 0;
+  let hi = WIDE.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    const [a, b] = WIDE[mid];
+    if (cp < a)
+      hi = mid - 1;
+    else if (cp > b)
+      lo = mid + 1;
+    else
+      return true;
+  }
+  return false;
+}
+function fallbackClusterWidth(cluster) {
+  const cp = cluster.codePointAt(0) ?? 0;
+  if (cp < 32 || cp >= 127 && cp <= 159 || LEADING_FORMAT.test(cluster))
+    return 0;
+  return isWide2(cp) || LEADING_EMOJI_PRESENTATION.test(cluster) || cluster.includes(VS16) ? 2 : 1;
+}
+function displayWidth(s) {
+  if (NATIVE_WIDTH)
+    return NATIVE_WIDTH(s);
+  let w = 0;
+  for (const { segment } of seg.segment(s))
+    w += fallbackClusterWidth(segment);
+  return w;
+}
+function truncate3(s, width) {
+  const n = columns(width, "truncate");
+  if (n === 0)
+    return "";
+  const clean = sanitize2(s);
+  if (displayWidth(clean) <= n)
+    return clean;
+  let out = "";
+  let w = 0;
+  for (const { segment } of seg.segment(clean)) {
+    const cw = displayWidth(segment);
+    if (w + cw > n - 1)
+      break;
+    out += segment;
+    w += cw;
+  }
+  return `${out}\u2026`;
+}
+function padTo(s, width) {
+  const n = columns(width, "padTo");
+  if (n === 0)
+    return "";
+  const clean = sanitize2(s);
+  const clipped = displayWidth(clean) > n ? truncate3(clean, n) : clean;
+  return clipped + " ".repeat(Math.max(0, n - displayWidth(clipped)));
+}
+function padStartTo(s, width) {
+  const n = columns(width, "padStartTo");
+  if (n === 0)
+    return "";
+  const clean = sanitize2(s);
+  const clipped = displayWidth(clean) > n ? truncate3(clean, n) : clean;
+  return " ".repeat(Math.max(0, n - displayWidth(clipped))) + clipped;
+}
+function splitCells(parts, cells) {
+  const n = columns(cells, "splitCells", "cells");
+  const finite = parts.map((p) => Number.isFinite(p) && p > 0 ? p : 0);
+  const out = finite.map(() => 0);
+  let safe = finite;
+  let sum = finite.reduce((a, b) => a + b, 0);
+  if (!Number.isFinite(sum)) {
+    const max = finite.reduce((a, b) => b > a ? b : a, 0);
+    safe = finite.map((p) => p / max);
+    sum = safe.reduce((a, b) => a + b, 0);
+  }
+  if (n <= 0 || sum <= 0)
+    return out;
+  const byShare = safe.map((p, i) => ({ p, i })).sort((a, b) => b.p - a.p);
+  if (n < byShare.filter(({ p }) => p > 0).length) {
+    for (const { i } of byShare.slice(0, n))
+      out[i] = 1;
+    return out;
+  }
+  const exact = safe.map((p) => n * (p / sum));
+  exact.forEach((e, i) => {
+    out[i] = Math.floor(e);
+  });
+  const rank = exact.map((e, i) => ({ rem: e % 1, i })).sort((a, b) => b.rem - a.rem);
+  for (let k = 0, left = n - out.reduce((a, b) => a + b, 0);left > 0; k++, left--)
+    out[rank[k % rank.length].i] += 1;
+  for (const { p, i } of byShare)
+    if (p > 0 && out[i] === 0) {
+      const d = byShare.reduce((m, c) => out[c.i] > out[m] ? c.i : m, 0);
+      if (out[d] > 1) {
+        out[d] -= 1;
+        out[i] = 1;
+      }
+    }
+  return out;
+}
+var NATIVE_WIDTH, WIDE, seg, VS16 = "\uFE0F", LEADING_FORMAT, LEADING_EMOJI_PRESENTATION, CONTROL, sanitize2 = (s) => s.replace(CONTROL, " ");
+var init_text = __esm(() => {
+  NATIVE_WIDTH = (() => {
+    const b = globalThis.Bun;
+    return typeof b?.stringWidth === "function" ? b.stringWidth.bind(b) : null;
+  })();
+  WIDE = [
+    [4352, 4447],
+    [9001, 9002],
+    [11904, 12350],
+    [12353, 12771],
+    [12774, 12871],
+    [12880, 13311],
+    [13312, 19903],
+    [19968, 40959],
+    [40960, 42191],
+    [43360, 43391],
+    [44032, 55203],
+    [63744, 64255],
+    [65040, 65049],
+    [65072, 65135],
+    [65280, 65376],
+    [65504, 65510],
+    [94176, 94180],
+    [94192, 94193],
+    [94208, 100343],
+    [100352, 101589],
+    [101632, 101640],
+    [110576, 110579],
+    [110581, 110587],
+    [110589, 110590],
+    [110592, 110882],
+    [110898, 110898],
+    [110928, 110930],
+    [110933, 110933],
+    [110948, 110951],
+    [110960, 111355],
+    [127488, 127490],
+    [127504, 127547],
+    [127552, 127560],
+    [127568, 127569],
+    [127584, 127589],
+    [131072, 196605],
+    [196608, 262141]
+  ];
+  seg = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+  LEADING_FORMAT = /^\p{Cf}/u;
+  LEADING_EMOJI_PRESENTATION = /^\p{Emoji_Presentation}/u;
+  CONTROL = /[\u0000-\u001f\u007f-\u009f]/g;
+});
+
+// src/tui/viz/tokens.ts
+var tokens, ramps;
+var init_tokens = __esm(() => {
+  init_theme2();
+  tokens = {
+    fatal: C.red,
+    error: C.red,
+    warn: C.orange,
+    info: C.cyan,
+    debug: C.fgMuted,
+    trace: C.dim,
+    success: C.green,
+    running: C.blue,
+    idle: C.fgMuted,
+    dead: C.dim,
+    border: C.border,
+    subtle: C.dim,
+    text: C.fg,
+    accent: C.focusBorder,
+    bgPanel: C.bgAlt,
+    ink: C.black
+  };
+  ramps = {
+    load: [tokens.success, C.yellow, tokens.error],
+    temperature: [tokens.running, tokens.success, C.orange, tokens.error],
+    network: [tokens.success, C.yellow, tokens.error],
+    savings: [tokens.error, C.yellow, tokens.success],
+    volume: [C.border, C.blue, C.cyan]
+  };
+});
+
+// src/tui/viz/color.ts
+import { RGBA, parseColor, rgbToHex } from "@opentui/core";
+function mix(a, b, t) {
+  const k = clamp01(t);
+  return hex3(RGBA.fromValues(a.r + (b.r - a.r) * k, a.g + (b.g - a.g) * k, a.b + (b.b - a.b) * k, a.a + (b.a - a.a) * k));
+}
+function blend1D(steps, from, to) {
+  if (!Number.isInteger(steps) || steps <= 0)
+    return [];
+  const a = rgba(from);
+  if (steps === 1)
+    return [hex3(a)];
+  const b = rgba(to);
+  return Array.from({ length: steps }, (_, i) => mix(a, b, i / (steps - 1)));
+}
+function blendStops(steps, ...stops) {
+  if (!Number.isInteger(steps) || steps <= 0 || stops.length === 0)
+    return [];
+  if (stops.length === 1 || steps === 1)
+    return blend1D(steps, stops[0], stops.at(-1));
+  const pts = stops.map(rgba);
+  const segs = pts.length - 1;
+  return Array.from({ length: steps }, (_, i) => {
+    const p = i / (steps - 1) * segs;
+    const s = Math.min(segs - 1, Math.floor(p));
+    return mix(pts[s], pts[s + 1], p - s);
+  });
+}
+function luminance(c) {
+  const f = (v) => v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+  return 0.2126 * f(clamp01(c.r)) + 0.7152 * f(clamp01(c.g)) + 0.0722 * f(clamp01(c.b));
+}
+function contrastRatio(a, b) {
+  const [x, y] = [luminance(a), luminance(b)];
+  return x >= y ? (x + 0.05) / (y + 0.05) : (y + 0.05) / (x + 0.05);
+}
+function over(fg, bg) {
+  const a = clamp01(fg.a);
+  if (a >= 1)
+    return fg;
+  return RGBA.fromValues(fg.r * a + bg.r * (1 - a), fg.g * a + bg.g * (1 - a), fg.b * a + bg.b * (1 - a), 1);
+}
+function pickInk(bg, dark = tokens.ink, light = tokens.text) {
+  const surface = over(rgba(bg), rgba(tokens.bgPanel));
+  const inkDark = over(rgba(dark), surface);
+  const inkLight = over(rgba(light), surface);
+  return hex3(contrastRatio(inkDark, surface) >= contrastRatio(inkLight, surface) ? inkDark : inkLight);
+}
+var rgba = (c) => parseColor(c), hex3 = (c) => rgbToHex(c), clamp01 = (n) => Number.isFinite(n) ? Math.min(1, Math.max(0, n)) : 0;
+var init_color = __esm(() => {
+  init_tokens();
+});
+
+// src/tui/viz/widgets.tsx
+import { createTextAttributes as createTextAttributes2 } from "@opentui/core";
+import { jsxDEV as jsxDEV18, Fragment as Fragment11 } from "@opentui/react/jsx-dev-runtime";
+function rampFor(width, stops) {
+  const use = stops.length > 0 ? stops : ramps.load;
+  const key = `${width}|${use.join(":")}`;
+  const hit = RAMP_CACHE.get(key);
+  if (hit)
+    return hit;
+  const built = blendStops(width, ...use);
+  if (RAMP_CACHE.size >= RAMP_CACHE_MAX)
+    RAMP_CACHE.delete(RAMP_CACHE.keys().next().value);
+  RAMP_CACHE.set(key, built);
+  return built;
+}
+function fillCells(pct, width) {
+  const cells = Math.floor(width);
+  if (!Number.isFinite(cells) || cells <= 0 || Number.isNaN(pct))
+    return 0;
+  return Math.round(Math.min(100, Math.max(0, pct)) / 100 * cells);
+}
+function MeterSpan({
+  pct,
+  width,
+  ramp = ramps.load
+}) {
+  const cells = Math.floor(width);
+  if (!Number.isFinite(cells) || cells <= 0)
+    return null;
+  if (Number.isNaN(pct))
+    return /* @__PURE__ */ jsxDEV18("span", {
+      fg: tokens.dead,
+      children: NODATA.repeat(cells)
+    }, undefined, false, undefined, this);
+  const cols = rampFor(cells, ramp);
+  const filled = fillCells(pct, cells);
+  return /* @__PURE__ */ jsxDEV18(Fragment11, {
+    children: Array.from({ length: cells }, (_, i) => /* @__PURE__ */ jsxDEV18("span", {
+      fg: i < filled ? cols[i] : tokens.border,
+      children: i < filled ? FILL : TRACK
+    }, i, false, undefined, this))
+  }, undefined, false, undefined, this);
+}
+function Sparkline({
+  values,
+  fg = tokens.info,
+  style,
+  ...layout
+}) {
+  const row = sparkGlyphs(values);
+  if (row === null)
+    return null;
+  return /* @__PURE__ */ jsxDEV18("text", {
+    fg,
+    flexShrink: 0,
+    ...layout,
+    style,
+    children: row
+  }, undefined, false, undefined, this);
+}
+function sparkGlyphs(values) {
+  if (values.length === 0)
+    return null;
+  let max = Number.NEGATIVE_INFINITY;
+  let min = Number.POSITIVE_INFINITY;
+  for (const v of values)
+    if (Number.isFinite(v)) {
+      max = Math.max(max, v);
+      min = Math.min(min, v);
+    }
+  if (max === Number.NEGATIVE_INFINITY)
+    return GAP.repeat(values.length);
+  const half = max / 2 - min / 2;
+  const mid = SPARK[Math.floor((SPARK.length - 1) / 2)];
+  const top = SPARK.length - 1;
+  const glyph = (v) => SPARK[Math.min(top, Math.max(0, Math.round((v / 2 - min / 2) / half * top)))];
+  return values.map((v) => !Number.isFinite(v) ? GAP : half > 0 ? glyph(v) : mid).join("");
+}
+function SparklineSpan({
+  values,
+  fg = tokens.info
+}) {
+  const row = sparkGlyphs(values);
+  return row === null ? null : /* @__PURE__ */ jsxDEV18("span", {
+    fg,
+    children: row
+  }, undefined, false, undefined, this);
+}
+function badgePad(label, width) {
+  const pad2 = Math.max(0, (width ?? 0) - displayWidth(label) - 2);
+  return pad2 > 0 ? /* @__PURE__ */ jsxDEV18("span", {
+    children: " ".repeat(pad2)
+  }, undefined, false, undefined, this) : null;
+}
+function BadgeSpan({ label, bg, width }) {
+  return /* @__PURE__ */ jsxDEV18(Fragment11, {
+    children: [
+      /* @__PURE__ */ jsxDEV18("span", {
+        fg: pickInk(bg),
+        bg,
+        attributes: BOLD4,
+        children: ` ${label} `
+      }, undefined, false, undefined, this),
+      badgePad(label, width)
+    ]
+  }, undefined, true, undefined, this);
+}
+function Panel({
+  title,
+  focused = false,
+  flush = false,
+  children,
+  style,
+  ...layout
+}) {
+  return /* @__PURE__ */ jsxDEV18("box", {
+    border: true,
+    borderStyle: "rounded",
+    borderColor: focused ? tokens.accent : tokens.border,
+    backgroundColor: tokens.bgPanel,
+    title,
+    titleAlignment: "left",
+    flexDirection: "column",
+    overflow: "hidden",
+    paddingLeft: flush ? 0 : 1,
+    paddingRight: flush ? 0 : 1,
+    ...layout,
+    style,
+    children
+  }, undefined, false, undefined, this);
+}
+var BOLD4, FILL = "\u2588", TRACK = "\u2591", SPARK, GAP = " ", NODATA = "\u254C", RAMP_CACHE, RAMP_CACHE_MAX = 64;
+var init_widgets = __esm(() => {
+  init_color();
+  init_text();
+  init_tokens();
+  BOLD4 = createTextAttributes2({ bold: true });
+  SPARK = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+  RAMP_CACHE = new Map;
+});
+
+// src/session/session-discovery.ts
+var exports_session_discovery = {};
+__export(exports_session_discovery, {
+  slugForPath: () => slugForPath,
+  sessionLabel: () => sessionLabel,
+  mainConversationTurn: () => mainConversationTurn,
+  isHarnessNoise: () => isHarnessNoise,
+  isAgentSession: () => isAgentSession,
+  isActive: () => isActive,
+  hydrateSession: () => hydrateSession,
+  hydrateConversation: () => hydrateConversation,
+  getRepoContext: () => getRepoContext,
+  findLatestSessionId: () => findLatestSessionId,
+  enrichWorktreeGit: () => enrichWorktreeGit,
+  discoverWorktreeGroups: () => discoverWorktreeGroups,
+  PROJECTS_DIR: () => PROJECTS_DIR,
+  ACTIVE_WINDOW_MS: () => ACTIVE_WINDOW_MS
+});
+import { execFile, execFileSync as execFileSync2 } from "child_process";
+import { closeSync as closeSync5, openSync as openSync5, readSync, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
+import { homedir as homedir34 } from "os";
+import { basename, join as join37 } from "path";
+function slugForPath(absPath) {
+  return absPath.replace(/[/.]/g, "-");
+}
+function isAgentSession(row) {
+  return row.entrypoint !== undefined && row.entrypoint !== "cli";
+}
+function getRepoContext(cwd = process.cwd()) {
+  const git = (args) => {
+    try {
+      return execFileSync2("git", args, {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+    } catch {
+      return null;
+    }
+  };
+  const current = git(["rev-parse", "--show-toplevel"]);
+  const commonDir = git(["rev-parse", "--git-common-dir"]);
+  if (!current || !commonDir)
+    return null;
+  const root = commonDir.endsWith("/.git") ? commonDir.slice(0, -"/.git".length) : current;
+  const liveWorktrees = [];
+  const branchByPath = new Map;
+  const porcelain = git(["worktree", "list", "--porcelain"]);
+  if (porcelain) {
+    let currentPath = null;
+    for (const line of porcelain.split(`
+`)) {
+      if (line.startsWith("worktree ")) {
+        currentPath = line.slice("worktree ".length);
+        liveWorktrees.push(currentPath);
+      } else if (line.startsWith("branch ") && currentPath) {
+        branchByPath.set(currentPath, line.slice("branch ".length).replace(/^refs\/heads\//, ""));
+      }
+    }
+  }
+  return { root, current, liveWorktrees, branchByPath };
+}
+function projectDirs() {
+  try {
+    return readdirSync7(PROJECTS_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function sessionsIn(dirName) {
+  const dir = join37(PROJECTS_DIR, dirName);
+  let names;
+  try {
+    names = readdirSync7(dir).filter((n) => n.endsWith(".jsonl"));
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const n of names) {
+    const file2 = join37(dir, n);
+    try {
+      const st = statSync6(file2);
+      if (st.size === 0)
+        continue;
+      const row = {
+        id: basename(n, ".jsonl"),
+        file: file2,
+        mtimeMs: st.mtimeMs,
+        sizeBytes: st.size
+      };
+      const head = readChunk(file2, 0, Math.min(ENTRYPOINT_BYTES, st.size));
+      const m = /"entrypoint":"([a-z-]+)"/.exec(head);
+      if (m)
+        row.entrypoint = m[1];
+      rows.push(row);
+    } catch {}
+  }
+  return rows;
+}
+async function enrichWorktreeGit(groups, repoRoot) {
+  const run = (cwd, args) => new Promise((resolve5) => {
+    execFile("git", args, { cwd, encoding: "utf-8" }, (err, stdout) => resolve5(err ? "" : stdout));
+  });
+  const trackByBranch = new Map;
+  const refs = await run(repoRoot, [
+    "for-each-ref",
+    "--format=%(refname:short)\t%(upstream:track)",
+    "refs/heads/"
+  ]);
+  for (const line of refs.split(`
+`)) {
+    const [name, track] = line.split("\t");
+    if (!name || !track)
+      continue;
+    const ahead = /ahead (\d+)/.exec(track)?.[1];
+    const behind = /behind (\d+)/.exec(track)?.[1];
+    if (ahead || behind) {
+      trackByBranch.set(name, {
+        ...ahead ? { ahead: Number(ahead) } : {},
+        ...behind ? { behind: Number(behind) } : {}
+      });
+    }
+  }
+  await Promise.all(groups.map(async (g) => {
+    if (g.branch)
+      Object.assign(g, trackByBranch.get(g.branch) ?? {});
+    if (!g.path || !g.live)
+      return;
+    const out = await run(g.path, ["status", "--porcelain"]);
+    g.dirty = out.split(`
+`).filter((l) => l.trim().length > 0).length;
+  }));
+}
+function isUnder(p, root) {
+  return p === root || p.startsWith(`${root}/`);
+}
+function readProjectCwd(dirName) {
+  const rows = sessionsIn(dirName);
+  if (rows.length === 0)
+    return null;
+  rows.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  for (const row of rows.slice(0, 2)) {
+    for (const r of parseRecords(readChunk(row.file, 0, Math.min(HEAD_BYTES, row.sizeBytes)), false)) {
+      if (typeof r.cwd === "string" && r.cwd)
+        return r.cwd;
+    }
+  }
+  return null;
+}
+function isActive(row, now = Date.now()) {
+  return now - row.mtimeMs < ACTIVE_WINDOW_MS;
+}
+function discoverWorktreeGroups(repo) {
+  const rootSlug = slugForPath(repo.root);
+  const mine = projectDirs();
+  const known = [...repo.liveWorktrees].map((p) => ({ path: p, slug: slugForPath(p) })).sort((a, b) => b.slug.length - a.slug.length);
+  const groups = new Map;
+  const groupCwd = new Map;
+  const upsert = (name, path2, live) => {
+    let g = groups.get(name);
+    if (!g) {
+      g = {
+        name,
+        path: path2,
+        live,
+        current: path2 !== null && path2 === repo.current,
+        sessions: [],
+        lastActiveMs: 0,
+        activeNow: false,
+        ...path2 ? { branch: repo.branchByPath.get(path2) } : {}
+      };
+      groups.set(name, g);
+    }
+    return g;
+  };
+  const WORKTREE_MARK = "--claude-worktrees-";
+  const worktreeMatches = known.filter((k) => k.path !== repo.root);
+  for (const dir of mine) {
+    const at = dir.indexOf(WORKTREE_MARK);
+    let name;
+    let path2;
+    let live;
+    const hit = worktreeMatches.find((k) => dir === k.slug || dir.startsWith(`${k.slug}-`));
+    if (hit) {
+      path2 = hit.path;
+      live = true;
+      name = hit.path === repo.root ? "(root)" : basename(hit.path);
+    } else if (at !== -1 && dir.startsWith(rootSlug)) {
+      path2 = null;
+      live = false;
+      name = dir.slice(at + WORKTREE_MARK.length);
+    } else if (dir === rootSlug) {
+      name = "(root)";
+      path2 = repo.root;
+      live = true;
+    } else if (dir.startsWith(`${rootSlug}-`) && at === -1) {
+      const cwd = readProjectCwd(dir);
+      if (!cwd || !isUnder(cwd, repo.root))
+        continue;
+      name = "(root)";
+      path2 = repo.root;
+      live = true;
+    } else {
+      continue;
+    }
+    const g = upsert(name, path2, live);
+    if (path2)
+      groupCwd.set(name, path2);
+    else if (!groupCwd.has(name)) {
+      const cwd = readProjectCwd(dir);
+      if (cwd)
+        groupCwd.set(name, cwd);
+    }
+    for (const s of sessionsIn(dir)) {
+      g.sessions.push(s);
+      if (s.mtimeMs > g.lastActiveMs)
+        g.lastActiveMs = s.mtimeMs;
+    }
+  }
+  const names = [...groups.keys()].sort((a, b) => b.length - a.length);
+  for (const name of [...groups.keys()]) {
+    const g = groups.get(name);
+    if (!g || g.live)
+      continue;
+    const parent = names.find((n) => n !== name && name.startsWith(`${n}-`) && groups.has(n));
+    if (!parent)
+      continue;
+    const into = groups.get(parent);
+    const childCwd = groupCwd.get(name);
+    const parentCwd = groupCwd.get(parent);
+    if (!childCwd || !parentCwd || !isUnder(childCwd, parentCwd))
+      continue;
+    into.sessions.push(...g.sessions);
+    into.lastActiveMs = Math.max(into.lastActiveMs, g.lastActiveMs);
+    groups.delete(name);
+  }
+  for (const g of groups.values()) {
+    g.sessions.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    g.activeNow = g.sessions.some((s) => isActive(s));
+    if (g.path) {
+      try {
+        g.createdMs = statSync6(g.path).birthtimeMs;
+      } catch {}
+    }
+    if (!g.createdMs && g.sessions.length > 0) {
+      g.createdMs = g.sessions.reduce((m, s) => Math.min(m, s.mtimeMs), Number.POSITIVE_INFINITY);
+    }
+  }
+  return [...groups.values()].filter((g) => g.sessions.length > 0).sort((a, b) => {
+    if (a.current !== b.current)
+      return a.current ? -1 : 1;
+    return b.lastActiveMs - a.lastActiveMs;
+  });
+}
+function readChunk(file2, pos, len) {
+  if (len <= 0)
+    return "";
+  let fd = null;
+  try {
+    fd = openSync5(file2, "r");
+    const buf = Buffer.allocUnsafe(len);
+    const n = readSync(fd, buf, 0, len, pos);
+    return buf.subarray(0, n).toString("utf-8");
+  } catch {
+    return "";
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync5(fd);
+      } catch {}
+    }
+  }
+}
+function parseRecords(chunk, dropFirstPartial) {
+  const lines = chunk.split(`
+`);
+  if (dropFirstPartial)
+    lines.shift();
+  else
+    lines.pop();
+  const out = [];
+  for (const l of lines) {
+    if (!l)
+      continue;
+    try {
+      const o = JSON.parse(l);
+      if (o && typeof o === "object")
+        out.push(o);
+    } catch {}
+  }
+  return out;
+}
+function contentText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((b) => b && typeof b === "object" && typeof b.text === "string" ? b.text : "").join(`
+`);
+}
+function isHarnessNoise(raw2) {
+  const t = raw2.trimStart();
+  if (t.startsWith("[Request interrupted by user"))
+    return true;
+  return HARNESS_ENVELOPES.some((e) => t.startsWith(e));
+}
+function mainConversationTurn(r) {
+  if (r.type !== "user" && r.type !== "assistant")
+    return null;
+  if (r.isMeta || r.isSidechain)
+    return null;
+  const content = r.message?.content;
+  if (Array.isArray(content) && content.some((b) => b?.type === "tool_result")) {
+    return null;
+  }
+  const raw2 = contentText(content);
+  if (!raw2.trim() || isHarnessNoise(raw2))
+    return null;
+  return { role: r.type === "user" ? "user" : "assistant", raw: raw2 };
+}
+function cleanPrompt(text) {
+  return text.replace(/<command-[a-z-]+>[\s\S]*?<\/command-[a-z-]+>/g, " ").replace(/<local-command-[a-z-]+>[\s\S]*?<\/local-command-[a-z-]+>/g, " ").replace(/<[^>]{1,40}>/g, " ").replace(/\s+/g, " ").trim();
+}
+function hydrateSession(row) {
+  if (row.hydrated)
+    return row;
+  row.hydrated = true;
+  if (isActive(row)) {
+    try {
+      row.sizeBytes = statSync6(row.file).size;
+    } catch {}
+  }
+  const head = parseRecords(readChunk(row.file, 0, Math.min(HEAD_BYTES, row.sizeBytes)), false);
+  for (const r of head) {
+    if (!row.gitBranch && typeof r.gitBranch === "string")
+      row.gitBranch = r.gitBranch;
+    if (!row.firstPrompt && r.type === "user" && !r.isMeta) {
+      const raw2 = contentText(r.message?.content);
+      const t = isHarnessNoise(raw2) ? "" : cleanPrompt(raw2);
+      if (t)
+        row.firstPrompt = t;
+    }
+    if (row.gitBranch && row.firstPrompt)
+      break;
+  }
+  const tailStart = Math.max(0, row.sizeBytes - TAIL_BYTES);
+  const tail = parseRecords(readChunk(row.file, tailStart, row.sizeBytes - tailStart), tailStart > 0);
+  for (let i = tail.length - 1;i >= 0; i--) {
+    const r = tail[i];
+    if (!row.title && r.type === "ai-title" && typeof r.aiTitle === "string" && r.aiTitle.trim()) {
+      row.title = r.aiTitle.trim();
+    }
+    if (row.lastMessageChars === undefined && r.type === "user" && !r.isMeta) {
+      const raw2 = contentText(r.message?.content);
+      const t = isHarnessNoise(raw2) ? "" : cleanPrompt(raw2);
+      if (t)
+        row.lastMessageChars = t.length;
+    }
+  }
+  row.recentTurns = extractRecentTurns(tail);
+  return row;
+}
+function extractRecentTurns(records) {
+  const out = [];
+  let ai = 0;
+  let user = 0;
+  for (let i = records.length - 1;i >= 0; i--) {
+    if (ai >= RECENT_AI_TURNS && user >= RECENT_USER_TURNS)
+      break;
+    const r = records[i];
+    if (r.type !== "user" && r.type !== "assistant")
+      continue;
+    const role = r.type === "user" ? "user" : "assistant";
+    if (role === "assistant" ? ai >= RECENT_AI_TURNS : user >= RECENT_USER_TURNS)
+      continue;
+    const turn = mainConversationTurn(r);
+    if (!turn)
+      continue;
+    const text = cleanPrompt(turn.raw);
+    if (!text)
+      continue;
+    out.push({ role, text });
+    if (role === "assistant")
+      ai++;
+    else
+      user++;
+  }
+  return out.reverse();
+}
+function hydrateConversation(row) {
+  if (row.conversationDeepened)
+    return row;
+  row.conversationDeepened = true;
+  const turns = row.recentTurns;
+  if (!turns || turns.some((t) => t.role === "user"))
+    return row;
+  const start = Math.max(0, row.sizeBytes - DEEP_TAIL_BYTES);
+  const chunk = readChunk(row.file, start, row.sizeBytes - start);
+  if (!chunk)
+    return row;
+  const lines = chunk.split(`
+`);
+  if (start > 0)
+    lines.shift();
+  for (let i = lines.length - 1;i >= 0; i--) {
+    const line = lines[i];
+    if (!line.includes('"type":"user"'))
+      continue;
+    let r;
+    try {
+      r = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const turn = mainConversationTurn(r);
+    if (!turn || turn.role !== "user")
+      continue;
+    const text = cleanPrompt(turn.raw);
+    if (!text)
+      continue;
+    turns.unshift({ role: "user", text });
+    if (row.lastMessageChars === undefined)
+      row.lastMessageChars = text.length;
+    return row;
+  }
+  return row;
+}
+function sessionLabel(row) {
+  return row.title || row.firstPrompt || row.id;
+}
+function findLatestSessionId(cwd = process.cwd(), sinceMs = 0) {
+  const rows = sessionsIn(slugForPath(cwd)).filter((r) => r.mtimeMs >= sinceMs);
+  if (rows.length === 0)
+    return null;
+  return rows.reduce((a, b) => b.mtimeMs > a.mtimeMs ? b : a).id;
+}
+var ENTRYPOINT_BYTES = 8192, PROJECTS_DIR, ACTIVE_WINDOW_MS = 120000, HEAD_BYTES, TAIL_BYTES, HARNESS_ENVELOPES, DEEP_TAIL_BYTES, RECENT_AI_TURNS = 5, RECENT_USER_TURNS = 1;
+var init_session_discovery = __esm(() => {
+  PROJECTS_DIR = join37(homedir34(), ".claude", "projects");
+  HEAD_BYTES = 64 * 1024;
+  TAIL_BYTES = 128 * 1024;
+  HARNESS_ENVELOPES = [
+    "<task-notification>",
+    "<system-reminder>",
+    "<local-command-stdout>",
+    "<user-prompt-submit-hook>"
+  ];
+  DEEP_TAIL_BYTES = 4 * 1024 * 1024;
+});
+
+// src/session/conversation.ts
+import { closeSync as closeSync6, openSync as openSync6, readSync as readSync2, statSync as statSync7 } from "fs";
+import { StringDecoder } from "string_decoder";
+function looksLikeTurn(line) {
+  const assistant = line.includes('"type":"assistant"');
+  if (!assistant && !line.includes('"type":"user"'))
+    return false;
+  if (line.includes('"isSidechain":true'))
+    return false;
+  if (line.includes('"isMeta":true'))
+    return false;
+  if (line.includes('"type":"tool_result"'))
+    return false;
+  if (assistant && !line.includes('"type":"text"'))
+    return false;
+  return true;
+}
+function cleanTurnText(raw2) {
+  let t = raw2;
+  for (const re of INLINE_ENVELOPES)
+    t = t.replace(re, "");
+  t = t.replace(/<command-name>([\s\S]*?)<\/command-name>/g, "/$1");
+  return t.replace(/\t/g, "  ").replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "").replace(/\r\n?/g, `
+`).split(`
+`).map((l) => l.replace(/\s+$/, "")).join(`
+`).replace(/\n{3,}/g, `
+
+`).trim();
+}
+function readConversation(file2, opts = {}) {
+  const maxTurn = opts.maxTurnChars ?? MAX_TURN_CHARS;
+  const maxTotal = opts.maxTotalChars ?? MAX_TOTAL_CHARS;
+  const chunkBytes = opts.chunkBytes ?? CHUNK_BYTES;
+  const started = Date.now();
+  const turns = [];
+  let chars = 0;
+  let dropped = 0;
+  let anyElided = false;
+  let bytes2 = 0;
+  const take = (turn) => {
+    turns.push(turn);
+    chars += turn.text.length;
+    if (chars <= maxTotal)
+      return;
+    let freed = 0;
+    let n = 0;
+    while (n < turns.length - 1 && chars - freed > maxTotal) {
+      freed += turns[n].text.length;
+      n++;
+    }
+    turns.splice(0, n);
+    chars -= freed;
+    dropped += n;
+  };
+  let fd = null;
+  try {
+    const size = statSync7(file2).size;
+    fd = openSync6(file2, "r");
+    const buf = Buffer.allocUnsafe(chunkBytes);
+    const decoder = new StringDecoder("utf-8");
+    let pending = "";
+    let pos = 0;
+    const consume = (line) => {
+      if (!line || !looksLikeTurn(line))
+        return;
+      let record4;
+      try {
+        record4 = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (!record4 || typeof record4 !== "object")
+        return;
+      const raw2 = mainConversationTurn(record4);
+      if (!raw2)
+        return;
+      let text = cleanTurnText(raw2.raw);
+      if (!text)
+        return;
+      const elided = text.length > maxTurn;
+      if (elided) {
+        anyElided = true;
+        text = `${text.slice(0, maxTurn)}
+
+\u2026 turn truncated at ${maxTurn.toLocaleString()} characters`;
+      }
+      take({ role: raw2.role, text, elided });
+    };
+    while (pos < size) {
+      const n = readSync2(fd, buf, 0, Math.min(chunkBytes, size - pos), pos);
+      if (n <= 0)
+        break;
+      pos += n;
+      bytes2 += n;
+      pending += decoder.write(buf.subarray(0, n));
+      let from = 0;
+      let nl = pending.indexOf(`
+`, from);
+      while (nl !== -1) {
+        consume(pending.slice(from, nl));
+        from = nl + 1;
+        nl = pending.indexOf(`
+`, from);
+      }
+      if (from > 0)
+        pending = pending.slice(from);
+    }
+    pending += decoder.end();
+    if (pending)
+      consume(pending);
+  } catch {} finally {
+    if (fd !== null) {
+      try {
+        closeSync6(fd);
+      } catch {}
+    }
+  }
+  return { turns, bytes: bytes2, elapsedMs: Date.now() - started, chars, dropped, anyElided };
+}
+function cpWidth(cp) {
+  if (cp >= 32 && cp < 127)
+    return 1;
+  return displayWidth(String.fromCodePoint(cp));
+}
+function wrapOffsets(text, width) {
+  const out = [];
+  const w = Math.max(1, Math.floor(width));
+  const n = text.length;
+  let paraStart = 0;
+  for (;; ) {
+    let nl = text.indexOf(`
+`, paraStart);
+    if (nl === -1)
+      nl = n;
+    let s = paraStart;
+    for (;; ) {
+      if (s >= nl) {
+        if (s === paraStart || paraStart === nl)
+          out.push({ start: s, end: nl });
+        break;
+      }
+      let cols = 0;
+      let j = s;
+      let lastSpace = -1;
+      while (j < nl) {
+        const cp = text.codePointAt(j);
+        const size = cp > 65535 ? 2 : 1;
+        const cw = cpWidth(cp);
+        if (cols + cw > w)
+          break;
+        if (cp === 32 && j > s && text.charCodeAt(j - 1) !== 32)
+          lastSpace = j;
+        cols += cw;
+        j += size;
+      }
+      if (j >= nl) {
+        out.push({ start: s, end: nl });
+        break;
+      }
+      const brk = text.charCodeAt(j) === 32 ? j : lastSpace > s ? lastSpace : j;
+      out.push({ start: s, end: brk });
+      s = brk === j && text.charCodeAt(j) !== 32 ? j : brk + 1;
+      while (s < nl && text.charCodeAt(s) === 32)
+        s++;
+    }
+    if (nl >= n)
+      break;
+    paraStart = nl + 1;
+    if (paraStart > n)
+      break;
+    if (paraStart === n) {
+      out.push({ start: n, end: n });
+      break;
+    }
+  }
+  return out;
+}
+var CHUNK_BYTES, MAX_TURN_CHARS = 32000, MAX_TOTAL_CHARS = 8000000, INLINE_ENVELOPES;
+var init_conversation = __esm(() => {
+  init_text();
+  init_session_discovery();
+  CHUNK_BYTES = 1024 * 1024;
+  INLINE_ENVELOPES = [
+    /<system-reminder>[\s\S]*?<\/system-reminder>/g,
+    /<command-message>[\s\S]*?<\/command-message>/g,
+    /<command-args>[\s\S]*?<\/command-args>/g,
+    /<local-command-stdout>[\s\S]*?<\/local-command-stdout>/g,
+    /<user-prompt-submit-hook>[\s\S]*?<\/user-prompt-submit-hook>/g
+  ];
+});
+
+// src/session/conversation-reader.tsx
+import { useKeyboard as useKeyboard3 } from "@opentui/react";
+import { useEffect as useEffect5, useMemo as useMemo3, useState as useState6 } from "react";
+import { jsxDEV as jsxDEV19, Fragment as Fragment12 } from "@opentui/react/jsx-dev-runtime";
+function layoutRows(turns, textWidth) {
+  const rows = [];
+  const turnStart = [];
+  const turnEnd = [];
+  for (let t = 0;t < turns.length; t++) {
+    turnStart.push(rows.length);
+    const slices = wrapOffsets(turns[t].text, textWidth);
+    for (let i = 0;i < slices.length; i++) {
+      rows.push({ turn: t, first: i === 0, start: slices[i].start, end: slices[i].end });
+    }
+    turnEnd.push(rows.length);
+    if (t < turns.length - 1)
+      rows.push({ turn: -1, first: false, start: 0, end: 0 });
+  }
+  return { rows, turnStart, turnEnd };
+}
+function buildSearch(turns, rows, turnStart, turnEnd, query) {
+  if (!query)
+    return EMPTY_SEARCH;
+  const q = query.toLowerCase();
+  const hits = [];
+  const ranges = new Map;
+  let capped = false;
+  for (let t = 0;t < turns.length && !capped; t++) {
+    const hay = turns[t].text.toLowerCase();
+    let at = hay.indexOf(q);
+    if (at === -1)
+      continue;
+    const lo = turnStart[t];
+    const hi = turnEnd[t];
+    let r = lo;
+    while (at !== -1) {
+      if (hits.length >= MAX_MATCHES) {
+        capped = true;
+        break;
+      }
+      const end = at + q.length;
+      while (r < hi - 1 && rows[r].end <= at)
+        r++;
+      const hit = hits.length;
+      hits.push(r);
+      for (let k = r;k < hi; k++) {
+        const row = rows[k];
+        if (row.start >= end)
+          break;
+        const s = Math.max(at, row.start);
+        const e = Math.min(end, row.end);
+        if (e > s) {
+          const list = ranges.get(k);
+          if (list)
+            list.push({ s: s - row.start, e: e - row.start, hit });
+          else
+            ranges.set(k, [{ s: s - row.start, e: e - row.start, hit }]);
+        }
+      }
+      at = hay.indexOf(q, at + 1);
+    }
+  }
+  return { hits, ranges, capped };
+}
+function ConversationReader({
+  row,
+  conv,
+  width,
+  height: height2,
+  onClose,
+  onResume,
+  onCancel
+}) {
+  const [top, setTop] = useState6(0);
+  const [query, setQuery] = useState6("");
+  const [typing, setTyping] = useState6(false);
+  const [matchIdx, setMatchIdx] = useState6(0);
+  const CHROME_ROWS = 5;
+  const viewport = Math.max(1, height2 - CHROME_ROWS);
+  const inner = Math.max(20, width - 2);
+  const contentW = inner - BAR_W;
+  const textW = Math.max(8, contentW - GUTTER - 1);
+  const turns = useMemo3(() => conv?.turns ?? NO_TURNS, [conv]);
+  const { rows, turnStart, turnEnd } = useMemo3(() => layoutRows(turns, textW), [turns, textW]);
+  const search = useMemo3(() => buildSearch(turns, rows, turnStart, turnEnd, query), [turns, rows, turnStart, turnEnd, query]);
+  const maxTop = Math.max(0, rows.length - viewport);
+  const clampTop = (v) => Math.max(0, Math.min(v, maxTop));
+  const reveal = (r) => setTop(clampTop(r - Math.floor(viewport / 3)));
+  useEffect5(() => {
+    setTop(Math.max(0, rows.length - viewport));
+  }, [rows.length, viewport]);
+  useEffect5(() => {
+    if (search.hits.length === 0)
+      return;
+    let i = search.hits.findIndex((r) => r >= top);
+    if (i === -1)
+      i = 0;
+    setMatchIdx(i);
+    reveal(search.hits[i]);
+  }, [search]);
+  const step = (d) => {
+    if (search.hits.length === 0)
+      return;
+    const i = (matchIdx + d + search.hits.length) % search.hits.length;
+    setMatchIdx(i);
+    reveal(search.hits[i]);
+  };
+  useKeyboard3((key) => {
+    const name = key.name;
+    if (key.ctrl && name === "c") {
+      onCancel();
+      return;
+    }
+    if (name === "escape") {
+      if (typing || query) {
+        setTyping(false);
+        setQuery("");
+        return;
+      }
+      onClose();
+      return;
+    }
+    if (name === "return" || name === "enter") {
+      if (typing) {
+        setTyping(false);
+        return;
+      }
+      onResume();
+      return;
+    }
+    if (name === "up")
+      return setTop((t) => clampTop(t - 1));
+    if (name === "down")
+      return setTop((t) => clampTop(t + 1));
+    if (name === "pageup")
+      return setTop((t) => clampTop(t - viewport));
+    if (name === "pagedown")
+      return setTop((t) => clampTop(t + viewport));
+    if (name === "home")
+      return setTop(0);
+    if (name === "end")
+      return setTop(maxTop);
+    if (name === "backspace") {
+      if (typing)
+        setQuery((q) => q.slice(0, -1));
+      return;
+    }
+    const ch = key.raw;
+    const printable = ch && ch.length === 1 && ch >= " " && ch !== "\x7F";
+    if (typing) {
+      if (printable)
+        setQuery((q) => q + ch);
+      return;
+    }
+    if (name === "slash" || ch === "/") {
+      setTyping(true);
+      return;
+    }
+    if (name === "n")
+      return step(key.shift ? -1 : 1);
+    if (ch === "g")
+      return setTop(0);
+    if (ch === "G")
+      return setTop(maxTop);
+    if (name === "space")
+      return setTop((t) => clampTop(t + viewport));
+  });
+  const label = sessionLabel(row);
+  const mb = row.sizeBytes / 1048576;
+  const size = mb >= 0.1 ? `${mb.toFixed(1)} MB` : `${Math.max(1, Math.round(row.sizeBytes / 1024))} KB`;
+  const stats = conv ? `${turns.length} turns \xB7 ${rows.length} lines \xB7 ${size} transcript` : `reading ${size}\u2026`;
+  const visible = rows.slice(top, top + viewport);
+  const barCells = useMemo3(() => scrollbarCells(viewport, rows.length, top, search.hits), [viewport, rows.length, top, search.hits]);
+  const pct = rows.length <= viewport ? 100 : top / maxTop * 100;
+  const POSITION_COLS = 26;
+  const matchLabel = search.hits.length ? `${matchIdx + 1} of ${search.hits.length}${search.capped ? "+" : ""} matches` : query ? "no matches" : "";
+  return /* @__PURE__ */ jsxDEV19("box", {
+    flexDirection: "column",
+    height: height2,
+    backgroundColor: C.bg,
+    children: [
+      /* @__PURE__ */ jsxDEV19("box", {
+        flexDirection: "row",
+        justifyContent: "space-between",
+        height: 1,
+        paddingX: 1,
+        children: [
+          /* @__PURE__ */ jsxDEV19("text", {
+            children: [
+              /* @__PURE__ */ jsxDEV19("span", {
+                fg: tokens.accent,
+                attributes: A.bold,
+                children: "claudish"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV19("span", {
+                fg: tokens.subtle,
+                children: " reader"
+              }, undefined, false, undefined, this),
+              conv && conv.dropped > 0 ? /* @__PURE__ */ jsxDEV19("span", {
+                fg: tokens.warn,
+                children: `  ${conv.dropped} older turns dropped (cap)`
+              }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV19("span", {}, undefined, false, undefined, this),
+              conv?.anyElided ? /* @__PURE__ */ jsxDEV19("span", {
+                fg: tokens.warn,
+                children: "  long turns truncated"
+              }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV19("span", {}, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV19("text", {
+            children: /* @__PURE__ */ jsxDEV19("span", {
+              fg: tokens.subtle,
+              children: stats
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV19(Panel, {
+        title: `conversation \xB7 ${truncate3(label, Math.max(10, width - 20))}`,
+        flush: true,
+        flexGrow: 1,
+        flexBasis: 0,
+        children: !conv ? /* @__PURE__ */ jsxDEV19("text", {
+          fg: tokens.subtle,
+          children: "  reading transcript\u2026"
+        }, undefined, false, undefined, this) : rows.length === 0 ? /* @__PURE__ */ jsxDEV19("text", {
+          fg: tokens.trace,
+          children: "  no conversation recorded \u2014 this transcript has no main-thread prose"
+        }, undefined, false, undefined, this) : visible.map((r, i) => {
+          const line = top + i;
+          return /* @__PURE__ */ jsxDEV19(ReaderRow, {
+            row: r,
+            turn: r.turn >= 0 ? turns[r.turn] : undefined,
+            hl: search.ranges.get(line),
+            current: matchIdx,
+            width: contentW,
+            bar: barCells[i] ?? "track"
+          }, line, false, undefined, this);
+        })
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV19("box", {
+        flexDirection: "row",
+        justifyContent: "space-between",
+        height: 1,
+        paddingX: 1,
+        children: [
+          /* @__PURE__ */ jsxDEV19("text", {
+            children: query || typing ? /* @__PURE__ */ jsxDEV19(Fragment12, {
+              children: [
+                /* @__PURE__ */ jsxDEV19("span", {
+                  fg: tokens.warn,
+                  attributes: A.bold,
+                  children: truncate3(`/${query}`, Math.max(4, width - POSITION_COLS - displayWidth(matchLabel) - 4))
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV19("span", {
+                  fg: typing ? tokens.warn : tokens.trace,
+                  children: typing ? "\u258C" : " "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV19("span", {
+                  fg: search.hits.length ? tokens.subtle : tokens.trace,
+                  children: matchLabel ? `  ${matchLabel}` : ""
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV19("span", {
+              fg: tokens.trace,
+              children: "/ to search"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV19("text", {
+            children: [
+              /* @__PURE__ */ jsxDEV19("span", {
+                fg: tokens.subtle,
+                children: `${Math.min(rows.length, top + viewport)}/${rows.length}  `
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV19(MeterSpan, {
+                pct,
+                width: 12,
+                ramp: ramps.volume
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV19("box", {
+        flexDirection: "row",
+        height: 1,
+        paddingX: 1,
+        gap: 2,
+        children: [
+          /* @__PURE__ */ jsxDEV19("text", {
+            fg: tokens.subtle,
+            children: "\u2191\u2193 \u21DE\u21DF scroll"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV19("text", {
+            fg: tokens.subtle,
+            children: "g/G ends"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV19("text", {
+            fg: typing ? tokens.warn : tokens.subtle,
+            children: "/ search"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV19("text", {
+            fg: search.hits.length ? tokens.subtle : tokens.trace,
+            children: "n/N match"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV19("text", {
+            fg: tokens.accent,
+            children: "\u23CE resume"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV19("text", {
+            fg: tokens.subtle,
+            children: "esc back"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function scrollbarCells(viewport, total, top, hits) {
+  const cells = new Array(viewport).fill("track");
+  if (total <= 0)
+    return cells;
+  if (total > viewport) {
+    const size = Math.max(1, Math.round(viewport / total * viewport));
+    const span = Math.max(1, total - viewport);
+    const start = Math.min(viewport - size, Math.round(top / span * (viewport - size)));
+    for (let i = 0;i < size; i++)
+      cells[start + i] = "thumb";
+  } else {
+    cells.fill("thumb");
+  }
+  for (const h of hits) {
+    const i = Math.min(viewport - 1, Math.floor(h / total * viewport));
+    if (i >= 0)
+      cells[i] = "hit";
+  }
+  return cells;
+}
+function ReaderRow({
+  row,
+  turn,
+  hl,
+  current,
+  width,
+  bar
+}) {
+  if (!turn) {
+    return /* @__PURE__ */ jsxDEV19("text", {
+      children: [
+        /* @__PURE__ */ jsxDEV19("span", {
+          children: " ".repeat(Math.max(0, width))
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV19("span", {
+          bg: BAR_COLOR[bar],
+          children: " "
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  const text = turn.text.slice(row.start, row.end);
+  const fg = turn.role === "user" ? tokens.text : C.fgMuted;
+  const railFg = turn.role === "user" ? SPEAKER.you : SPEAKER.ai;
+  const pad2 = Math.max(0, width - GUTTER - displayWidth(text));
+  return /* @__PURE__ */ jsxDEV19("text", {
+    children: [
+      /* @__PURE__ */ jsxDEV19("span", {
+        fg: railFg,
+        children: RAIL
+      }, undefined, false, undefined, this),
+      row.first ? /* @__PURE__ */ jsxDEV19(BadgeSpan, {
+        label: turn.role === "user" ? "you" : "ai",
+        bg: turn.role === "user" ? SPEAKER.you : SPEAKER.ai,
+        width: ROLE_W
+      }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV19("span", {
+        children: " ".repeat(ROLE_W)
+      }, undefined, false, undefined, this),
+      hl && hl.length > 0 ? highlighted(text, hl, current, fg) : /* @__PURE__ */ jsxDEV19("span", {
+        fg,
+        children: text
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV19("span", {
+        children: " ".repeat(pad2)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV19("span", {
+        bg: BAR_COLOR[bar],
+        children: " "
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function highlighted(text, hl, current, fg) {
+  const out = [];
+  let from = 0;
+  for (let i = 0;i < hl.length; i++) {
+    const { s, e, hit } = hl[i];
+    if (e <= from)
+      continue;
+    const start = Math.max(from, s);
+    if (start > from)
+      out.push(/* @__PURE__ */ jsxDEV19("span", {
+        fg,
+        children: text.slice(from, start)
+      }, `p${i}`, false, undefined, this));
+    const bg = hit === current ? tokens.accent : tokens.warn;
+    out.push(/* @__PURE__ */ jsxDEV19("span", {
+      fg: tokens.ink,
+      bg,
+      attributes: A.bold,
+      children: text.slice(start, e)
+    }, `h${i}`, false, undefined, this));
+    from = e;
+  }
+  if (from < text.length)
+    out.push(/* @__PURE__ */ jsxDEV19("span", {
+      fg,
+      children: text.slice(from)
+    }, "tail", false, undefined, this));
+  return /* @__PURE__ */ jsxDEV19(Fragment12, {
+    children: out
+  }, undefined, false, undefined, this);
+}
+var RAIL = "\u258D", RAIL_W = 2, ROLE_W = 6, GUTTER, BAR_W = 1, SPEAKER, MAX_MATCHES = 5000, EMPTY_SEARCH, NO_TURNS, BAR_COLOR;
+var init_conversation_reader = __esm(() => {
+  init_theme2();
+  init_text();
+  init_tokens();
+  init_widgets();
+  init_conversation();
+  init_session_discovery();
+  GUTTER = RAIL_W + ROLE_W;
+  SPEAKER = {
+    you: "#39d353",
+    ai: "#39c5cf"
+  };
+  EMPTY_SEARCH = { hits: [], ranges: new Map, capped: false };
+  NO_TURNS = [];
+  BAR_COLOR = {
+    track: tokens.border,
+    thumb: tokens.accent,
+    hit: tokens.warn
+  };
+});
+
+// src/session/resume-picker.tsx
+import { useKeyboard as useKeyboard4, useTerminalDimensions as useTerminalDimensions3 } from "@opentui/react";
+import { useEffect as useEffect6, useMemo as useMemo4, useState as useState7 } from "react";
+import { jsxDEV as jsxDEV20 } from "@opentui/react/jsx-dev-runtime";
+function detailTurns(height2) {
+  return height2 >= 40 ? 6 : height2 >= 30 ? 4 : 2;
+}
+function fuzzy(needle, hay) {
+  if (!needle)
+    return true;
+  const n = needle.toLowerCase();
+  const h = hay.toLowerCase();
+  let i = 0;
+  for (let j = 0;j < h.length && i < n.length; j++)
+    if (h[j] === n[i])
+      i++;
+  return i === n.length;
+}
+function age(ms) {
+  const s = Math.max(0, Math.round((Date.now() - ms) / 1000));
+  if (s < 60)
+    return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60)
+    return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 24)
+    return `${h}h`;
+  return `${Math.floor(h / 24)}d`;
+}
+function chipW(label) {
+  return label + 2;
+}
+function blockWidth(c) {
+  return LIVE_W + chipW(c.age) + chipW(c.count) + (c.dirty > 0 ? chipW(c.dirty + 1) : 0) + (c.sync > 0 ? 2 * chipW(c.sync + 1) : 0);
+}
+function sizePct(bytes2, max) {
+  const lo = Math.log(SIZE_FLOOR_BYTES);
+  const hi = Math.log(Math.max(max, SIZE_FLOOR_BYTES * 2));
+  const v = Math.log(Math.max(bytes2, SIZE_FLOOR_BYTES));
+  return Math.max(0, Math.min(100, (v - lo) / (hi - lo) * 100));
+}
+function Slot({
+  label,
+  bg,
+  labelW
+}) {
+  if (!label || !bg)
+    return /* @__PURE__ */ jsxDEV20("span", {
+      children: " ".repeat(chipW(labelW))
+    }, undefined, false, undefined, this);
+  return /* @__PURE__ */ jsxDEV20(BadgeSpan, {
+    label,
+    bg
+  }, undefined, false, undefined, this);
+}
+function WorktreeRow({
+  g,
+  cursor,
+  width,
+  count,
+  cols
+}) {
+  const nameColor = !g.live ? tokens.dead : g.current ? tokens.success : tokens.text;
+  const stale = !g.lastActiveMs || Date.now() - g.lastActiveMs >= STALE_MS;
+  const room = Math.max(0, width - blockWidth(cols));
+  const series = room >= SPARK_MIN_DAYS ? activitySeries(g.sessions, room) : null;
+  const spark = series && hasActivity(series) ? series : null;
+  const chips = [];
+  if (cols.sync > 0 && g.ahead) {
+    chips.push({
+      label: `\u2191${padStartTo(String(g.ahead), cols.sync)}`,
+      bg: CHIP.ahead,
+      labelW: cols.sync + 1
+    });
+  }
+  if (cols.sync > 0 && g.behind) {
+    chips.push({
+      label: `\u2193${padStartTo(String(g.behind), cols.sync)}`,
+      bg: CHIP.behind,
+      labelW: cols.sync + 1
+    });
+  }
+  if (cols.dirty > 0 && g.dirty) {
+    chips.push({
+      label: `${DIRTY_GLYPH}${padStartTo(String(g.dirty), cols.dirty)}`,
+      bg: CHIP.dirty,
+      labelW: cols.dirty + 1
+    });
+  }
+  chips.push({ label: padStartTo(String(count), cols.count), bg: CHIP.count, labelW: cols.count });
+  chips.push({
+    label: padStartTo(g.lastActiveMs ? age(g.lastActiveMs) : "\u2014", cols.age),
+    bg: stale ? CHIP.stale : CHIP.fresh,
+    labelW: cols.age
+  });
+  const used = chips.reduce((w, c) => w + c.labelW + 2, 0) + LIVE_W;
+  const gap = Math.max(0, width - room - used);
+  return /* @__PURE__ */ jsxDEV20("box", {
+    flexDirection: "column",
+    height: 2,
+    backgroundColor: cursor ? C.bgHighlight : undefined,
+    children: [
+      /* @__PURE__ */ jsxDEV20("text", {
+        children: /* @__PURE__ */ jsxDEV20("span", {
+          fg: nameColor,
+          attributes: cursor || g.current ? A.bold : undefined,
+          children: truncate3(g.name, width)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV20("box", {
+        height: 1,
+        children: /* @__PURE__ */ jsxDEV20("text", {
+          children: [
+            spark ? /* @__PURE__ */ jsxDEV20(SparklineSpan, {
+              values: spark,
+              fg: SPARK_FG
+            }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV20("span", {
+              children: " ".repeat(room)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV20("span", {
+              children: " ".repeat(gap)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV20("span", {
+              fg: tokens.success,
+              children: g.activeNow ? "\u25CF " : "  "
+            }, undefined, false, undefined, this),
+            chips.map((c) => /* @__PURE__ */ jsxDEV20(Slot, {
+              label: c.label,
+              bg: c.bg,
+              labelW: c.labelW
+            }, c.bg + c.label, false, undefined, this))
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function dailyActivity(groups, days) {
+  const day = 86400000;
+  const today = Math.floor(Date.now() / day);
+  const buckets = new Array(days).fill(0);
+  for (const g of groups) {
+    for (const s of g.sessions) {
+      const idx = days - 1 - (today - Math.floor(s.mtimeMs / day));
+      if (idx >= 0 && idx < days)
+        buckets[idx] += 1;
+    }
+  }
+  return buckets;
+}
+function activityLevels(days) {
+  const nz = days.filter((v) => v > 0).sort((a, b) => a - b);
+  if (nz.length === 0)
+    return days.map(() => 0);
+  const at = (p) => nz[Math.min(nz.length - 1, Math.floor(nz.length * p))];
+  const q1 = at(0.25);
+  const q2 = at(0.5);
+  const q3 = at(0.75);
+  return days.map((v) => v <= 0 ? 0 : v <= q1 ? 1 : v <= q2 ? 2 : v <= q3 ? 3 : 4);
+}
+function ActivityCalendar({
+  days,
+  width
+}) {
+  const levels = activityLevels(days);
+  const title = `activity \xB7 ${ACTIVITY_WEEKS}w `;
+  const grid = Math.max(WEEK_DAYS, width - WEEK_LABEL_W);
+  const base = Math.floor(grid / WEEK_DAYS);
+  const extra = grid - base * WEEK_DAYS;
+  return /* @__PURE__ */ jsxDEV20("box", {
+    flexDirection: "column",
+    flexShrink: 0,
+    paddingTop: 1,
+    children: [
+      /* @__PURE__ */ jsxDEV20("text", {
+        children: [
+          /* @__PURE__ */ jsxDEV20("span", {
+            fg: tokens.subtle,
+            attributes: A.bold,
+            children: title
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("span", {
+            fg: tokens.border,
+            children: "\u2500".repeat(Math.max(0, width - title.length))
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      Array.from({ length: ACTIVITY_WEEKS }, (_, w) => {
+        const ago = ACTIVITY_WEEKS - 1 - w;
+        return /* @__PURE__ */ jsxDEV20("text", {
+          children: [
+            /* @__PURE__ */ jsxDEV20("span", {
+              fg: tokens.trace,
+              children: padTo(ago === 0 ? "now" : `-${ago}w`, WEEK_LABEL_W)
+            }, undefined, false, undefined, this),
+            Array.from({ length: WEEK_DAYS }, (_2, d) => /* @__PURE__ */ jsxDEV20("span", {
+              bg: GH_LEVELS[levels[w * WEEK_DAYS + d] ?? 0],
+              children: " ".repeat(base + (d < extra ? 1 : 0))
+            }, d, false, undefined, this))
+          ]
+        }, w, true, undefined, this);
+      })
+    ]
+  }, undefined, true, undefined, this);
+}
+function SectionHeader({ label, width }) {
+  const text = `${label} `;
+  return /* @__PURE__ */ jsxDEV20("box", {
+    flexDirection: "column",
+    height: 2,
+    children: [
+      /* @__PURE__ */ jsxDEV20("text", {
+        children: " "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV20("text", {
+        children: [
+          /* @__PURE__ */ jsxDEV20("span", {
+            fg: tokens.subtle,
+            attributes: A.bold,
+            children: text
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("span", {
+            fg: tokens.border,
+            children: "\u2500".repeat(Math.max(0, width - text.length))
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function hasActivity(series) {
+  return series.some((v) => v > 0);
+}
+function activitySeries(sessions2, days = WEEK_DAYS * 2) {
+  const day = 86400000;
+  const today = Math.floor(Date.now() / day);
+  const buckets = new Array(days).fill(0);
+  for (const s of sessions2) {
+    const idx = days - 1 - (today - Math.floor(s.mtimeMs / day));
+    if (idx >= 0 && idx < days)
+      buckets[idx] += 1;
+  }
+  return buckets;
+}
+function SessionRowView({
+  row,
+  cursor,
+  width,
+  even,
+  indent = 0,
+  maxSize,
+  meterW
+}) {
+  const live = isActive(row);
+  const pad2 = " ".repeat(indent);
+  const mb = row.sizeBytes / 1048576;
+  const size = mb >= 0.1 ? `${mb.toFixed(1)} MB` : `${Math.max(1, Math.round(row.sizeBytes / 1024))} KB`;
+  const titleW = Math.max(10, width - indent - 2);
+  const metaPad = `${pad2}  `;
+  const SIZE_COL = 8;
+  return /* @__PURE__ */ jsxDEV20("box", {
+    flexDirection: "column",
+    height: 2,
+    backgroundColor: cursor ? C.bgHighlight : even ? undefined : C.bgAlt,
+    children: [
+      /* @__PURE__ */ jsxDEV20("text", {
+        children: [
+          /* @__PURE__ */ jsxDEV20("span", {
+            fg: live ? tokens.success : tokens.border,
+            children: `${pad2}${live ? "\u25CF" : "\xB7"} `
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("span", {
+            fg: tokens.text,
+            attributes: cursor ? A.bold : undefined,
+            children: truncate3(sessionLabel(row), titleW)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV20("text", {
+        children: [
+          /* @__PURE__ */ jsxDEV20("span", {
+            children: metaPad
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20(BadgeSpan, {
+            label: padStartTo(age(row.mtimeMs), SESSION_AGE_W),
+            bg: Date.now() - row.mtimeMs < STALE_MS ? CHIP.fresh : CHIP.stale,
+            width: SESSION_AGE_COL
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20(MeterSpan, {
+            pct: sizePct(row.sizeBytes, maxSize),
+            width: meterW,
+            ramp: ramps.volume
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("span", {
+            fg: MUTED,
+            children: padStartTo(size, SIZE_COL)
+          }, undefined, false, undefined, this),
+          row.gitBranch ? /* @__PURE__ */ jsxDEV20("span", {
+            fg: tokens.trace,
+            children: `  ${BRANCH_ICON} ${truncate3(row.gitBranch, Math.max(6, width - indent - 2 - SESSION_AGE_COL - meterW - SIZE_COL - BRANCH_LEAD_DENSE))}`
+          }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV20("span", {}, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function AgentNode({
+  count,
+  open,
+  cursor,
+  width
+}) {
+  const label = `${count} agent session${count === 1 ? "" : "s"}`;
+  const hint = open ? "enter to collapse" : "enter to expand \xB7 showing 3";
+  return /* @__PURE__ */ jsxDEV20("box", {
+    height: 1,
+    backgroundColor: cursor ? C.bgHighlight : undefined,
+    children: /* @__PURE__ */ jsxDEV20("text", {
+      children: [
+        /* @__PURE__ */ jsxDEV20("span", {
+          fg: cursor ? tokens.accent : tokens.trace,
+          children: `${cursor ? "\u258D" : " "} `
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV20("span", {
+          fg: tokens.warn,
+          children: open ? "\u25BE " : "\u25B8 "
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV20("span", {
+          fg: cursor ? tokens.text : tokens.subtle,
+          children: label
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV20("span", {
+          fg: tokens.trace,
+          children: truncate3(`  ${hint}`, Math.max(0, width - label.length - 6))
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function ResumePicker({ groups, onDone }) {
+  const { width, height: height2 } = useTerminalDimensions3();
+  const [pane, setPane] = useState7("worktrees");
+  const [wtCursor, setWtCursor] = useState7(0);
+  const [sessCursor, setSessCursor] = useState7(0);
+  const [filter, setFilter] = useState7("");
+  const [agentsOpen, setAgentsOpen] = useState7(false);
+  const [reader, setReader] = useState7(null);
+  const [, setTick] = useState7(0);
+  const listed = useMemo4(() => {
+    const m = new Map;
+    for (const g of groups)
+      m.set(g.name, g.sessions.filter((s) => !isAgentSession(s)));
+    return m;
+  }, [groups]);
+  const { fresh, stale, visibleGroups } = useMemo4(() => {
+    const withSessions = groups.filter((g) => (listed.get(g.name)?.length ?? 0) > 0);
+    const matching = filter ? withSessions.filter((g) => fuzzy(filter, g.name)) : withSessions;
+    const now = Date.now();
+    const byRecency = (a, b) => b.lastActiveMs - a.lastActiveMs;
+    const f = matching.filter((g) => g.current || now - g.lastActiveMs < STALE_MS).sort((a, b) => a.current !== b.current ? a.current ? -1 : 1 : byRecency(a, b));
+    const st = matching.filter((g) => !g.current && now - g.lastActiveMs >= STALE_MS).sort(byRecency);
+    return { fresh: f, stale: st, visibleGroups: [...f, ...st] };
+  }, [groups, filter, listed]);
+  const group = visibleGroups[Math.min(wtCursor, visibleGroups.length - 1)];
+  const sessions2 = useMemo4(() => {
+    if (!group)
+      return [];
+    const base = listed.get(group.name) ?? [];
+    if (!filter)
+      return base;
+    if (fuzzy(filter, group.name))
+      return base;
+    return base.filter((s) => fuzzy(filter, sessionLabel(s)));
+  }, [group, filter, listed]);
+  const agentRows = useMemo4(() => group ? group.sessions.filter(isAgentSession) : [], [group]);
+  const items = useMemo4(() => {
+    const out = sessions2.map((row) => ({ kind: "session", row }));
+    if (agentRows.length > 0 && !filter) {
+      out.push({ kind: "agents", count: agentRows.length });
+      for (const row of agentsOpen ? agentRows : agentRows.slice(0, 3)) {
+        out.push({ kind: "agent", row });
+      }
+    }
+    return out;
+  }, [sessions2, agentRows, agentsOpen, filter]);
+  const cursorItem = items[Math.min(sessCursor, items.length - 1)];
+  const selected = cursorItem && cursorItem.kind !== "agents" ? cursorItem.row : undefined;
+  const turns = detailTurns(height2);
+  const sessionDetailH = DETAIL_CHROME + turns;
+  const listRows = Math.max(3, height2 - sessionDetailH - WORKTREE_DETAIL_H - 4);
+  useEffect6(() => {
+    const start = Math.max(0, Math.min(sessCursor - 2, items.length - listRows));
+    for (const it of items.slice(start, start + listRows + 2)) {
+      if (it.kind !== "agents")
+        hydrateSession(it.row);
+    }
+    if (selected) {
+      hydrateSession(selected);
+      hydrateConversation(selected);
+    }
+    setTick((t) => t + 1);
+  }, [items, sessCursor, listRows, selected]);
+  useEffect6(() => {
+    if (!reader || reader.conv)
+      return;
+    const file2 = reader.row.file;
+    const timer = setTimeout(() => {
+      const conv = readConversation(file2);
+      setReader((r) => r && r.row.file === file2 && !r.conv ? { row: r.row, conv } : r);
+    }, 0);
+    return () => clearTimeout(timer);
+  }, [reader]);
+  const clamp = (v, len) => Math.max(0, Math.min(v, len - 1));
+  useKeyboard4((key) => {
+    if (reader)
+      return;
+    const name = key.name;
+    if (name === "escape") {
+      if (filter) {
+        setFilter("");
+        return;
+      }
+      onDone(null);
+      return;
+    }
+    if (key.ctrl && name === "c") {
+      onDone(null);
+      return;
+    }
+    if (name === "return" || name === "enter") {
+      if (pane === "worktrees") {
+        setPane("sessions");
+        setSessCursor(0);
+        return;
+      }
+      if (cursorItem?.kind === "agents") {
+        setAgentsOpen((v) => !v);
+        return;
+      }
+      if (selected)
+        onDone(selected.id);
+      return;
+    }
+    if (name === "tab") {
+      setPane((p) => p === "worktrees" ? "sessions" : "worktrees");
+      return;
+    }
+    if (name === "left") {
+      setPane("worktrees");
+      return;
+    }
+    if (name === "right") {
+      setPane("sessions");
+      return;
+    }
+    if (name === "up" || name === "down") {
+      const d = name === "up" ? -1 : 1;
+      if (pane === "worktrees") {
+        setWtCursor((c) => clamp(c + d, visibleGroups.length));
+        setSessCursor(0);
+      } else {
+        setSessCursor((c) => clamp(c + d, items.length));
+      }
+      return;
+    }
+    if (name === "a" && !key.ctrl && !key.meta) {
+      setAgentsOpen((v) => !v);
+      return;
+    }
+    if (name === "v" && !key.ctrl && !key.meta) {
+      if (selected)
+        setReader({ row: selected, conv: null });
+      return;
+    }
+    if (name === "backspace") {
+      setFilter((f) => f.slice(0, -1));
+      setWtCursor(0);
+      setSessCursor(0);
+      return;
+    }
+    const ch = key.raw;
+    if (ch && ch.length === 1 && ch >= " " && ch !== "\x7F" && ch !== "a" && ch !== "v") {
+      setFilter((f) => f + ch);
+      setWtCursor(0);
+      setSessCursor(0);
+    }
+  });
+  const bodyW = width;
+  const sidebarW = Math.max(SIDEBAR_MIN, Math.min(SIDEBAR_MAX, Math.round(width * 0.34)));
+  const rightW = Math.max(30, bodyW - sidebarW);
+  const sessInner = rightW - PANEL_BORDER - SCROLL_CHROME;
+  const sideInner = sidebarW - PANEL_BORDER - SCROLL_CHROME - 1;
+  const sessionDetailInner = rightW - PANEL_CHROME;
+  const worktreeDetailInner = width - PANEL_CHROME;
+  const chipCols = useMemo4(() => {
+    let cols = { age: 1, count: 1, dirty: 0, sync: 0 };
+    for (const g of visibleGroups) {
+      cols.age = Math.max(cols.age, displayWidth(g.lastActiveMs ? age(g.lastActiveMs) : "\u2014"));
+      cols.count = Math.max(cols.count, String(listed.get(g.name)?.length ?? 0).length);
+      if (g.dirty)
+        cols.dirty = Math.max(cols.dirty, String(g.dirty).length);
+      if (g.ahead)
+        cols.sync = Math.max(cols.sync, String(g.ahead).length);
+      if (g.behind)
+        cols.sync = Math.max(cols.sync, String(g.behind).length);
+    }
+    if (blockWidth(cols) > sideInner)
+      cols = { ...cols, sync: 0 };
+    if (blockWidth(cols) > sideInner)
+      cols = { ...cols, dirty: 0 };
+    return cols;
+  }, [visibleGroups, listed, sideInner]);
+  const maxSize = Math.max(1, ...sessions2.slice(0, 400).map((s) => s.sizeBytes));
+  const meterW = Math.max(6, Math.min(14, Math.round(sessInner * 0.16)));
+  const sidebarInnerH = height2 - 1 - WORKTREE_DETAIL_H - 1 - PANEL_BORDER;
+  const listContentH = visibleGroups.length * 2 + (stale.length > 0 ? 2 : 0);
+  const showActivity = sidebarInnerH - listContentH >= ACTIVITY_H;
+  const activityDays = useMemo4(() => dailyActivity(visibleGroups, ACTIVITY_WEEKS * WEEK_DAYS), [visibleGroups]);
+  const shownSessions = [...listed.values()].reduce((a, v) => a + v.length, 0);
+  if (reader) {
+    return /* @__PURE__ */ jsxDEV20(ConversationReader, {
+      row: reader.row,
+      conv: reader.conv,
+      width,
+      height: height2,
+      onClose: () => setReader(null),
+      onResume: () => onDone(reader.row.id),
+      onCancel: () => onDone(null)
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsxDEV20("box", {
+    flexDirection: "column",
+    height: height2,
+    backgroundColor: C.bg,
+    children: [
+      /* @__PURE__ */ jsxDEV20("box", {
+        flexDirection: "row",
+        justifyContent: "space-between",
+        height: 1,
+        paddingX: 1,
+        children: [
+          /* @__PURE__ */ jsxDEV20("text", {
+            children: [
+              /* @__PURE__ */ jsxDEV20("span", {
+                fg: tokens.accent,
+                attributes: 1,
+                children: "claudish"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV20("span", {
+                fg: tokens.subtle,
+                children: " resume"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV20("text", {
+            children: [
+              /* @__PURE__ */ jsxDEV20("span", {
+                fg: tokens.subtle,
+                children: `${visibleGroups.length} worktrees \xB7 ${shownSessions} sessions`
+              }, undefined, false, undefined, this),
+              filter ? /* @__PURE__ */ jsxDEV20("span", {
+                fg: tokens.warn,
+                children: `  /${filter}`
+              }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV20("span", {}, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV20("box", {
+        flexDirection: "row",
+        flexGrow: 1,
+        minHeight: 0,
+        children: [
+          /* @__PURE__ */ jsxDEV20("box", {
+            width: sidebarW,
+            flexDirection: "column",
+            minHeight: 0,
+            children: /* @__PURE__ */ jsxDEV20(Panel, {
+              title: "worktrees",
+              focused: pane === "worktrees",
+              flush: true,
+              flexGrow: 1,
+              flexBasis: 0,
+              children: [
+                /* @__PURE__ */ jsxDEV20("scrollbox", {
+                  focused: false,
+                  flexGrow: 1,
+                  scrollbarOptions: SCROLLBAR,
+                  children: [
+                    fresh.map((g, i) => /* @__PURE__ */ jsxDEV20(WorktreeRow, {
+                      g,
+                      cursor: i === wtCursor,
+                      width: sideInner,
+                      count: listed.get(g.name)?.length ?? 0,
+                      cols: chipCols
+                    }, g.name, false, undefined, this)),
+                    stale.length > 0 ? /* @__PURE__ */ jsxDEV20(SectionHeader, {
+                      label: `stale \xB7 ${stale.length} \xB7 idle 3d+`,
+                      width: sideInner
+                    }, undefined, false, undefined, this) : null,
+                    stale.map((g, i) => /* @__PURE__ */ jsxDEV20(WorktreeRow, {
+                      g,
+                      cursor: fresh.length + i === wtCursor,
+                      width: sideInner,
+                      count: listed.get(g.name)?.length ?? 0,
+                      cols: chipCols
+                    }, g.name, false, undefined, this))
+                  ]
+                }, undefined, true, undefined, this),
+                showActivity ? /* @__PURE__ */ jsxDEV20(ActivityCalendar, {
+                  days: activityDays,
+                  width: sideInner
+                }, undefined, false, undefined, this) : null
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("box", {
+            flexDirection: "column",
+            flexGrow: 1,
+            minWidth: 0,
+            minHeight: 0,
+            children: [
+              /* @__PURE__ */ jsxDEV20(Panel, {
+                title: group ? `sessions \xB7 ${truncate3(group.name, 28)}` : "sessions",
+                focused: pane === "sessions",
+                flush: true,
+                flexGrow: 1,
+                flexBasis: 0,
+                children: /* @__PURE__ */ jsxDEV20("scrollbox", {
+                  focused: false,
+                  flexGrow: 1,
+                  scrollbarOptions: SCROLLBAR,
+                  children: items.length === 0 ? /* @__PURE__ */ jsxDEV20("text", {
+                    fg: tokens.subtle,
+                    children: " no sessions match"
+                  }, undefined, false, undefined, this) : items.map((it, i) => it.kind === "agents" ? /* @__PURE__ */ jsxDEV20(AgentNode, {
+                    count: it.count,
+                    open: agentsOpen,
+                    cursor: i === sessCursor && pane === "sessions",
+                    width: sessInner
+                  }, "agents", false, undefined, this) : /* @__PURE__ */ jsxDEV20(SessionRowView, {
+                    row: it.row,
+                    cursor: i === sessCursor && pane === "sessions",
+                    width: sessInner,
+                    even: i % 2 === 0,
+                    indent: it.kind === "agent" ? 2 : 0,
+                    maxSize,
+                    meterW
+                  }, it.row.id, false, undefined, this))
+                }, undefined, false, undefined, this)
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV20("box", {
+                height: sessionDetailH,
+                flexShrink: 0,
+                children: /* @__PURE__ */ jsxDEV20(Panel, {
+                  title: "session",
+                  flexGrow: 1,
+                  children: selected ? /* @__PURE__ */ jsxDEV20(SessionDetail, {
+                    row: selected,
+                    width: sessionDetailInner,
+                    turns
+                  }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV20("text", {
+                    fg: tokens.subtle,
+                    children: cursorItem?.kind === "agents" ? "agent sessions \u2014 enter to expand" : "nothing selected"
+                  }, undefined, false, undefined, this)
+                }, undefined, false, undefined, this)
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV20("box", {
+        height: WORKTREE_DETAIL_H,
+        flexShrink: 0,
+        children: /* @__PURE__ */ jsxDEV20(Panel, {
+          title: "worktree",
+          flexGrow: 1,
+          children: /* @__PURE__ */ jsxDEV20(WorktreeDetail, {
+            group,
+            width: worktreeDetailInner,
+            count: sessions2.length
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV20("box", {
+        flexDirection: "row",
+        height: 1,
+        paddingX: 1,
+        gap: 2,
+        children: [
+          /* @__PURE__ */ jsxDEV20("text", {
+            fg: tokens.subtle,
+            children: "\u2191\u2193 move"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("text", {
+            fg: tokens.subtle,
+            children: "\u21E5 pane"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("text", {
+            fg: tokens.subtle,
+            children: "type to filter"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("text", {
+            fg: tokens.accent,
+            children: "\u23CE resume"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("text", {
+            fg: selected ? tokens.info : tokens.trace,
+            children: "v read"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("text", {
+            fg: agentRows.length > 0 ? tokens.subtle : tokens.trace,
+            children: agentRows.length > 0 ? `a ${agentsOpen ? "collapse" : "expand"} agents` : ""
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("text", {
+            fg: tokens.subtle,
+            children: "esc cancel"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function Field({
+  label,
+  width,
+  children
+}) {
+  return /* @__PURE__ */ jsxDEV20("box", {
+    flexDirection: "row",
+    height: 1,
+    gap: 1,
+    children: [
+      /* @__PURE__ */ jsxDEV20("text", {
+        fg: tokens.subtle,
+        children: padTo(label, width)
+      }, undefined, false, undefined, this),
+      children
+    ]
+  }, undefined, true, undefined, this);
+}
+function WorktreeDetail({
+  group,
+  width,
+  count
+}) {
+  if (!group)
+    return /* @__PURE__ */ jsxDEV20("text", {
+      fg: tokens.subtle,
+      children: "no worktree selected"
+    }, undefined, false, undefined, this);
+  const L = 9;
+  const badges = [];
+  if (group.dirty !== undefined) {
+    badges.push({
+      label: group.dirty > 0 ? `${DIRTY_GLYPH}${group.dirty} uncommitted` : "clean",
+      bg: group.dirty > 0 ? CHIP.dirty : CHIP.clean
+    });
+  }
+  if (group.ahead)
+    badges.push({ label: `\u2191${group.ahead}`, bg: CHIP.ahead });
+  if (group.behind)
+    badges.push({ label: `\u2193${group.behind}`, bg: CHIP.behind });
+  const badgeW = badges.reduce((w, b) => w + displayWidth(b.label) + 2, 0);
+  const marker = group.current ? "  \u25B6 you are here" : !group.live ? "  worktree deleted" : "";
+  const branch = group.branch ?? (group.live ? "detached" : "\u2014");
+  const idAvail = Math.max(12, width - L - displayWidth(marker) - (BRANCH_LEAD + 1) - badgeW - 1);
+  const nameW = Math.max(8, Math.min(displayWidth(group.name), Math.floor(idAvail / 2)));
+  const branchW = Math.max(6, idAvail - nameW);
+  const spark = activitySeries(group.sessions);
+  const summary = ` ${count} session${count === 1 ? "" : "s"} \xB7 created ${group.createdMs ? age(group.createdMs) : "?"} ago \xB7 used ${group.lastActiveMs ? age(group.lastActiveMs) : "?"} ago`;
+  const locAvail = Math.max(20, width - L - spark.length - 2);
+  const pathW = Math.min(displayWidth(group.path ?? "\u2014"), Math.max(16, Math.floor(locAvail * 0.45)));
+  return /* @__PURE__ */ jsxDEV20("box", {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsxDEV20("text", {
+        children: [
+          /* @__PURE__ */ jsxDEV20("span", {
+            fg: tokens.subtle,
+            children: padTo("worktree", L)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("span", {
+            fg: tokens.text,
+            attributes: A.bold,
+            children: truncate3(group.name, nameW)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("span", {
+            fg: group.current ? HERE_FG : tokens.dead,
+            children: marker
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("span", {
+            fg: tokens.subtle,
+            children: `   ${BRANCH_ICON} `
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("span", {
+            fg: group.live ? tokens.info : tokens.dead,
+            children: `${truncate3(branch, branchW)} `
+          }, undefined, false, undefined, this),
+          badges.map((b) => /* @__PURE__ */ jsxDEV20(BadgeSpan, {
+            label: b.label,
+            bg: b.bg
+          }, b.label, false, undefined, this))
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV20("box", {
+        flexDirection: "row",
+        height: 1,
+        children: [
+          /* @__PURE__ */ jsxDEV20("text", {
+            fg: tokens.subtle,
+            flexShrink: 0,
+            children: padTo("path", L)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("text", {
+            fg: tokens.trace,
+            flexShrink: 0,
+            children: `${padTo(truncate3(group.path ?? "\u2014", pathW), pathW)}  `
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20(Sparkline, {
+            values: hasActivity(spark) ? spark : [],
+            fg: SPARK_FG
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV20("text", {
+            fg: tokens.trace,
+            flexShrink: 0,
+            children: truncate3(summary, Math.max(0, locAvail - pathW))
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function SessionDetail({
+  row,
+  width,
+  turns
+}) {
+  const mb = row.sizeBytes / 1048576;
+  const L = 9;
+  const size = mb >= 0.1 ? `${mb.toFixed(1)} MB` : `${Math.round(row.sizeBytes / 1024)} KB`;
+  const full = `\xB7 ${size}${row.lastMessageChars !== undefined ? ` \xB7 last msg ${row.lastMessageChars} ch` : ""}`;
+  const suffixRoom = width - L - 1 - row.id.length - 1;
+  const suffix = displayWidth(full) <= suffixRoom ? full : displayWidth(`\xB7 ${size}`) <= suffixRoom ? `\xB7 ${size}` : "";
+  return /* @__PURE__ */ jsxDEV20("box", {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsxDEV20(Field, {
+        label: "title",
+        width: L,
+        children: /* @__PURE__ */ jsxDEV20("text", {
+          fg: tokens.text,
+          attributes: A.bold,
+          children: truncate3(sessionLabel(row), width - L)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV20(Field, {
+        label: "id",
+        width: L,
+        children: [
+          /* @__PURE__ */ jsxDEV20("text", {
+            fg: tokens.info,
+            flexShrink: 0,
+            children: row.id
+          }, undefined, false, undefined, this),
+          suffix ? /* @__PURE__ */ jsxDEV20("text", {
+            fg: tokens.trace,
+            flexShrink: 0,
+            children: suffix
+          }, undefined, false, undefined, this) : null
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV20("box", {
+        height: 1
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV20(Conversation, {
+        turns: row.recentTurns ?? [],
+        width,
+        max: turns
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function Conversation({
+  turns,
+  width,
+  max
+}) {
+  if (turns.length === 0) {
+    return /* @__PURE__ */ jsxDEV20("box", {
+      flexDirection: "column",
+      width,
+      children: /* @__PURE__ */ jsxDEV20("text", {
+        fg: tokens.trace,
+        children: "no conversation recorded"
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  const ROLE_W2 = 6;
+  const textW = Math.max(10, width - ROLE_W2 - 2);
+  const shown = turns.slice(-max);
+  return /* @__PURE__ */ jsxDEV20("box", {
+    flexDirection: "column",
+    width,
+    flexShrink: 0,
+    children: shown.map((t, i) => /* @__PURE__ */ jsxDEV20("text", {
+      children: [
+        /* @__PURE__ */ jsxDEV20("span", {
+          fg: tokens.trace,
+          children: "\u258D"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV20(BadgeSpan, {
+          label: t.role === "user" ? "you" : "ai",
+          bg: t.role === "user" ? SPEAKER.you : SPEAKER.ai,
+          width: ROLE_W2
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV20("span", {
+          fg: t.role === "user" ? tokens.text : MUTED,
+          children: truncate3(t.text, textW)
+        }, undefined, false, undefined, this)
+      ]
+    }, `${i}-${t.text.slice(0, 12)}`, true, undefined, this))
+  }, undefined, false, undefined, this);
+}
+var PANEL_CHROME = 4, PANEL_BORDER = 2, SCROLL_CHROME = 1, SIDEBAR_MIN = 28, SIDEBAR_MAX = 50, DETAIL_CHROME = 5, WORKTREE_DETAIL_H = 4, STALE_MS, GH_LEVELS, CHIP, HERE_FG, LIVE_W = 2, DIRTY_GLYPH = "+", SESSION_AGE_W = 3, SESSION_AGE_COL, SIZE_FLOOR_BYTES, MUTED, SCROLLBAR, WEEK_DAYS = 7, ACTIVITY_WEEKS = 6, BRANCH_ICON = "\u2387", BRANCH_LEAD = 5, BRANCH_LEAD_DENSE = 6, WEEK_LABEL_W = 4, ACTIVITY_H, SPARK_MIN_DAYS = 7, SPARK_FG = "#3f6f9e";
+var init_resume_picker = __esm(() => {
+  init_theme2();
+  init_text();
+  init_tokens();
+  init_widgets();
+  init_conversation_reader();
+  init_conversation();
+  init_session_discovery();
+  STALE_MS = 3 * 86400000;
+  GH_LEVELS = ["#21262d", "#0e4429", "#006d32", "#26a641", "#39d353"];
+  CHIP = {
+    fresh: GH_LEVELS[4],
+    stale: "#a1a9b3",
+    count: "#58a6ff",
+    dirty: "#d29922",
+    clean: GH_LEVELS[3],
+    ahead: "#bc8cff",
+    behind: "#d2a8ff"
+  };
+  HERE_FG = GH_LEVELS[4];
+  SESSION_AGE_COL = SESSION_AGE_W + 3;
+  SIZE_FLOOR_BYTES = 16 * 1024;
+  MUTED = C.fgMuted;
+  SCROLLBAR = {
+    showArrows: false,
+    trackOptions: { backgroundColor: tokens.bgPanel, foregroundColor: tokens.border }
+  };
+  ACTIVITY_H = 2 + ACTIVITY_WEEKS;
+});
+
+// src/session/resume-picker-run.tsx
+var exports_resume_picker_run = {};
+__export(exports_resume_picker_run, {
+  runResumePicker: () => runResumePicker
+});
+import { createCliRenderer as createCliRenderer3 } from "@opentui/core";
+import { createRoot as createRoot3 } from "@opentui/react";
+import { jsxDEV as jsxDEV21 } from "@opentui/react/jsx-dev-runtime";
+async function runResumePicker(cwd = process.cwd()) {
+  const repo = getRepoContext(cwd);
+  if (!repo)
+    return { sessionId: null, hadSessions: false };
+  const groups = discoverWorktreeGroups(repo);
+  if (groups.length === 0)
+    return { sessionId: null, hadSessions: false };
+  await enrichWorktreeGit(groups, repo.root);
+  setStderrQuiet(true);
+  const renderer = await createCliRenderer3({
+    useAlternateScreen: true,
+    exitOnCtrlC: false
+  });
+  const root = createRoot3(renderer);
+  let chosen = null;
+  try {
+    await new Promise((resolve5) => {
+      let settled = false;
+      const done = (id) => {
+        if (settled)
+          return;
+        settled = true;
+        chosen = id;
+        resolve5();
+      };
+      root.render(/* @__PURE__ */ jsxDEV21(ResumePicker, {
+        groups,
+        onDone: done
+      }, undefined, false, undefined, this));
+    });
+  } finally {
+    try {
+      root.unmount();
+    } catch {}
+    try {
+      renderer.destroy();
+    } catch {}
+    setStderrQuiet(false);
+  }
+  return { sessionId: chosen, hadSessions: true };
+}
+var init_resume_picker_run = __esm(() => {
+  init_logger();
+  init_resume_picker();
+  init_session_discovery();
+});
+
+// src/session/baseline-pricing.ts
+function resolveBaseline(alias, label) {
+  const entry = findEntryByAlias(alias);
+  if (!entry)
+    return null;
+  const firstParty = entry.aggregators?.find((a) => a.provider === FIRST_PARTY && typeof a.pricing?.input === "number");
+  const input = firstParty?.pricing?.input;
+  const output = firstParty?.pricing?.output;
+  if (typeof input !== "number" || typeof output !== "number")
+    return null;
+  if (input <= 0 || output <= 0)
+    return null;
+  return { modelId: entry.modelId, label, inputPerM: input, outputPerM: output };
+}
+function getBaselines() {
+  return BASELINE_ALIASES.map(({ alias, label }) => resolveBaseline(alias, label)).filter((b) => b !== null);
+}
+function baselineCost(b, inputTokens, outputTokens) {
+  return inputTokens / 1e6 * b.inputPerM + outputTokens / 1e6 * b.outputPerM;
+}
+var BASELINE_ALIASES, FIRST_PARTY = "anthropic";
+var init_baseline_pricing = __esm(() => {
+  init_catalog_query();
+  BASELINE_ALIASES = [
+    { alias: "~anthropic/claude-sonnet-latest", label: "Sonnet" },
+    { alias: "~anthropic/claude-opus-latest", label: "Opus" }
+  ];
+});
+
+// src/session/session-stats.ts
+var exports_session_stats = {};
+__export(exports_session_stats, {
+  tokenFilePath: () => tokenFilePath,
+  readSessionStats: () => readSessionStats,
+  computeSavings: () => computeSavings
+});
+import { readFileSync as readFileSync28 } from "fs";
+import { homedir as homedir35 } from "os";
+import { join as join38 } from "path";
+function tokenFilePath(port) {
+  return process.env.CLAUDISH_TOKEN_FILE || join38(homedir35(), ".claudish", `tokens-${port}.json`);
+}
+function readSessionStats(port) {
+  let raw2;
+  try {
+    raw2 = JSON.parse(readFileSync28(tokenFilePath(port), "utf-8"));
+  } catch {
+    return null;
+  }
+  if (!raw2 || typeof raw2 !== "object")
+    return null;
+  const d = raw2;
+  const inputTokens = num(d.input_tokens);
+  const outputTokens = num(d.output_tokens);
+  if (inputTokens <= 0 && outputTokens <= 0)
+    return null;
+  const costUsd = num(d.total_cost);
+  const isFree = d.is_free === true;
+  const contextWindow = typeof d.context_window === "number" ? d.context_window : null;
+  const contextUsed = contextWindow && contextWindow > 0 ? Math.min(1, Math.max(0, inputTokens / contextWindow)) : null;
+  const toolCalls = Array.isArray(d.tool_calls) ? d.tool_calls.map((t) => t).filter((t) => typeof t?.name === "string" && num(t.count) > 0).map((t) => ({ name: String(t.name), count: num(t.count) })) : [];
+  const startedAt = num(d.started_at);
+  const updatedAt = num(d.updated_at);
+  const durationMs = startedAt > 0 && updatedAt > startedAt ? updatedAt - startedAt : 0;
+  const billedInputTokens = num(d.billed_input_tokens) || inputTokens;
+  const rawIn = billedInputTokens / 1e6 * num(d.input_per_m);
+  const rawOut = outputTokens / 1e6 * num(d.output_per_m);
+  const rawTotal = rawIn + rawOut;
+  const scale = rawTotal > 0 && costUsd > 0 ? costUsd / rawTotal : 0;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: num(d.total_tokens) || inputTokens + outputTokens,
+    costUsd,
+    isFree,
+    isEstimated: d.is_estimated === true,
+    providerName: typeof d.provider_name === "string" ? d.provider_name : "",
+    modelName: typeof d.model_name === "string" ? d.model_name : "",
+    contextWindow,
+    contextUsed,
+    toolCalls,
+    toolCallTotal: toolCalls.reduce((a, t) => a + t.count, 0),
+    durationMs,
+    savings: computeSavings(billedInputTokens, outputTokens, costUsd),
+    inputCostUsd: rawIn * scale,
+    outputCostUsd: rawOut * scale,
+    billedInputTokens
+  };
+}
+function computeSavings(inputTokens, outputTokens, actualUsd) {
+  return getBaselines().map((b) => {
+    const baselineUsd = baselineCost(b, inputTokens, outputTokens);
+    return {
+      label: b.label,
+      modelId: b.modelId,
+      baselineUsd,
+      savedUsd: baselineUsd - actualUsd
+    };
+  });
+}
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var init_session_stats = __esm(() => {
+  init_baseline_pricing();
+});
+
+// src/session/ansi-viz.ts
+function rgb(hex4) {
+  return [
+    Number.parseInt(hex4.slice(1, 3), 16),
+    Number.parseInt(hex4.slice(3, 5), 16),
+    Number.parseInt(hex4.slice(5, 7), 16)
+  ];
+}
+function fg(hex4) {
+  const [r, g, b] = rgb(hex4);
+  return `\x1B[38;2;${r};${g};${b}m`;
+}
+function bg(hex4) {
+  const [r, g, b] = rgb(hex4);
+  return `\x1B[48;2;${r};${g};${b}m`;
+}
+function paint(text, hex4, bold4 = false) {
+  return `${bold4 ? BOLD5 : ""}${fg(hex4)}${text}${RESET4}`;
+}
+function meter(pct, width, ramp = ramps.load) {
+  const cells = Math.floor(width);
+  if (!Number.isFinite(cells) || cells <= 0)
+    return "";
+  if (Number.isNaN(pct))
+    return paint(NODATA2.repeat(cells), tokens.dead);
+  const cols = rampFor(cells, ramp);
+  const filled = fillCells(pct, cells);
+  let out = "";
+  let last = "";
+  for (let i = 0;i < cells; i++) {
+    const hex4 = i < filled ? cols[i] : tokens.border;
+    if (hex4 !== last) {
+      out += fg(hex4);
+      last = hex4;
+    }
+    out += i < filled ? FILL2 : TRACK2;
+  }
+  return out + RESET4;
+}
+function stackedBar(segments, width) {
+  const cells = Math.floor(width);
+  if (!Number.isFinite(cells) || cells <= 0 || segments.length === 0)
+    return "";
+  const split = splitCells(segments.map((s) => s.value), cells);
+  if (split.reduce((a, b) => a + b, 0) === 0)
+    return paint(TRACK2.repeat(cells), tokens.border);
+  let out = "";
+  for (let i = 0;i < split.length; i++) {
+    const n = split[i];
+    if (n > 0)
+      out += `${bg(segments[i].color)}${" ".repeat(n)}`;
+  }
+  return out + RESET4;
+}
+function badge(label, hex4) {
+  return `${BOLD5}${fg(pickInk(hex4))}${bg(hex4)} ${label} ${RESET4}`;
+}
+function stripAnsi4(s) {
+  return s.replace(ANSI_RE3, "");
+}
+function visibleWidth(s) {
+  return displayWidth(stripAnsi4(s));
+}
+function clipStyled(s, width) {
+  if (width <= 0)
+    return "";
+  if (visibleWidth(s) <= width)
+    return s;
+  let out = "";
+  let w = 0;
+  let i = 0;
+  while (i < s.length) {
+    if (s[i] === "\x1B") {
+      const end = s.indexOf("m", i);
+      if (end === -1)
+        break;
+      out += s.slice(i, end + 1);
+      i = end + 1;
+      continue;
+    }
+    const ch = [...s.slice(i)][0] ?? "";
+    const cw = displayWidth(ch);
+    if (w + cw > width)
+      break;
+    out += ch;
+    w += cw;
+    i += ch.length;
+  }
+  return out + RESET4;
+}
+function padVisible2(s, width, align = "left") {
+  const clipped = clipStyled(s, width);
+  const pad2 = Math.max(0, width - visibleWidth(clipped));
+  return align === "left" ? clipped + " ".repeat(pad2) : " ".repeat(pad2) + clipped;
+}
+function compact(n) {
+  if (!Number.isFinite(n))
+    return "\u2014";
+  const a = Math.abs(n);
+  if (a >= 1e9)
+    return `${(n / 1e9).toFixed(1)}G`;
+  if (a >= 1e6)
+    return `${(n / 1e6).toFixed(1)}M`;
+  if (a >= 1000)
+    return `${(n / 1000).toFixed(1)}K`;
+  return String(Math.round(n));
+}
+function duration3(ms) {
+  if (!Number.isFinite(ms) || ms <= 0)
+    return "\u2014";
+  const s = Math.round(ms / 1000);
+  if (s < 60)
+    return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60)
+    return `${m}m ${String(s % 60).padStart(2, "0")}s`;
+  return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, "0")}m`;
+}
+function usd(n) {
+  if (!Number.isFinite(n))
+    return "\u2014";
+  const a = Math.abs(n);
+  if (a === 0)
+    return "$0";
+  if (a < 0.01)
+    return `$${n.toFixed(4)}`;
+  if (a < 1)
+    return `$${n.toFixed(3)}`;
+  return `$${n.toFixed(2)}`;
+}
+var RESET4 = "\x1B[0m", BOLD5 = "\x1B[1m", FILL2 = "\u2588", TRACK2 = "\u2591", NODATA2 = "\u254C", ANSI_RE3;
+var init_ansi_viz = __esm(() => {
+  init_color();
+  init_text();
+  init_tokens();
+  init_widgets();
+  ANSI_RE3 = /\x1b\[[0-9;]*m/g;
+});
+
+// src/session/session-summary.ts
+var exports_session_summary = {};
+__export(exports_session_summary, {
+  renderSessionSummary: () => renderSessionSummary,
+  printSessionSummary: () => printSessionSummary
+});
+function cardWidth() {
+  const cols = process.stdout.columns || 80;
+  return Math.max(MIN_W, Math.min(MAX_W, cols - 2));
+}
+function renderSessionSummary(input) {
+  const { stats, modelSpec, resumeModelSpec, resumeId, exitCode } = input;
+  const W2 = cardWidth();
+  const inner = W2 - CHROME;
+  const out = [];
+  const dim3 = (s) => paint(s, tokens.subtle);
+  const body = (s) => paint(s, tokens.text);
+  const titleText = exitCode === 0 ? " session " : " session \xB7 failed ";
+  const titleHex = exitCode === 0 ? tokens.accent : tokens.error;
+  const rule = "\u2500".repeat(Math.max(0, W2 - 2 - visibleWidth(titleText) - 1));
+  out.push(paint("\u256D\u2500", tokens.border) + paint(titleText, titleHex) + paint(rule + "\u256E", tokens.border));
+  const row = (s) => {
+    out.push(`${paint("\u2502", tokens.border)} ${padVisible2(s, inner)} ${paint("\u2502", tokens.border)}`);
+  };
+  const blank = () => row("");
+  const chips = [badge(truncate3(modelSpec, 34), tokens.accent)];
+  if (stats.isFree)
+    chips.push(badge("FREE", C.pillKeyBg));
+  else if (stats.isEstimated)
+    chips.push(badge("EST", "#8a7d1e"));
+  if (exitCode !== 0)
+    chips.push(badge(`EXIT ${exitCode}`, "#9e2b2b"));
+  const right = body(duration3(stats.durationMs));
+  const left = clipStyled(chips.join(" "), Math.max(0, inner - visibleWidth(right) - 1));
+  const gap = Math.max(1, inner - visibleWidth(left) - visibleWidth(right));
+  row(left + " ".repeat(gap) + right);
+  if (stats.providerName)
+    row(dim3(truncate3(stats.providerName, inner)));
+  blank();
+  const VALUE_W = 24;
+  const barW = Math.max(12, inner - LABEL_W - VALUE_W);
+  const dataRow = (label, bar, values) => {
+    row(dim3(padTo(label, LABEL_W)) + bar + padVisible2(values, VALUE_W, "right"));
+  };
+  if (stats.contextUsed !== null && stats.contextWindow) {
+    const pct = stats.contextUsed * 100;
+    dataRow("context", meter(pct, barW, ramps.load), body(padStartTo(`${Math.round(pct)}%`, 4)) + dim3(`  ${compact(stats.inputTokens)}/${compact(stats.contextWindow)}`));
+  }
+  dataRow("tokens", stackedBar([
+    { value: stats.inputTokens, color: C.blue },
+    { value: stats.outputTokens, color: C.cyan }
+  ], barW), dim3("in ") + body(compact(stats.inputTokens)) + dim3(" out ") + body(compact(stats.outputTokens)));
+  if (!stats.isFree && stats.inputCostUsd + stats.outputCostUsd > 0) {
+    dataRow("spend", stackedBar([
+      { value: stats.inputCostUsd, color: C.blue },
+      { value: stats.outputCostUsd, color: C.cyan }
+    ], barW), dim3("in ") + body(usd(stats.inputCostUsd)) + dim3(" out ") + body(usd(stats.outputCostUsd)));
+  }
+  if (stats.toolCallTotal > 0) {
+    const shown = stats.toolCalls.slice(0, TOOL_COLORS.length);
+    const rest = stats.toolCalls.slice(TOOL_COLORS.length).reduce((a, t) => a + t.count, 0);
+    const segs = shown.map((t, i) => ({ value: t.count, color: TOOL_COLORS[i] }));
+    if (rest > 0)
+      segs.push({ value: rest, color: TOOL_OTHER });
+    dataRow("tools", stackedBar(segs, barW), body(padStartTo(String(stats.toolCallTotal), 4)) + dim3(" calls"));
+    const legend = shown.map((t, i) => paint(`${t.name} ${t.count}`, TOOL_COLORS[i])).concat(rest > 0 ? [paint(`other ${rest}`, TOOL_OTHER)] : []);
+    for (const line of wrapStyled(legend, dim3(" \xB7 "), inner - LABEL_W)) {
+      row(" ".repeat(LABEL_W) + line);
+    }
+  }
+  blank();
+  row(dim3(padTo("cost", LABEL_W)) + paint(stats.isFree ? "free" : usd(stats.costUsd), stats.isFree ? tokens.success : tokens.text, true) + (stats.isEstimated && !stats.isFree ? dim3("  estimated") : ""));
+  for (const s of stats.savings) {
+    const label = padTo(`vs ${s.label}`, LABEL_W);
+    if (s.savedUsd >= 0) {
+      const pct = s.baselineUsd > 0 ? s.savedUsd / s.baselineUsd * 100 : 0;
+      dataRow(label, meter(pct, barW, ramps.savings), paint(padStartTo(`${Math.round(pct)}%`, 4), tokens.success) + dim3(" saved ") + paint(usd(s.savedUsd), tokens.success));
+    } else {
+      dataRow(label, meter(0, barW, ramps.savings), dim3("over by ") + paint(usd(-s.savedUsd), tokens.error));
+    }
+  }
+  out.push(paint(`\u2570${"\u2500".repeat(W2 - 2)}\u256F`, tokens.border));
+  if (resumeId) {
+    out.push("");
+    out.push(dim3("Resume this session with:"));
+    const modelFlag = resumeModelSpec ? `--model ${resumeModelSpec} ` : "";
+    out.push(`claudish ${modelFlag}--resume ${resumeId}`);
+  }
+  return out;
+}
+function wrapStyled(chips, sep, width) {
+  const lines = [];
+  let cur = "";
+  let curW = 0;
+  const sepW = visibleWidth(sep);
+  for (const chip of chips) {
+    const w = visibleWidth(chip);
+    if (cur && curW + sepW + w > width) {
+      lines.push(cur);
+      cur = chip;
+      curW = w;
+    } else {
+      cur = cur ? cur + sep + chip : chip;
+      curW = cur === chip ? w : curW + sepW + w;
+    }
+  }
+  if (cur)
+    lines.push(cur);
+  return lines;
+}
+function printSessionSummary(input, write) {
+  for (const line of renderSessionSummary(input))
+    write(line);
+  write(RESET4);
+}
+var TOOL_COLORS, TOOL_OTHER, MIN_W = 62, MAX_W = 96, CHROME = 4, LABEL_W = 10;
+var init_session_summary = __esm(() => {
+  init_theme2();
+  init_text();
+  init_tokens();
+  init_ansi_viz();
+  TOOL_COLORS = [
+    C.blue,
+    C.cyan,
+    "#8a7d1e",
+    "#1f6d75",
+    C.magenta,
+    "#2d6e3e",
+    C.orange
+  ];
+  TOOL_OTHER = C.dim;
+});
+
 // src/index.ts
 init_op_source();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync29, readFileSync as readFileSync28 } from "fs";
-import { join as join37, resolve as resolve5 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync29 } from "fs";
+import { join as join39, resolve as resolve5 } from "path";
 import_dotenv3.config({ quiet: true });
 function classifyStartupKind() {
   const argv = process.argv.slice(2);
@@ -78659,14 +81593,14 @@ async function runCli() {
     if (cliConfig.team && cliConfig.team.length > 0) {
       let prompt = cliConfig.claudeArgs.join(" ");
       if (cliConfig.inputFile) {
-        prompt = readFileSync28(cliConfig.inputFile, "utf-8");
+        prompt = readFileSync29(cliConfig.inputFile, "utf-8");
       }
       if (!prompt.trim()) {
         console.error("Error: --team requires a prompt (positional args or -f <file>)");
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join37(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join39(process.cwd(), `.claudish-team-${Date.now()}`);
       if (mode === "json") {
         const { setupSession: setupSession2, runModels: runModels2 } = await Promise.resolve().then(() => (init_team_orchestrator(), exports_team_orchestrator));
         setupSession2(sessionPath, cliConfig.team, prompt);
@@ -78676,9 +81610,9 @@ async function runCli() {
         });
         const result = { ...status2, responses: {} };
         for (const anonId of Object.keys(status2.models)) {
-          const responsePath = join37(sessionPath, `response-${anonId}.md`);
+          const responsePath = join39(sessionPath, `response-${anonId}.md`);
           try {
-            const raw2 = readFileSync28(responsePath, "utf-8").trim();
+            const raw2 = readFileSync29(responsePath, "utf-8").trim();
             try {
               result.responses[anonId] = JSON.parse(raw2);
             } catch {
@@ -78703,8 +81637,8 @@ async function runCli() {
 Team Status`);
       for (const id of modelIds) {
         const m = status.models[id];
-        const duration3 = m.startedAt && m.completedAt ? `${Math.round((new Date(m.completedAt).getTime() - new Date(m.startedAt).getTime()) / 1000)}s` : "pending";
-        console.log(`  ${id}  ${m.state.padEnd(10)}  ${duration3}`);
+        const duration4 = m.startedAt && m.completedAt ? `${Math.round((new Date(m.completedAt).getTime() - new Date(m.startedAt).getTime()) / 1000)}s` : "pending";
+        console.log(`  ${id}  ${m.state.padEnd(10)}  ${duration4}`);
       }
       process.exit(0);
     }
@@ -78855,6 +81789,28 @@ Team Status`);
       haiku: cliConfig.modelHaiku,
       subagent: cliConfig.modelSubagent
     };
+    let resumedSessionId = (() => {
+      const i = cliConfig.claudeArgs.indexOf("--resume");
+      const v = i !== -1 ? cliConfig.claudeArgs[i + 1] : undefined;
+      return v && !v.startsWith("-") ? v : null;
+    })();
+    if (cliConfig._resumePicker) {
+      const canDrawTui = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+      if (!canDrawTui || cliConfig._hasPrintFlag || !cliConfig.interactive) {
+        cliConfig.claudeArgs.push("--resume");
+      } else {
+        const { runResumePicker: runResumePicker2 } = await Promise.resolve().then(() => (init_resume_picker_run(), exports_resume_picker_run));
+        const outcome = await runResumePicker2();
+        if (!outcome.hadSessions) {
+          cliConfig.claudeArgs.push("--resume");
+        } else if (!outcome.sessionId) {
+          process.exit(0);
+        } else {
+          cliConfig.claudeArgs.push("--resume", outcome.sessionId);
+          resumedSessionId = outcome.sessionId;
+        }
+      }
+    }
     const proxy = await traceSpan("startup:proxy-start", () => createProxyServer2(port, cliConfig.monitor ? undefined : cliConfig.openrouterApiKey, cliConfig.monitor ? undefined : explicitModel, cliConfig.monitor, cliConfig.anthropicApiKey, modelMap, {
       summarizeTools: cliConfig.summarizeTools,
       quiet: cliConfig.quiet,
@@ -78888,6 +81844,25 @@ Team Status`);
       const write = cliConfig.interactive ? console.log : console.error;
       write(`[claudish] Done
 `);
+      try {
+        const [{ readSessionStats: readSessionStats2 }, { printSessionSummary: printSessionSummary2 }, { findLatestSessionId: findLatestSessionId2 }] = await Promise.all([
+          Promise.resolve().then(() => (init_session_stats(), exports_session_stats)),
+          Promise.resolve().then(() => (init_session_summary(), exports_session_summary)),
+          Promise.resolve().then(() => (init_session_discovery(), exports_session_discovery))
+        ]);
+        const stats = readSessionStats2(port);
+        if (stats) {
+          printSessionSummary2({
+            stats,
+            modelSpec: explicitModel || stats.modelName || "",
+            resumeModelSpec: explicitModel ?? null,
+            resumeId: resumedSessionId ?? findLatestSessionId2(process.cwd(), Date.now() - stats.durationMs),
+            exitCode
+          }, write);
+        }
+      } catch (e) {
+        console.error(`[claudish] session summary unavailable: ${e}`);
+      }
     }
     const sessionLogPath = getAlwaysOnLogPath2();
     if (exitCode !== 0 && sessionLogPath && !cliConfig.quiet) {