@hasna/oldpal 0.4.1 → 0.5.0

package/dist/index.js

@@ -28613,7 +28613,7 @@ var import_react20 = __toESM(require_react(), 1);
 // node_modules/.pnpm/ink@5.2.1_@types+react@18.3.27_react-devtools-core@4.28.5_react@18.3.1/node_modules/ink/build/hooks/use-focus-manager.js
 var import_react21 = __toESM(require_react(), 1);
 // packages/terminal/src/components/App.tsx
-var import_react26 = __toESM(require_react(), 1);
+var import_react27 = __toESM(require_react(), 1);
 // packages/shared/src/utils.ts
 import { randomUUID } from "crypto";
 function generateId() {
@@ -29868,7 +29868,8 @@ ARGUMENTS: ${args.join(" ")}`;
       const fullMatch = match[0];
       const command = match[1];
       try {
-        const output = await Bun.$`cd ${skillDir} && ${command}`.quiet().text();
+        const fullCommand = `cd ${skillDir} && ${command}`;
+        const output = await Bun.$`sh -c ${fullCommand}`.quiet().text();
         result = result.replace(fullMatch, output.trim());
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
@@ -30259,6 +30260,7 @@ class BuiltinCommands {
     loader.register(this.helpCommand(loader));
     loader.register(this.clearCommand());
     loader.register(this.newCommand());
+    loader.register(this.sessionCommand());
     loader.register(this.statusCommand());
     loader.register(this.tokensCommand());
     loader.register(this.compactCommand());
@@ -30381,6 +30383,29 @@ class BuiltinCommands {
       }
     };
   }
+  sessionCommand() {
+    return {
+      name: "session",
+      description: "List sessions or switch to a session by number",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        const arg = args.trim();
+        if (arg === "new") {
+          context.emit("done");
+          return { handled: true, sessionAction: "new" };
+        }
+        const num = parseInt(arg, 10);
+        if (!isNaN(num) && num > 0) {
+          context.emit("done");
+          return { handled: true, sessionAction: "switch", sessionNumber: num };
+        }
+        context.emit("done");
+        return { handled: true, sessionAction: "list" };
+      }
+    };
+  }
   tokensCommand() {
     return {
       name: "tokens",
@@ -31423,6 +31448,153 @@ class EmbeddedClient {
     this.messages = [];
     this.logger.info("Conversation cleared");
   }
+  getCwd() {
+    return this.cwd;
+  }
+  getStartedAt() {
+    return this.startedAt;
+  }
+  getMessages() {
+    return [...this.messages];
+  }
+}
+// packages/core/src/sessions/registry.ts
+class SessionRegistry {
+  sessions = new Map;
+  activeSessionId = null;
+  chunkBuffers = new Map;
+  chunkCallbacks = [];
+  errorCallbacks = [];
+  async createSession(cwd2) {
+    const client = new EmbeddedClient(cwd2);
+    await client.initialize();
+    const sessionInfo = {
+      id: client.getSessionId(),
+      cwd: cwd2,
+      startedAt: Date.now(),
+      updatedAt: Date.now(),
+      isProcessing: false,
+      client
+    };
+    client.onChunk((chunk) => {
+      this.handleChunk(sessionInfo.id, chunk);
+    });
+    client.onError((error) => {
+      if (this.activeSessionId === sessionInfo.id) {
+        for (const callback of this.errorCallbacks) {
+          callback(error);
+        }
+      }
+    });
+    this.sessions.set(sessionInfo.id, sessionInfo);
+    this.chunkBuffers.set(sessionInfo.id, []);
+    if (this.activeSessionId === null) {
+      this.activeSessionId = sessionInfo.id;
+    }
+    return sessionInfo;
+  }
+  handleChunk(sessionId, chunk) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.updatedAt = Date.now();
+      if (chunk.type === "done") {
+        session.isProcessing = false;
+      }
+    }
+    if (sessionId === this.activeSessionId) {
+      for (const callback of this.chunkCallbacks) {
+        callback(chunk);
+      }
+    } else {
+      const buffer = this.chunkBuffers.get(sessionId);
+      if (buffer) {
+        buffer.push(chunk);
+      }
+    }
+  }
+  async switchSession(id) {
+    if (!this.sessions.has(id)) {
+      throw new Error(`Session ${id} not found`);
+    }
+    if (this.activeSessionId === id) {
+      return;
+    }
+    this.activeSessionId = id;
+    const buffer = this.chunkBuffers.get(id);
+    if (buffer && buffer.length > 0) {
+      for (const chunk of buffer) {
+        for (const callback of this.chunkCallbacks) {
+          callback(chunk);
+        }
+      }
+      this.chunkBuffers.set(id, []);
+    }
+  }
+  listSessions() {
+    return Array.from(this.sessions.values()).sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  getActiveSession() {
+    if (!this.activeSessionId)
+      return null;
+    return this.sessions.get(this.activeSessionId) || null;
+  }
+  getActiveSessionId() {
+    return this.activeSessionId;
+  }
+  getSession(id) {
+    return this.sessions.get(id) || null;
+  }
+  getSessionIndex(id) {
+    const sessions = this.listSessions();
+    return sessions.findIndex((s) => s.id === id) + 1;
+  }
+  getSessionCount() {
+    return this.sessions.size;
+  }
+  closeSession(id) {
+    const session = this.sessions.get(id);
+    if (session) {
+      session.client.disconnect();
+      this.sessions.delete(id);
+      this.chunkBuffers.delete(id);
+      if (this.activeSessionId === id) {
+        const remaining = this.listSessions();
+        this.activeSessionId = remaining.length > 0 ? remaining[0].id : null;
+      }
+    }
+  }
+  closeAll() {
+    for (const session of this.sessions.values()) {
+      session.client.disconnect();
+    }
+    this.sessions.clear();
+    this.chunkBuffers.clear();
+    this.activeSessionId = null;
+  }
+  onChunk(callback) {
+    this.chunkCallbacks.push(callback);
+  }
+  onError(callback) {
+    this.errorCallbacks.push(callback);
+  }
+  setProcessing(id, isProcessing) {
+    const session = this.sessions.get(id);
+    if (session) {
+      session.isProcessing = isProcessing;
+      session.updatedAt = Date.now();
+    }
+  }
+  hasProcessingSession() {
+    for (const session of this.sessions.values()) {
+      if (session.isProcessing) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getBackgroundProcessingSessions() {
+    return Array.from(this.sessions.values()).filter((s) => s.isProcessing && s.id !== this.activeSessionId);
+  }
 }
 // packages/terminal/src/components/Input.tsx
 var import_react23 = __toESM(require_react(), 1);
@@ -32000,26 +32172,47 @@ function truncate(text, maxLength) {
 
 // packages/terminal/src/components/Status.tsx
 var jsx_dev_runtime4 = __toESM(require_jsx_dev_runtime(), 1);
-function Status({ isProcessing, cwd: cwd2, queueLength = 0, tokenUsage }) {
+function Status({
+  isProcessing,
+  cwd: cwd2,
+  queueLength = 0,
+  tokenUsage,
+  sessionIndex,
+  sessionCount,
+  backgroundProcessingCount = 0
+}) {
   let contextInfo = "";
   if (tokenUsage && tokenUsage.maxContextTokens > 0) {
     const percent = Math.round(tokenUsage.totalTokens / tokenUsage.maxContextTokens * 100);
-    contextInfo = `${percent}% context used`;
+    contextInfo = `${percent}% context`;
   }
+  const sessionInfo = sessionIndex && sessionCount ? `Session ${sessionIndex}/${sessionCount}` : "";
+  const bgIndicator = backgroundProcessingCount > 0 ? ` (${backgroundProcessingCount} processing)` : "";
   return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
     marginTop: 1,
     justifyContent: "space-between",
     children: [
       /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
         dimColor: true,
-        children: "/help for commands"
-      }, undefined, false, undefined, this),
+        children: [
+          "/help for commands",
+          sessionCount && sessionCount > 1 ? " | Ctrl+S sessions" : ""
+        ]
+      }, undefined, true, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
         children: [
           isProcessing && /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
             dimColor: true,
             children: "esc to stop \xB7 "
           }, undefined, false, undefined, this),
+          sessionInfo && /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
+            dimColor: true,
+            children: [
+              sessionInfo,
+              bgIndicator,
+              contextInfo ? " \xB7 " : ""
+            ]
+          }, undefined, true, undefined, this),
           contextInfo && /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
             dimColor: true,
             children: contextInfo
@@ -32218,8 +32411,131 @@ function WelcomeBanner({ version, model, directory }) {
   }, undefined, true, undefined, this);
 }
 
-// packages/terminal/src/components/App.tsx
+// packages/terminal/src/components/SessionSelector.tsx
+var import_react26 = __toESM(require_react(), 1);
 var jsx_dev_runtime8 = __toESM(require_jsx_dev_runtime(), 1);
+function formatSessionTime(timestamp) {
+  const date = new Date(timestamp);
+  const now2 = new Date;
+  const isToday = date.toDateString() === now2.toDateString();
+  if (isToday) {
+    return date.toLocaleTimeString("en-US", {
+      hour: "numeric",
+      minute: "2-digit",
+      hour12: true
+    }).toLowerCase();
+  }
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true
+  }).toLowerCase();
+}
+function formatPath(cwd2) {
+  const home = process.env.HOME || "";
+  if (cwd2.startsWith(home)) {
+    return "~" + cwd2.slice(home.length);
+  }
+  return cwd2;
+}
+function SessionSelector({
+  sessions,
+  activeSessionId,
+  onSelect,
+  onNew,
+  onCancel
+}) {
+  const [selectedIndex, setSelectedIndex] = import_react26.useState(0);
+  use_input_default((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      if (selectedIndex === sessions.length) {
+        onNew();
+      } else {
+        onSelect(sessions[selectedIndex].id);
+      }
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+    }
+    if (key.downArrow) {
+      setSelectedIndex((prev) => Math.min(sessions.length, prev + 1));
+    }
+    const num = parseInt(input, 10);
+    if (!isNaN(num) && num >= 1 && num <= sessions.length) {
+      onSelect(sessions[num - 1].id);
+    }
+    if (input === "n") {
+      onNew();
+    }
+  });
+  return /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+    flexDirection: "column",
+    paddingY: 1,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+        marginBottom: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+          bold: true,
+          children: "Sessions"
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      sessions.map((session, index) => {
+        const isActive = session.id === activeSessionId;
+        const isSelected = index === selectedIndex;
+        const prefix = isActive ? "[*]" : "   ";
+        const time = formatSessionTime(session.updatedAt);
+        const path = formatPath(session.cwd);
+        const processing = session.isProcessing ? " (processing)" : "";
+        return /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+          children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+            inverse: isSelected,
+            color: isActive ? "green" : undefined,
+            dimColor: !isSelected && !isActive,
+            children: [
+              prefix,
+              " ",
+              index + 1,
+              ". ",
+              time,
+              "  ",
+              path,
+              processing
+            ]
+          }, undefined, true, undefined, this)
+        }, session.id, false, undefined, this);
+      }),
+      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+        marginTop: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+          inverse: selectedIndex === sessions.length,
+          dimColor: selectedIndex !== sessions.length,
+          children: "+ New session (n)"
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+        marginTop: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+          dimColor: true,
+          children: [
+            "Enter to select | Esc to cancel | 1-",
+            sessions.length,
+            " to switch | n for new"
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// packages/terminal/src/components/App.tsx
+var jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
 function formatToolName(toolCall) {
   const { name, input } = toolCall;
   switch (name) {
@@ -32246,27 +32562,183 @@ function formatToolName(toolCall) {
 }
 function App2({ cwd: cwd2 }) {
   const { exit } = use_app_default();
-  const [client, setClient] = import_react26.useState(null);
-  const [messages, setMessages] = import_react26.useState([]);
-  const [currentResponse, setCurrentResponse] = import_react26.useState("");
-  const [currentToolCall, setCurrentToolCall] = import_react26.useState();
-  const [lastToolResult, setLastToolResult] = import_react26.useState();
-  const [isProcessing, setIsProcessing] = import_react26.useState(false);
-  const [isInitializing, setIsInitializing] = import_react26.useState(true);
-  const [error, setError] = import_react26.useState(null);
-  const [messageQueue, setMessageQueue] = import_react26.useState([]);
-  const [activityLog, setActivityLog] = import_react26.useState([]);
-  const [tokenUsage, setTokenUsage] = import_react26.useState();
-  const [processingStartTime, setProcessingStartTime] = import_react26.useState();
-  const [currentTurnTokens, setCurrentTurnTokens] = import_react26.useState(0);
-  const [scrollOffset, setScrollOffset] = import_react26.useState(0);
-  const [autoScroll, setAutoScroll] = import_react26.useState(true);
-  const responseRef = import_react26.useRef("");
-  const clientRef = import_react26.useRef(null);
-  const toolCallsRef = import_react26.useRef([]);
-  const toolResultsRef = import_react26.useRef([]);
-  const processQueue = import_react26.useCallback(async () => {
-    if (!clientRef.current || messageQueue.length === 0)
+  const [registry2] = import_react27.useState(() => new SessionRegistry);
+  const registryRef = import_react27.useRef(registry2);
+  const [activeSessionId, setActiveSessionId] = import_react27.useState(null);
+  const [isInitializing, setIsInitializing] = import_react27.useState(true);
+  const [showSessionSelector, setShowSessionSelector] = import_react27.useState(false);
+  const sessionUIStates = import_react27.useRef(new Map);
+  const [messages, setMessages] = import_react27.useState([]);
+  const [currentResponse, setCurrentResponse] = import_react27.useState("");
+  const [currentToolCall, setCurrentToolCall] = import_react27.useState();
+  const [isProcessing, setIsProcessing] = import_react27.useState(false);
+  const [error, setError] = import_react27.useState(null);
+  const [messageQueue, setMessageQueue] = import_react27.useState([]);
+  const [activityLog, setActivityLog] = import_react27.useState([]);
+  const [tokenUsage, setTokenUsage] = import_react27.useState();
+  const [processingStartTime, setProcessingStartTime] = import_react27.useState();
+  const [currentTurnTokens, setCurrentTurnTokens] = import_react27.useState(0);
+  const [scrollOffset, setScrollOffset] = import_react27.useState(0);
+  const [autoScroll, setAutoScroll] = import_react27.useState(true);
+  const responseRef = import_react27.useRef("");
+  const toolCallsRef = import_react27.useRef([]);
+  const toolResultsRef = import_react27.useRef([]);
+  const activityLogRef = import_react27.useRef([]);
+  const saveCurrentSessionState = import_react27.useCallback(() => {
+    if (activeSessionId) {
+      sessionUIStates.current.set(activeSessionId, {
+        messages,
+        currentResponse: responseRef.current,
+        activityLog: activityLogRef.current,
+        tokenUsage,
+        processingStartTime,
+        currentTurnTokens,
+        messageQueue,
+        error
+      });
+    }
+  }, [activeSessionId, messages, tokenUsage, processingStartTime, currentTurnTokens, messageQueue, error]);
+  const loadSessionState = import_react27.useCallback((sessionId) => {
+    const state = sessionUIStates.current.get(sessionId);
+    if (state) {
+      setMessages(state.messages);
+      setCurrentResponse(state.currentResponse);
+      responseRef.current = state.currentResponse;
+      setActivityLog(state.activityLog);
+      activityLogRef.current = state.activityLog;
+      setTokenUsage(state.tokenUsage);
+      setProcessingStartTime(state.processingStartTime);
+      setCurrentTurnTokens(state.currentTurnTokens);
+      setMessageQueue(state.messageQueue);
+      setError(state.error);
+    } else {
+      setMessages([]);
+      setCurrentResponse("");
+      responseRef.current = "";
+      setActivityLog([]);
+      activityLogRef.current = [];
+      setTokenUsage(undefined);
+      setProcessingStartTime(undefined);
+      setCurrentTurnTokens(0);
+      setMessageQueue([]);
+      setError(null);
+    }
+    setScrollOffset(0);
+    setAutoScroll(true);
+  }, []);
+  const handleChunk = import_react27.useCallback((chunk) => {
+    if (chunk.type === "text" && chunk.content) {
+      responseRef.current += chunk.content;
+      setCurrentResponse(responseRef.current);
+    } else if (chunk.type === "tool_use" && chunk.toolCall) {
+      if (responseRef.current.trim()) {
+        const textEntry = {
+          id: generateId(),
+          type: "text",
+          content: responseRef.current,
+          timestamp: now()
+        };
+        activityLogRef.current = [...activityLogRef.current, textEntry];
+        setActivityLog(activityLogRef.current);
+        setCurrentResponse("");
+        responseRef.current = "";
+      }
+      toolCallsRef.current.push(chunk.toolCall);
+      const toolEntry = {
+        id: generateId(),
+        type: "tool_call",
+        toolCall: chunk.toolCall,
+        timestamp: now()
+      };
+      activityLogRef.current = [...activityLogRef.current, toolEntry];
+      setActivityLog(activityLogRef.current);
+      setCurrentToolCall(chunk.toolCall);
+    } else if (chunk.type === "tool_result" && chunk.toolResult) {
+      toolResultsRef.current.push(chunk.toolResult);
+      const resultEntry = {
+        id: generateId(),
+        type: "tool_result",
+        toolResult: chunk.toolResult,
+        timestamp: now()
+      };
+      activityLogRef.current = [...activityLogRef.current, resultEntry];
+      setActivityLog(activityLogRef.current);
+      setCurrentToolCall(undefined);
+    } else if (chunk.type === "error" && chunk.error) {
+      setError(chunk.error);
+      setIsProcessing(false);
+    } else if (chunk.type === "exit") {
+      registry2.closeAll();
+      exit();
+    } else if (chunk.type === "usage" && chunk.usage) {
+      setTokenUsage(chunk.usage);
+      setCurrentTurnTokens((prev) => prev + (chunk.usage?.outputTokens || 0));
+    } else if (chunk.type === "done") {
+      if (responseRef.current.trim()) {
+        const textEntry = {
+          id: generateId(),
+          type: "text",
+          content: responseRef.current,
+          timestamp: now()
+        };
+        activityLogRef.current = [...activityLogRef.current, textEntry];
+      }
+      const fullContent = activityLogRef.current.filter((e) => e.type === "text").map((e) => e.content).join(`
+`) + (responseRef.current ? `
+` + responseRef.current : "");
+      if (fullContent.trim() || toolCallsRef.current.length > 0) {
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: generateId(),
+            role: "assistant",
+            content: fullContent.trim(),
+            timestamp: now(),
+            toolCalls: toolCallsRef.current.length > 0 ? [...toolCallsRef.current] : undefined,
+            toolResults: toolResultsRef.current.length > 0 ? [...toolResultsRef.current] : undefined
+          }
+        ]);
+      }
+      setCurrentResponse("");
+      responseRef.current = "";
+      toolCallsRef.current = [];
+      toolResultsRef.current = [];
+      setCurrentToolCall(undefined);
+      setActivityLog([]);
+      activityLogRef.current = [];
+      setProcessingStartTime(undefined);
+      setCurrentTurnTokens(0);
+      setIsProcessing(false);
+      const activeSession2 = registry2.getActiveSession();
+      if (activeSession2) {
+        setTokenUsage(activeSession2.client.getTokenUsage());
+      }
+    }
+  }, [registry2, exit]);
+  import_react27.useEffect(() => {
+    const initSession = async () => {
+      try {
+        registry2.onChunk(handleChunk);
+        registry2.onError((err) => {
+          setError(err.message);
+          setIsProcessing(false);
+        });
+        const session = await registry2.createSession(cwd2);
+        setActiveSessionId(session.id);
+        setIsInitializing(false);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setIsInitializing(false);
+      }
+    };
+    initSession();
+    return () => {
+      registry2.closeAll();
+    };
+  }, [cwd2, registry2, handleChunk]);
+  const processQueue = import_react27.useCallback(async () => {
+    const activeSession2 = registryRef.current.getActiveSession();
+    if (!activeSession2 || messageQueue.length === 0)
       return;
     const nextMessage = messageQueue[0];
     setMessageQueue((prev) => prev.slice(1));
@@ -32283,129 +32755,20 @@ function App2({ cwd: cwd2 }) {
     toolResultsRef.current = [];
     setError(null);
     setCurrentToolCall(undefined);
-    setLastToolResult(undefined);
     setActivityLog([]);
+    activityLogRef.current = [];
     setProcessingStartTime(Date.now());
     setCurrentTurnTokens(0);
     setIsProcessing(true);
-    await clientRef.current.send(nextMessage);
+    registryRef.current.setProcessing(activeSession2.id, true);
+    await activeSession2.client.send(nextMessage);
   }, [messageQueue]);
-  import_react26.useEffect(() => {
-    const initClient = async () => {
-      try {
-        const newClient = new EmbeddedClient(cwd2);
-        clientRef.current = newClient;
-        newClient.onChunk((chunk) => {
-          if (chunk.type === "text" && chunk.content) {
-            responseRef.current += chunk.content;
-            setCurrentResponse(responseRef.current);
-          } else if (chunk.type === "tool_use" && chunk.toolCall) {
-            if (responseRef.current.trim()) {
-              setActivityLog((prev) => [
-                ...prev,
-                {
-                  id: generateId(),
-                  type: "text",
-                  content: responseRef.current,
-                  timestamp: now()
-                }
-              ]);
-              setCurrentResponse("");
-              responseRef.current = "";
-            }
-            toolCallsRef.current.push(chunk.toolCall);
-            setActivityLog((prev) => [
-              ...prev,
-              {
-                id: generateId(),
-                type: "tool_call",
-                toolCall: chunk.toolCall,
-                timestamp: now()
-              }
-            ]);
-            setCurrentToolCall(chunk.toolCall);
-          } else if (chunk.type === "tool_result" && chunk.toolResult) {
-            toolResultsRef.current.push(chunk.toolResult);
-            setActivityLog((prev) => [
-              ...prev,
-              {
-                id: generateId(),
-                type: "tool_result",
-                toolResult: chunk.toolResult,
-                timestamp: now()
-              }
-            ]);
-            setCurrentToolCall(undefined);
-          } else if (chunk.type === "error" && chunk.error) {
-            setError(chunk.error);
-            setIsProcessing(false);
-          } else if (chunk.type === "exit") {
-            exit();
-          } else if (chunk.type === "usage" && chunk.usage) {
-            setTokenUsage(chunk.usage);
-            setCurrentTurnTokens((prev) => prev + (chunk.usage?.outputTokens || 0));
-          } else if (chunk.type === "done") {
-            if (responseRef.current.trim()) {
-              setActivityLog((prev) => [
-                ...prev,
-                {
-                  id: generateId(),
-                  type: "text",
-                  content: responseRef.current,
-                  timestamp: now()
-                }
-              ]);
-            }
-            const fullContent = activityLog.filter((e) => e.type === "text").map((e) => e.content).join(`
-`) + (responseRef.current ? `
-` + responseRef.current : "");
-            if (fullContent.trim() || toolCallsRef.current.length > 0) {
-              setMessages((prev) => [
-                ...prev,
-                {
-                  id: generateId(),
-                  role: "assistant",
-                  content: fullContent.trim(),
-                  timestamp: now(),
-                  toolCalls: toolCallsRef.current.length > 0 ? [...toolCallsRef.current] : undefined,
-                  toolResults: toolResultsRef.current.length > 0 ? [...toolResultsRef.current] : undefined
-                }
-              ]);
-            }
-            setCurrentResponse("");
-            responseRef.current = "";
-            toolCallsRef.current = [];
-            toolResultsRef.current = [];
-            setCurrentToolCall(undefined);
-            setActivityLog([]);
-            setProcessingStartTime(undefined);
-            setCurrentTurnTokens(0);
-            setIsProcessing(false);
-            if (newClient) {
-              setTokenUsage(newClient.getTokenUsage());
-            }
-          }
-        });
-        newClient.onError((err) => {
-          setError(err.message);
-          setIsProcessing(false);
-        });
-        await newClient.initialize();
-        setClient(newClient);
-        setIsInitializing(false);
-      } catch (err) {
-        setError(err instanceof Error ? err.message : String(err));
-        setIsInitializing(false);
-      }
-    };
-    initClient();
-  }, [cwd2]);
-  import_react26.useEffect(() => {
+  import_react27.useEffect(() => {
     if (!isProcessing && messageQueue.length > 0) {
       processQueue();
     }
   }, [isProcessing, messageQueue.length, processQueue]);
-  import_react26.useEffect(() => {
+  import_react27.useEffect(() => {
     if (autoScroll) {
       setScrollOffset(0);
     }
@@ -32413,10 +32776,48 @@ function App2({ cwd: cwd2 }) {
   const baseMaxVisible = 10;
   const toolCallsHeight = isProcessing ? Math.min(toolCallsRef.current.length, 5) : 0;
   const maxVisibleMessages = Math.max(3, baseMaxVisible - toolCallsHeight);
+  const sessions = registry2.listSessions();
+  const activeSession = registry2.getActiveSession();
+  const sessionIndex = activeSessionId ? registry2.getSessionIndex(activeSessionId) : 0;
+  const sessionCount = registry2.getSessionCount();
+  const backgroundProcessingCount = registry2.getBackgroundProcessingSessions().length;
+  const handleSessionSwitch = import_react27.useCallback(async (sessionId) => {
+    if (sessionId === activeSessionId) {
+      setShowSessionSelector(false);
+      return;
+    }
+    saveCurrentSessionState();
+    await registry2.switchSession(sessionId);
+    setActiveSessionId(sessionId);
+    loadSessionState(sessionId);
+    const session = registry2.getSession(sessionId);
+    if (session) {
+      setIsProcessing(session.isProcessing);
+    }
+    setShowSessionSelector(false);
+  }, [activeSessionId, registry2, saveCurrentSessionState, loadSessionState]);
+  const handleNewSession = import_react27.useCallback(async () => {
+    saveCurrentSessionState();
+    const newSession = await registry2.createSession(cwd2);
+    await registry2.switchSession(newSession.id);
+    setActiveSessionId(newSession.id);
+    loadSessionState(newSession.id);
+    setIsProcessing(false);
+    setShowSessionSelector(false);
+  }, [cwd2, registry2, saveCurrentSessionState, loadSessionState]);
   use_input_default((input, key) => {
+    if (showSessionSelector) {
+      return;
+    }
+    if (key.ctrl && input === "s") {
+      if (sessions.length > 0) {
+        setShowSessionSelector(true);
+      }
+      return;
+    }
     if (key.ctrl && input === "c") {
-      if (isProcessing && client) {
-        client.stop();
+      if (isProcessing && activeSession) {
+        activeSession.client.stop();
         if (responseRef.current) {
           setMessages((prev) => [
             ...prev,
@@ -32434,27 +32835,30 @@ function App2({ cwd: cwd2 }) {
         }
         setIsProcessing(false);
       } else {
+        registry2.closeAll();
         exit();
       }
     }
-    if (key.escape && isProcessing && client) {
-      client.stop();
-      if (responseRef.current) {
-        setMessages((prev) => [
-          ...prev,
-          {
-            id: generateId(),
-            role: "assistant",
-            content: responseRef.current + `
+    if (key.escape) {
+      if (isProcessing && activeSession) {
+        activeSession.client.stop();
+        if (responseRef.current) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: generateId(),
+              role: "assistant",
+              content: responseRef.current + `
 
 [stopped]`,
-            timestamp: now()
-          }
-        ]);
-        setCurrentResponse("");
-        responseRef.current = "";
+              timestamp: now()
+            }
+          ]);
+          setCurrentResponse("");
+          responseRef.current = "";
+        }
+        setIsProcessing(false);
       }
