@hasna/oldpal 0.4.0 → 0.5.0

package/dist/index.js

@@ -20451,10 +20451,10 @@ __export(exports_anthropic, {
   AnthropicClient: () => AnthropicClient
 });
 import { readFileSync as readFileSync2, existsSync as existsSync5 } from "fs";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir7 } from "os";
 import { join as join7 } from "path";
 function loadApiKeyFromSecrets() {
-  const secretsPath = join7(homedir6(), ".secrets");
+  const secretsPath = join7(homedir7(), ".secrets");
   if (existsSync5(secretsPath)) {
     try {
       const content = readFileSync2(secretsPath, "utf-8");
@@ -28328,6 +28328,25 @@ var getInstance = (stdout, createInstance) => {
 };
 // 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/components/Static.js
 var import_react11 = __toESM(require_react(), 1);
+function Static(props) {
+  const { items, children: render2, style: customStyle } = props;
+  const [index, setIndex] = import_react11.useState(0);
+  const itemsToRender = import_react11.useMemo(() => {
+    return items.slice(index);
+  }, [items, index]);
+  import_react11.useLayoutEffect(() => {
+    setIndex(items.length);
+  }, [items.length]);
+  const children = itemsToRender.map((item, itemIndex) => {
+    return render2(item, index + itemIndex);
+  });
+  const style = import_react11.useMemo(() => ({
+    position: "absolute",
+    flexDirection: "column",
+    ...customStyle
+  }), [customStyle]);
+  return import_react11.default.createElement("ink-box", { internal_static: true, style }, children);
+}
 // 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/components/Transform.js
 var import_react12 = __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/components/Newline.js
@@ -28594,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() {
@@ -28973,13 +28992,13 @@ class ConnectorBridge {
 class BashTool {
   static tool = {
     name: "bash",
-    description: "Execute a shell command. Use for system operations, running scripts, git commands, etc.",
+    description: "Execute a shell command. RESTRICTED to read-only operations: ls, cat, grep, find, git status/log/diff, pwd, which, echo. Cannot modify files, install packages, or run destructive commands.",
     parameters: {
       type: "object",
       properties: {
         command: {
           type: "string",
-          description: "The shell command to execute"
+          description: "The shell command to execute (read-only commands only)"
         },
         cwd: {
           type: "string",
@@ -28987,29 +29006,111 @@ class BashTool {
         },
         timeout: {
           type: "number",
-          description: "Timeout in milliseconds (default: 120000)"
+          description: "Timeout in milliseconds (default: 30000)"
         }
       },
       required: ["command"]
     }
   };
+  static ALLOWED_COMMANDS = [
+    "cat",
+    "head",
+    "tail",
+    "less",
+    "more",
+    "ls",
+    "tree",
+    "find",
+    "locate",
+    "grep",
+    "rg",
+    "ag",
+    "ack",
+    "wc",
+    "file",
+    "stat",
+    "du",
+    "df",
+    "pwd",
+    "whoami",
+    "date",
+    "which",
+    "where",
+    "type",
+    "env",
+    "printenv",
+    "echo",
+    "git status",
+    "git log",
+    "git diff",
+    "git branch",
+    "git show",
+    "git remote",
+    "git tag",
+    "connect-",
+    "node --version",
+    "bun --version",
+    "npm --version",
+    "pnpm --version"
+  ];
+  static BLOCKED_PATTERNS = [
+    /\brm\b/,
+    /\brmdir\b/,
+    /\bunlink\b/,
+    /\bmv\b/,
+    /\bcp\b/,
+    /\bchmod\b/,
+    /\bchown\b/,
+    /\bchgrp\b/,
+    /\bsudo\b/,
+    /\bsu\b/,
+    /\bdoas\b/,
+    /\bnpm\s+(install|i|add|ci)\b/,
+    /\bpnpm\s+(install|i|add)\b/,
+    /\byarn\s+(install|add)\b/,
+    /\bbun\s+(install|add|i)\b/,
+    /\bpip\s+install\b/,
+    /\bpip3\s+install\b/,
+    /\bbrew\s+install\b/,
+    /\bapt\s+install\b/,
+    /\bapt-get\s+install\b/,
+    /\bgit\s+(push|commit|checkout|reset|rebase|merge|pull|stash|cherry-pick|revert)\b/,
+    /\bgit\s+add\b/,
+    /\|\s*(bash|sh|zsh|fish)\b/,
+    /curl.*\|\s*(bash|sh)/,
+    /wget.*\|\s*(bash|sh)/,
+    />\s*[^|]/,
+    />>/,
+    /\bkill\b/,
+    /\bpkill\b/,
+    /\bkillall\b/,
+    /\bmkfs\b/,
+    /\bdd\b/,
+    /\bfdisk\b/,
+    /\bparted\b/,
+    /\bnc\s+-l/,
+    /\bnetcat\s+-l/,
+    /\bvim?\b/,
+    /\bnano\b/,
+    /\bemacs\b/,
+    /\bmake\b/,
+    /\bcmake\b/,
+    /\bdocker\s+(run|exec|build|push)\b/
+  ];
   static executor = async (input) => {
     const command = input.command;
     const cwd2 = input.cwd || process.cwd();
-    const timeout = input.timeout || 120000;
-    const dangerousPatterns = [
-      /rm\s+-rf\s+[\/~]/i,
-      /rm\s+-rf\s+\*/i,
-      /mkfs/i,
-      /dd\s+if=/i,
-      />\s*\/dev\/sd/i,
-      /chmod\s+-R\s+777\s+\//i
-    ];
-    for (const pattern of dangerousPatterns) {
+    const timeout = input.timeout || 30000;
+    for (const pattern of this.BLOCKED_PATTERNS) {
       if (pattern.test(command)) {
-        return `Error: This command appears dangerous and was blocked for safety.`;
+        return `Error: This command is not allowed. Only read-only commands are permitted (ls, cat, grep, find, git status/log/diff, etc.)`;
       }
     }
+    const commandTrimmed = command.trim().toLowerCase();
+    const isAllowed = this.ALLOWED_COMMANDS.some((allowed) => commandTrimmed.startsWith(allowed.toLowerCase()));
+    if (!isAllowed) {
+      return `Error: Command not in allowed list. Permitted commands: cat, head, tail, ls, find, grep, wc, file, stat, pwd, which, echo, git status/log/diff/branch/show, connect-*`;
+    }
     try {
       const proc = Bun.spawn(["bash", "-c", command], {
         cwd: cwd2,
@@ -29038,15 +29139,31 @@ ${stderr || stdout}`.trim();
 
 // packages/core/src/tools/filesystem.ts
 import { join as join2, resolve, dirname } from "path";
+import { homedir as homedir2 } from "os";
 var {Glob } = globalThis.Bun;
+var currentSessionId = "default";
+function getTempFolder() {
+  return join2(homedir2(), ".oldpal", "temp", currentSessionId);
+}
+function isInTempFolder(path) {
+  const tempFolder = getTempFolder();
+  const resolved = resolve(path);
+  return resolved.startsWith(tempFolder);
+}
 
 class FilesystemTools {
-  static registerAll(registry) {
+  static registerAll(registry, sessionId) {
+    if (sessionId) {
+      currentSessionId = sessionId;
+    }
     registry.register(this.readTool, this.readExecutor);
     registry.register(this.writeTool, this.writeExecutor);
     registry.register(this.globTool, this.globExecutor);
     registry.register(this.grepTool, this.grepExecutor);
   }
+  static setSessionId(sessionId) {
+    currentSessionId = sessionId;
+  }
   static readTool = {
     name: "read",
     description: "Read the contents of a file",
@@ -29093,30 +29210,38 @@ class FilesystemTools {
   };
   static writeTool = {
     name: "write",
-    description: "Write content to a file (creates or overwrites)",
+    description: "Write content to a file. RESTRICTED: Can only write to ~/.oldpal/temp/{session}/ folder. Provide just the filename and it will be saved to the temp folder.",
     parameters: {
       type: "object",
       properties: {
-        path: {
+        filename: {
           type: "string",
-          description: "The file path to write to"
+          description: "The filename to write to (will be saved in temp folder)"
         },
         content: {
           type: "string",
           description: "The content to write"
         }
       },
-      required: ["path", "content"]
+      required: ["filename", "content"]
     }
   };
   static writeExecutor = async (input) => {
-    const path = resolve(process.cwd(), input.path);
+    const filename = input.filename || input.path;
     const content = input.content;
+    const tempFolder = getTempFolder();
+    const sanitizedFilename = filename.replace(/\.\./g, "").replace(/^\/+/, "");
+    const path = join2(tempFolder, sanitizedFilename);
+    if (!isInTempFolder(path)) {
+      return `Error: Cannot write outside temp folder. Files are saved to ${tempFolder}`;
+    }
     try {
       const dir = dirname(path);
       await Bun.$`mkdir -p ${dir}`.quiet();
       await Bun.write(path, content);
-      return `Successfully wrote ${content.length} characters to ${path}`;
+      return `Successfully wrote ${content.length} characters to ${path}
+
+You can review and copy this file to your project if needed.`;
     } catch (error) {
       return `Error: ${error instanceof Error ? error.message : String(error)}`;
     }
@@ -29506,11 +29631,11 @@ class WebTools {
 import { existsSync as existsSync2, writeFileSync, unlinkSync } from "fs";
 import { tmpdir } from "os";
 import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 async function getViuPath() {
   const locations = [
     "viu",
-    join3(homedir2(), ".cargo", "bin", "viu"),
+    join3(homedir3(), ".cargo", "bin", "viu"),
     "/usr/local/bin/viu",
     "/opt/homebrew/bin/viu"
   ];
@@ -29621,12 +29746,12 @@ class ImageTools {
 
 // packages/core/src/skills/loader.ts
 import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 var {Glob: Glob2 } = globalThis.Bun;
 class SkillLoader {
   skills = new Map;
   async loadAll(projectDir = process.cwd()) {
-    const userSkillsDir = join4(homedir3(), ".oldpal", "skills");
+    const userSkillsDir = join4(homedir4(), ".oldpal", "skills");
     await this.loadFromDirectory(userSkillsDir);
     const projectSkillsDir = join4(projectDir, ".oldpal", "skills");
     await this.loadFromDirectory(projectSkillsDir);
@@ -29743,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);
@@ -29921,7 +30047,7 @@ class HookExecutor {
 // packages/core/src/commands/loader.ts
 import { existsSync as existsSync3, readdirSync, statSync } from "fs";
 import { join as join5, basename, extname } from "path";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 
 class CommandLoader {
   commands = new Map;
@@ -29931,7 +30057,7 @@ class CommandLoader {
   }
   async loadAll() {
     this.commands.clear();
-    const globalDir = join5(homedir4(), ".oldpal", "commands");
+    const globalDir = join5(homedir5(), ".oldpal", "commands");
     await this.loadFromDirectory(globalDir, "global");
     const projectDir = join5(this.cwd, ".oldpal", "commands");
     await this.loadFromDirectory(projectDir, "project");
@@ -30120,7 +30246,7 @@ ${stderr}`;
 }
 // packages/core/src/commands/builtin.ts
 import { join as join6 } from "path";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 import { existsSync as existsSync4, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
 
 class BuiltinCommands {
@@ -30134,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());
@@ -30256,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",
@@ -30407,7 +30557,7 @@ Format the summary as a brief bullet-point list. This summary will replace the c
       handler: async (args, context) => {
         const configPaths = [
           join6(context.cwd, ".oldpal", "config.json"),
-          join6(homedir5(), ".oldpal", "config.json")
+          join6(homedir6(), ".oldpal", "config.json")
         ];
         let message = `
 **Configuration**
@@ -30425,7 +30575,7 @@ Format the summary as a brief bullet-point list. This summary will replace the c
 `;
         message += `  - Project: ${join6(context.cwd, ".oldpal", "commands")}
 `;
-        message += `  - Global: ${join6(homedir5(), ".oldpal", "commands")}
+        message += `  - Global: ${join6(homedir6(), ".oldpal", "commands")}
 `;
         context.emit("text", message);
         context.emit("done");
@@ -30647,7 +30797,7 @@ async function createLLMClient(config) {
 
 // packages/core/src/config.ts
 import { join as join8 } from "path";
-import { homedir as homedir7 } from "os";
+import { homedir as homedir8 } from "os";
 var DEFAULT_CONFIG = {
   llm: {
     provider: "anthropic",
@@ -30677,7 +30827,7 @@ var DEFAULT_CONFIG = {
   ]
 };
 function getConfigDir() {
-  return join8(homedir7(), ".oldpal");
+  return join8(homedir8(), ".oldpal");
 }
 function getConfigPath(filename) {
   return join8(getConfigDir(), filename);
@@ -30749,14 +30899,19 @@ async function loadJsonFile(path) {
     return null;
   }
 }
-async function ensureConfigDir() {
+async function ensureConfigDir(sessionId) {
   const { mkdir } = await import("fs/promises");
   const configDir = getConfigDir();
-  await Promise.all([
+  const dirs = [
     mkdir(configDir, { recursive: true }),
     mkdir(join8(configDir, "sessions"), { recursive: true }),
-    mkdir(join8(configDir, "skills"), { recursive: true })
-  ]);
+    mkdir(join8(configDir, "skills"), { recursive: true }),
+    mkdir(join8(configDir, "temp"), { recursive: true })
+  ];
+  if (sessionId) {
+    dirs.push(mkdir(join8(configDir, "temp", sessionId), { recursive: true }));
+  }
+  await Promise.all(dirs);
 }
 async function loadSystemPrompt(cwd2 = process.cwd()) {
   const prompts = [];
@@ -30834,7 +30989,7 @@ class AgentLoop {
   async initialize() {
     const [config] = await Promise.all([
       loadConfig(this.cwd),
-      ensureConfigDir()
+      ensureConfigDir(this.sessionId)
     ]);
     this.config = config;
     const [, , , hooksConfig, systemPrompt] = await Promise.all([
@@ -30848,7 +31003,7 @@ class AgentLoop {
       this.commandLoader.loadAll()
     ]);
     this.toolRegistry.register(BashTool.tool, BashTool.executor);
-    FilesystemTools.registerAll(this.toolRegistry);
+    FilesystemTools.registerAll(this.toolRegistry, this.sessionId);
     WebTools.registerAll(this.toolRegistry);
     ImageTools.registerAll(this.toolRegistry);
     this.connectorBridge.registerAll(this.toolRegistry);
@@ -31060,7 +31215,7 @@ init_anthropic();
 // packages/core/src/logger.ts
 import { existsSync as existsSync6, mkdirSync as mkdirSync2, appendFileSync } from "fs";
 import { join as join9 } from "path";
-import { homedir as homedir8 } from "os";
+import { homedir as homedir9 } from "os";
 
 class Logger {
   logDir;
@@ -31068,7 +31223,7 @@ class Logger {
   sessionId;
   constructor(sessionId) {
     this.sessionId = sessionId;
-    this.logDir = join9(homedir8(), ".oldpal", "logs");
+    this.logDir = join9(homedir9(), ".oldpal", "logs");
     this.ensureDir(this.logDir);
     const date = new Date().toISOString().split("T")[0];
     this.logFile = join9(this.logDir, `${date}.log`);
@@ -31114,7 +31269,7 @@ class SessionStorage {
   sessionId;
   constructor(sessionId) {
     this.sessionId = sessionId;
-    this.sessionsDir = join9(homedir8(), ".oldpal", "sessions");
+    this.sessionsDir = join9(homedir9(), ".oldpal", "sessions");
     this.ensureDir(this.sessionsDir);
     this.sessionFile = join9(this.sessionsDir, `${sessionId}.json`);
   }
@@ -31133,7 +31288,7 @@ class SessionStorage {
   }
 }
 function initOldpalDir() {
-  const baseDir = join9(homedir8(), ".oldpal");
+  const baseDir = join9(homedir9(), ".oldpal");
   const dirs = [
     baseDir,
     join9(baseDir, "sessions"),
@@ -31293,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);
@@ -31579,19 +31881,28 @@ function Messages4({
   const startIndex = Math.max(0, endIndex - maxVisible);
   const visibleMessages = messages.slice(startIndex, endIndex);
   const groupedMessages = groupConsecutiveToolMessages(visibleMessages);
+  const historicalItems = groupedMessages.map((group) => {
+    if (group.type === "single") {
+      return { id: group.message.id, group };
+    }
+    return { id: group.messages[0].id, group };
+  });
   return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
     flexDirection: "column",
     children: [
-      groupedMessages.map((group) => {
-        if (group.type === "single") {
-          return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(MessageBubble, {
-            message: group.message
-          }, group.message.id, false, undefined, this);
-        }
-        return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(CombinedToolMessage, {
-          messages: group.messages
-        }, group.messages[0].id, false, undefined, this);
-      }),
+      /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Static, {
+        items: historicalItems,
+        children: (item) => {
+          if (item.group.type === "single") {
+            return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(MessageBubble, {
+              message: item.group.message
+            }, item.id, false, undefined, this);
+          }
+          return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(CombinedToolMessage, {
+            messages: item.group.messages
+          }, item.id, false, undefined, this);
+        }
+      }, undefined, false, undefined, this),
       activityLog.map((entry) => {
         if (entry.type === "text" && entry.content) {
           return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
@@ -31861,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
@@ -32079,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) {
@@ -32107,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));
@@ -32144,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);
     }
@@ -32274,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,
@@ -32295,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) => {
@@ -32344,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,
@@ -32385,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, {
-        version: "0.4.0",
-        model: "claude-4-sonnet",
-        directory: cwd2
+      showWelcome && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(WelcomeBanner, {
+        version: "0.4.1",
+        model: "claude-sonnet-4",
+        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 ",
@@ -32426,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,
@@ -32435,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 ",
@@ -32450,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,
@@ -32462,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: ",
@@ -32472,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(),
@@ -32502,7 +33088,7 @@ var options = {
   help: args.includes("--help") || args.includes("-h")
 };
 if (options.version) {
-  console.log("oldpal v0.4.0");
+  console.log("oldpal v0.4.1");
   process.exit(0);
 }
 if (options.help) {
@@ -32526,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=CE824906A098BE1564756E2164756E21
+//# debugId=E37514F436BDCDD964756E2164756E21