@hasna/assistants 0.6.21 → 0.6.23

package/dist/index.js

@@ -27290,16 +27290,16 @@ var exports_anthropic = {};
 __export(exports_anthropic, {
   AnthropicClient: () => AnthropicClient
 });
-import { readFileSync as readFileSync3, existsSync as existsSync8 } from "fs";
+import { readFileSync as readFileSync4, existsSync as existsSync8 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function loadApiKeyFromSecrets() {
   const envHome = process.env.HOME || process.env.USERPROFILE;
   const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir8();
-  const secretsPath = join12(homeDir, ".secrets");
+  const secretsPath = join13(homeDir, ".secrets");
   if (existsSync8(secretsPath)) {
     try {
-      const content = readFileSync3(secretsPath, "utf-8");
+      const content = readFileSync4(secretsPath, "utf-8");
       const match = content.match(/export\s+ANTHROPIC_API_KEY\s*=\s*["']?([^"'\n]+)["']?/);
       if (match) {
         return match[1];
@@ -35505,9 +35505,12 @@ var import_react19 = __toESM(require_react(), 1);
 var import_react20 = __toESM(require_react(), 1);
 // node_modules/.bun/ink@5.2.1+f4eacebf2041cd4f/node_modules/ink/build/hooks/use-focus-manager.js
 var import_react21 = __toESM(require_react(), 1);
+// packages/terminal/src/components/App.tsx
+var import_react29 = __toESM(require_react(), 1);
+
 // packages/core/src/agent/loop.ts
 init_src();
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 
 // packages/core/src/agent/context.ts
 init_src();
@@ -35515,6 +35518,7 @@ init_src();
 class AgentContext {
   messages = [];
   maxMessages;
+  scopeContext = null;
   constructor(maxMessages = 100) {
     this.maxMessages = maxMessages;
   }
@@ -35610,6 +35614,15 @@ class AgentContext {
   import(messages) {
     this.messages = messages;
   }
+  setScopeContext(scope) {
+    this.scopeContext = scope;
+  }
+  getScopeContext() {
+    return this.scopeContext;
+  }
+  clearScopeContext() {
+    this.scopeContext = null;
+  }
 }
 
 // packages/core/src/context/manager.ts
@@ -36140,7 +36153,7 @@ import { dirname, join as join2 } from "path";
 // packages/core/src/config.ts
 import { join } from "path";
 import { homedir } from "os";
-var DEFAULT_SYSTEM_PROMPT = `You are a helpful AI assistant running in the terminal.
+var DEFAULT_SYSTEM_PROMPT = `You are Hasna Assistant, a helpful AI assistant running in the terminal.
 
 ## Runtime Environment
 - Use **Bun** as the default runtime for JavaScript/TypeScript scripts
@@ -36292,10 +36305,6 @@ function getConfigDir() {
   if (assistantsOverride && assistantsOverride.trim()) {
     return assistantsOverride;
   }
-  const legacyOverride = process.env.OLDPAL_DIR;
-  if (legacyOverride && legacyOverride.trim()) {
-    return legacyOverride;
-  }
   const envHome = process.env.HOME || process.env.USERPROFILE;
   const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir();
   return join(homeDir, ".assistants");
@@ -36313,12 +36322,10 @@ async function loadConfig(cwd2 = process.cwd()) {
   const userConfig = await loadJsonFile(userConfigPath) || await loadJsonFile(legacyUserConfigPath);
   config = mergeConfig(config, userConfig || undefined);
   const projectConfigPath = join(getProjectConfigDir(cwd2), "config.json");
-  const legacyProjectConfigPath = join(cwd2, ".oldpal", "settings.json");
-  const projectConfig = await loadJsonFile(projectConfigPath) || await loadJsonFile(legacyProjectConfigPath);
+  const projectConfig = await loadJsonFile(projectConfigPath);
   config = mergeConfig(config, projectConfig || undefined);
   const localConfigPath = join(getProjectConfigDir(cwd2), "config.local.json");
-  const legacyLocalConfigPath = join(cwd2, ".oldpal", "settings.local.json");
-  const localConfig = await loadJsonFile(localConfigPath) || await loadJsonFile(legacyLocalConfigPath);
+  const localConfig = await loadJsonFile(localConfigPath);
   config = mergeConfig(config, localConfig || undefined);
   return config;
 }
@@ -36377,13 +36384,11 @@ async function ensureConfigDir(sessionId) {
 async function loadSystemPrompt(cwd2 = process.cwd()) {
   const prompts = [];
   const globalPromptPath = getConfigPath("ASSISTANTS.md");
-  const legacyGlobalPromptPath = getConfigPath("OLDPAL.md");
-  const globalPrompt = await loadTextFile(globalPromptPath) ?? await loadTextFile(legacyGlobalPromptPath);
+  const globalPrompt = await loadTextFile(globalPromptPath);
   if (globalPrompt)
     prompts.push(globalPrompt);
   const projectPromptPath = join(getProjectConfigDir(cwd2), "ASSISTANTS.md");
-  const legacyProjectPromptPath = join(cwd2, ".oldpal", "OLDPAL.md");
-  const projectPrompt = await loadTextFile(projectPromptPath) ?? await loadTextFile(legacyProjectPromptPath);
+  const projectPrompt = await loadTextFile(projectPromptPath);
   if (projectPrompt)
     prompts.push(projectPrompt);
   if (prompts.length === 0) {
@@ -37379,7 +37384,6 @@ ${stderr || stdout}`.trim(), {
 
 // packages/core/src/tools/filesystem.ts
 import { join as join4, resolve as resolve3, dirname as dirname2, sep } from "path";
-import { existsSync as existsSync3 } from "fs";
 init_errors();
 var {Glob } = globalThis.Bun;
 
@@ -37469,10 +37473,6 @@ async function isPathSafe(targetPath, operation, options = {}) {
 var currentSessionId = "default";
 function getScriptsFolder(cwd2, sessionId) {
   const resolvedSessionId = sessionId || currentSessionId;
-  const legacyDir = join4(cwd2, ".oldpal");
-  if (existsSync3(legacyDir)) {
-    return join4(legacyDir, "scripts", resolvedSessionId);
-  }
   return join4(getProjectConfigDir(cwd2), "scripts", resolvedSessionId);
 }
 function isInScriptsFolder(path2, cwd2, sessionId) {
@@ -37608,7 +37608,7 @@ class FilesystemTools {
   };
   static writeTool = {
     name: "write",
-    description: "Write content to a file. RESTRICTED: Can only write to the project scripts folder (.oldpal/scripts/{session} or .assistants/scripts/{session}). Provide a filename and it will be saved under the scripts folder.",
+    description: "Write content to a file. RESTRICTED: Can only write to the project scripts folder (.assistants/scripts/{session}). Provide a filename and it will be saved under the scripts folder.",
     parameters: {
       type: "object",
       properties: {
@@ -37894,16 +37894,22 @@ class WebFetchTool {
           });
         }
         const controller = new AbortController;
-        const timeoutId = setTimeout(abortController, timeout, controller);
-        response = await fetch(currentUrl, {
-          signal: controller.signal,
-          redirect: "manual",
-          headers: {
-            "User-Agent": "assistants/1.0 (AI Assistant)",
-            Accept: extractType === "json" ? "application/json" : "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        let timeoutId = null;
+        try {
+          timeoutId = setTimeout(abortController, timeout, controller);
+          response = await fetch(currentUrl, {
+            signal: controller.signal,
+            redirect: "manual",
+            headers: {
+              "User-Agent": "assistants/1.0 (AI Assistant)",
+              Accept: extractType === "json" ? "application/json" : "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+            }
+          });
+        } finally {
+          if (timeoutId) {
+            clearTimeout(timeoutId);
           }
-        });
-        clearTimeout(timeoutId);
+        }
         if ([301, 302, 303, 307, 308].includes(response.status)) {
           const location = response.headers.get("location");
           if (!location) {
@@ -38179,18 +38185,24 @@ class CurlTool {
           });
         }
         const controller = new AbortController;
-        const timeoutId = setTimeout(abortController, timeout, controller);
-        response = await fetch(currentUrl, {
-          method,
-          signal: controller.signal,
-          redirect: "manual",
-          headers: {
-            "User-Agent": "assistants/1.0 (AI Assistant)",
-            ...headers
-          },
-          body: body && ["POST", "PUT"].includes(method) ? body : undefined
-        });
-        clearTimeout(timeoutId);
+        let timeoutId = null;
+        try {
+          timeoutId = setTimeout(abortController, timeout, controller);
+          response = await fetch(currentUrl, {
+            method,
+            signal: controller.signal,
+            redirect: "manual",
+            headers: {
+              "User-Agent": "assistants/1.0 (AI Assistant)",
+              ...headers
+            },
+            body: body && ["POST", "PUT"].includes(method) ? body : undefined
+          });
+        } finally {
+          if (timeoutId) {
+            clearTimeout(timeoutId);
+          }
+        }
         if ([301, 302, 303, 307, 308].includes(response.status)) {
           if (!["GET", "HEAD"].includes(method)) {
             throw new ToolExecutionError("Redirects are only supported for GET/HEAD requests", {
@@ -38395,7 +38407,7 @@ function isPrivateIPv4(octets) {
 // packages/core/src/tools/feedback.ts
 init_src();
 import { join as join5 } from "path";
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 function normalizeTags(value) {
   if (Array.isArray(value)) {
     const tags = value.map((t) => String(t).trim()).filter(Boolean);
@@ -38409,9 +38421,9 @@ function normalizeTags(value) {
 }
 function resolveFeedbackDir(cwd2) {
   const baseCwd = cwd2 && cwd2.trim().length > 0 ? cwd2 : process.cwd();
-  const legacyDir = join5(baseCwd, ".oldpal");
-  if (existsSync4(legacyDir)) {
-    return join5(legacyDir, "feedback");
+  const projectConfigDir = join5(baseCwd, ".assistants");
+  if (existsSync3(projectConfigDir)) {
+    return join5(projectConfigDir, "feedback");
   }
   return join5(getConfigDir(), "feedback");
 }
@@ -38734,7 +38746,7 @@ async function updateSchedule(cwd2, id, updater) {
     return null;
   }
 }
-async function acquireScheduleLock(cwd2, id, ownerId, ttlMs = DEFAULT_LOCK_TTL_MS) {
+async function acquireScheduleLock(cwd2, id, ownerId, ttlMs = DEFAULT_LOCK_TTL_MS, allowRetry = true) {
   await ensureDirs(cwd2);
   const path2 = lockPath(cwd2, id);
   const now2 = Date.now();
@@ -38751,9 +38763,18 @@ async function acquireScheduleLock(cwd2, id, ownerId, ttlMs = DEFAULT_LOCK_TTL_M
       const ttl = lock?.ttlMs ?? ttlMs;
       if (now2 - updatedAt > ttl) {
         await unlink(path2);
-        return acquireScheduleLock(cwd2, id, ownerId, ttlMs);
+        return acquireScheduleLock(cwd2, id, ownerId, ttlMs, false);
       }
-    } catch {}
+    } catch {
+      if (allowRetry) {
+        try {
+          await unlink(path2);
+          return acquireScheduleLock(cwd2, id, ownerId, ttlMs, false);
+        } catch {
+          return false;
+        }
+      }
+    }
   }
   return false;
 }
@@ -38980,7 +39001,7 @@ class SchedulerTool {
 
 // packages/core/src/tools/image.ts
 init_src();
-import { existsSync as existsSync5, writeFileSync as writeFileSync3, unlinkSync } from "fs";
+import { existsSync as existsSync4, writeFileSync as writeFileSync3, unlinkSync } from "fs";
 import { tmpdir } from "os";
 import { join as join7 } from "path";
 import { homedir as homedir4 } from "os";
@@ -39067,7 +39088,7 @@ class ImageDisplayTool {
         return `Error: Failed to fetch image: ${error instanceof Error ? error.message : String(error)}`;
       }
     }
-    if (!existsSync5(localPath)) {
+    if (!existsSync4(localPath)) {
       return `Error: Image file not found: ${localPath}`;
     }
     try {
@@ -39092,7 +39113,7 @@ class ImageDisplayTool {
     } catch (error) {
       return `Error: ${error instanceof Error ? error.message : String(error)}`;
     } finally {
-      if (tempFile && existsSync5(tempFile)) {
+      if (tempFile && existsSync4(tempFile)) {
         try {
           unlinkSync(tempFile);
         } catch {}
@@ -39156,10 +39177,6 @@ class SkillLoader {
     await this.loadFromDirectory(userSkillsDir);
     const projectSkillsDir = join8(projectDir, ".assistants", "skills");
     await this.loadFromDirectory(projectSkillsDir);
-    const legacyUserSkillsDir = join8(userHome, ".oldpal", "skills");
-    const legacyProjectSkillsDir = join8(projectDir, ".oldpal", "skills");
-    await this.loadFromDirectory(legacyUserSkillsDir);
-    await this.loadFromDirectory(legacyProjectSkillsDir);
     const nestedGlob = new Glob2("**/.assistants/skills/*/SKILL.md");
     for await (const file of nestedGlob.scan({ cwd: projectDir, dot: true })) {
       await this.loadSkillFile(join8(projectDir, file));
@@ -39369,7 +39386,6 @@ class HookLoader {
     this.hooks = {};
   }
 }
-
 // packages/core/src/hooks/executor.ts
 init_src();
 function killSpawnedProcess(proc) {
@@ -39595,211 +39611,720 @@ Respond with JSON only: {"allow": boolean, "reason": string}`;
     return result;
   }
 }
-// packages/core/src/commands/loader.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join9, basename as basename2, extname } from "path";
-import { homedir as homedir6 } from "os";
-
-class CommandLoader {
-  commands = new Map;
-  cwd;
-  constructor(cwd2) {
-    this.cwd = cwd2 || process.cwd();
+// packages/core/src/hooks/native.ts
+class NativeHookRegistry {
+  hooks = new Map;
+  config = {};
+  register(hook) {
+    const eventHooks = this.hooks.get(hook.event) || [];
+    eventHooks.push(hook);
+    eventHooks.sort((a, b) => a.priority - b.priority);
+    this.hooks.set(hook.event, eventHooks);
   }
-  async loadAll() {
-    this.commands.clear();
-    const envHome = process.env.HOME || process.env.USERPROFILE;
-    const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir6();
-    const globalDir = join9(homeDir, ".assistants", "commands");
-    await this.loadFromDirectory(globalDir, "global");
-    const projectDir = join9(this.cwd, ".assistants", "commands");
-    await this.loadFromDirectory(projectDir, "project");
-    const legacyGlobalDir = join9(homeDir, ".oldpal", "commands");
-    const legacyProjectDir = join9(this.cwd, ".oldpal", "commands");
-    await this.loadFromDirectory(legacyGlobalDir, "global");
-    await this.loadFromDirectory(legacyProjectDir, "project");
+  getHooks(event) {
+    return this.hooks.get(event) || [];
   }
-  async loadFromDirectory(dir, source, prefix = "") {
-    if (!existsSync6(dir))
-      return;
-    const entries = readdirSync2(dir);
-    for (const entry of entries) {
-      const fullPath = join9(dir, entry);
-      const stat = statSync2(fullPath);
-      if (stat.isDirectory()) {
-        const newPrefix = prefix ? `${prefix}:${entry}` : entry;
-        await this.loadFromDirectory(fullPath, source, newPrefix);
-      } else if (stat.isFile() && extname(entry) === ".md") {
-        const command = await this.loadCommandFile(fullPath, prefix);
-        if (command) {
-          this.commands.set(command.name, command);
-        }
-      }
-    }
+  hasHooks(event) {
+    const hooks = this.hooks.get(event);
+    return hooks !== undefined && hooks.length > 0;
   }
-  async loadCommandFile(filePath, prefix) {
-    try {
-      const content = await Bun.file(filePath).text();
-      const { frontmatter, body } = this.parseFrontmatter(content);
-      const fileName = basename2(filePath, ".md");
-      const name = frontmatter.name || (prefix ? `${prefix}:${fileName}` : fileName);
-      const allowedToolsRaw = frontmatter["allowed-tools"];
-      const allowedTools = Array.isArray(allowedToolsRaw) ? allowedToolsRaw.map((t) => String(t).trim()).filter(Boolean) : typeof allowedToolsRaw === "string" ? allowedToolsRaw.split(",").map((t) => t.trim()).filter(Boolean) : undefined;
-      return {
-        name,
-        description: frontmatter.description || `Run the ${name} command`,
-        tags: frontmatter.tags,
-        allowedTools,
-        content: body,
-        filePath,
-        builtin: false
-      };
-    } catch (error) {
-      console.error(`Failed to load command from ${filePath}:`, error);
-      return null;
-    }
+  setConfig(config) {
+    this.config = config;
   }
-  parseFrontmatter(content) {
-    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
-    const match = content.match(frontmatterRegex);
-    if (!match) {
-      return { frontmatter: {}, body: content };
+  getConfig() {
+    return this.config;
+  }
+  async execute(event, input, context) {
+    const hooks = this.getHooks(event);
+    if (hooks.length === 0) {
+      return null;
     }
-    const [, yamlContent, body] = match;
-    const frontmatter = {};
-    const lines = yamlContent.split(`
-`);
-    let currentListKey = null;
-    for (const rawLine of lines) {
-      const line = rawLine.trimEnd();
-      if (!line.trim() || line.trim().startsWith("#"))
-        continue;
-      const listMatch = line.match(/^\s*-\s+(.+)$/);
-      if (listMatch && currentListKey) {
-        const list = frontmatter[currentListKey] ?? [];
-        list.push(this.parseYamlValue(listMatch[1]));
-        frontmatter[currentListKey] = list;
+    const fullContext = {
+      ...context,
+      config: this.config
+    };
+    for (const hook of hooks) {
+      if (hook.enabled === false) {
         continue;
       }
-      const keyMatch = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
-      if (!keyMatch)
+      if (this.isHookDisabled(hook.id)) {
         continue;
-      const key = keyMatch[1];
-      const valueRaw = keyMatch[2] ?? "";
-      if (valueRaw.trim() === "") {
-        currentListKey = key;
-        if (!frontmatter[key]) {
-          frontmatter[key] = [];
+      }
+      try {
+        const result = await hook.handler(input, fullContext);
+        if (result && result.continue === false) {
+          return result;
+        }
+        if (result?.permissionDecision) {
+          return result;
         }
+      } catch (error) {
+        console.error(`Native hook ${hook.id} error:`, error);
         continue;
       }
-      currentListKey = null;
-      frontmatter[key] = this.parseYamlValue(valueRaw);
     }
-    return { frontmatter, body: body.trim() };
+    return null;
   }
-  parseYamlValue(value) {
-    const trimmed = value.trim();
-    if (trimmed === "true")
-      return true;
-    if (trimmed === "false")
-      return false;
-    if (!Number.isNaN(Number(trimmed)) && trimmed !== "")
-      return Number(trimmed);
-    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-      const inner = trimmed.slice(1, -1).trim();
-      if (!inner)
-        return [];
-      return inner.split(",").map((item) => this.parseYamlValue(item));
-    }
-    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-      return trimmed.slice(1, -1);
+  isHookDisabled(hookId) {
+    if (hookId === "scope-verification") {
+      return this.config.scopeVerification?.enabled === false;
     }
-    return trimmed;
+    return false;
   }
-  register(command) {
-    this.commands.set(command.name, command);
+  listAll() {
+    const result = [];
+    for (const [event, hooks] of this.hooks.entries()) {
+      result.push({ event, hooks });
+    }
+    return result;
   }
-  getCommand(name) {
-    return this.commands.get(name);
+  clear() {
+    this.hooks.clear();
   }
-  getCommands() {
-    return Array.from(this.commands.values());
+}
+var nativeHookRegistry = new NativeHookRegistry;
+// packages/core/src/hooks/scope-context.ts
+init_src();
+var DEFAULT_EXCLUDE_PATTERNS = [
+  /^(hi|hello|hey|good\s+(morning|afternoon|evening))[\s!.,]*$/i,
+  /^(thanks|thank\s+you|ty|thx)[\s!.,]*$/i,
+  /^(bye|goodbye|see\s+you|later)[\s!.,]*$/i,
+  /^what\s+(is|are)\s+/i,
+  /^how\s+(do|does|can|could)\s+/i,
+  /^(can|could)\s+you\s+(tell|explain|describe)\s+/i,
+  /^(who|when|where|why)\s+(is|are|was|were|did)\s+/i,
+  /^\?+$/
+];
+
+class ScopeContextManager {
+  scopeContext = null;
+  config;
+  constructor(config = {}) {
+    this.config = {
+      enabled: config.enabled ?? true,
+      maxRetries: config.maxRetries ?? 2,
+      excludePatterns: config.excludePatterns ?? []
+    };
   }
-  hasCommand(name) {
-    return this.commands.has(name);
+  setConfig(config) {
+    this.config = {
+      enabled: config.enabled ?? this.config.enabled,
+      maxRetries: config.maxRetries ?? this.config.maxRetries,
+      excludePatterns: config.excludePatterns ?? this.config.excludePatterns
+    };
   }
-  findMatching(partial) {
-    const lower = partial.toLowerCase();
-    return this.getCommands().filter((cmd) => cmd.name.toLowerCase().startsWith(lower) || cmd.description.toLowerCase().includes(lower));
+  isEnabled() {
+    return this.config.enabled !== false;
   }
-}
-// packages/core/src/commands/executor.ts
-class CommandExecutor {
-  loader;
-  constructor(loader) {
-    this.loader = loader;
+  shouldExclude(message) {
+    const trimmed = message.trim();
+    for (const pattern of DEFAULT_EXCLUDE_PATTERNS) {
+      if (pattern.test(trimmed)) {
+        return true;
+      }
+    }
+    const userPatterns = this.config.excludePatterns || [];
+    for (const patternStr of userPatterns) {
+      try {
+        const pattern = new RegExp(patternStr, "i");
+        if (pattern.test(trimmed)) {
+          return true;
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (trimmed.startsWith("!")) {
+      return true;
+    }
+    return false;
   }
-  parseCommand(input) {
-    const trimmed = input.trim();
-    if (!trimmed.startsWith("/")) {
+  async createContext(message, llmClient) {
+    if (!this.isEnabled()) {
       return null;
     }
-    const match = trimmed.match(/^\/(\S+)(?:\s+(.*))?$/);
-    if (!match) {
+    if (this.shouldExclude(message)) {
       return null;
     }
-    return {
-      name: match[1],
-      args: match[2] || ""
+    const goals = await this.extractGoals(message, llmClient);
+    if (goals.length === 0) {
+      return null;
+    }
+    this.scopeContext = {
+      originalMessage: message,
+      extractedGoals: goals,
+      timestamp: Date.now(),
+      verificationAttempts: 0,
+      maxAttempts: this.config.maxRetries ?? 2
     };
+    return this.scopeContext;
   }
-  isCommand(input) {
-    return this.parseCommand(input) !== null;
-  }
-  async execute(input, context) {
-    const parsed = this.parseCommand(input);
-    if (!parsed) {
-      return { handled: false };
+  async extractGoals(message, llmClient) {
+    if (!llmClient) {
+      return this.extractGoalsHeuristic(message);
     }
-    const command = this.loader.getCommand(parsed.name);
-    if (!command) {
-      context.emit("text", `Unknown command: /${parsed.name}
+    try {
+      const prompt = `Analyze the following user request and extract the specific goals or tasks they want accomplished.
+Return a JSON array of strings, where each string is a concise, actionable goal.
+If the message is just a greeting, question, or doesn't contain actionable goals, return an empty array [].
 
-Use /help to see available commands.
-`);
-      context.emit("done");
-      return { handled: true };
-    }
-    if (command.selfHandled && command.handler) {
-      return command.handler(parsed.args, context);
+User request: "${message}"
+
+Respond with ONLY a JSON array, no other text. Example: ["goal 1", "goal 2"]`;
+      const messages = [
+        { id: generateId(), role: "user", content: prompt, timestamp: Date.now() }
+      ];
+      let response = "";
+      for await (const chunk of llmClient.chat(messages)) {
+        if (chunk.type === "text" && chunk.content) {
+          response += chunk.content;
+        }
+      }
+      const jsonMatch = response.match(/\[[\s\S]*\]/);
+      if (jsonMatch) {
+        const goals = JSON.parse(jsonMatch[0]);
+        if (Array.isArray(goals) && goals.every((g) => typeof g === "string")) {
+          return goals.filter((g) => g.trim().length > 0);
+        }
+      }
+      return this.extractGoalsHeuristic(message);
+    } catch (error) {
+      console.error("Goal extraction error:", error);
+      return this.extractGoalsHeuristic(message);
     }
-    const prompt = await this.preparePrompt(command, parsed.args, context);
-    return {
-      handled: false,
-      prompt
-    };
-  }
-  async preparePrompt(command, args, context) {
-    let content = command.content;
-    content = content.replace(/\$ARGUMENTS/g, args || "(no arguments provided)");
-    content = await this.processShellCommands(content, context.cwd);
-    return content;
   }
-  async processShellCommands(content, cwd2) {
-    const lines = content.split(`
-`);
-    const processedLines = [];
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith("!")) {
-        const command = trimmed.slice(1).trim();
-        const output = await this.executeShell(command, cwd2);
-        processedLines.push(`\`\`\`
-${output}
-\`\`\``);
-      } else {
-        processedLines.push(line);
+  extractGoalsHeuristic(message) {
+    const goals = [];
+    const trimmed = message.trim();
+    if (trimmed.length < 10) {
+      return goals;
+    }
+    const taskIndicators = [
+      /^(create|make|build|write|implement|add|fix|update|change|modify|remove|delete|refactor)/i,
+      /^(find|search|look for|locate|get|fetch)/i,
+      /^(run|execute|test|deploy|install|configure|setup)/i,
+      /^(explain|describe|document|analyze|review)/i
+    ];
+    for (const pattern of taskIndicators) {
+      if (pattern.test(trimmed)) {
+        goals.push(trimmed);
+        return goals;
+      }
+    }
+    const lines = trimmed.split(/\n/);
+    for (const line of lines) {
+      const listMatch = line.match(/^[\d\-\*\\u2022]\s*[.)\]:]?\s*(.+)/);
+      if (listMatch && listMatch[1].trim().length > 5) {
+        goals.push(listMatch[1].trim());
+      }
+    }
+    if (goals.length === 0 && trimmed.length >= 20) {
+      goals.push(trimmed);
+    }
+    return goals;
+  }
+  getContext() {
+    return this.scopeContext;
+  }
+  setContext(context) {
+    this.scopeContext = context;
+  }
+  incrementAttempts() {
+    if (this.scopeContext) {
+      this.scopeContext.verificationAttempts++;
+    }
+  }
+  hasReachedMaxAttempts() {
+    if (!this.scopeContext) {
+      return true;
+    }
+    return this.scopeContext.verificationAttempts >= this.scopeContext.maxAttempts;
+  }
+  clear() {
+    this.scopeContext = null;
+  }
+}
+// packages/core/src/hooks/scope-verification.ts
+init_src();
+
+// packages/core/src/sessions/verification.ts
+init_src();
+import { join as join9 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4, readdirSync as readdirSync2 } from "fs";
+
+class VerificationSessionStore {
+  basePath;
+  maxSessions;
+  constructor(basePath, maxSessions = 100) {
+    this.basePath = join9(basePath, "verifications");
+    this.maxSessions = maxSessions;
+    this.ensureDirectory();
+  }
+  ensureDirectory() {
+    if (!existsSync5(this.basePath)) {
+      mkdirSync3(this.basePath, { recursive: true });
+    }
+  }
+  create(parentSessionId, goals, verificationResult) {
+    const session = {
+      id: generateId(),
+      parentSessionId,
+      type: "scope-verification",
+      result: verificationResult.goalsMet ? "pass" : "fail",
+      goals,
+      reason: verificationResult.reason,
+      suggestions: verificationResult.suggestions,
+      verificationResult,
+      createdAt: new Date().toISOString()
+    };
+    this.save(session);
+    this.pruneOldSessions();
+    return session;
+  }
+  save(session) {
+    const filePath = join9(this.basePath, `${session.id}.json`);
+    writeFileSync4(filePath, JSON.stringify(session, null, 2));
+  }
+  get(id) {
+    const filePath = join9(this.basePath, `${id}.json`);
+    if (!existsSync5(filePath)) {
+      return null;
+    }
+    try {
+      const content = readFileSync3(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  getByParentSession(parentSessionId) {
+    const sessions = [];
+    const files = this.listFiles();
+    for (const file of files) {
+      try {
+        const content = readFileSync3(join9(this.basePath, file), "utf-8");
+        const session = JSON.parse(content);
+        if (session.parentSessionId === parentSessionId) {
+          sessions.push(session);
+        }
+      } catch {
+        continue;
+      }
+    }
+    return sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+  }
+  listRecent(limit = 10) {
+    const sessions = [];
+    const files = this.listFiles();
+    for (const file of files) {
+      try {
+        const content = readFileSync3(join9(this.basePath, file), "utf-8");
+        const session = JSON.parse(content);
+        sessions.push(session);
+      } catch {
+        continue;
+      }
+    }
+    return sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, limit);
+  }
+  updateResult(id, result) {
+    const session = this.get(id);
+    if (!session)
+      return;
+    session.result = result;
+    this.save(session);
+  }
+  listFiles() {
+    if (!existsSync5(this.basePath)) {
+      return [];
+    }
+    return readdirSync2(this.basePath).filter((f) => f.endsWith(".json"));
+  }
+  pruneOldSessions() {
+    const files = this.listFiles();
+    if (files.length <= this.maxSessions) {
+      return;
+    }
+    const sessions = [];
+    for (const file of files) {
+      try {
+        const content = readFileSync3(join9(this.basePath, file), "utf-8");
+        const session = JSON.parse(content);
+        sessions.push({
+          file,
+          timestamp: new Date(session.createdAt).getTime()
+        });
+      } catch {
+        continue;
+      }
+    }
+    sessions.sort((a, b) => a.timestamp - b.timestamp);
+    const toRemove = sessions.slice(0, sessions.length - this.maxSessions);
+    for (const item of toRemove) {
+      try {
+        const { unlinkSync: unlinkSync2 } = __require("fs");
+        unlinkSync2(join9(this.basePath, item.file));
+      } catch {
+        continue;
+      }
+    }
+  }
+  clear() {
+    const files = this.listFiles();
+    for (const file of files) {
+      try {
+        const { unlinkSync: unlinkSync2 } = __require("fs");
+        unlinkSync2(join9(this.basePath, file));
+      } catch {
+        continue;
+      }
+    }
+  }
+}
+
+// packages/core/src/hooks/scope-verification.ts
+var VERIFICATION_PROMPT = `You are a goal verification assistant. Your task is to determine if the user's original goals were accomplished based on the conversation history.
+
+Original request: {originalMessage}
+
+Extracted goals:
+{goals}
+
+Analyze the conversation history that follows. For each goal, determine if it was addressed and provide evidence.
+
+Respond with ONLY valid JSON in this exact format:
+{
+  "goalsMet": boolean,
+  "goalsAnalysis": [
+    {"goal": "string", "met": boolean, "evidence": "string"}
+  ],
+  "reason": "string explaining overall assessment",
+  "suggestions": ["string"] // Only include if goalsMet is false, listing what still needs to be done
+}`;
+function summarizeConversation(messages) {
+  const relevant = messages.filter((m) => m.role !== "system");
+  const summary = [];
+  for (const msg of relevant.slice(-20)) {
+    if (msg.role === "user") {
+      if (msg.toolResults && msg.toolResults.length > 0) {
+        for (const result of msg.toolResults) {
+          const content = result.content.slice(0, 500);
+          summary.push(`[Tool Result - ${result.toolName || "unknown"}]: ${content}`);
+        }
+      } else {
+        summary.push(`User: ${msg.content.slice(0, 300)}`);
+      }
+    } else if (msg.role === "assistant") {
+      if (msg.toolCalls && msg.toolCalls.length > 0) {
+        for (const call of msg.toolCalls) {
+          const input = JSON.stringify(call.input).slice(0, 200);
+          summary.push(`[Tool Call - ${call.name}]: ${input}`);
+        }
+      }
+      if (msg.content.trim()) {
+        summary.push(`Assistant: ${msg.content.slice(0, 300)}`);
+      }
+    }
+  }
+  return summary.join(`
+
+`);
+}
+async function runVerification(scopeContext, messages, llmClient) {
+  const goalsText = scopeContext.extractedGoals.map((g, i) => `${i + 1}. ${g}`).join(`
+`);
+  const prompt = VERIFICATION_PROMPT.replace("{originalMessage}", scopeContext.originalMessage).replace("{goals}", goalsText);
+  const conversationSummary = summarizeConversation(messages);
+  const verificationMessages = [
+    {
+      id: generateId(),
+      role: "user",
+      content: `${prompt}
+
+---
+
+Conversation history:
+${conversationSummary}`,
+      timestamp: Date.now()
+    }
+  ];
+  let response = "";
+  for await (const chunk of llmClient.chat(verificationMessages)) {
+    if (chunk.type === "text" && chunk.content) {
+      response += chunk.content;
+    }
+  }
+  try {
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      const result = JSON.parse(jsonMatch[0]);
+      if (typeof result.goalsMet === "boolean" && typeof result.reason === "string" && Array.isArray(result.goalsAnalysis)) {
+        return result;
+      }
+    }
+  } catch {}
+  return {
+    goalsMet: true,
+    goalsAnalysis: scopeContext.extractedGoals.map((goal) => ({
+      goal,
+      met: true,
+      evidence: "Unable to verify - defaulting to complete"
+    })),
+    reason: "Verification parsing failed - assuming goals were met"
+  };
+}
+async function scopeVerificationHandler(input, context) {
+  const { scopeContext, messages, config, sessionId, cwd: cwd2 } = context;
+  const llmClient = context.llmClient;
+  if (!scopeContext || !llmClient) {
+    return null;
+  }
+  if (scopeContext.verificationAttempts >= scopeContext.maxAttempts) {
+    return null;
+  }
+  if (config?.scopeVerification?.enabled === false) {
+    return null;
+  }
+  if (scopeContext.extractedGoals.length === 0) {
+    return null;
+  }
+  try {
+    const result = await runVerification(scopeContext, messages, llmClient);
+    const store = new VerificationSessionStore(getConfigDir());
+    const session = store.create(sessionId, scopeContext.extractedGoals, result);
+    if (result.goalsMet) {
+      return null;
+    }
+    const suggestions = result.suggestions?.join(`
+- `) || "Please complete the remaining tasks.";
+    return {
+      continue: false,
+      stopReason: "Goals not fully achieved",
+      systemMessage: `[Scope Verification - Session ${session.id}]
+The following goals were not completed:
+${result.goalsAnalysis.filter((g) => !g.met).map((g) => `- ${g.goal}: ${g.evidence}`).join(`
+`)}
+
+${result.reason}
+
+Please continue and:
+- ${suggestions}`,
+      additionalContext: `Verification session: ${session.id}`
+    };
+  } catch (error) {
+    console.error("Scope verification error:", error);
+    return null;
+  }
+}
+function createScopeVerificationHook() {
+  return {
+    id: "scope-verification",
+    event: "Stop",
+    priority: 100,
+    handler: scopeVerificationHandler
+  };
+}
+// packages/core/src/commands/loader.ts
+import { existsSync as existsSync6, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join10, basename as basename2, extname } from "path";
+import { homedir as homedir6 } from "os";
+
+class CommandLoader {
+  commands = new Map;
+  cwd;
+  constructor(cwd2) {
+    this.cwd = cwd2 || process.cwd();
+  }
+  async loadAll() {
+    this.commands.clear();
+    const envHome = process.env.HOME || process.env.USERPROFILE;
+    const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir6();
+    const globalDir = join10(homeDir, ".assistants", "commands");
+    await this.loadFromDirectory(globalDir, "global");
+    const projectDir = join10(this.cwd, ".assistants", "commands");
+    await this.loadFromDirectory(projectDir, "project");
+  }
+  async loadFromDirectory(dir, source, prefix = "") {
+    if (!existsSync6(dir))
+      return;
+    const entries = readdirSync3(dir);
+    for (const entry of entries) {
+      const fullPath = join10(dir, entry);
+      const stat = statSync2(fullPath);
+      if (stat.isDirectory()) {
+        const newPrefix = prefix ? `${prefix}:${entry}` : entry;
+        await this.loadFromDirectory(fullPath, source, newPrefix);
+      } else if (stat.isFile() && extname(entry) === ".md") {
+        const command = await this.loadCommandFile(fullPath, prefix);
+        if (command) {
+          this.commands.set(command.name, command);
+        }
+      }
+    }
+  }
+  async loadCommandFile(filePath, prefix) {
+    try {
+      const content = await Bun.file(filePath).text();
+      const { frontmatter, body } = this.parseFrontmatter(content);
+      const fileName = basename2(filePath, ".md");
+      const name = frontmatter.name || (prefix ? `${prefix}:${fileName}` : fileName);
+      const allowedToolsRaw = frontmatter["allowed-tools"];
+      const allowedTools = Array.isArray(allowedToolsRaw) ? allowedToolsRaw.map((t) => String(t).trim()).filter(Boolean) : typeof allowedToolsRaw === "string" ? allowedToolsRaw.split(",").map((t) => t.trim()).filter(Boolean) : undefined;
+      return {
+        name,
+        description: frontmatter.description || `Run the ${name} command`,
+        tags: frontmatter.tags,
+        allowedTools,
+        content: body,
+        filePath,
+        builtin: false
+      };
+    } catch (error) {
+      console.error(`Failed to load command from ${filePath}:`, error);
+      return null;
+    }
+  }
+  parseFrontmatter(content) {
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+      return { frontmatter: {}, body: content };
+    }
+    const [, yamlContent, body] = match;
+    const frontmatter = {};
+    const lines = yamlContent.split(`
+`);
+    let currentListKey = null;
+    for (const rawLine of lines) {
+      const line = rawLine.trimEnd();
+      if (!line.trim() || line.trim().startsWith("#"))
+        continue;
+      const listMatch = line.match(/^\s*-\s+(.+)$/);
+      if (listMatch && currentListKey) {
+        const list = frontmatter[currentListKey] ?? [];
+        list.push(this.parseYamlValue(listMatch[1]));
+        frontmatter[currentListKey] = list;
+        continue;
+      }
+      const keyMatch = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+      if (!keyMatch)
+        continue;
+      const key = keyMatch[1];
+      const valueRaw = keyMatch[2] ?? "";
+      if (valueRaw.trim() === "") {
+        currentListKey = key;
+        if (!frontmatter[key]) {
+          frontmatter[key] = [];
+        }
+        continue;
+      }
+      currentListKey = null;
+      frontmatter[key] = this.parseYamlValue(valueRaw);
+    }
+    return { frontmatter, body: body.trim() };
+  }
+  parseYamlValue(value) {
+    const trimmed = value.trim();
+    if (trimmed === "true")
+      return true;
+    if (trimmed === "false")
+      return false;
+    if (!Number.isNaN(Number(trimmed)) && trimmed !== "")
+      return Number(trimmed);
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      const inner = trimmed.slice(1, -1).trim();
+      if (!inner)
+        return [];
+      return inner.split(",").map((item) => this.parseYamlValue(item));
+    }
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+      return trimmed.slice(1, -1);
+    }
+    return trimmed;
+  }
+  register(command) {
+    this.commands.set(command.name, command);
+  }
+  getCommand(name) {
+    return this.commands.get(name);
+  }
+  getCommands() {
+    return Array.from(this.commands.values());
+  }
+  hasCommand(name) {
+    return this.commands.has(name);
+  }
+  findMatching(partial) {
+    const lower = partial.toLowerCase();
+    return this.getCommands().filter((cmd) => cmd.name.toLowerCase().startsWith(lower) || cmd.description.toLowerCase().includes(lower));
+  }
+}
+// packages/core/src/commands/executor.ts
+class CommandExecutor {
+  loader;
+  constructor(loader) {
+    this.loader = loader;
+  }
+  parseCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/")) {
+      return null;
+    }
+    const match = trimmed.match(/^\/(\S+)(?:\s+(.*))?$/);
+    if (!match) {
+      return null;
+    }
+    return {
+      name: match[1],
+      args: match[2] || ""
+    };
+  }
+  isCommand(input) {
+    return this.parseCommand(input) !== null;
+  }
+  async execute(input, context) {
+    const parsed = this.parseCommand(input);
+    if (!parsed) {
+      return { handled: false };
+    }
+    const command = this.loader.getCommand(parsed.name);
+    if (!command) {
+      context.emit("text", `Unknown command: /${parsed.name}
+
+Use /help to see available commands.
+`);
+      context.emit("done");
+      return { handled: true };
+    }
+    if (command.selfHandled && command.handler) {
+      return command.handler(parsed.args, context);
+    }
+    const prompt = await this.preparePrompt(command, parsed.args, context);
+    return {
+      handled: false,
+      prompt
+    };
+  }
+  async preparePrompt(command, args, context) {
+    let content = command.content;
+    content = content.replace(/\$ARGUMENTS/g, args || "(no arguments provided)");
+    content = await this.processShellCommands(content, context.cwd);
+    return content;
+  }
+  async processShellCommands(content, cwd2) {
+    const lines = content.split(`
+`);
+    const processedLines = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("!")) {
+        const command = trimmed.slice(1).trim();
+        const output = await this.executeShell(command, cwd2);
+        processedLines.push(`\`\`\`
+${output}
+\`\`\``);
+      } else {
+        processedLines.push(line);
       }
     }
     return processedLines.join(`
@@ -39849,20 +40374,20 @@ ${stderr}`;
   }
 }
 // packages/core/src/commands/builtin.ts
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import { homedir as homedir7, platform as platform2, release, arch } from "os";
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
 init_src();
 
 // packages/core/src/projects/store.ts
 init_src();
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { mkdir as mkdir3, readdir as readdir2, readFile as readFile2, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
 function projectsDir(cwd2) {
-  return join10(cwd2, ".oldpal", "projects");
+  return join11(cwd2, ".assistants", "projects");
 }
 function projectPath(cwd2, id) {
-  return join10(projectsDir(cwd2), `${id}.json`);
+  return join11(projectsDir(cwd2), `${id}.json`);
 }
 async function ensureProjectsDir(cwd2) {
   await mkdir3(projectsDir(cwd2), { recursive: true });
@@ -39879,7 +40404,7 @@ async function listProjects(cwd2) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const raw = await readFile2(join10(dir, file), "utf-8");
+        const raw = await readFile2(join11(dir, file), "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed?.id && parsed?.name) {
           projects.push(parsed);
@@ -40057,7 +40582,7 @@ async function buildProjectContext(project, options) {
 }
 
 // packages/core/src/commands/builtin.ts
-var VERSION = process.env.ASSISTANTS_VERSION || process.env.npm_package_version || process.env.OLDPAL_VERSION || "unknown";
+var VERSION = process.env.ASSISTANTS_VERSION || process.env.npm_package_version || "unknown";
 function resolveAuthTimeout(resolve5) {
   resolve5({ exitCode: 1, stdout: { toString: () => "{}" } });
 }
@@ -40133,6 +40658,7 @@ class BuiltinCommands {
     loader.register(this.resumeScheduleCommand());
     loader.register(this.connectorsCommand());
     loader.register(this.securityLogCommand());
+    loader.register(this.verificationCommand());
     loader.register(this.exitCommand());
   }
   voiceCommand() {
@@ -40642,6 +41168,130 @@ Identities:
       }
     };
   }
+  verificationCommand() {
+    return {
+      name: "verification",
+      description: "Manage scope verification (list/view/enable/disable)",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        const arg = args.trim().toLowerCase();
+        const store = new VerificationSessionStore(getConfigDir());
+        if (arg === "disable" || arg === "off") {
+          nativeHookRegistry.setConfig({
+            ...nativeHookRegistry.getConfig(),
+            scopeVerification: {
+              ...nativeHookRegistry.getConfig().scopeVerification,
+              enabled: false
+            }
+          });
+          context.emit("text", `Scope verification disabled.
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (arg === "enable" || arg === "on") {
+          nativeHookRegistry.setConfig({
+            ...nativeHookRegistry.getConfig(),
+            scopeVerification: {
+              ...nativeHookRegistry.getConfig().scopeVerification,
+              enabled: true
+            }
+          });
+          context.emit("text", `Scope verification enabled.
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (arg === "status") {
+          const config = nativeHookRegistry.getConfig();
+          const enabled = config.scopeVerification?.enabled !== false;
+          const maxRetries = config.scopeVerification?.maxRetries ?? 2;
+          context.emit("text", `Scope verification: ${enabled ? "enabled" : "disabled"}
+`);
+          context.emit("text", `Max retries: ${maxRetries}
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (arg === "" || arg === "list") {
+          const sessions2 = store.listRecent(10);
+          if (sessions2.length === 0) {
+            context.emit("text", `No verification sessions found.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          context.emit("text", `Recent verification sessions:
+
+`);
+          for (const session of sessions2) {
+            const date = new Date(session.createdAt).toLocaleString();
+            const status = session.result === "pass" ? "\u2713" : session.result === "force-continue" ? "\u2192" : "\u2717";
+            context.emit("text", `${status} ${session.id.slice(0, 8)} - ${date} - ${session.result}
+`);
+            context.emit("text", `  Goals: ${session.goals.slice(0, 2).join(", ")}${session.goals.length > 2 ? "..." : ""}
+`);
+          }
+          context.emit("text", `
+Use /verification <id> to view details.
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        const sessions = store.listRecent(100);
+        const match = sessions.find((s) => s.id.startsWith(arg) || s.id === arg);
+        if (!match) {
+          context.emit("text", `No verification session found matching "${arg}".
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        context.emit("text", `
+=== Verification Session ${match.id} ===
+
+`);
+        context.emit("text", `Created: ${new Date(match.createdAt).toLocaleString()}
+`);
+        context.emit("text", `Parent Session: ${match.parentSessionId}
+`);
+        context.emit("text", `Result: ${match.result}
+
+`);
+        context.emit("text", `Goals:
+`);
+        for (const goal of match.goals) {
+          context.emit("text", `  \u2022 ${goal}
+`);
+        }
+        context.emit("text", `
+Analysis:
+`);
+        for (const analysis of match.verificationResult.goalsAnalysis) {
+          const icon = analysis.met ? "\u2713" : "\u2717";
+          context.emit("text", `  ${icon} ${analysis.goal}
+`);
+          context.emit("text", `    ${analysis.evidence}
+`);
+        }
+        context.emit("text", `
+Reason: ${match.reason}
+`);
+        if (match.suggestions && match.suggestions.length > 0) {
+          context.emit("text", `
+Suggestions:
+`);
+          for (const suggestion of match.suggestions) {
+            context.emit("text", `  \u2022 ${suggestion}
+`);
+          }
+        }
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
   exitCommand() {
     return {
       name: "exit",
@@ -41608,9 +42258,9 @@ Format the summary as a brief bullet-point list. This summary will replace the c
       content: "",
       handler: async (args, context) => {
         const configPaths = [
-          join11(context.cwd, ".assistants", "config.json"),
-          join11(context.cwd, ".assistants", "config.local.json"),
-          join11(getConfigDir(), "config.json")
+          join12(context.cwd, ".assistants", "config.json"),
+          join12(context.cwd, ".assistants", "config.local.json"),
+          join12(getConfigDir(), "config.json")
         ];
         let message = `
 **Configuration**
@@ -41628,9 +42278,9 @@ Format the summary as a brief bullet-point list. This summary will replace the c
         message += `
 **Commands Directories:**
 `;
-        message += `  - Project: ${join11(context.cwd, ".assistants", "commands")}
+        message += `  - Project: ${join12(context.cwd, ".assistants", "commands")}
 `;
-        message += `  - Global: ${join11(homeDir, ".assistants", "commands")}
+        message += `  - Global: ${join12(homeDir, ".assistants", "commands")}
 `;
         context.emit("text", message);
         context.emit("done");
@@ -41646,8 +42296,8 @@ Format the summary as a brief bullet-point list. This summary will replace the c
       selfHandled: true,
       content: "",
       handler: async (args, context) => {
-        const commandsDir = join11(context.cwd, ".assistants", "commands");
-        mkdirSync3(commandsDir, { recursive: true });
+        const commandsDir = join12(context.cwd, ".assistants", "commands");
+        mkdirSync4(commandsDir, { recursive: true });
         const exampleCommand = `---
 name: reflect
 description: Reflect on the conversation and suggest next steps
@@ -41662,9 +42312,9 @@ Please summarize the last interaction and suggest 2-3 next steps.
 - Focus on clarity
 - Ask a follow-up question if needed
 `;
-        const examplePath = join11(commandsDir, "reflect.md");
+        const examplePath = join12(commandsDir, "reflect.md");
         if (!existsSync7(examplePath)) {
-          writeFileSync4(examplePath, exampleCommand);
+          writeFileSync5(examplePath, exampleCommand);
         }
         let message = `
 **Initialized assistants**
@@ -41900,8 +42550,19 @@ Keep it concise but comprehensive.`
       handler: async (args, context) => {
         const id = args.trim();
         if (!id) {
-          context.emit("text", `Usage: /pause <id>
+          const schedules = await listSchedules(context.cwd);
+          if (schedules.length === 0) {
+            context.emit("text", `No schedules found.
+`);
+          } else {
+            const lines = schedules.sort((a, b) => (a.nextRunAt || 0) - (b.nextRunAt || 0)).map((schedule) => `- ${schedule.id} [${schedule.status}] ${schedule.command}`);
+            context.emit("text", `Usage: /pause <id>
+
+Available schedules:
+${lines.join(`
+`)}
 `);
+          }
           context.emit("done");
           return { handled: true };
         }
@@ -41927,8 +42588,19 @@ Keep it concise but comprehensive.`
       handler: async (args, context) => {
         const id = args.trim();
         if (!id) {
-          context.emit("text", `Usage: /resume <id>
+          const schedules = await listSchedules(context.cwd);
+          if (schedules.length === 0) {
+            context.emit("text", `No schedules found.
+`);
+          } else {
+            const lines = schedules.sort((a, b) => (a.nextRunAt || 0) - (b.nextRunAt || 0)).map((schedule) => `- ${schedule.id} [${schedule.status}] ${schedule.command}`);
+            context.emit("text", `Usage: /resume <id>
+
+Available schedules:
+${lines.join(`
+`)}
 `);
+          }
           context.emit("done");
           return { handled: true };
         }
@@ -42363,7 +43035,7 @@ async function createLLMClient(config) {
 
 // packages/core/src/heartbeat/manager.ts
 import { dirname as dirname5 } from "path";
-import { mkdirSync as mkdirSync4 } from "fs";
+import { mkdirSync as mkdirSync5 } from "fs";
 import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 
 class HeartbeatManager {
@@ -42385,7 +43057,7 @@ class HeartbeatManager {
       uptimeSeconds: 0
     };
     const dir = dirname5(config.persistPath);
-    mkdirSync4(dir, { recursive: true });
+    mkdirSync5(dir, { recursive: true });
   }
   start(sessionId) {
     if (this.intervalId)
@@ -42459,14 +43131,14 @@ class HeartbeatManager {
 }
 // packages/core/src/heartbeat/persistence.ts
 import { dirname as dirname6 } from "path";
-import { mkdirSync as mkdirSync5 } from "fs";
+import { mkdirSync as mkdirSync6 } from "fs";
 import { readFile as readFile5, writeFile as writeFile4, unlink as unlink3 } from "fs/promises";
 
 class StatePersistence {
   path;
   constructor(path2) {
     this.path = path2;
-    mkdirSync5(dirname6(path2), { recursive: true });
+    mkdirSync6(dirname6(path2), { recursive: true });
   }
   async save(state) {
     try {
@@ -42686,14 +43358,14 @@ class EnergyManager {
 }
 // packages/core/src/energy/storage.ts
 import { dirname as dirname7 } from "path";
-import { mkdirSync as mkdirSync6 } from "fs";
+import { mkdirSync as mkdirSync7 } from "fs";
 import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
 
 class EnergyStorage {
   path;
   constructor(path2) {
     this.path = path2;
-    mkdirSync6(dirname7(path2), { recursive: true });
+    mkdirSync7(dirname7(path2), { recursive: true });
   }
   async save(state) {
     try {
@@ -42760,18 +43432,18 @@ function validateToolCalls(toolCalls, tools) {
 }
 
 // packages/core/src/voice/utils.ts
-import { existsSync as existsSync9, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import { spawnSync } from "child_process";
 function loadApiKeyFromSecrets2(key) {
   const envHome = process.env.HOME || process.env.USERPROFILE;
   const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir9();
-  const secretsPath = join13(homeDir, ".secrets");
+  const secretsPath = join14(homeDir, ".secrets");
   if (!existsSync9(secretsPath))
     return;
   try {
-    const content = readFileSync4(secretsPath, "utf-8");
+    const content = readFileSync5(secretsPath, "utf-8");
     const match = content.match(new RegExp(`export\\s+${key}\\s*=\\s*['"]?([^'"\\n]+)['"]?`));
     return match?.[1];
   } catch {
@@ -42841,8 +43513,8 @@ class SystemSTT {
 // packages/core/src/voice/tts.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join14 } from "path";
-import { readFileSync as readFileSync5, unlinkSync as unlinkSync2 } from "fs";
+import { join as join15 } from "path";
+import { readFileSync as readFileSync6, unlinkSync as unlinkSync2 } from "fs";
 class ElevenLabsTTS {
   apiKey;
   voiceId;
@@ -42945,7 +43617,7 @@ class SystemTTS {
       if (!say) {
         throw new Error('System TTS not available: missing "say" command.');
       }
-      const output = join14(tmpdir2(), `assistants-tts-${Date.now()}.aiff`);
+      const output = join15(tmpdir2(), `assistants-tts-${Date.now()}.aiff`);
       const args = [];
       if (this.voiceId) {
         args.push("-v", this.voiceId);
@@ -42958,7 +43630,7 @@ class SystemTTS {
       if (result.status !== 0) {
         throw new Error(`System TTS failed: ${result.stderr || "unknown error"}`);
       }
-      const audio = readFileSync5(output);
+      const audio = readFileSync6(output);
       unlinkSync2(output);
       return {
         audio: audio.buffer.slice(audio.byteOffset, audio.byteOffset + audio.byteLength),
@@ -42967,7 +43639,7 @@ class SystemTTS {
     }
     const espeak = findExecutable("espeak") || findExecutable("espeak-ng");
     if (espeak) {
-      const output = join14(tmpdir2(), `assistants-tts-${Date.now()}.wav`);
+      const output = join15(tmpdir2(), `assistants-tts-${Date.now()}.wav`);
       const args = ["-w", output];
       if (this.voiceId) {
         args.push("-v", this.voiceId);
@@ -42980,7 +43652,7 @@ class SystemTTS {
       if (result.status !== 0) {
         throw new Error(`System TTS failed: ${result.stderr || "unknown error"}`);
       }
-      const audio = readFileSync5(output);
+      const audio = readFileSync6(output);
       unlinkSync2(output);
       return {
         audio: audio.buffer.slice(audio.byteOffset, audio.byteOffset + audio.byteLength),
@@ -42994,15 +43666,15 @@ class SystemTTS {
 // packages/core/src/voice/player.ts
 import { spawn } from "child_process";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join15 } from "path";
-import { unlink as unlink4, writeFileSync as writeFileSync5 } from "fs";
+import { join as join16 } from "path";
+import { unlink as unlink4, writeFileSync as writeFileSync6 } from "fs";
 class AudioPlayer {
   currentProcess = null;
   playing = false;
   async play(audio, options = {}) {
     const format = options.format ?? "mp3";
-    const tempFile = join15(tmpdir3(), `assistants-audio-${Date.now()}.${format}`);
-    writeFileSync5(tempFile, Buffer.from(audio));
+    const tempFile = join16(tmpdir3(), `assistants-audio-${Date.now()}.${format}`);
+    writeFileSync6(tempFile, Buffer.from(audio));
     const player = this.resolvePlayer(format);
     if (!player) {
       throw new Error("No supported audio player found. Install afplay, ffplay, mpg123, or aplay.");
@@ -43069,8 +43741,8 @@ class AudioPlayer {
 // packages/core/src/voice/recorder.ts
 import { spawn as spawn2 } from "child_process";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join16 } from "path";
-import { readFileSync as readFileSync6, unlink as unlink5 } from "fs";
+import { join as join17 } from "path";
+import { readFileSync as readFileSync7, unlink as unlink5 } from "fs";
 class AudioRecorder {
   currentProcess = null;
   async record(options = {}) {
@@ -43080,7 +43752,7 @@ class AudioRecorder {
     const duration = options.durationSeconds ?? 5;
     const sampleRate = options.sampleRate ?? 16000;
     const channels = options.channels ?? 1;
-    const output = join16(tmpdir4(), `assistants-record-${Date.now()}.wav`);
+    const output = join17(tmpdir4(), `assistants-record-${Date.now()}.wav`);
     const recorder = this.resolveRecorder(sampleRate, channels, duration, output);
     if (!recorder) {
       throw new Error("No supported audio recorder found. Install sox or ffmpeg.");
@@ -43100,7 +43772,7 @@ class AudioRecorder {
         reject(error);
       });
     });
-    const data = readFileSync6(output);
+    const data = readFileSync7(output);
     unlink5(output, () => {});
     return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
   }
@@ -43274,13 +43946,13 @@ class VoiceManager {
 init_src();
 import { existsSync as existsSync11 } from "fs";
 import { mkdir as mkdir5, readFile as readFile8, writeFile as writeFile7, rm as rm2 } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // packages/core/src/identity/identity-manager.ts
 init_src();
 import { existsSync as existsSync10 } from "fs";
 import { mkdir as mkdir4, readFile as readFile7, writeFile as writeFile6, rm } from "fs/promises";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 var DEFAULT_PROFILE = {
   displayName: "Assistant",
   timezone: "UTC",
@@ -43310,19 +43982,19 @@ class IdentityManager {
     this.basePath = basePath;
   }
   get identitiesRoot() {
-    return join17(this.basePath, "assistants", this.assistantId, "identities");
+    return join18(this.basePath, "assistants", this.assistantId, "identities");
   }
   get indexPath() {
-    return join17(this.identitiesRoot, "index.json");
+    return join18(this.identitiesRoot, "index.json");
   }
   get activePath() {
-    return join17(this.identitiesRoot, "active.json");
+    return join18(this.identitiesRoot, "active.json");
   }
   identityPath(id) {
-    return join17(this.identitiesRoot, `${id}.json`);
+    return join18(this.identitiesRoot, `${id}.json`);
   }
   assistantConfigPath() {
-    return join17(this.basePath, "assistants", this.assistantId, "config.json");
+    return join18(this.basePath, "assistants", this.assistantId, "config.json");
   }
   async initialize() {
     await mkdir4(this.identitiesRoot, { recursive: true });
@@ -43506,16 +44178,16 @@ class AssistantManager {
     this.basePath = basePath;
   }
   get assistantsRoot() {
-    return join18(this.basePath, "assistants");
+    return join19(this.basePath, "assistants");
   }
   get indexPath() {
-    return join18(this.assistantsRoot, "index.json");
+    return join19(this.assistantsRoot, "index.json");
   }
   get activePath() {
-    return join18(this.basePath, "active.json");
+    return join19(this.basePath, "active.json");
   }
   assistantConfigPath(id) {
-    return join18(this.assistantsRoot, id, "config.json");
+    return join19(this.assistantsRoot, id, "config.json");
   }
   async initialize() {
     await mkdir5(this.assistantsRoot, { recursive: true });
@@ -43569,7 +44241,7 @@ class AssistantManager {
     if (!this.assistants.has(id)) {
       throw new Error(`Assistant ${id} not found`);
     }
-    await rm2(join18(this.assistantsRoot, id), { recursive: true, force: true });
+    await rm2(join19(this.assistantsRoot, id), { recursive: true, force: true });
     this.assistants.delete(id);
     await this.removeFromIndex(id);
     if (this.activeId === id) {
@@ -43635,7 +44307,7 @@ class AssistantManager {
     }
   }
   async persistAssistant(assistant) {
-    const dir = join18(this.assistantsRoot, assistant.id);
+    const dir = join19(this.assistantsRoot, assistant.id);
     await mkdir5(dir, { recursive: true });
     await writeFile7(this.assistantConfigPath(assistant.id), JSON.stringify(assistant, null, 2));
   }
@@ -43675,6 +44347,7 @@ class AgentLoop {
   skillExecutor;
   hookLoader;
   hookExecutor;
+  scopeContextManager;
   commandLoader;
   commandExecutor;
   builtinCommands;
@@ -43716,6 +44389,7 @@ class AgentLoop {
     this.skillExecutor = new SkillExecutor;
     this.hookLoader = new HookLoader;
     this.hookExecutor = new HookExecutor;
+    this.scopeContextManager = new ScopeContextManager;
     this.commandLoader = new CommandLoader(this.cwd);
     this.commandExecutor = new CommandExecutor(this.commandLoader);
     this.builtinCommands = new BuiltinCommands;
@@ -43781,6 +44455,14 @@ class AgentLoop {
     this.connectorBridge.registerAll(this.toolRegistry);
     this.builtinCommands.registerAll(this.commandLoader);
     this.hookLoader.load(hooksConfig);
+    nativeHookRegistry.register(createScopeVerificationHook());
+    const nativeConfig = hooksConfig?.native;
+    if (nativeConfig) {
+      nativeHookRegistry.setConfig(nativeConfig);
+      if (nativeConfig.scopeVerification) {
+        this.scopeContextManager.setConfig(nativeConfig.scopeVerification);
+      }
+    }
     this.hookExecutor.setAgentRunner((hook, input, timeout) => runHookAgent({ hook, input, timeout, cwd: this.cwd }));
     this.systemPrompt = systemPrompt || null;
     if (this.systemPrompt) {
@@ -43829,6 +44511,10 @@ class AgentLoop {
           return { ok: false, error: promptHookResult.stopReason || "Blocked by hook" };
         }
       }
+      const explicitToolResult = await this.handleExplicitToolCommand(userMessage);
+      if (explicitToolResult) {
+        return explicitToolResult;
+      }
       if (userMessage.startsWith("/")) {
         const parsed = this.commandExecutor.parseCommand(userMessage);
         const command = parsed ? this.commandLoader.getCommand(parsed.name) : undefined;
@@ -43863,6 +44549,12 @@ class AgentLoop {
       }
       const limits = getLimits();
       userMessage = enforceMessageLimit(userMessage, limits.maxUserMessageLength);
+      if (source === "user") {
+        const scopeContext = await this.scopeContextManager.createContext(userMessage, this.llmClient);
+        if (scopeContext) {
+          this.context.setScopeContext(scopeContext);
+        }
+      }
       this.context.addUserMessage(userMessage);
       await this.runLoop();
       this.contextManager?.refreshState(this.context.getMessages());
@@ -43880,6 +44572,47 @@ class AgentLoop {
       this.drainScheduledQueue();
     }
   }
+  async handleExplicitToolCommand(userMessage) {
+    const match = userMessage.match(/^!\[(\w+)\]\s*([\s\S]*)$/);
+    if (!match)
+      return null;
+    const toolName = match[1].toLowerCase();
+    const command = match[2].trim();
+    if (!command) {
+      this.emit({ type: "text", content: `Usage: ![${toolName}] <command>
+` });
+      this.emit({ type: "done" });
+      return { ok: false, error: "Missing command" };
+    }
+    if (toolName !== "bash") {
+      this.emit({ type: "text", content: `Unsupported tool: ${toolName}
+` });
+      this.emit({ type: "done" });
+      return { ok: false, error: "Unsupported tool" };
+    }
+    const toolCall = {
+      id: generateId(),
+      name: "bash",
+      type: "tool",
+      input: {
+        command,
+        cwd: this.cwd,
+        sessionId: this.sessionId
+      }
+    };
+    this.context.addUserMessage(userMessage);
+    this.context.addAssistantMessage("", [toolCall]);
+    this.emit({ type: "tool_use", toolCall });
+    const results = await this.executeToolCalls([toolCall]);
+    this.context.addToolResults(results);
+    this.emit({ type: "done" });
+    const failed = results.some((result) => result.isError);
+    if (failed) {
+      const error = results.find((result) => result.isError)?.content;
+      return { ok: false, error: error ? String(error) : "Tool execution failed" };
+    }
+    return { ok: true, summary: `Executed ${toolName}` };
+  }
   async runLoop() {
     const maxTurns = 50;
     let turn = 0;
@@ -43945,6 +44678,21 @@ class AgentLoop {
         hook_event_name: "Stop",
         cwd: this.cwd
       });
+      const verificationResult = await this.runScopeVerification();
+      if (verificationResult && verificationResult.continue === false) {
+        if (verificationResult.systemMessage) {
+          this.context.addSystemMessage(verificationResult.systemMessage);
+        }
+        this.scopeContextManager.incrementAttempts();
+        const scope = this.scopeContextManager.getContext();
+        if (scope) {
+          this.context.setScopeContext(scope);
+        }
+        await this.runLoop();
+        return;
+      }
+      this.scopeContextManager.clear();
+      this.context.clearScopeContext();
       this.emit({ type: "done" });
     }
     if (streamError) {
@@ -43976,6 +44724,36 @@ class AgentLoop {
 ` });
     }
   }
+  async runScopeVerification() {
+    if (!this.scopeContextManager.isEnabled()) {
+      return null;
+    }
+    if (this.scopeContextManager.hasReachedMaxAttempts()) {
+      return null;
+    }
+    const scopeContext = this.context.getScopeContext();
+    if (!scopeContext) {
+      return null;
+    }
+    const result = await nativeHookRegistry.execute("Stop", {
+      session_id: this.sessionId,
+      hook_event_name: "Stop",
+      cwd: this.cwd
+    }, {
+      sessionId: this.sessionId,
+      cwd: this.cwd,
+      messages: this.context.getMessages(),
+      scopeContext,
+      llmClient: this.llmClient
+    });
+    if (!result) {
+      return null;
+    }
+    return {
+      continue: result.continue !== false,
+      systemMessage: result.systemMessage
+    };
+  }
   async executeToolCalls(toolCalls) {
     const results = [];
     for (const toolCall of toolCalls) {
@@ -44365,7 +45143,7 @@ ${content.trim()}`);
     const heartbeatConfig = this.buildHeartbeatConfig(this.config);
     if (!heartbeatConfig)
       return;
-    const statePath = join19(getConfigDir(), "state", `${this.sessionId}.json`);
+    const statePath = join20(getConfigDir(), "state", `${this.sessionId}.json`);
     this.heartbeatManager = new HeartbeatManager(heartbeatConfig);
     this.heartbeatPersistence = new StatePersistence(statePath);
     this.heartbeatRecovery = new RecoveryManager(this.heartbeatPersistence, heartbeatConfig.persistPath, heartbeatConfig.staleThresholdMs, {
@@ -44414,7 +45192,7 @@ ${content.trim()}`);
   async startEnergySystem() {
     if (!this.config || this.config.energy?.enabled === false)
       return;
-    const statePath = join19(getConfigDir(), "energy", "state.json");
+    const statePath = join20(getConfigDir(), "energy", "state.json");
     this.energyManager = new EnergyManager(this.config.energy, new EnergyStorage(statePath));
     await this.energyManager.initialize();
     this.refreshEnergyEffects();
@@ -44481,7 +45259,24 @@ ${effects.message}
           await releaseScheduleLock(this.cwd, schedule.id, this.sessionId);
           continue;
         }
-        this.scheduledQueue.push(schedule);
+        let scheduleToQueue = schedule;
+        if (!schedule.sessionId) {
+          const claimed = await updateSchedule(this.cwd, schedule.id, (current) => {
+            if (current.sessionId)
+              return current;
+            return {
+              ...current,
+              sessionId: this.sessionId,
+              updatedAt: Date.now()
+            };
+          });
+          if (!claimed || claimed.sessionId && claimed.sessionId !== this.sessionId) {
+            await releaseScheduleLock(this.cwd, schedule.id, this.sessionId);
+            continue;
+          }
+          scheduleToQueue = claimed;
+        }
+        this.scheduledQueue.push(scheduleToQueue);
       }
       this.drainScheduledQueue();
     } catch (error) {
@@ -44643,7 +45438,7 @@ ${this.identityContext}`);
       return null;
     const intervalMs = Math.max(1000, config.heartbeat?.intervalMs ?? 15000);
     const staleThresholdMs = Math.max(intervalMs * 2, config.heartbeat?.staleThresholdMs ?? 120000);
-    const persistPath = config.heartbeat?.persistPath ?? join19(getConfigDir(), "heartbeats", `${this.sessionId}.json`);
+    const persistPath = config.heartbeat?.persistPath ?? join20(getConfigDir(), "heartbeats", `${this.sessionId}.json`);
     return {
       intervalMs,
       staleThresholdMs,
@@ -44733,116 +45528,13 @@ function parseErrorCode(message) {
 }
 // packages/core/src/memory/sessions.ts
 init_src();
-// packages/core/src/migration/migrate-to-assistants.ts
-import { existsSync as existsSync12 } from "fs";
-import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile8, rename, cp } from "fs/promises";
-import { join as join20 } from "path";
-import { homedir as homedir10 } from "os";
-var MIGRATION_MARKER = ".migrated-from-oldpal";
-async function ensureDir(path2) {
-  await mkdir6(path2, { recursive: true });
-}
-async function copyIfExists(source, destination) {
-  if (!existsSync12(source))
-    return false;
-  await ensureDir(join20(destination, ".."));
-  await cp(source, destination, { recursive: true });
-  return true;
-}
-async function readJson(path2) {
-  if (!existsSync12(path2))
-    return null;
-  try {
-    const raw = await readFile9(path2, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-async function migrateFromOldpal() {
-  const result = {
-    success: false,
-    migrated: [],
-    errors: []
-  };
-  const home = homedir10();
-  const oldPath = join20(home, ".oldpal");
-  const newPath = join20(home, ".assistants");
-  if (!existsSync12(oldPath)) {
-    result.success = true;
-    return result;
-  }
-  if (existsSync12(newPath)) {
-    const marker = join20(newPath, "migration", MIGRATION_MARKER);
-    if (existsSync12(marker)) {
-      result.success = true;
-      return result;
-    }
-    result.errors.push("Both ~/.oldpal and ~/.assistants exist. Manual merge required.");
-    return result;
-  }
-  try {
-    await ensureDir(newPath);
-    await ensureDir(join20(newPath, "assistants"));
-    await ensureDir(join20(newPath, "shared", "skills"));
-    await ensureDir(join20(newPath, "logs"));
-    await ensureDir(join20(newPath, "migration"));
-    const config = await readJson(join20(oldPath, "settings.json"));
-    if (config) {
-      await writeFile8(join20(newPath, "config.json"), JSON.stringify(config, null, 2));
-      result.migrated.push("config.json");
-    }
-    if (await copyIfExists(join20(oldPath, "settings.local.json"), join20(newPath, "config.local.json"))) {
-      result.migrated.push("config.local.json");
-    }
-    if (await copyIfExists(join20(oldPath, "hooks.json"), join20(newPath, "hooks.json"))) {
-      result.migrated.push("hooks.json");
-    }
-    if (await copyIfExists(join20(oldPath, "commands"), join20(newPath, "commands"))) {
-      result.migrated.push("commands");
-    }
-    if (await copyIfExists(join20(oldPath, "OLDPAL.md"), join20(newPath, "ASSISTANTS.md"))) {
-      result.migrated.push("ASSISTANTS.md");
-    }
-    if (await copyIfExists(join20(oldPath, "skills"), join20(newPath, "shared", "skills"))) {
-      result.migrated.push("skills");
-    }
-    if (await copyIfExists(join20(oldPath, "logs"), join20(newPath, "logs"))) {
-      result.migrated.push("logs");
-    }
-    const manager = new AssistantManager(newPath);
-    await manager.initialize();
-    const assistant = await manager.createAssistant({
-      name: config?.llm?.model ? `Assistant (${config.llm.model})` : "Default Assistant",
-      settings: config?.llm ? {
-        model: config.llm.model,
-        maxTokens: config.llm.maxTokens
-      } : undefined
-    });
-    const identityManager = manager.getIdentityManager(assistant.id);
-    await identityManager.initialize();
-    await identityManager.createIdentity({ name: "Default" });
-    if (await copyIfExists(join20(oldPath, "sessions"), join20(newPath, "assistants", assistant.id, "sessions"))) {
-      result.migrated.push("sessions");
-    }
-    await writeFile8(join20(newPath, "migration", MIGRATION_MARKER), JSON.stringify({ migratedAt: new Date().toISOString() }, null, 2));
-    const backupPath = `${oldPath}.backup`;
-    await rename(oldPath, backupPath);
-    result.backupPath = backupPath;
-    result.migrated.push("backup");
-    result.success = true;
-  } catch (error) {
-    result.errors.push(`Migration failed: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  return result;
-}
 // packages/core/src/index.ts
 init_anthropic();
 // packages/core/src/client.ts
 init_src();
 
 // packages/core/src/logger.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync7, appendFileSync, readdirSync as readdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, appendFileSync, readdirSync as readdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
 import { join as join21 } from "path";
 class Logger {
   logDir;
@@ -44856,8 +45548,8 @@ class Logger {
     this.logFile = join21(this.logDir, `${date}.log`);
   }
   ensureDir(dir) {
-    if (!existsSync13(dir)) {
-      mkdirSync7(dir, { recursive: true });
+    if (!existsSync12(dir)) {
+      mkdirSync8(dir, { recursive: true });
     }
   }
   write(level, message, data) {
@@ -44902,13 +45594,13 @@ class SessionStorage {
     this.sessionFile = join21(this.sessionsDir, `${sessionId}.json`);
   }
   ensureDir(dir) {
-    if (!existsSync13(dir)) {
-      mkdirSync7(dir, { recursive: true });
+    if (!existsSync12(dir)) {
+      mkdirSync8(dir, { recursive: true });
     }
   }
   save(data) {
     try {
-      writeFileSync6(this.sessionFile, JSON.stringify(data, null, 2));
+      writeFileSync7(this.sessionFile, JSON.stringify(data, null, 2));
     } catch {}
   }
   getSessionId() {
@@ -44916,9 +45608,9 @@ class SessionStorage {
   }
   load() {
     try {
-      if (!existsSync13(this.sessionFile))
+      if (!existsSync12(this.sessionFile))
         return null;
-      return JSON.parse(readFileSync7(this.sessionFile, "utf-8"));
+      return JSON.parse(readFileSync8(this.sessionFile, "utf-8"));
     } catch {
       return null;
     }
@@ -44926,9 +45618,9 @@ class SessionStorage {
   static getActiveAssistantId() {
     try {
       const activePath = join21(getConfigDir(), "active.json");
-      if (!existsSync13(activePath))
+      if (!existsSync12(activePath))
         return null;
-      const raw = readFileSync7(activePath, "utf-8");
+      const raw = readFileSync8(activePath, "utf-8");
       const data = JSON.parse(raw);
       return data.id || null;
     } catch {
@@ -44940,7 +45632,7 @@ class SessionStorage {
     const resolvedId = assistantId ?? SessionStorage.getActiveAssistantId();
     if (resolvedId) {
       const assistantDir = join21(root, "assistants", resolvedId, "sessions");
-      if (existsSync13(assistantDir)) {
+      if (existsSync12(assistantDir)) {
         return assistantDir;
       }
     }
@@ -44948,17 +45640,17 @@ class SessionStorage {
   }
   static listSessions(assistantId) {
     const sessionsDir = SessionStorage.resolveSessionsDir(assistantId);
-    if (!existsSync13(sessionsDir))
+    if (!existsSync12(sessionsDir))
       return [];
     const sessions = [];
-    const files = readdirSync3(sessionsDir);
+    const files = readdirSync4(sessionsDir);
     for (const file of files) {
       if (!file.endsWith(".json"))
         continue;
       try {
         const filePath = join21(sessionsDir, file);
         const stat = Bun.file(filePath);
-        const content = JSON.parse(readFileSync7(filePath, "utf-8"));
+        const content = JSON.parse(readFileSync8(filePath, "utf-8"));
         sessions.push({
           id: file.replace(".json", ""),
           cwd: content.cwd,
@@ -44978,9 +45670,9 @@ class SessionStorage {
     const sessionsDir = SessionStorage.resolveSessionsDir(assistantId);
     const sessionFile = join21(sessionsDir, `${sessionId}.json`);
     try {
-      if (!existsSync13(sessionFile))
+      if (!existsSync12(sessionFile))
         return null;
-      return JSON.parse(readFileSync7(sessionFile, "utf-8"));
+      return JSON.parse(readFileSync8(sessionFile, "utf-8"));
     } catch {
       return null;
     }
@@ -45001,8 +45693,8 @@ function initAssistantsDir() {
     join21(baseDir, "migration")
   ];
   for (const dir of dirs) {
-    if (!existsSync13(dir)) {
-      mkdirSync7(dir, { recursive: true });
+    if (!existsSync12(dir)) {
+      mkdirSync8(dir, { recursive: true });
     }
   }
 }
@@ -45022,6 +45714,7 @@ class EmbeddedClient {
   assistantId = null;
   messageQueue = [];
   processingQueue = false;
+  sawErrorChunk = false;
   constructor(cwd2, options) {
     initAssistantsDir();
     const sessionId = options?.sessionId || generateId();
@@ -45041,6 +45734,9 @@ class EmbeddedClient {
         for (const callback of this.chunkCallbacks) {
           callback(chunk);
         }
+        if (chunk.type === "error") {
+          this.sawErrorChunk = true;
+        }
         if (chunk.type === "done" || chunk.type === "error") {
           queueMicrotask(() => {
             this.drainQueue();
@@ -45097,6 +45793,7 @@ class EmbeddedClient {
   }
   async processMessage(message) {
     this.logger.info("User message", { message });
+    this.sawErrorChunk = false;
     try {
       await this.agent.process(message);
       const context = this.agent.getContext();
@@ -45113,6 +45810,9 @@ class EmbeddedClient {
       }
       this.saveSession();
     } catch (error) {
+      if (this.sawErrorChunk) {
+        return;
+      }
       const err = error instanceof Error ? error : new Error(String(error));
       this.logger.error("Error processing message", { error: err.message });
       for (const callback of this.errorCallbacks) {
@@ -45267,6 +45967,9 @@ class SessionRegistry {
     const session = this.sessions.get(sessionId);
     if (session) {
       session.updatedAt = Date.now();
+      if (chunk.type === "text" || chunk.type === "tool_use" || chunk.type === "tool_result") {
+        session.isProcessing = true;
+      }
       if (chunk.type === "done" || chunk.type === "error" || chunk.type === "exit") {
         session.isProcessing = false;
       }
@@ -45374,7 +46077,6 @@ init_errors();
 init_src();
 
 // packages/terminal/src/components/App.tsx
-var import_react29 = __toESM(require_react(), 1);
 init_src();
 
 // packages/terminal/src/components/Input.tsx
@@ -46449,9 +47151,9 @@ function estimateToolPanelLines(toolCalls, toolResults, hasContent) {
   if (!toolCalls || toolCalls.length === 0) {
     return 0;
   }
-  const resultMap = new Set;
+  const resultLines = new Map;
   for (const result of toolResults || []) {
-    resultMap.add(result.toolCallId);
+    resultLines.set(result.toolCallId, estimateToolResultLines(result));
   }
   let lines = 3;
   if (hasContent) {
@@ -46459,26 +47161,53 @@ function estimateToolPanelLines(toolCalls, toolResults, hasContent) {
   }
   for (const call of toolCalls) {
     lines += 3;
-    if (resultMap.has(call.id)) {
-      lines += 1;
+    const toolResultLines = resultLines.get(call.id);
+    if (toolResultLines && toolResultLines > 0) {
+      lines += toolResultLines;
     }
   }
   return lines;
 }
-function estimateMessageLines(message) {
+function estimateToolResultLines(result, maxLines = 4) {
+  const content = String(result.content || "");
+  if (!content)
+    return 1;
+  const lines = content.replace(/\x1B\[[0-9;]*m/g, "").split(`
+`);
+  if (lines.length <= maxLines)
+    return Math.max(1, lines.length);
+  return maxLines + 1;
+}
+function estimateMessageLines(message, maxWidth) {
   if (message.role === "system") {
     return 0;
   }
   const content = message.content ?? "";
   const contentLines = content.length > 0 ? content.split(`
-`).length : 0;
-  const hasContent = contentLines > 0;
-  let lines = Math.max(1, contentLines);
+`) : [];
+  const hasContent = contentLines.length > 0;
+  const wrappedLines = contentLines.length > 0 ? countWrappedLines(contentLines, maxWidth) : 0;
+  let lines = hasContent ? Math.max(1, wrappedLines) : 0;
   if (message.role === "assistant" && message.toolCalls?.length) {
     lines += estimateToolPanelLines(message.toolCalls, message.toolResults, hasContent);
   }
   return lines;
 }
+function countWrappedLines(lines, maxWidth) {
+  if (!maxWidth || maxWidth <= 0) {
+    return lines.length;
+  }
+  let total = 0;
+  for (const line of lines) {
+    const visible = stripAnsi3(line).length;
+    const wrapped = Math.max(1, Math.ceil(visible / maxWidth));
+    total += wrapped;
+  }
+  return total;
+}
+function stripAnsi3(text) {
+  return text.replace(/\x1B\[[0-9;]*m/g, "");
+}
 
 // packages/terminal/src/components/Messages.tsx
 var jsx_dev_runtime3 = __toESM(require_jsx_dev_runtime(), 1);
@@ -46494,16 +47223,18 @@ function Messages4({
   queuedMessageIds
 }) {
   const [now2, setNow] = import_react24.useState(Date.now());
+  const { columns } = use_stdout_default();
+  const messageWidth = columns ? Math.max(10, columns - 2) : undefined;
   const combinedMessages = import_react24.useMemo(() => [...messages, ...streamingMessages], [messages, streamingMessages]);
   const lineSpans = import_react24.useMemo(() => {
     let cursor = 0;
     return combinedMessages.map((message, index) => {
-      const lines = estimateMessageLines(message);
+      const lines = estimateMessageLines(message, messageWidth);
       const start = cursor;
       cursor += lines;
       return { message, index, start, end: cursor, lines };
     });
-  }, [combinedMessages]);
+  }, [combinedMessages, messageWidth]);
   const totalLines = lineSpans.length > 0 ? lineSpans[lineSpans.length - 1].end : 0;
   const endLine = Math.max(0, totalLines - scrollOffsetLines);
   const startLine = Math.max(0, endLine - maxVisibleLines);
@@ -46511,6 +47242,7 @@ function Messages4({
   const historicalCount = messages.length;
   const visibleMessages = visibleSpans.filter((span) => span.index < historicalCount).map((span) => span.message);
   const visibleStreaming = visibleSpans.filter((span) => span.index >= historicalCount).map((span) => span.message);
+  const showCurrentResponse = Boolean(currentResponse) && streamingMessages.length === 0;
   const groupedMessages = groupConsecutiveToolMessages(visibleMessages);
   const historicalItems = groupedMessages.map((group) => {
     if (group.type === "single") {
@@ -46636,7 +47368,7 @@ function Messages4({
         message,
         queuedMessageIds
       }, message.id, false, undefined, this)),
-      currentResponse && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+      showCurrentResponse && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
         marginY: 1,
         children: [
           /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
@@ -47597,7 +48329,7 @@ function SessionSelector({
 
 // packages/terminal/src/components/App.tsx
 var jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
-var SHOW_ERROR_CODES = process.env.ASSISTANTS_DEBUG === "1" || process.env.OLDPAL_DEBUG === "1";
+var SHOW_ERROR_CODES = process.env.ASSISTANTS_DEBUG === "1";
 function parseErrorMessage(error) {
   const lines = error.split(`
 `);
@@ -47642,15 +48374,30 @@ function wrapTextLines(text, wrapChars) {
   }
   return lines;
 }
-function stripAnsi3(text) {
+function stripAnsi4(text) {
   return text.replace(/\x1B\[[0-9;]*m/g, "");
 }
+function truncateActivityContent(content, maxLines = 15, maxChars = 3000) {
+  let output = content.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+  output = output.replace(/\t/g, "  ");
+  const lines = output.split(`
+`);
+  if (lines.length > maxLines) {
+    output = lines.slice(0, maxLines).join(`
+`) + `
+... (${lines.length - maxLines} more lines)`;
+  }
+  if (output.length > maxChars) {
+    output = output.slice(0, maxChars) + "...";
+  }
+  return output;
+}
 function chunkRenderedLines(lines, chunkLines) {
   const chunks = [];
   let current = [];
   let i = 0;
-  const isBoxStart = (line) => stripAnsi3(line).trimStart().startsWith("\u250C");
-  const isBoxEnd = (line) => stripAnsi3(line).trimStart().startsWith("\u2514");
+  const isBoxStart = (line) => stripAnsi4(line).trimStart().startsWith("\u250C");
+  const isBoxEnd = (line) => stripAnsi4(line).trimStart().startsWith("\u2514");
   while (i < lines.length) {
     const line = lines[i];
     if (isBoxStart(line)) {
@@ -47760,9 +48507,14 @@ function App2({ cwd: cwd2, version }) {
   const prevDisplayLineCountRef = import_react29.useRef(0);
   const skipNextDoneRef = import_react29.useRef(false);
   const isProcessingRef = import_react29.useRef(isProcessing);
+  const processingStartTimeRef = import_react29.useRef(processingStartTime);
+  const turnIdRef = import_react29.useRef(0);
   import_react29.useEffect(() => {
     isProcessingRef.current = isProcessing;
   }, [isProcessing]);
+  import_react29.useEffect(() => {
+    processingStartTimeRef.current = processingStartTime;
+  }, [processingStartTime]);
   import_react29.useEffect(() => {
     if (isProcessing && !processingStartTime) {
       setProcessingStartTime(Date.now());
@@ -47815,8 +48567,8 @@ function App2({ cwd: cwd2, version }) {
 
 [error]` : "[error]";
     }
-    if (processingStartTime) {
-      const workedFor = formatElapsedDuration(Date.now() - processingStartTime);
+    if (processingStartTimeRef.current) {
+      const workedFor = formatElapsedDuration(Date.now() - processingStartTimeRef.current);
       content = content ? `${content}
 
 \u273B Worked for ${workedFor}` : `\u273B Worked for ${workedFor}`;
@@ -47833,7 +48585,7 @@ function App2({ cwd: cwd2, version }) {
       }
     ]);
     return true;
-  }, [buildFullResponse, processingStartTime]);
+  }, [buildFullResponse]);
   const resetTurnState = import_react29.useCallback(() => {
     setCurrentResponse("");
     responseRef.current = "";
@@ -47902,9 +48654,14 @@ function App2({ cwd: cwd2, version }) {
     setAutoScroll(true);
   }, []);
   const handleChunk = import_react29.useCallback((chunk) => {
-    if (!isProcessingRef.current && (chunk.type === "text" || chunk.type === "tool_use" || chunk.type === "tool_result")) {
+    const isStartChunk = chunk.type === "text" || chunk.type === "tool_use";
+    const isTerminalChunk = chunk.type === "error" || chunk.type === "done";
+    if (!isProcessingRef.current && (isStartChunk || isTerminalChunk)) {
       const active = registryRef.current.getActiveSession();
       if (active) {
+        turnIdRef.current += 1;
+        resetTurnState();
+        setError(null);
         registryRef.current.setProcessing(active.id, true);
         setIsProcessing(true);
         isProcessingRef.current = true;
@@ -48004,8 +48761,11 @@ function App2({ cwd: cwd2, version }) {
       if (active) {
         registryRef.current.setProcessing(active.id, false);
       }
+      const turnId = turnIdRef.current;
       queueMicrotask(() => {
-        resetTurnState();
+        if (!isProcessingRef.current && turnIdRef.current === turnId) {
+          resetTurnState();
+        }
       });
       const activeSession2 = registry2.getActiveSession();
       if (activeSession2) {
@@ -48102,8 +48862,94 @@ function App2({ cwd: cwd2, version }) {
   const activeQueue = activeSessionId ? messageQueue.filter((msg) => msg.sessionId === activeSessionId) : [];
   const activeInline = activeSessionId ? inlinePending.filter((msg) => msg.sessionId === activeSessionId) : [];
   const queuedMessageIds = import_react29.useMemo(() => new Set(activeQueue.filter((msg) => msg.mode === "queued").map((msg) => msg.id)), [activeQueue]);
+  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 MAX_QUEUED_PREVIEW = 3;
+  const truncateQueued = (text, maxLen = 80) => {
+    if (text.length <= maxLen)
+      return text;
+    return text.slice(0, maxLen - 3) + "...";
+  };
+  const queuedCount = activeQueue.filter((msg) => msg.mode === "queued").length;
+  const inlineCount = activeInline.length;
+  const showWelcome = messages.length === 0 && !isProcessing;
   const wrapChars = columns ? Math.max(40, columns - 4) : MESSAGE_WRAP_CHARS;
   const renderWidth = columns ? Math.max(20, columns - 2) : undefined;
+  const activityLogLineCount = import_react29.useMemo(() => {
+    if (activityLog.length === 0)
+      return 0;
+    let lines = 0;
+    for (const entry of activityLog) {
+      if (entry.type === "text" && entry.content) {
+        const rendered = renderMarkdown(entry.content, { maxWidth: renderWidth });
+        const entryLines = wrapTextLines(stripAnsi4(rendered), wrapChars).length;
+        lines += entryLines + 2;
+        continue;
+      }
+      if (entry.type === "tool_call" && entry.toolCall) {
+        lines += 4;
+        continue;
+      }
+      if (entry.type === "tool_result" && entry.toolResult) {
+        const truncated = truncateActivityContent(String(entry.toolResult.content ?? ""));
+        const entryLines = wrapTextLines(truncated, wrapChars).length;
+        lines += entryLines + 2;
+        continue;
+      }
+    }
+    return lines;
+  }, [activityLog, renderWidth, wrapChars]);
+  const reservedLines = import_react29.useMemo(() => {
+    let lines = 0;
+    if (showWelcome) {
+      lines += 5;
+    }
+    if (backgroundProcessingCount > 0) {
+      lines += 1;
+    }
+    if (scrollOffset > 0) {
+      lines += 1;
+    }
+    if (activeQueue.length > 0 || inlineCount > 0) {
+      const previewCount = Math.min(MAX_QUEUED_PREVIEW, activeQueue.length + inlineCount);
+      const hasMore = activeQueue.length + inlineCount > MAX_QUEUED_PREVIEW;
+      lines += 2;
+      lines += 1;
+      lines += previewCount;
+      if (hasMore)
+        lines += 1;
+    }
+    if (error) {
+      const parsed = parseErrorMessage(error);
+      const messageLines = parsed.message ? parsed.message.split(`
+`).length : 1;
+      const suggestionLines = parsed.suggestion ? parsed.suggestion.split(`
+`).length : 0;
+      lines += 2;
+      lines += Math.max(1, messageLines) + suggestionLines;
+    }
+    if (isProcessing) {
+      lines += 3;
+    }
+    lines += 1;
+    lines += 1;
+    if (isProcessing) {
+      lines += 2;
+    }
+    lines += 2;
+    return lines;
+  }, [
+    activeQueue.length,
+    inlineCount,
+    backgroundProcessingCount,
+    scrollOffset,
+    error,
+    isProcessing,
+    showWelcome
+  ]);
   const displayMessages = import_react29.useMemo(() => buildDisplayMessages(messages, MESSAGE_CHUNK_LINES, wrapChars, { maxWidth: renderWidth }), [messages, wrapChars, renderWidth]);
   const streamingMessages = import_react29.useMemo(() => {
     if (!isProcessing || !currentResponse.trim())
@@ -48118,8 +48964,9 @@ function App2({ cwd: cwd2, version }) {
   }, [currentResponse, isProcessing, wrapChars, renderWidth]);
   const displayLineCount = import_react29.useMemo(() => {
     const combined = [...displayMessages, ...streamingMessages];
-    return combined.reduce((sum, msg) => sum + estimateMessageLines(msg), 0);
-  }, [displayMessages, streamingMessages]);
+    return combined.reduce((sum, msg) => sum + estimateMessageLines(msg, renderWidth), 0);
+  }, [displayMessages, streamingMessages, renderWidth]);
+  const totalLineCount = displayLineCount + activityLogLineCount;
   import_react29.useEffect(() => {
     if (!isProcessing && activeQueue.length > 0) {
       processQueue();
@@ -48129,26 +48976,20 @@ function App2({ cwd: cwd2, version }) {
     if (autoScroll) {
       setScrollOffset(0);
     }
-  }, [displayLineCount, autoScroll]);
+  }, [totalLineCount, autoScroll]);
   import_react29.useEffect(() => {
     const prevCount = prevDisplayLineCountRef.current;
-    if (!autoScroll && displayLineCount > prevCount) {
-      const delta = displayLineCount - prevCount;
+    if (!autoScroll && totalLineCount > prevCount) {
+      const delta = totalLineCount - prevCount;
       setScrollOffset((prev) => prev + delta);
     }
-    prevDisplayLineCountRef.current = displayLineCount;
-  }, [displayLineCount, autoScroll]);
-  const reservedLines = 8;
-  const maxVisibleLines = rows ? Math.max(6, rows - reservedLines) : 20;
+    prevDisplayLineCountRef.current = totalLineCount;
+  }, [totalLineCount, autoScroll]);
+  const maxVisibleLines = rows ? Math.max(4, rows - reservedLines) : 20;
   import_react29.useEffect(() => {
-    const maxOffset = Math.max(0, displayLineCount - maxVisibleLines);
+    const maxOffset = Math.max(0, totalLineCount - maxVisibleLines);
     setScrollOffset((prev) => Math.min(prev, maxOffset));
-  }, [displayLineCount, maxVisibleLines]);
-  const sessions = registry2.listSessions();
-  const activeSession = registry2.getActiveSession();
-  const sessionIndex = activeSessionId ? registry2.getSessionIndex(activeSessionId) : 0;
-  const sessionCount = registry2.getSessionCount();
-  const backgroundProcessingCount = registry2.getBackgroundProcessingSessions().length;
+  }, [totalLineCount, maxVisibleLines]);
   const handleSessionSwitch = import_react29.useCallback(async (sessionId) => {
     setShowSessionSelector(false);
     if (sessionId === activeSessionId) {
@@ -48222,7 +49063,7 @@ function App2({ cwd: cwd2, version }) {
     }
     if (key.pageUp || key.shift && key.upArrow) {
       setScrollOffset((prev) => {
-        const maxOffset = Math.max(0, displayLineCount - maxVisibleLines);
+        const maxOffset = Math.max(0, totalLineCount - maxVisibleLines);
         const step = Math.max(3, Math.floor(maxVisibleLines / 2));
         const newOffset = Math.min(prev + step, maxOffset);
         if (newOffset > 0)
@@ -48240,7 +49081,7 @@ function App2({ cwd: cwd2, version }) {
       });
     }
     if (key.ctrl && input === "u") {
-      const maxOffset = Math.max(0, displayLineCount - maxVisibleLines);
+      const maxOffset = Math.max(0, totalLineCount - maxVisibleLines);
       setScrollOffset(maxOffset);
       setAutoScroll(false);
     }
@@ -48399,15 +49240,6 @@ function App2({ cwd: cwd2, version }) {
     return { toolCall: e.toolCall, result };
   });
   const isThinking = isProcessing && !currentResponse && !currentToolCall && toolCallEntries.length === 0;
-  const MAX_QUEUED_PREVIEW = 3;
-  const truncateQueued = (text, maxLen = 80) => {
-    if (text.length <= maxLen)
-      return text;
-    return text.slice(0, maxLen - 3) + "...";
-  };
-  const queuedCount = activeQueue.filter((msg) => msg.mode === "queued").length;
-  const inlineCount = activeInline.length;
-  const showWelcome = messages.length === 0 && !isProcessing;
   return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
     flexDirection: "column",
     padding: 1,
@@ -48714,7 +49546,7 @@ function formatStreamEvent(chunk) {
 
 // packages/terminal/src/index.tsx
 var jsx_dev_runtime10 = __toESM(require_jsx_dev_runtime(), 1);
-var VERSION3 = "0.6.21";
+var VERSION3 = "0.6.22";
 process.env.ASSISTANTS_VERSION ??= VERSION3;
 function parseArgs(argv) {
   const args = argv.slice(2);
@@ -48841,7 +49673,6 @@ Interactive Mode:
 `);
   process.exit(0);
 }
-migrateFromOldpal().catch(() => {});
 if (options.print !== null) {
   if (!options.print.trim()) {
     console.error("Error: Prompt is required with -p/--print flag");
@@ -48871,4 +49702,4 @@ if (options.print !== null) {
   });
 }
 
-//# debugId=9F87F41E551C4D1964756E2164756E21
+//# debugId=A428BC3DC0A7465964756E2164756E21