@hasna/oldpal 0.1.9 → 0.3.0

package/dist/index.js

@@ -20450,12 +20450,12 @@ var exports_anthropic = {};
 __export(exports_anthropic, {
   AnthropicClient: () => AnthropicClient
 });
-import { readFileSync as readFileSync2, existsSync as existsSync4 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync5 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
 function loadApiKeyFromSecrets() {
-  const secretsPath = join6(homedir5(), ".secrets");
-  if (existsSync4(secretsPath)) {
+  const secretsPath = join7(homedir6(), ".secrets");
+  if (existsSync5(secretsPath)) {
     try {
       const content = readFileSync2(secretsPath, "utf-8");
       const match = content.match(/export\s+ANTHROPIC_API_KEY\s*=\s*["']?([^"'\n]+)["']?/);
@@ -20543,6 +20543,7 @@ class AnthropicClient {
   }
   convertMessages(messages) {
     const result = [];
+    const pendingToolUseIds = new Set;
     for (const msg of messages) {
       if (msg.role === "system")
         continue;
@@ -20558,16 +20559,20 @@ class AnthropicClient {
             name: toolCall.name,
             input: toolCall.input
           });
+          pendingToolUseIds.add(toolCall.id);
         }
       }
       if (msg.toolResults) {
         for (const toolResult of msg.toolResults) {
-          content.push({
-            type: "tool_result",
-            tool_use_id: toolResult.toolCallId,
-            content: toolResult.content,
-            is_error: toolResult.isError
-          });
+          if (pendingToolUseIds.has(toolResult.toolCallId)) {
+            content.push({
+              type: "tool_result",
+              tool_use_id: toolResult.toolCallId,
+              content: toolResult.content,
+              is_error: toolResult.isError
+            });
+            pendingToolUseIds.delete(toolResult.toolCallId);
+          }
         }
       }
       if (content.length > 0) {
@@ -28589,7 +28594,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_react25 = __toESM(require_react(), 1);
+var import_react27 = __toESM(require_react(), 1);
 // packages/shared/src/utils.ts
 import { randomUUID } from "crypto";
 function generateId() {
@@ -28702,11 +28707,25 @@ class AgentContext {
     this.messages = [];
   }
   prune() {
-    if (this.messages.length > this.maxMessages) {
-      const systemMessages = this.messages.filter((m) => m.role === "system");
-      const recentMessages = this.messages.filter((m) => m.role !== "system").slice(-(this.maxMessages - systemMessages.length));
-      this.messages = [...systemMessages, ...recentMessages];
+    if (this.messages.length <= this.maxMessages) {
+      return;
     }
+    const systemMessages = this.messages.filter((m) => m.role === "system");
+    const nonSystemMessages = this.messages.filter((m) => m.role !== "system");
+    const targetCount = this.maxMessages - systemMessages.length;
+    let recentMessages = nonSystemMessages.slice(-targetCount);
+    while (recentMessages.length > 0 && recentMessages[0].toolResults) {
+      const firstIndex = nonSystemMessages.indexOf(recentMessages[0]);
+      if (firstIndex > 0) {
+        recentMessages = nonSystemMessages.slice(firstIndex - 1);
+        if (recentMessages.length > targetCount + 1) {
+          recentMessages = recentMessages.slice(-(targetCount + 1));
+        }
+      } else {
+        recentMessages = recentMessages.slice(1);
+      }
+    }
+    this.messages = [...systemMessages, ...recentMessages];
   }
   export() {
     return this.messages;
@@ -28770,7 +28789,6 @@ import { join } from "path";
 class ConnectorBridge {
   connectors = new Map;
   async discover(connectorNames) {
-    const discovered = [];
     const names = connectorNames || [
       "notion",
       "googledrive",
@@ -28787,19 +28805,22 @@ class ConnectorBridge {
       "openai",
       "elevenlabs"
     ];
-    for (const name of names) {
+    const results = await Promise.all(names.map(async (name) => {
       const cli = `connect-${name}`;
       try {
-        const result = await Bun.$`which ${cli}`.quiet();
+        const result = await Bun.$`which ${cli}`.quiet().nothrow();
         if (result.exitCode !== 0)
-          continue;
+          return null;
       } catch {
-        continue;
+        return null;
       }
-      const connector = await this.discoverConnector(name, cli);
+      return this.discoverConnector(name, cli);
+    }));
+    const discovered = [];
+    for (const connector of results) {
       if (connector) {
         discovered.push(connector);
-        this.connectors.set(name, connector);
+        this.connectors.set(connector.name, connector);
       }
     }
     return discovered;
@@ -29368,35 +29389,260 @@ function parseDuckDuckGoResults(html, maxResults) {
   return results;
 }
 
+class CurlTool {
+  static tool = {
+    name: "curl",
+    description: "Fetch content from a URL (like curl). Returns text content from web pages, JSON from APIs, etc.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to fetch"
+        },
+        method: {
+          type: "string",
+          description: "HTTP method (GET, POST, PUT, DELETE). Defaults to GET.",
+          enum: ["GET", "POST", "PUT", "DELETE"],
+          default: "GET"
+        },
+        headers: {
+          type: "object",
+          description: "Optional headers to send with the request"
+        },
+        body: {
+          type: "string",
+          description: "Request body for POST/PUT requests"
+        }
+      },
+      required: ["url"]
+    }
+  };
+  static executor = async (input) => {
+    const url = input.url;
+    const method = input.method || "GET";
+    const headers = input.headers || {};
+    const body = input.body;
+    const timeout = 30000;
+    try {
+      const parsedUrl = new URL(url);
+      const hostname = parsedUrl.hostname;
+      if (hostname === "localhost" || hostname === "127.0.0.1" || hostname.startsWith("192.168.") || hostname.startsWith("10.") || hostname.startsWith("172.")) {
+        return "Error: Cannot fetch from local/private network addresses for security reasons";
+      }
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const response = await fetch(url, {
+        method,
+        signal: controller.signal,
+        headers: {
+          "User-Agent": "oldpal/1.0 (AI Assistant)",
+          ...headers
+        },
+        body: body && ["POST", "PUT"].includes(method) ? body : undefined
+      });
+      clearTimeout(timeoutId);
+      const contentType = response.headers.get("content-type") || "";
+      let responseBody;
+      if (contentType.includes("application/json")) {
+        try {
+          const json = await response.json();
+          responseBody = JSON.stringify(json, null, 2);
+        } catch {
+          responseBody = await response.text();
+        }
+      } else {
+        responseBody = await response.text();
+        if (contentType.includes("text/html")) {
+          responseBody = extractReadableText(responseBody);
+        }
+      }
+      const maxLength = 30000;
+      if (responseBody.length > maxLength) {
+        responseBody = responseBody.slice(0, maxLength) + `
+
+[Content truncated...]`;
+      }
+      const statusLine = `HTTP ${response.status} ${response.statusText}`;
+      return `${statusLine}
+
+${responseBody || "(empty response)"}`;
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          return `Error: Request timed out after ${timeout}ms`;
+        }
+        return `Error: ${error.message}`;
+      }
+      return `Error: ${String(error)}`;
+    }
+  };
+}
+
 class WebTools {
   static registerAll(registry) {
     registry.register(WebFetchTool.tool, WebFetchTool.executor);
     registry.register(WebSearchTool.tool, WebSearchTool.executor);
+    registry.register(CurlTool.tool, CurlTool.executor);
   }
 }
 
-// packages/core/src/skills/loader.ts
+// packages/core/src/tools/image.ts
+import { existsSync as existsSync2, writeFileSync, unlinkSync } from "fs";
+import { tmpdir } from "os";
 import { join as join3 } from "path";
 import { homedir as homedir2 } from "os";
+async function getViuPath() {
+  const locations = [
+    "viu",
+    join3(homedir2(), ".cargo", "bin", "viu"),
+    "/usr/local/bin/viu",
+    "/opt/homebrew/bin/viu"
+  ];
+  for (const path of locations) {
+    try {
+      const result = await Bun.$`${path} --version`.quiet().nothrow();
+      if (result.exitCode === 0) {
+        return path;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+class ImageDisplayTool {
+  static tool = {
+    name: "display_image",
+    description: "Display an image in the terminal. Works with local files and URLs. Supports PNG, JPG, GIF, BMP, and other common formats.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the image file or URL to fetch"
+        },
+        width: {
+          type: "number",
+          description: "Width in characters (optional, defaults to terminal width)"
+        },
+        height: {
+          type: "number",
+          description: "Height in characters (optional)"
+        }
+      },
+      required: ["path"]
+    }
+  };
+  static executor = async (input) => {
+    const imagePath = input.path;
+    const width = input.width;
+    const height = input.height;
+    const viuPath = await getViuPath();
+    if (!viuPath) {
+      return "Error: viu is not installed. Install with: cargo install viu";
+    }
+    let localPath = imagePath;
+    let tempFile = null;
+    if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
+      try {
+        const response = await fetch(imagePath);
+        if (!response.ok) {
+          return `Error: Failed to fetch image: HTTP ${response.status}`;
+        }
+        const contentType = response.headers.get("content-type") || "";
+        if (!contentType.startsWith("image/")) {
+          return `Error: URL does not point to an image (content-type: ${contentType})`;
+        }
+        const buffer = await response.arrayBuffer();
+        const ext = contentType.split("/")[1]?.split(";")[0] || "png";
+        tempFile = join3(tmpdir(), `oldpal-image-${generateId()}.${ext}`);
+        writeFileSync(tempFile, Buffer.from(buffer));
+        localPath = tempFile;
+      } catch (error) {
+        return `Error: Failed to fetch image: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+    if (!existsSync2(localPath)) {
+      return `Error: Image file not found: ${localPath}`;
+    }
+    try {
+      const args = [];
+      if (width) {
+        args.push("-w", String(width));
+      }
+      if (height) {
+        args.push("-h", String(height));
+      }
+      args.push(localPath);
+      const result = await Bun.$`${viuPath} ${args}`.quiet().nothrow();
+      if (result.exitCode !== 0) {
+        const stderr = result.stderr.toString().trim();
+        return `Error displaying image: ${stderr || "Unknown error"}`;
+      }
+      const output = result.stdout.toString();
+      if (output) {
+        process.stdout.write(output);
+      }
+      return `Image displayed: ${imagePath}${width ? ` (width: ${width})` : ""}${height ? ` (height: ${height})` : ""}`;
+    } catch (error) {
+      return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    } finally {
+      if (tempFile && existsSync2(tempFile)) {
+        try {
+          unlinkSync(tempFile);
+        } catch {}
+      }
+    }
+  };
+}
+
+class ImageTools {
+  static registerAll(registry) {
+    registry.register(ImageDisplayTool.tool, ImageDisplayTool.executor);
+  }
+}
+
+// packages/core/src/skills/loader.ts
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
 var {Glob: Glob2 } = globalThis.Bun;
 class SkillLoader {
   skills = new Map;
   async loadAll(projectDir = process.cwd()) {
-    const userSkillsDir = join3(homedir2(), ".oldpal", "skills");
+    const userSkillsDir = join4(homedir3(), ".oldpal", "skills");
     await this.loadFromDirectory(userSkillsDir);
-    const projectSkillsDir = join3(projectDir, ".oldpal", "skills");
+    const projectSkillsDir = join4(projectDir, ".oldpal", "skills");
     await this.loadFromDirectory(projectSkillsDir);
     const nestedGlob = new Glob2("**/.oldpal/skills/*/SKILL.md");
     for await (const file of nestedGlob.scan({ cwd: projectDir })) {
-      await this.loadSkillFile(join3(projectDir, file));
+      await this.loadSkillFile(join4(projectDir, file));
     }
   }
   async loadFromDirectory(dir) {
     try {
-      const glob = new Glob2("*/SKILL.md");
-      for await (const file of glob.scan({ cwd: dir })) {
-        await this.loadSkillFile(join3(dir, file));
+      const { stat } = await import("fs/promises");
+      try {
+        const stats = await stat(dir);
+        if (!stats.isDirectory())
+          return;
+      } catch {
+        return;
+      }
+      const filesToLoad = [];
+      const skillPrefixGlob = new Glob2("skill-*/SKILL.md");
+      for await (const file of skillPrefixGlob.scan({ cwd: dir })) {
+        filesToLoad.push(join4(dir, file));
+      }
+      const regularGlob = new Glob2("*/SKILL.md");
+      for await (const file of regularGlob.scan({ cwd: dir })) {
+        const dirName = file.split("/")[0];
+        if (!dirName.startsWith("skill-")) {
+          filesToLoad.push(join4(dir, file));
+        }
       }
+      await Promise.all(filesToLoad.map((file) => this.loadSkillFile(file)));
     } catch {}
   }
   async loadSkillFile(filePath) {
@@ -29457,8 +29703,9 @@ class SkillLoader {
 }
 
 // packages/core/src/skills/executor.ts
+import { dirname as dirname2 } from "path";
 class SkillExecutor {
-  prepare(skill, args) {
+  async prepare(skill, args) {
     let content = skill.content;
     content = substituteVariables(content, args);
     if (!skill.content.includes("$ARGUMENTS") && args.length > 0) {
@@ -29466,15 +29713,28 @@ class SkillExecutor {
 
 ARGUMENTS: ${args.join(" ")}`;
     }
-    content = this.executeDynamicContext(content);
+    content = await this.executeDynamicContext(content, skill.filePath);
     return content;
   }
-  executeDynamicContext(content) {
-    const backtickPattern = /`!([^`]+)`/g;
+  async executeDynamicContext(content, skillFilePath) {
+    const backtickPattern = /!\`([^`]+)\`/g;
+    const matches = [...content.matchAll(backtickPattern)];
+    if (matches.length === 0) {
+      return content;
+    }
+    const skillDir = dirname2(skillFilePath);
     let result = content;
-    result = result.replace(backtickPattern, (match, command) => {
-      return `[Dynamic context: ${command}]`;
-    });
+    for (const match of matches) {
+      const fullMatch = match[0];
+      const command = match[1];
+      try {
+        const output = await Bun.$`cd ${skillDir} && ${command}`.quiet().text();
+        result = result.replace(fullMatch, output.trim());
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        result = result.replace(fullMatch, `[Command failed: ${errorMsg}]`);
+      }
+    }
     return result;
   }
   shouldAutoInvoke(skill, userMessage) {
@@ -29644,9 +29904,9 @@ class HookExecutor {
   }
 }
 // packages/core/src/commands/loader.ts
-import { existsSync as existsSync2, readdirSync, statSync } from "fs";
-import { join as join4, basename, extname } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync3, readdirSync, statSync } from "fs";
+import { join as join5, basename, extname } from "path";
+import { homedir as homedir4 } from "os";
 
 class CommandLoader {
   commands = new Map;
@@ -29656,17 +29916,17 @@ class CommandLoader {
   }
   async loadAll() {
     this.commands.clear();
-    const globalDir = join4(homedir3(), ".oldpal", "commands");
+    const globalDir = join5(homedir4(), ".oldpal", "commands");
     await this.loadFromDirectory(globalDir, "global");
-    const projectDir = join4(this.cwd, ".oldpal", "commands");
+    const projectDir = join5(this.cwd, ".oldpal", "commands");
     await this.loadFromDirectory(projectDir, "project");
   }
   async loadFromDirectory(dir, source, prefix = "") {
-    if (!existsSync2(dir))
+    if (!existsSync3(dir))
       return;
     const entries = readdirSync(dir);
     for (const entry of entries) {
-      const fullPath = join4(dir, entry);
+      const fullPath = join5(dir, entry);
       const stat = statSync(fullPath);
       if (stat.isDirectory()) {
         const newPrefix = prefix ? `${prefix}:${entry}` : entry;
@@ -29844,9 +30104,9 @@ ${stderr}`;
   }
 }
 // packages/core/src/commands/builtin.ts
-import { join as join5 } from "path";
-import { homedir as homedir4 } from "os";
-import { existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
+import { existsSync as existsSync4, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
 
 class BuiltinCommands {
   tokenUsage = {
@@ -30016,8 +30276,8 @@ Format the summary as a brief bullet-point list. This summary will replace the c
       content: "",
       handler: async (args, context) => {
         const configPaths = [
-          join5(context.cwd, ".oldpal", "config.json"),
-          join5(homedir4(), ".oldpal", "config.json")
+          join6(context.cwd, ".oldpal", "config.json"),
+          join6(homedir5(), ".oldpal", "config.json")
         ];
         let message = `
 **Configuration**
@@ -30026,16 +30286,16 @@ Format the summary as a brief bullet-point list. This summary will replace the c
         message += `**Config File Locations:**
 `;
         for (const path of configPaths) {
-          const exists = existsSync3(path);
+          const exists = existsSync4(path);
           message += `  ${exists ? "\u2713" : "\u25CB"} ${path}
 `;
         }
         message += `
 **Commands Directories:**
 `;
-        message += `  - Project: ${join5(context.cwd, ".oldpal", "commands")}
+        message += `  - Project: ${join6(context.cwd, ".oldpal", "commands")}
 `;
-        message += `  - Global: ${join5(homedir4(), ".oldpal", "commands")}
+        message += `  - Global: ${join6(homedir5(), ".oldpal", "commands")}
 `;
         context.emit("text", message);
         context.emit("done");
@@ -30051,7 +30311,7 @@ Format the summary as a brief bullet-point list. This summary will replace the c
       selfHandled: true,
       content: "",
       handler: async (args, context) => {
-        const commandsDir = join5(context.cwd, ".oldpal", "commands");
+        const commandsDir = join6(context.cwd, ".oldpal", "commands");
         mkdirSync(commandsDir, { recursive: true });
         const exampleCommand = `---
 name: review
@@ -30080,9 +30340,9 @@ Please review the current code changes and provide feedback on:
 
 If there are staged git changes, focus on those. Otherwise, ask what code to review.
 `;
-        const examplePath = join5(commandsDir, "review.md");
-        if (!existsSync3(examplePath)) {
-          writeFileSync(examplePath, exampleCommand);
+        const examplePath = join6(commandsDir, "review.md");
+        if (!existsSync4(examplePath)) {
+          writeFileSync2(examplePath, exampleCommand);
         }
         let message = `
 **Initialized oldpal**
@@ -30256,8 +30516,8 @@ async function createLLMClient(config) {
 }
 
 // packages/core/src/config.ts
-import { join as join7 } from "path";
-import { homedir as homedir6 } from "os";
+import { join as join8 } from "path";
+import { homedir as homedir7 } from "os";
 var DEFAULT_CONFIG = {
   llm: {
     provider: "anthropic",
@@ -30287,13 +30547,13 @@ var DEFAULT_CONFIG = {
   ]
 };
 function getConfigDir() {
-  return join7(homedir6(), ".oldpal");
+  return join8(homedir7(), ".oldpal");
 }
 function getConfigPath(filename) {
-  return join7(getConfigDir(), filename);
+  return join8(getConfigDir(), filename);
 }
 function getProjectConfigDir(cwd2 = process.cwd()) {
-  return join7(cwd2, ".oldpal");
+  return join8(cwd2, ".oldpal");
 }
 async function loadConfig(cwd2 = process.cwd()) {
   const config = { ...DEFAULT_CONFIG };
@@ -30306,7 +30566,7 @@ async function loadConfig(cwd2 = process.cwd()) {
     if (userConfig.voice)
       config.voice = { ...config.voice, ...userConfig.voice };
   }
-  const projectConfigPath = join7(getProjectConfigDir(cwd2), "settings.json");
+  const projectConfigPath = join8(getProjectConfigDir(cwd2), "settings.json");
   const projectConfig = await loadJsonFile(projectConfigPath);
   if (projectConfig) {
     Object.assign(config, projectConfig);
@@ -30315,7 +30575,7 @@ async function loadConfig(cwd2 = process.cwd()) {
     if (projectConfig.voice)
       config.voice = { ...config.voice, ...projectConfig.voice };
   }
-  const localConfigPath = join7(getProjectConfigDir(cwd2), "settings.local.json");
+  const localConfigPath = join8(getProjectConfigDir(cwd2), "settings.local.json");
   const localConfig = await loadJsonFile(localConfigPath);
   if (localConfig) {
     Object.assign(config, localConfig);
@@ -30333,7 +30593,7 @@ async function loadHooksConfig(cwd2 = process.cwd()) {
   if (userHooks?.hooks) {
     mergeHooks(hooks, userHooks.hooks);
   }
-  const projectHooksPath = join7(getProjectConfigDir(cwd2), "hooks.json");
+  const projectHooksPath = join8(getProjectConfigDir(cwd2), "hooks.json");
   const projectHooks = await loadJsonFile(projectHooksPath);
   if (projectHooks?.hooks) {
     mergeHooks(hooks, projectHooks.hooks);
@@ -30359,6 +30619,47 @@ async function loadJsonFile(path) {
     return null;
   }
 }
+async function ensureConfigDir() {
+  const { mkdir } = await import("fs/promises");
+  const configDir = getConfigDir();
+  await Promise.all([
+    mkdir(configDir, { recursive: true }),
+    mkdir(join8(configDir, "sessions"), { recursive: true }),
+    mkdir(join8(configDir, "skills"), { recursive: true })
+  ]);
+}
+async function loadSystemPrompt(cwd2 = process.cwd()) {
+  const prompts = [];
+  const globalPromptPath = getConfigPath("OLDPAL.md");
+  const globalPrompt = await loadTextFile(globalPromptPath);
+  if (globalPrompt) {
+    prompts.push(globalPrompt);
+  }
+  const projectPromptPath = join8(getProjectConfigDir(cwd2), "OLDPAL.md");
+  const projectPrompt = await loadTextFile(projectPromptPath);
+  if (projectPrompt) {
+    prompts.push(projectPrompt);
+  }
+  if (prompts.length === 0) {
+    return null;
+  }
+  return prompts.join(`
+
+---
+
+`);
+}
+async function loadTextFile(path) {
+  try {
+    const file = Bun.file(path);
+    if (!await file.exists()) {
+      return null;
+    }
+    return await file.text();
+  } catch {
+    return null;
+  }
+}
 
 // packages/core/src/agent/loop.ts
 class AgentLoop {
@@ -30401,18 +30702,31 @@ class AgentLoop {
     this.onTokenUsage = options.onTokenUsage;
   }
   async initialize() {
-    this.config = await loadConfig(this.cwd);
-    this.llmClient = await createLLMClient(this.config.llm);
+    const [config] = await Promise.all([
+      loadConfig(this.cwd),
+      ensureConfigDir()
+    ]);
+    this.config = config;
+    const [, , , hooksConfig, systemPrompt] = await Promise.all([
+      createLLMClient(this.config.llm).then((client) => {
+        this.llmClient = client;
+      }),
+      this.connectorBridge.discover(this.config.connectors),
+      this.skillLoader.loadAll(this.cwd),
+      loadHooksConfig(this.cwd),
+      loadSystemPrompt(this.cwd),
+      this.commandLoader.loadAll()
+    ]);
     this.toolRegistry.register(BashTool.tool, BashTool.executor);
     FilesystemTools.registerAll(this.toolRegistry);
     WebTools.registerAll(this.toolRegistry);
-    await this.connectorBridge.discover(this.config.connectors);
+    ImageTools.registerAll(this.toolRegistry);
     this.connectorBridge.registerAll(this.toolRegistry);
-    await this.skillLoader.loadAll(this.cwd);
-    await this.commandLoader.loadAll();
     this.builtinCommands.registerAll(this.commandLoader);
-    const hooksConfig = await loadHooksConfig(this.cwd);
     this.hookLoader.load(hooksConfig);
+    if (systemPrompt) {
+      this.context.addSystemMessage(systemPrompt);
+    }
     await this.hookExecutor.execute(this.hookLoader.getHooks("SessionStart"), {
       session_id: this.sessionId,
       hook_event_name: "SessionStart",
@@ -30565,7 +30879,7 @@ class AgentLoop {
       return false;
     }
     const argsList = args ? args.split(/\s+/) : [];
-    const content = this.skillExecutor.prepare(skill, argsList);
+    const content = await this.skillExecutor.prepare(skill, argsList);
     this.context.addSystemMessage(content);
     this.context.addUserMessage(`Execute the "${skillName}" skill with arguments: ${args || "(none)"}`);
     await this.runLoop();
@@ -30611,9 +30925,9 @@ class AgentLoop {
 init_anthropic();
 
 // packages/core/src/logger.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, appendFileSync } from "fs";
-import { join as join8 } from "path";
-import { homedir as homedir7 } from "os";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, appendFileSync } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir8 } from "os";
 
 class Logger {
   logDir;
@@ -30621,13 +30935,13 @@ class Logger {
   sessionId;
   constructor(sessionId) {
     this.sessionId = sessionId;
-    this.logDir = join8(homedir7(), ".oldpal", "logs");
+    this.logDir = join9(homedir8(), ".oldpal", "logs");
     this.ensureDir(this.logDir);
     const date = new Date().toISOString().split("T")[0];
-    this.logFile = join8(this.logDir, `${date}.log`);
+    this.logFile = join9(this.logDir, `${date}.log`);
   }
   ensureDir(dir) {
-    if (!existsSync5(dir)) {
+    if (!existsSync6(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
   }
@@ -30667,12 +30981,12 @@ class SessionStorage {
   sessionId;
   constructor(sessionId) {
     this.sessionId = sessionId;
-    this.sessionsDir = join8(homedir7(), ".oldpal", "sessions");
+    this.sessionsDir = join9(homedir8(), ".oldpal", "sessions");
     this.ensureDir(this.sessionsDir);
-    this.sessionFile = join8(this.sessionsDir, `${sessionId}.json`);
+    this.sessionFile = join9(this.sessionsDir, `${sessionId}.json`);
   }
   ensureDir(dir) {
-    if (!existsSync5(dir)) {
+    if (!existsSync6(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
   }
@@ -30686,15 +31000,15 @@ class SessionStorage {
   }
 }
 function initOldpalDir() {
-  const baseDir = join8(homedir7(), ".oldpal");
+  const baseDir = join9(homedir8(), ".oldpal");
   const dirs = [
     baseDir,
-    join8(baseDir, "sessions"),
-    join8(baseDir, "logs"),
-    join8(baseDir, "skills")
+    join9(baseDir, "sessions"),
+    join9(baseDir, "logs"),
+    join9(baseDir, "skills")
   ];
   for (const dir of dirs) {
-    if (!existsSync5(dir)) {
+    if (!existsSync6(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
   }
@@ -31027,8 +31341,18 @@ function parseMarkdown(text) {
 
 // packages/terminal/src/components/Messages.tsx
 var jsx_dev_runtime3 = __toESM(require_jsx_dev_runtime(), 1);
-function Messages4({ messages, currentResponse, currentToolCall, lastToolResult, activityLog = [] }) {
-  const visibleMessages = messages.slice(-15);
+function Messages4({
+  messages,
+  currentResponse,
+  currentToolCall,
+  lastToolResult,
+  activityLog = [],
+  scrollOffset = 0,
+  maxVisible = 10
+}) {
+  const endIndex = messages.length - scrollOffset;
+  const startIndex = Math.max(0, endIndex - maxVisible);
+  const visibleMessages = messages.slice(startIndex, endIndex);
   return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
     flexDirection: "column",
     children: [
@@ -31036,59 +31360,25 @@ function Messages4({ messages, currentResponse, currentToolCall, lastToolResult,
         message
       }, message.id, false, undefined, this)),
       activityLog.map((entry) => {
-        if (entry.type === "tool_call" && entry.toolCall) {
+        if (entry.type === "text" && entry.content) {
           return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
             marginY: 1,
             children: [
               /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
                 dimColor: true,
-                children: "\u25D0 "
+                children: "\u25CF "
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
-                dimColor: true,
-                children: formatToolCall(entry.toolCall)
+              /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+                flexGrow: 1,
+                children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Markdown, {
+                  content: entry.content
+                }, undefined, false, undefined, this)
               }, undefined, false, undefined, this)
             ]
           }, entry.id, true, undefined, this);
         }
-        if (entry.type === "tool_result" && entry.toolResult) {
-          return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
-            marginLeft: 2,
-            children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
-              dimColor: true,
-              children: [
-                "\u2192 ",
-                truncate(entry.toolResult.content, 100)
-              ]
-            }, undefined, true, undefined, this)
-          }, entry.id, false, undefined, this);
-        }
         return null;
       }),
-      currentToolCall && !activityLog.some((e) => e.toolCall?.id === currentToolCall.id) && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
-        marginY: 1,
-        children: [
-          /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
-            dimColor: true,
-            children: "\u25D0 "
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
-            dimColor: true,
-            children: formatToolCall(currentToolCall)
-          }, undefined, false, undefined, this)
-        ]
-      }, undefined, true, undefined, this),
-      lastToolResult && !activityLog.some((e) => e.toolResult?.toolCallId === lastToolResult.toolCallId) && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
-        marginY: 1,
-        marginLeft: 2,
-        children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
-          dimColor: true,
-          children: [
-            "\u2192 ",
-            truncate(lastToolResult.content, 100)
-          ]
-        }, undefined, true, undefined, this)
-      }, undefined, false, undefined, this),
       currentResponse && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
         marginY: 1,
         children: [
@@ -31127,6 +31417,7 @@ function MessageBubble({ message }) {
       ]
     }, undefined, true, undefined, this);
   }
+  const toolCount = message.toolCalls?.length || 0;
   return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
     marginY: 1,
     flexDirection: "column",
@@ -31145,54 +31436,22 @@ function MessageBubble({ message }) {
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      message.toolCalls?.map((toolCall) => /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+      toolCount > 0 && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
         marginLeft: 2,
-        marginTop: 1,
         children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
           dimColor: true,
           children: [
-            "\u25D0 ",
-            formatToolCall(toolCall)
+            "[",
+            toolCount,
+            " tool",
+            toolCount > 1 ? "s" : "",
+            " used]"
           ]
         }, undefined, true, undefined, this)
-      }, toolCall.id, false, undefined, this))
+      }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
 }
-function formatToolCall(toolCall) {
-  const { name, input } = toolCall;
-  switch (name) {
-    case "bash":
-      return `Running: ${truncate(String(input.command || ""), 60)}`;
-    case "read":
-      return `Reading: ${truncate(String(input.path || input.file_path || ""), 60)}`;
-    case "write":
-      return `Writing: ${truncate(String(input.path || input.file_path || ""), 60)}`;
-    case "glob":
-      return `Finding: ${truncate(String(input.pattern || ""), 60)}`;
-    case "grep":
-      return `Searching: ${truncate(String(input.pattern || ""), 60)}`;
-    case "notion":
-      return `Notion: ${truncate(String(input.command || input.action || ""), 60)}`;
-    case "gmail":
-      return `Gmail: ${truncate(String(input.command || input.action || ""), 60)}`;
-    case "googledrive":
-      return `Drive: ${truncate(String(input.command || input.action || ""), 60)}`;
-    case "googlecalendar":
-      return `Calendar: ${truncate(String(input.command || input.action || ""), 60)}`;
-    case "linear":
-      return `Linear: ${truncate(String(input.command || input.action || ""), 60)}`;
-    case "slack":
-      return `Slack: ${truncate(String(input.command || input.action || ""), 60)}`;
-    default:
-      return `${name}: ${truncate(JSON.stringify(input), 50)}`;
-  }
-}
-function truncate(text, maxLength) {
-  if (text.length <= maxLength)
-    return text;
-  return text.slice(0, maxLength - 3) + "...";
-}
 
 // packages/terminal/src/components/Status.tsx
 var jsx_dev_runtime4 = __toESM(require_jsx_dev_runtime(), 1);
@@ -31289,26 +31548,232 @@ function Spinner2({ label }) {
   }, undefined, true, undefined, this);
 }
 
-// packages/terminal/src/components/App.tsx
+// packages/terminal/src/components/ProcessingIndicator.tsx
+var import_react25 = __toESM(require_react(), 1);
 var jsx_dev_runtime6 = __toESM(require_jsx_dev_runtime(), 1);
+function ProcessingIndicator({
+  isProcessing,
+  startTime,
+  tokenCount = 0,
+  isThinking = false
+}) {
+  const [elapsed, setElapsed] = import_react25.useState(0);
+  import_react25.useEffect(() => {
+    if (!isProcessing || !startTime) {
+      setElapsed(0);
+      return;
+    }
+    const interval = setInterval(() => {
+      setElapsed(Math.floor((Date.now() - startTime) / 1000));
+    }, 1000);
+    setElapsed(Math.floor((Date.now() - startTime) / 1000));
+    return () => clearInterval(interval);
+  }, [isProcessing, startTime]);
+  if (!isProcessing) {
+    return null;
+  }
+  const formatTime = (seconds) => {
+    if (seconds < 60) {
+      return `${seconds}s`;
+    }
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins}m ${secs}s`;
+  };
+  const formatTokens = (tokens) => {
+    if (tokens >= 1000) {
+      return `${(tokens / 1000).toFixed(1)}k`;
+    }
+    return String(tokens);
+  };
+  const parts = [];
+  parts.push("esc to interrupt");
+  if (elapsed > 0) {
+    parts.push(formatTime(elapsed));
+  }
+  if (tokenCount > 0) {
+    parts.push(`\u2193 ${formatTokens(tokenCount)} tokens`);
+  }
+  if (isThinking) {
+    parts.push("thinking");
+  }
+  const label = isThinking ? "Thinking" : "Working";
+  return /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
+    marginY: 1,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
+        dimColor: true,
+        children: /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(build_default2, {
+          type: "dots"
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
+        dimColor: true,
+        children: [
+          " ",
+          label,
+          "... "
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
+        dimColor: true,
+        children: [
+          "(",
+          parts.join(" \xB7 "),
+          ")"
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// packages/terminal/src/components/ToolCallBox.tsx
+var import_react26 = __toESM(require_react(), 1);
+var jsx_dev_runtime7 = __toESM(require_jsx_dev_runtime(), 1);
+function ToolCallBox({
+  entries,
+  maxVisible = 3,
+  isExpanded = false,
+  onToggleExpand
+}) {
+  if (entries.length === 0) {
+    return null;
+  }
+  const visibleEntries = isExpanded ? entries : entries.slice(-maxVisible);
+  const hiddenCount = entries.length - visibleEntries.length;
+  return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
+    flexDirection: "column",
+    borderStyle: "round",
+    borderColor: "gray",
+    paddingX: 1,
+    marginY: 1,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
+        justifyContent: "space-between",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+            dimColor: true,
+            bold: true,
+            children: [
+              "Tools (",
+              entries.length,
+              ")"
+            ]
+          }, undefined, true, undefined, this),
+          entries.length > maxVisible && /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+            dimColor: true,
+            children: isExpanded ? "Ctrl+O to collapse" : "Ctrl+O to expand"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      hiddenCount > 0 && !isExpanded && /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+        dimColor: true,
+        children: [
+          "  +",
+          hiddenCount,
+          " more above..."
+        ]
+      }, undefined, true, undefined, this),
+      visibleEntries.map((entry, index) => /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ToolCallRow, {
+        entry
+      }, entry.toolCall.id, false, undefined, this))
+    ]
+  }, undefined, true, undefined, this);
+}
+function ToolCallRow({ entry }) {
+  const { toolCall, result } = entry;
+  const statusIcon = result ? result.isError ? "\u2717" : "\u2713" : "\u25D0";
+  const statusColor = result ? result.isError ? "red" : "green" : "yellow";
+  return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+        color: statusColor,
+        children: [
+          statusIcon,
+          " "
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+        dimColor: true,
+        children: formatToolCall(toolCall)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function formatToolCall(toolCall) {
+  const { name, input } = toolCall;
+  switch (name) {
+    case "bash":
+      return `bash: ${truncate(String(input.command || ""), 50)}`;
+    case "curl":
+    case "web_fetch":
+      return `fetch: ${truncate(String(input.url || ""), 50)}`;
+    case "web_search":
+      return `search: ${truncate(String(input.query || ""), 50)}`;
+    case "read":
+      return `read: ${truncate(String(input.path || input.file_path || ""), 50)}`;
+    case "write":
+      return `write: ${truncate(String(input.path || input.file_path || ""), 50)}`;
+    case "glob":
+      return `glob: ${truncate(String(input.pattern || ""), 50)}`;
+    case "grep":
+      return `grep: ${truncate(String(input.pattern || ""), 50)}`;
+    case "notion":
+      return `notion: ${truncate(String(input.command || input.action || ""), 50)}`;
+    case "gmail":
+      return `gmail: ${truncate(String(input.command || input.action || ""), 50)}`;
+    case "googledrive":
+      return `drive: ${truncate(String(input.command || input.action || ""), 50)}`;
+    case "googlecalendar":
+      return `calendar: ${truncate(String(input.command || input.action || ""), 50)}`;
+    case "linear":
+      return `linear: ${truncate(String(input.command || input.action || ""), 50)}`;
+    case "slack":
+      return `slack: ${truncate(String(input.command || input.action || ""), 50)}`;
+    default:
+      return `${name}: ${truncate(JSON.stringify(input), 40)}`;
+  }
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+function useToolCallExpansion() {
+  const [isExpanded, setIsExpanded] = import_react26.useState(false);
+  use_input_default((input, key) => {
+    if (key.ctrl && input === "o") {
+      setIsExpanded((prev) => !prev);
+    }
+  });
+  return { isExpanded, setIsExpanded };
+}
+
+// packages/terminal/src/components/App.tsx
+var jsx_dev_runtime8 = __toESM(require_jsx_dev_runtime(), 1);
 function App2({ cwd: cwd2 }) {
   const { exit } = use_app_default();
-  const [client, setClient] = import_react25.useState(null);
-  const [messages, setMessages] = import_react25.useState([]);
-  const [currentResponse, setCurrentResponse] = import_react25.useState("");
-  const [currentToolCall, setCurrentToolCall] = import_react25.useState();
-  const [lastToolResult, setLastToolResult] = import_react25.useState();
-  const [isProcessing, setIsProcessing] = import_react25.useState(false);
-  const [isInitializing, setIsInitializing] = import_react25.useState(true);
-  const [error, setError] = import_react25.useState(null);
-  const [messageQueue, setMessageQueue] = import_react25.useState([]);
-  const [activityLog, setActivityLog] = import_react25.useState([]);
-  const [tokenUsage, setTokenUsage] = import_react25.useState();
-  const responseRef = import_react25.useRef("");
-  const clientRef = import_react25.useRef(null);
-  const toolCallsRef = import_react25.useRef([]);
-  const toolResultsRef = import_react25.useRef([]);
-  const processQueue = import_react25.useCallback(async () => {
+  const [client, setClient] = import_react27.useState(null);
+  const [messages, setMessages] = import_react27.useState([]);
+  const [currentResponse, setCurrentResponse] = import_react27.useState("");
+  const [currentToolCall, setCurrentToolCall] = import_react27.useState();
+  const [lastToolResult, setLastToolResult] = import_react27.useState();
+  const [isProcessing, setIsProcessing] = import_react27.useState(false);
+  const [isInitializing, setIsInitializing] = import_react27.useState(true);
+  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 { isExpanded: toolsExpanded } = useToolCallExpansion();
+  const responseRef = import_react27.useRef("");
+  const clientRef = import_react27.useRef(null);
+  const toolCallsRef = import_react27.useRef([]);
+  const toolResultsRef = import_react27.useRef([]);
+  const processQueue = import_react27.useCallback(async () => {
     if (!clientRef.current || messageQueue.length === 0)
       return;
     const nextMessage = messageQueue[0];
@@ -31328,10 +31793,12 @@ function App2({ cwd: cwd2 }) {
     setCurrentToolCall(undefined);
     setLastToolResult(undefined);
     setActivityLog([]);
+    setProcessingStartTime(Date.now());
+    setCurrentTurnTokens(0);
     setIsProcessing(true);
     await clientRef.current.send(nextMessage);
   }, [messageQueue]);
-  import_react25.useEffect(() => {
+  import_react27.useEffect(() => {
     const initClient = async () => {
       try {
         const newClient = new EmbeddedClient(cwd2);
@@ -31341,6 +31808,19 @@ function App2({ cwd: cwd2 }) {
             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,
@@ -31352,7 +31832,6 @@ function App2({ cwd: cwd2 }) {
               }
             ]);
             setCurrentToolCall(chunk.toolCall);
-            setLastToolResult(undefined);
           } else if (chunk.type === "tool_result" && chunk.toolResult) {
             toolResultsRef.current.push(chunk.toolResult);
             setActivityLog((prev) => [
@@ -31364,33 +31843,49 @@ function App2({ cwd: cwd2 }) {
                 timestamp: now()
               }
             ]);
-            setLastToolResult(chunk.toolResult);
             setCurrentToolCall(undefined);
           } else if (chunk.type === "error" && chunk.error) {
             setError(chunk.error);
             setIsProcessing(false);
           } 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 || toolCallsRef.current.length > 0) {
+            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: responseRef.current,
+                  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 = [];
             }
+            setCurrentResponse("");
+            responseRef.current = "";
+            toolCallsRef.current = [];
+            toolResultsRef.current = [];
             setCurrentToolCall(undefined);
-            setLastToolResult(undefined);
+            setActivityLog([]);
+            setProcessingStartTime(undefined);
+            setCurrentTurnTokens(0);
             setIsProcessing(false);
             if (newClient) {
               setTokenUsage(newClient.getTokenUsage());
@@ -31411,11 +31906,17 @@ function App2({ cwd: cwd2 }) {
     };
     initClient();
   }, [cwd2]);
-  import_react25.useEffect(() => {
+  import_react27.useEffect(() => {
     if (!isProcessing && messageQueue.length > 0) {
       processQueue();
     }
   }, [isProcessing, messageQueue.length, processQueue]);
+  import_react27.useEffect(() => {
+    if (autoScroll) {
+      setScrollOffset(0);
+    }
+  }, [messages.length, autoScroll]);
+  const maxVisibleMessages = 10;
   use_input_default((input, key) => {
     if (key.ctrl && input === "c") {
       if (isProcessing && client) {
@@ -31459,8 +31960,34 @@ function App2({ cwd: cwd2 }) {
       }
       setIsProcessing(false);
     }
+    if (key.pageUp || key.shift && key.upArrow) {
+      setScrollOffset((prev) => {
+        const maxOffset = Math.max(0, messages.length - maxVisibleMessages);
+        const newOffset = Math.min(prev + 3, maxOffset);
+        if (newOffset > 0)
+          setAutoScroll(false);
+        return newOffset;
+      });
+    }
+    if (key.pageDown || key.shift && key.downArrow) {
+      setScrollOffset((prev) => {
+        const newOffset = Math.max(0, prev - 3);
+        if (newOffset === 0)
+          setAutoScroll(true);
+        return newOffset;
+      });
+    }
+    if (key.ctrl && input === "u") {
+      const maxOffset = Math.max(0, messages.length - maxVisibleMessages);
+      setScrollOffset(maxOffset);
+      setAutoScroll(false);
+    }
+    if (key.ctrl && input === "d") {
+      setScrollOffset(0);
+      setAutoScroll(true);
+    }
   });
-  const handleSubmit = import_react25.useCallback(async (input, mode = "normal") => {
+  const handleSubmit = import_react27.useCallback(async (input, mode = "normal") => {
     if (!client || !input.trim())
       return;
     const trimmedInput = input.trim();
@@ -31503,32 +32030,56 @@ function App2({ cwd: cwd2 }) {
     setCurrentToolCall(undefined);
     setLastToolResult(undefined);
     setActivityLog([]);
+    setProcessingStartTime(Date.now());
+    setCurrentTurnTokens(0);
     setIsProcessing(true);
     await client.send(trimmedInput);
   }, [client, isProcessing]);
   if (isInitializing) {
-    return /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Spinner2, {
+      children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Spinner2, {
         label: "Initializing..."
       }, undefined, false, undefined, this)
     }, undefined, false, undefined, this);
   }
-  return /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
+  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;
+  return /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
     flexDirection: "column",
     padding: 1,
     children: [
-      /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Messages4, {
+      scrollOffset > 0 && /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+        children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+          dimColor: true,
+          children: [
+            "\u2191 ",
+            scrollOffset,
+            " more messages above (Shift+\u2193 or Ctrl+D to scroll down)"
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Messages4, {
         messages,
         currentResponse: isProcessing ? currentResponse : undefined,
-        currentToolCall,
-        lastToolResult,
-        activityLog: isProcessing ? activityLog : []
+        currentToolCall: undefined,
+        lastToolResult: undefined,
+        activityLog: isProcessing ? activityLog.filter((e) => e.type === "text") : [],
+        scrollOffset,
+        maxVisible: maxVisibleMessages
       }, undefined, false, undefined, this),
-      messageQueue.length > 0 && /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
+      isProcessing && toolCallEntries.length > 0 && /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(ToolCallBox, {
+        entries: toolCallEntries,
+        maxVisible: 3,
+        isExpanded: toolsExpanded
+      }, undefined, false, undefined, this),
+      messageQueue.length > 0 && /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
         marginY: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
+        children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
           dimColor: true,
           children: [
             messageQueue.length,
@@ -31538,9 +32089,9 @@ function App2({ cwd: cwd2 }) {
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      error && /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
+      error && /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
         marginY: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
+        children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
           color: "red",
           children: [
             "Error: ",
@@ -31548,18 +32099,18 @@ function App2({ cwd: cwd2 }) {
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      isProcessing && !currentToolCall && !currentResponse && /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
-        marginY: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Spinner2, {
-          label: "Thinking..."
-        }, undefined, false, undefined, this)
+      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(ProcessingIndicator, {
+        isProcessing,
+        startTime: processingStartTime,
+        tokenCount: currentTurnTokens,
+        isThinking
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Input, {
+      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Input, {
         onSubmit: handleSubmit,
         isProcessing,
         queueLength: messageQueue.length
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Status, {
+      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Status, {
         isProcessing,
         cwd: cwd2,
         queueLength: messageQueue.length,
@@ -31570,7 +32121,7 @@ function App2({ cwd: cwd2 }) {
 }
 
 // packages/terminal/src/index.tsx
-var jsx_dev_runtime7 = __toESM(require_jsx_dev_runtime(), 1);
+var jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
 var args = process.argv.slice(2);
 var options = {
   cwd: process.cwd(),
@@ -31578,7 +32129,7 @@ var options = {
   help: args.includes("--help") || args.includes("-h")
 };
 if (options.version) {
-  console.log("oldpal v0.1.9");
+  console.log("oldpal v0.2.0");
   process.exit(0);
 }
 if (options.help) {
@@ -31602,11 +32153,11 @@ In interactive mode:
 `);
   process.exit(0);
 }
-var { waitUntilExit } = render_default(/* @__PURE__ */ jsx_dev_runtime7.jsxDEV(App2, {
+var { waitUntilExit } = render_default(/* @__PURE__ */ jsx_dev_runtime9.jsxDEV(App2, {
   cwd: options.cwd
 }, undefined, false, undefined, this));
 waitUntilExit().then(() => {
   process.exit(0);
 });
 
-//# debugId=307434E7D5151E5864756E2164756E21
+//# debugId=B53720C03AFA977C64756E2164756E21