-      setIsProcessing(false);
     }
     if (key.pageUp || key.shift && key.upArrow) {
       setScrollOffset((prev) => {
@@ -32483,16 +32887,30 @@ function App2({ cwd: cwd2 }) {
       setAutoScroll(true);
     }
   });
-  const handleSubmit = import_react26.useCallback(async (input, mode = "normal") => {
-    if (!client || !input.trim())
+  const handleSubmit = import_react27.useCallback(async (input, mode = "normal") => {
+    if (!activeSession || !input.trim())
       return;
     const trimmedInput = input.trim();
+    if (trimmedInput.startsWith("/session")) {
+      const arg = trimmedInput.slice(8).trim();
+      if (arg === "new") {
+        await handleNewSession();
+        return;
+      }
+      const num = parseInt(arg, 10);
+      if (!isNaN(num) && num > 0 && num <= sessions.length) {
+        await handleSessionSwitch(sessions[num - 1].id);
+        return;
+      }
+      setShowSessionSelector(true);
+      return;
+    }
     if (mode === "queue" || isProcessing && mode === "normal") {
       setMessageQueue((prev) => [...prev, trimmedInput]);
       return;
     }
     if (mode === "interrupt" && isProcessing) {
-      client.stop();
+      activeSession.client.stop();
       if (responseRef.current) {
         setMessages((prev) => [
           ...prev,
@@ -32524,39 +32942,65 @@ function App2({ cwd: cwd2 }) {
     toolResultsRef.current = [];
     setError(null);
     setCurrentToolCall(undefined);
-    setLastToolResult(undefined);
     setActivityLog([]);
+    activityLogRef.current = [];
     setProcessingStartTime(Date.now());
     setCurrentTurnTokens(0);
     setIsProcessing(true);
-    await client.send(trimmedInput);
-  }, [client, isProcessing]);
+    registry2.setProcessing(activeSession.id, true);
+    await activeSession.client.send(trimmedInput);
+  }, [activeSession, isProcessing, registry2, sessions, handleNewSession, handleSessionSwitch]);
   if (isInitializing) {
-    return /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Spinner2, {
+      children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Spinner2, {
         label: "Initializing..."
       }, undefined, false, undefined, this)
     }, undefined, false, undefined, this);
   }
+  if (showSessionSelector) {
+    return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
+      flexDirection: "column",
+      padding: 1,
+      children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(SessionSelector, {
+        sessions,
+        activeSessionId,
+        onSelect: handleSessionSwitch,
+        onNew: handleNewSession,
+        onCancel: () => setShowSessionSelector(false)
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
   const toolCallEntries = activityLog.filter((e) => e.type === "tool_call" && e.toolCall).map((e) => {
     const result = activityLog.find((r) => r.type === "tool_result" && r.toolResult?.toolCallId === e.toolCall?.id)?.toolResult;
     return { toolCall: e.toolCall, result };
   });
   const isThinking = isProcessing && !currentResponse && !currentToolCall && toolCallEntries.length === 0;
   const showWelcome = messages.length === 0 && !isProcessing;
-  return /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
     flexDirection: "column",
     padding: 1,
     children: [
-      showWelcome && /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(WelcomeBanner, {
+      showWelcome && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(WelcomeBanner, {
         version: "0.4.1",
         model: "claude-sonnet-4",
-        directory: cwd2
+        directory: activeSession?.cwd || cwd2
       }, undefined, false, undefined, this),
-      scrollOffset > 0 && /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
-        children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+      backgroundProcessingCount > 0 && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
+        marginBottom: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+          color: "yellow",
+          children: [
+            backgroundProcessingCount,
+            " session",
+            backgroundProcessingCount > 1 ? "s" : "",
+            " processing in background (Ctrl+S to switch)"
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      scrollOffset > 0 && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
+        children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
           dimColor: true,
           children: [
             "\u2191 ",
@@ -32565,7 +33009,7 @@ function App2({ cwd: cwd2 }) {
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Messages4, {
+      /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Messages4, {
         messages,
         currentResponse: isProcessing ? currentResponse : undefined,
         currentToolCall: undefined,
@@ -32574,9 +33018,9 @@ function App2({ cwd: cwd2 }) {
         scrollOffset,
         maxVisible: maxVisibleMessages
       }, undefined, false, undefined, this),
-      isProcessing && toolCallEntries.length > 0 && /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+      isProcessing && toolCallEntries.length > 0 && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
         marginY: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+        children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
           dimColor: true,
           children: [
             "\u2699 ",
@@ -32589,9 +33033,9 @@ function App2({ cwd: cwd2 }) {
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      messageQueue.length > 0 && /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+      messageQueue.length > 0 && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
         marginY: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+        children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
           dimColor: true,
           children: [
             messageQueue.length,
@@ -32601,9 +33045,9 @@ function App2({ cwd: cwd2 }) {
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      error && /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+      error && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
         marginY: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+        children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
           color: "red",
           children: [
             "Error: ",
@@ -32611,29 +33055,32 @@ function App2({ cwd: cwd2 }) {
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(ProcessingIndicator, {
+      /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(ProcessingIndicator, {
         isProcessing,
         startTime: processingStartTime,
         tokenCount: currentTurnTokens,
         isThinking
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Input, {
+      /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Input, {
         onSubmit: handleSubmit,
         isProcessing,
         queueLength: messageQueue.length
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Status, {
+      /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Status, {
         isProcessing,
-        cwd: cwd2,
+        cwd: activeSession?.cwd || cwd2,
         queueLength: messageQueue.length,
-        tokenUsage
+        tokenUsage,
+        sessionIndex,
+        sessionCount,
+        backgroundProcessingCount
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
 }
 
 // packages/terminal/src/index.tsx
-var jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
+var jsx_dev_runtime10 = __toESM(require_jsx_dev_runtime(), 1);
 var args = process.argv.slice(2);
 var options = {
   cwd: process.cwd(),
@@ -32665,11 +33112,11 @@ In interactive mode:
 `);
   process.exit(0);
 }
-var { waitUntilExit } = render_default(/* @__PURE__ */ jsx_dev_runtime9.jsxDEV(App2, {
+var { waitUntilExit } = render_default(/* @__PURE__ */ jsx_dev_runtime10.jsxDEV(App2, {
   cwd: options.cwd
 }, undefined, false, undefined, this));
 waitUntilExit().then(() => {
   process.exit(0);
 });
 
-//# debugId=165DC707B2BFFF8564756E2164756E21
+//# debugId=E37514F436BDCDD964756E2164756E21