@hasna/assistants 0.6.18 → 0.6.20

package/dist/index.js

@@ -25630,7 +25630,7 @@ var __classPrivateFieldSet = function(receiver, state, value, kind2, f) {
   }
 }, startsWithSchemeRegexp, isAbsoluteURL = (url) => {
   return startsWithSchemeRegexp.test(url);
-}, sleep2 = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms)), validatePositiveInteger = (name, n) => {
+}, sleep2 = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms)), validatePositiveInteger = (name, n) => {
   if (typeof n !== "number" || !Number.isInteger(n)) {
     throw new AnthropicError(`${name} must be an integer`);
   }
@@ -25696,8 +25696,8 @@ var init_core = __esm(() => {
   init_uploads();
   APIPromise = class APIPromise extends Promise {
     constructor(responsePromise, parseResponse = defaultParseResponse) {
-      super((resolve4) => {
-        resolve4(null);
+      super((resolve5) => {
+        resolve5(null);
       });
       this.responsePromise = responsePromise;
       this.parseResponse = parseResponse;
@@ -26295,12 +26295,12 @@ var init_PromptCachingBetaMessageStream = __esm(() => {
         }
         return this._emit("error", new AnthropicError(String(error)));
       });
-      __classPrivateFieldSet2(this, _PromptCachingBetaMessageStream_connectedPromise, new Promise((resolve4, reject) => {
-        __classPrivateFieldSet2(this, _PromptCachingBetaMessageStream_resolveConnectedPromise, resolve4, "f");
+      __classPrivateFieldSet2(this, _PromptCachingBetaMessageStream_connectedPromise, new Promise((resolve5, reject) => {
+        __classPrivateFieldSet2(this, _PromptCachingBetaMessageStream_resolveConnectedPromise, resolve5, "f");
         __classPrivateFieldSet2(this, _PromptCachingBetaMessageStream_rejectConnectedPromise, reject, "f");
       }), "f");
-      __classPrivateFieldSet2(this, _PromptCachingBetaMessageStream_endPromise, new Promise((resolve4, reject) => {
-        __classPrivateFieldSet2(this, _PromptCachingBetaMessageStream_resolveEndPromise, resolve4, "f");
+      __classPrivateFieldSet2(this, _PromptCachingBetaMessageStream_endPromise, new Promise((resolve5, reject) => {
+        __classPrivateFieldSet2(this, _PromptCachingBetaMessageStream_resolveEndPromise, resolve5, "f");
         __classPrivateFieldSet2(this, _PromptCachingBetaMessageStream_rejectEndPromise, reject, "f");
       }), "f");
       __classPrivateFieldGet2(this, _PromptCachingBetaMessageStream_connectedPromise, "f").catch(() => {});
@@ -26390,11 +26390,11 @@ var init_PromptCachingBetaMessageStream = __esm(() => {
       return this;
     }
     emitted(event) {
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve5, reject) => {
         __classPrivateFieldSet2(this, _PromptCachingBetaMessageStream_catchingPromiseCreated, true, "f");
         if (event !== "error")
           this.once("error", reject);
-        this.once(event, resolve4);
+        this.once(event, resolve5);
       });
     }
     async done() {
@@ -26612,7 +26612,7 @@ var init_PromptCachingBetaMessageStream = __esm(() => {
             if (done) {
               return { value: undefined, done: true };
             }
-            return new Promise((resolve4, reject) => readQueue.push({ resolve: resolve4, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: undefined, done: true });
+            return new Promise((resolve5, reject) => readQueue.push({ resolve: resolve5, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: undefined, done: true });
           }
           const chunk = pushQueue.shift();
           return { value: chunk, done: false };
@@ -26758,12 +26758,12 @@ var init_MessageStream = __esm(() => {
         }
         return this._emit("error", new AnthropicError(String(error)));
       });
-      __classPrivateFieldSet3(this, _MessageStream_connectedPromise, new Promise((resolve4, reject) => {
-        __classPrivateFieldSet3(this, _MessageStream_resolveConnectedPromise, resolve4, "f");
+      __classPrivateFieldSet3(this, _MessageStream_connectedPromise, new Promise((resolve5, reject) => {
+        __classPrivateFieldSet3(this, _MessageStream_resolveConnectedPromise, resolve5, "f");
         __classPrivateFieldSet3(this, _MessageStream_rejectConnectedPromise, reject, "f");
       }), "f");
-      __classPrivateFieldSet3(this, _MessageStream_endPromise, new Promise((resolve4, reject) => {
-        __classPrivateFieldSet3(this, _MessageStream_resolveEndPromise, resolve4, "f");
+      __classPrivateFieldSet3(this, _MessageStream_endPromise, new Promise((resolve5, reject) => {
+        __classPrivateFieldSet3(this, _MessageStream_resolveEndPromise, resolve5, "f");
         __classPrivateFieldSet3(this, _MessageStream_rejectEndPromise, reject, "f");
       }), "f");
       __classPrivateFieldGet3(this, _MessageStream_connectedPromise, "f").catch(() => {});
@@ -26853,11 +26853,11 @@ var init_MessageStream = __esm(() => {
       return this;
     }
     emitted(event) {
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve5, reject) => {
         __classPrivateFieldSet3(this, _MessageStream_catchingPromiseCreated, true, "f");
         if (event !== "error")
           this.once("error", reject);
-        this.once(event, resolve4);
+        this.once(event, resolve5);
       });
     }
     async done() {
@@ -27075,7 +27075,7 @@ var init_MessageStream = __esm(() => {
             if (done) {
               return { value: undefined, done: true };
             }
-            return new Promise((resolve4, reject) => readQueue.push({ resolve: resolve4, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: undefined, done: true });
+            return new Promise((resolve5, reject) => readQueue.push({ resolve: resolve5, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: undefined, done: true });
           }
           const chunk = pushQueue.shift();
           return { value: chunk, done: false };
@@ -27292,11 +27292,11 @@ __export(exports_anthropic, {
 });
 import { readFileSync as readFileSync2, existsSync as existsSync7 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function loadApiKeyFromSecrets() {
   const envHome = process.env.HOME || process.env.USERPROFILE;
   const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir8();
-  const secretsPath = join11(homeDir, ".secrets");
+  const secretsPath = join12(homeDir, ".secrets");
   if (existsSync7(secretsPath)) {
     try {
       const content = readFileSync2(secretsPath, "utf-8");
@@ -35507,7 +35507,7 @@ var import_react20 = __toESM(require_react(), 1);
 var import_react21 = __toESM(require_react(), 1);
 // packages/core/src/agent/loop.ts
 init_src();
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // packages/core/src/agent/context.ts
 init_src();
@@ -35567,6 +35567,13 @@ class AgentContext {
     this.messages.push(message);
     return message;
   }
+  removeSystemMessages(predicate) {
+    this.messages = this.messages.filter((msg) => {
+      if (msg.role !== "system")
+        return true;
+      return !predicate(msg.content);
+    });
+  }
   getMessages() {
     return [...this.messages];
   }
@@ -36637,6 +36644,10 @@ function resolveTimeout(resolve) {
 class ConnectorBridge {
   connectors = new Map;
   static cache = new Map;
+  cwd;
+  constructor(cwd2) {
+    this.cwd = cwd2;
+  }
   getHomeDir() {
     const envHome = process.env.HOME || process.env.USERPROFILE;
     return envHome && envHome.trim().length > 0 ? envHome : homedir2();
@@ -36644,8 +36655,10 @@ class ConnectorBridge {
   autoDiscoverConnectorNames() {
     const connectorNames = new Set;
     const pathDirs = (process.env.PATH || "").split(delimiter);
+    const baseCwd = this.cwd || process.cwd();
     const homeDir = this.getHomeDir();
     const extraDirs = [
+      join3(baseCwd, "node_modules", ".bin"),
       join3(homeDir, ".bun", "bin"),
       join3(homeDir, ".npm-global", "bin"),
       "/usr/local/bin"
@@ -36888,17 +36901,20 @@ class ConnectorBridge {
       }
       const lowerCommand = command.toLowerCase();
       const lowerArgs = args.map((arg) => arg.toLowerCase());
-      const isAuthLogin = lowerCommand.includes("auth") && (lowerCommand.includes("login") || lowerCommand.includes("authorize")) || lowerCommand.includes("auth") && (lowerArgs.includes("login") || lowerArgs.includes("authorize")) || lowerArgs.includes("auth") && (lowerArgs.includes("login") || lowerArgs.includes("authorize"));
-      if (isAuthLogin) {
+      const combined = [lowerCommand, ...lowerArgs].join(" ");
+      const isAuthLogin = /\bauth\b/.test(combined) && /(login|authorize|authorization|oauth|signin|sign-in|connect)/.test(combined);
+      const runInBackground = options.background === true;
+      if (isAuthLogin || runInBackground) {
         try {
-          Bun.spawn(cmdParts, {
+          const proc = Bun.spawn(cmdParts, {
             cwd: cwd2,
             stdin: "ignore",
             stdout: "ignore",
             stderr: "pipe"
           });
+          proc.unref?.();
         } catch {}
-        return "Auth login started in the background. Complete it in your browser, then run auth status to confirm.";
+        return isAuthLogin ? "Auth login started in the background. Complete it in your browser, then run auth status to confirm." : "Command started in the background.";
       }
       try {
         const proc = Bun.spawn(cmdParts, {
@@ -37036,6 +37052,38 @@ function stripQuotedSegments(input) {
   }
   return result;
 }
+function normalizeNewlinesOutsideQuotes(input) {
+  let result = "";
+  let quote = null;
+  let escaped = false;
+  for (let i = 0;i < input.length; i += 1) {
+    const char = input[i];
+    if (quote) {
+      result += char;
+      if (quote === '"' && !escaped && char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (!escaped && char === quote) {
+        quote = null;
+      }
+      escaped = false;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      result += char;
+      continue;
+    }
+    if (char === "\r" || char === `
+`) {
+      result += " ";
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
 
 class BashTool {
   static tool = {
@@ -37155,7 +37203,11 @@ class BashTool {
     const command = input.command;
     const cwd2 = input.cwd || process.cwd();
     const timeout = input.timeout || 30000;
-    const commandForChecks = command.replace(/\s*2>&1\s*/g, " ");
+    const baseCommand = command.replace(/\s*2>&1\s*/g, " ").trim();
+    const baseTrimmed = baseCommand.toLowerCase();
+    const allowConnectorNewlines = baseTrimmed.startsWith("connect-");
+    const commandForExec = allowConnectorNewlines ? normalizeNewlinesOutsideQuotes(baseCommand).trim() : baseCommand;
+    const commandForChecks = commandForExec;
     const commandSansQuotes = stripQuotedSegments(commandForChecks);
     const securityCheck = validateBashCommand(commandForChecks);
     if (!securityCheck.valid) {
@@ -37229,7 +37281,7 @@ class BashTool {
       });
     }
     try {
-      const proc = Bun.spawn(["bash", "-c", command], {
+      const proc = Bun.spawn(["bash", "-c", commandForExec], {
         cwd: cwd2,
         stdout: "pipe",
         stderr: "pipe"
@@ -37356,15 +37408,16 @@ async function isPathSafe(targetPath, operation, options = {}) {
 
 // packages/core/src/tools/filesystem.ts
 var currentSessionId = "default";
-function getScriptsFolder(cwd2) {
+function getScriptsFolder(cwd2, sessionId) {
+  const resolvedSessionId = sessionId || currentSessionId;
   const legacyDir = join4(cwd2, ".oldpal");
   if (existsSync2(legacyDir)) {
-    return join4(legacyDir, "scripts", currentSessionId);
+    return join4(legacyDir, "scripts", resolvedSessionId);
   }
-  return join4(getProjectConfigDir(cwd2), "scripts", currentSessionId);
+  return join4(getProjectConfigDir(cwd2), "scripts", resolvedSessionId);
 }
-function isInScriptsFolder(path2, cwd2) {
-  const scriptsFolder = resolve3(getScriptsFolder(cwd2));
+function isInScriptsFolder(path2, cwd2, sessionId) {
+  const scriptsFolder = resolve3(getScriptsFolder(cwd2, sessionId));
   const resolved = resolve3(path2);
   if (resolved === scriptsFolder)
     return true;
@@ -37520,7 +37573,7 @@ class FilesystemTools {
     const filename = input.filename || input.path;
     const content = input.content;
     const baseCwd = input.cwd || process.cwd();
-    const scriptsFolder = getScriptsFolder(baseCwd);
+    const scriptsFolder = getScriptsFolder(baseCwd, input.sessionId);
     if (!filename || !filename.trim()) {
       throw new ToolExecutionError("Filename is required", {
         toolName: "write",
@@ -37533,7 +37586,7 @@ class FilesystemTools {
     }
     const sanitizedFilename = filename.replace(/\.\.[/\\]/g, "").replace(/\.\./g, "").replace(/^[/\\]+/, "");
     const path2 = join4(scriptsFolder, sanitizedFilename);
-    if (!isInScriptsFolder(path2, baseCwd)) {
+    if (!isInScriptsFolder(path2, baseCwd, input.sessionId)) {
       throw new ToolExecutionError(`Cannot write outside scripts folder. Files are saved to ${scriptsFolder}`, {
         toolName: "write",
         toolInput: input,
@@ -38775,6 +38828,10 @@ class SchedulerTool {
           type: "string",
           description: "Optional description for this schedule"
         },
+        sessionId: {
+          type: "string",
+          description: "Session id to scope the schedule to"
+        },
         id: {
           type: "string",
           description: "Schedule id (for delete/pause/resume)"
@@ -38819,6 +38876,7 @@ class SchedulerTool {
         createdAt: now2,
         updatedAt: now2,
         createdBy: "agent",
+        sessionId: typeof input.sessionId === "string" ? input.sessionId : undefined,
         command,
         description: input.description,
         status: "active",
@@ -39732,13 +39790,217 @@ ${stderr}`;
   }
 }
 // packages/core/src/commands/builtin.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { homedir as homedir7, platform as platform2, release, arch } from "os";
 import { existsSync as existsSync6, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
 init_src();
-var VERSION = "0.6.14";
-function resolveAuthTimeout(resolve4) {
-  resolve4({ exitCode: 1, stdout: { toString: () => "{}" } });
+
+// packages/core/src/projects/store.ts
+init_src();
+import { join as join10 } 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");
+}
+function projectPath(cwd2, id) {
+  return join10(projectsDir(cwd2), `${id}.json`);
+}
+async function ensureProjectsDir(cwd2) {
+  await mkdir3(projectsDir(cwd2), { recursive: true });
+}
+function normalizeName(name) {
+  return name.trim().toLowerCase();
+}
+async function listProjects(cwd2) {
+  try {
+    const dir = projectsDir(cwd2);
+    const files = await readdir2(dir);
+    const projects = [];
+    for (const file of files) {
+      if (!file.endsWith(".json"))
+        continue;
+      try {
+        const raw = await readFile2(join10(dir, file), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed?.id && parsed?.name) {
+          projects.push(parsed);
+        }
+      } catch {}
+    }
+    return projects.sort((a, b) => b.updatedAt - a.updatedAt);
+  } catch {
+    return [];
+  }
+}
+async function readProject(cwd2, id) {
+  try {
+    const raw = await readFile2(projectPath(cwd2, id), "utf-8");
+    const project = JSON.parse(raw);
+    if (!project?.id || !project?.name)
+      return null;
+    return project;
+  } catch {
+    return null;
+  }
+}
+async function findProjectByName(cwd2, name) {
+  const normalized = normalizeName(name);
+  const projects = await listProjects(cwd2);
+  return projects.find((project) => normalizeName(project.name) === normalized) || null;
+}
+async function saveProject(cwd2, project) {
+  await ensureProjectsDir(cwd2);
+  await writeFile2(projectPath(cwd2, project.id), JSON.stringify(project, null, 2), "utf-8");
+}
+async function deleteProject(cwd2, id) {
+  try {
+    await unlink2(projectPath(cwd2, id));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function createProject(cwd2, name, description) {
+  const now2 = Date.now();
+  const project = {
+    id: generateId(),
+    name: name.trim(),
+    description: description?.trim() || undefined,
+    createdAt: now2,
+    updatedAt: now2,
+    context: [],
+    plans: []
+  };
+  await saveProject(cwd2, project);
+  return project;
+}
+async function updateProject(cwd2, id, updater) {
+  const project = await readProject(cwd2, id);
+  if (!project)
+    return null;
+  const updated = updater(project);
+  await saveProject(cwd2, updated);
+  return updated;
+}
+async function ensureDefaultProject(cwd2) {
+  const projects = await listProjects(cwd2);
+  if (projects.length > 0)
+    return projects[0];
+  return createProject(cwd2, "default", "Default project for this folder");
+}
+function hasProjectNameConflict(projects, name) {
+  const normalized = normalizeName(name);
+  return projects.some((project) => normalizeName(project.name) === normalized);
+}
+
+// packages/core/src/projects/context.ts
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+var DEFAULT_MAX_FILE_BYTES = 12000;
+function formatPlan(plan) {
+  const lines = [];
+  lines.push(`- ${plan.title} (${plan.steps.length} steps)`);
+  for (const step of plan.steps) {
+    lines.push(`  - [${step.status}] ${step.text}`);
+  }
+  return lines.join(`
+`);
+}
+function normalizeEntryLabel(entry) {
+  return entry.label ? entry.label.trim() : entry.value.trim();
+}
+async function renderFileEntry(entry, options) {
+  const rawPath = entry.value.trim();
+  const resolved = resolve4(options.cwd, rawPath);
+  const validation = await validatePath(resolved, { allowedPaths: [options.cwd] });
+  if (!validation.valid) {
+    return `- File: ${rawPath} (unavailable: ${validation.error || "invalid path"})`;
+  }
+  let content = "";
+  try {
+    const data = await readFile3(validation.resolved, "utf-8");
+    const limit = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+    if (data.length > limit) {
+      content = `${data.slice(0, limit)}
+
+... [truncated ${data.length - limit} chars]`;
+    } else {
+      content = data;
+    }
+  } catch (error) {
+    return `- File: ${rawPath} (unavailable: ${error instanceof Error ? error.message : String(error)})`;
+  }
+  return `- File: ${rawPath}
+\`\`\`
+${content}
+\`\`\``;
+}
+function renderConnectorEntry(entry, connectors) {
+  const name = entry.value.trim();
+  const connector = connectors?.find((c) => c.name === name);
+  if (!connector) {
+    return `- Connector: ${name}`;
+  }
+  const lines = [];
+  lines.push(`- Connector: ${connector.name}`);
+  if (connector.description) {
+    lines.push(`  - ${connector.description}`);
+  }
+  if (connector.cli) {
+    lines.push(`  - CLI: ${connector.cli}`);
+  }
+  if (connector.commands && connector.commands.length > 0) {
+    const subset = connector.commands.slice(0, 5);
+    for (const cmd of subset) {
+      lines.push(`  - ${cmd.name}: ${cmd.description}`);
+    }
+    if (connector.commands.length > subset.length) {
+      lines.push(`  - ... ${connector.commands.length - subset.length} more commands`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function renderGenericEntry(entry) {
+  const label = normalizeEntryLabel(entry);
+  return `- ${entry.type}: ${label}`;
+}
+async function buildProjectContext(project, options) {
+  const lines = [];
+  lines.push(`## Project: ${project.name}`);
+  if (project.description) {
+    lines.push(`Description: ${project.description}`);
+  }
+  if (project.context.length > 0) {
+    lines.push("");
+    lines.push("### Project Context");
+    for (const entry of project.context) {
+      if (entry.type === "file") {
+        lines.push(await renderFileEntry(entry, options));
+        continue;
+      }
+      if (entry.type === "connector") {
+        lines.push(renderConnectorEntry(entry, options.connectors));
+        continue;
+      }
+      lines.push(renderGenericEntry(entry));
+    }
+  }
+  if (project.plans.length > 0) {
+    lines.push("");
+    lines.push("### Plans");
+    for (const plan of project.plans) {
+      lines.push(formatPlan(plan));
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// packages/core/src/commands/builtin.ts
+var VERSION = process.env.ASSISTANTS_VERSION || process.env.npm_package_version || process.env.OLDPAL_VERSION || "unknown";
+function resolveAuthTimeout(resolve5) {
+  resolve5({ exitCode: 1, stdout: { toString: () => "{}" } });
 }
 function splitArgs(input) {
   const args = [];
@@ -39787,6 +40049,8 @@ class BuiltinCommands {
     loader.register(this.statusCommand());
     loader.register(this.tokensCommand());
     loader.register(this.contextCommand());
+    loader.register(this.projectsCommand());
+    loader.register(this.plansCommand());
     loader.register(this.summarizeCommand());
     loader.register(this.restCommand());
     loader.register(this.voiceCommand());
@@ -40392,148 +40656,740 @@ Identities:
   contextCommand() {
     return {
       name: "context",
-      description: "Show context summarization status",
+      description: "Manage injected project context (files, connectors, notes) or show status",
       builtin: true,
       selfHandled: true,
       content: "",
       handler: async (args, context) => {
-        const info = context.getContextInfo?.();
-        if (!info) {
+        const parts = splitArgs(args);
+        const sub = parts[0] || "status";
+        if (sub === "help") {
+          const usage = [
+            "Usage:",
+            "  /context status",
+            "  /context list",
+            "  /context add file <path>",
+            "  /context add connector <name>",
+            "  /context add database <name>",
+            "  /context add note <text>",
+            "  /context add entity <text>",
+            "  /context remove <id>",
+            "  /context clear"
+          ].join(`
+`);
           context.emit("text", `
-Context summarization is not available.
+${usage}
 `);
           context.emit("done");
           return { handled: true };
         }
-        const { config, state } = info;
-        const usedPercent = Math.round(state.totalTokens / config.maxContextTokens * 100);
-        let message = `
+        if (sub === "status") {
+          const info = context.getContextInfo?.();
+          if (!info) {
+            context.emit("text", `
+Context summarization is not available.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const { config, state } = info;
+          const usedPercent = Math.round(state.totalTokens / config.maxContextTokens * 100);
+          let message = `
 **Context Status**
 
 `;
-        message += `**Messages:** ${state.messageCount}
+          message += `**Messages:** ${state.messageCount}
 `;
-        message += `**Estimated Tokens:** ${state.totalTokens.toLocaleString()} / ${config.maxContextTokens.toLocaleString()} (${usedPercent}%)
+          message += `**Estimated Tokens:** ${state.totalTokens.toLocaleString()} / ${config.maxContextTokens.toLocaleString()} (${usedPercent}%)
 `;
-        message += `**Summary Count:** ${state.summaryCount}
+          message += `**Summary Count:** ${state.summaryCount}
 `;
-        message += `**Strategy:** ${config.summaryStrategy}
+          message += `**Strategy:** ${config.summaryStrategy}
 `;
-        message += `**Keep Recent Messages:** ${config.keepRecentMessages}
+          message += `**Keep Recent Messages:** ${config.keepRecentMessages}
 `;
-        if (state.lastSummaryAt) {
-          message += `**Last Summary:** ${state.lastSummaryAt}
+          if (state.lastSummaryAt) {
+            message += `**Last Summary:** ${state.lastSummaryAt}
 `;
-          if (state.lastSummaryTokensBefore && state.lastSummaryTokensAfter) {
-            message += `**Last Summary Tokens:** ${state.lastSummaryTokensBefore.toLocaleString()} -> ${state.lastSummaryTokensAfter.toLocaleString()}
+            if (state.lastSummaryTokensBefore && state.lastSummaryTokensAfter) {
+              message += `**Last Summary Tokens:** ${state.lastSummaryTokensBefore.toLocaleString()} -> ${state.lastSummaryTokensAfter.toLocaleString()}
 `;
+            }
           }
-        }
-        const barLength = 30;
-        const filledLength = Math.round(usedPercent / 100 * barLength);
-        const bar = "\u2588".repeat(filledLength) + "\u2591".repeat(barLength - filledLength);
-        message += `
+          const barLength = 30;
+          const filledLength = Math.round(usedPercent / 100 * barLength);
+          const bar = "\u2588".repeat(filledLength) + "\u2591".repeat(barLength - filledLength);
+          message += `
 [${bar}] ${usedPercent}%
 `;
-        context.emit("text", message);
-        context.emit("done");
-        return { handled: true };
-      }
-    };
-  }
-  summarizeCommand() {
-    return {
-      name: "summarize",
-      description: "Summarize and compress the current conversation",
-      builtin: true,
-      selfHandled: true,
-      content: "",
-      handler: async (args, context) => {
-        if (!context.summarizeContext) {
-          context.emit("text", `
-Context summarization is not available.
-`);
+          context.emit("text", message);
           context.emit("done");
           return { handled: true };
         }
-        const result = await context.summarizeContext();
-        if (!result.summarized) {
-          context.emit("text", `
-Nothing to summarize right now.
+        const project = await this.ensureActiveProject(context, true);
+        if (!project) {
+          context.emit("text", `No project found. Use /projects new <name> first.
 `);
           context.emit("done");
           return { handled: true };
         }
-        let message = `
-**Context Summary Generated**
-
-`;
-        message += `Summarized ${result.summarizedCount} message(s).
-`;
-        message += `Tokens: ${result.tokensBefore.toLocaleString()} -> ${result.tokensAfter.toLocaleString()}
+        if (sub === "list") {
+          if (project.context.length === 0) {
+            context.emit("text", `
+No context entries for project "${project.name}".
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          let output = `
+**Context Entries (${project.name})**
 
 `;
-        if (result.summary) {
-          message += `${result.summary}
+          for (const entry of project.context) {
+            const label = entry.label ? ` (${entry.label})` : "";
+            output += `- ${entry.id} [${entry.type}] ${entry.value}${label}
 `;
+          }
+          context.emit("text", output);
+          context.emit("done");
+          return { handled: true };
         }
-        context.emit("text", message);
+        if (sub === "clear") {
+          const updated = await updateProject(context.cwd, project.id, (current) => ({
+            ...current,
+            context: [],
+            updatedAt: Date.now()
+          }));
+          if (updated) {
+            await this.applyProjectContext(context, updated);
+            context.emit("text", `Cleared context entries for "${updated.name}".
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+        }
+        if (sub === "remove") {
+          const id = parts[1];
+          if (!id) {
+            context.emit("text", `Usage: /context remove <id>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          if (!project.context.some((entry) => entry.id === id)) {
+            context.emit("text", `Context entry not found: ${id}
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const updated = await updateProject(context.cwd, project.id, (current) => ({
+            ...current,
+            context: current.context.filter((entry) => entry.id !== id),
+            updatedAt: Date.now()
+          }));
+          if (updated) {
+            await this.applyProjectContext(context, updated);
+            context.emit("text", `Removed context entry ${id} from "${updated.name}".
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+        }
+        if (sub === "add") {
+          const type = parts[1];
+          const value = parts.slice(2).join(" ").trim();
+          if (!type) {
+            context.emit("text", `Usage: /context add <type> <value>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const allowedTypes = ["file", "connector", "database", "note", "entity"];
+          const entryType = allowedTypes.includes(type) ? type : "note";
+          const entryValue = entryType === "note" && !value ? parts.slice(1).join(" ").trim() : value;
+          if (!entryValue) {
+            context.emit("text", `Error: context value is required.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const entry = {
+            id: generateId(),
+            type: entryType,
+            value: entryValue,
+            addedAt: Date.now()
+          };
+          const updated = await updateProject(context.cwd, project.id, (current) => ({
+            ...current,
+            context: [...current.context, entry],
+            updatedAt: Date.now()
+          }));
+          if (updated) {
+            await this.applyProjectContext(context, updated);
+            context.emit("text", `Added ${entry.type} context to "${updated.name}".
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+        }
+        context.emit("text", `Unknown /context command. Use /context help.
+`);
         context.emit("done");
         return { handled: true };
       }
     };
   }
-  restCommand() {
+  projectsCommand() {
     return {
-      name: "rest",
-      description: "Recharge assistant energy",
+      name: "projects",
+      description: "Manage projects inside this folder",
       builtin: true,
       selfHandled: true,
       content: "",
       handler: async (args, context) => {
-        if (!context.restEnergy) {
+        const parts = splitArgs(args);
+        const sub = parts[0] || "list";
+        if (sub === "help") {
+          const usage = [
+            "Usage:",
+            "  /projects list",
+            "  /projects new <name>",
+            "  /projects use <id|name>",
+            "  /projects show [id|name]",
+            "  /projects delete <id|name>",
+            "  /projects describe <id|name> <description>"
+          ].join(`
+`);
           context.emit("text", `
-Energy system is not available.
+${usage}
 `);
           context.emit("done");
           return { handled: true };
         }
-        const parsed = parseInt(args.trim(), 10);
-        const amount = Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
-        context.restEnergy(amount);
-        const state = context.getEnergyState?.();
-        if (state) {
-          const percent = Math.round(state.current / Math.max(1, state.max) * 100);
-          context.emit("text", `
-Energy restored. Current level: ${percent}% (${state.current}/${state.max}).
-`);
-        } else {
-          context.emit("text", `
-Energy restored.
+        if (sub === "list" || sub === "ls") {
+          const projects = await listProjects(context.cwd);
+          if (projects.length === 0) {
+            context.emit("text", `
+No projects found. Use /projects new <name>.
 `);
-        }
-        context.emit("done");
-        return { handled: true };
-      }
-    };
-  }
-  skillsCommand(loader) {
-    return {
-      name: "skills",
-      description: "List available skills",
-      builtin: true,
-      selfHandled: true,
-      content: "",
-      handler: async (args, context) => {
-        let message = `
-**Available Skills**
-
-`;
-        message += `Skills are invoked with $skill-name [arguments] or /skill-name [arguments]
+            context.emit("done");
+            return { handled: true };
+          }
+          const activeId = context.getActiveProjectId?.();
+          let output = `
+**Projects**
 
 `;
-        if (context.skills.length === 0) {
-          message += `No skills loaded.
+          for (const project of projects) {
+            const marker = project.id === activeId ? "*" : " ";
+            output += `${marker} ${project.name} (${project.id})
+`;
+          }
+          context.emit("text", output);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (sub === "new" || sub === "create") {
+          const name = parts.slice(1).join(" ").trim();
+          if (!name) {
+            context.emit("text", `Usage: /projects new <name>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const existing = await listProjects(context.cwd);
+          if (hasProjectNameConflict(existing, name)) {
+            context.emit("text", `Project "${name}" already exists.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const project = await createProject(context.cwd, name);
+          context.setActiveProjectId?.(project.id);
+          await this.applyProjectContext(context, project);
+          context.emit("text", `Created project "${project.name}" (${project.id}).
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (sub === "use" || sub === "switch") {
+          const target = parts.slice(1).join(" ").trim();
+          if (!target) {
+            context.emit("text", `Usage: /projects use <id|name>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const project = await this.resolveProject(context, target);
+          if (!project) {
+            context.emit("text", `Project not found: ${target}
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          context.setActiveProjectId?.(project.id);
+          await this.applyProjectContext(context, project);
+          context.emit("text", `Switched to project "${project.name}".
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (sub === "show" || sub === "info") {
+          const target = parts.slice(1).join(" ").trim();
+          const project = target ? await this.resolveProject(context, target) : await this.ensureActiveProject(context, false);
+          if (!project) {
+            context.emit("text", `No project selected. Use /projects use <id|name>.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          let output = `
+**Project: ${project.name}**
+
+`;
+          output += `ID: ${project.id}
+`;
+          if (project.description) {
+            output += `Description: ${project.description}
+`;
+          }
+          output += `Context entries: ${project.context.length}
+`;
+          output += `Plans: ${project.plans.length}
+`;
+          context.emit("text", output);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (sub === "describe" || sub === "desc") {
+          const target = parts[1];
+          const description = parts.slice(2).join(" ").trim();
+          if (!target || !description) {
+            context.emit("text", `Usage: /projects describe <id|name> <description>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const project = await this.resolveProject(context, target);
+          if (!project) {
+            context.emit("text", `Project not found: ${target}
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const updated = await updateProject(context.cwd, project.id, (current) => ({
+            ...current,
+            description,
+            updatedAt: Date.now()
+          }));
+          if (updated) {
+            await this.applyProjectContext(context, updated);
+            context.emit("text", `Updated project "${updated.name}".
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+        }
+        if (sub === "delete" || sub === "rm") {
+          const target = parts.slice(1).join(" ").trim();
+          if (!target) {
+            context.emit("text", `Usage: /projects delete <id|name>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const project = await this.resolveProject(context, target);
+          if (!project) {
+            context.emit("text", `Project not found: ${target}
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const ok = await deleteProject(context.cwd, project.id);
+          if (ok) {
+            if (context.getActiveProjectId?.() === project.id) {
+              context.setActiveProjectId?.(null);
+              context.setProjectContext?.(null);
+            }
+            context.emit("text", `Deleted project "${project.name}".
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+        }
+        context.emit("text", `Unknown /projects command. Use /projects help.
+`);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  plansCommand() {
+    return {
+      name: "plans",
+      description: "Manage plans linked to the active project",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        const parts = splitArgs(args);
+        const sub = parts[0] || "list";
+        if (sub === "help") {
+          const usage = [
+            "Usage:",
+            "  /plans list",
+            "  /plans new <title>",
+            "  /plans show <planId>",
+            "  /plans add <planId> <step>",
+            "  /plans set <planId> <stepId> <todo|doing|done|blocked>",
+            "  /plans remove <planId> <stepId>",
+            "  /plans delete <planId>"
+          ].join(`
+`);
+          context.emit("text", `
+${usage}
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        const project = await this.ensureActiveProject(context, true);
+        if (!project) {
+          context.emit("text", `No project found. Use /projects new <name> first.
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (sub === "list" || sub === "ls") {
+          if (project.plans.length === 0) {
+            context.emit("text", `
+No plans for project "${project.name}".
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          let output = `
+**Plans (${project.name})**
+
+`;
+          for (const plan of project.plans) {
+            output += `- ${plan.id} ${plan.title} (${plan.steps.length} steps)
+`;
+          }
+          context.emit("text", output);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (sub === "new" || sub === "create") {
+          const title = parts.slice(1).join(" ").trim();
+          if (!title) {
+            context.emit("text", `Usage: /plans new <title>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const now2 = Date.now();
+          const plan = {
+            id: generateId(),
+            title,
+            createdAt: now2,
+            updatedAt: now2,
+            steps: []
+          };
+          const updated = await updateProject(context.cwd, project.id, (current) => ({
+            ...current,
+            plans: [...current.plans, plan],
+            updatedAt: now2
+          }));
+          if (updated) {
+            await this.applyProjectContext(context, updated);
+            context.emit("text", `Created plan "${plan.title}" (${plan.id}).
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+        }
+        if (sub === "show") {
+          const id = parts[1];
+          if (!id) {
+            context.emit("text", `Usage: /plans show <planId>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const plan = project.plans.find((p) => p.id === id);
+          if (!plan) {
+            context.emit("text", `Plan not found: ${id}
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          let output = `
+**Plan: ${plan.title}**
+
+`;
+          output += `ID: ${plan.id}
+`;
+          if (plan.steps.length === 0) {
+            output += `No steps yet.
+`;
+          } else {
+            for (const step of plan.steps) {
+              output += `- ${step.id} [${step.status}] ${step.text}
+`;
+            }
+          }
+          context.emit("text", output);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (sub === "add") {
+          const planId = parts[1];
+          const text = parts.slice(2).join(" ").trim();
+          if (!planId || !text) {
+            context.emit("text", `Usage: /plans add <planId> <step>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          if (!project.plans.some((plan) => plan.id === planId)) {
+            context.emit("text", `Plan not found: ${planId}
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const now2 = Date.now();
+          const step = {
+            id: generateId(),
+            text,
+            status: "todo",
+            createdAt: now2,
+            updatedAt: now2
+          };
+          const updated = await updateProject(context.cwd, project.id, (current) => ({
+            ...current,
+            plans: current.plans.map((plan) => plan.id === planId ? { ...plan, steps: [...plan.steps, step], updatedAt: now2 } : plan),
+            updatedAt: now2
+          }));
+          if (updated) {
+            await this.applyProjectContext(context, updated);
+            context.emit("text", `Added step to plan ${planId}.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+        }
+        if (sub === "set") {
+          const planId = parts[1];
+          const stepId = parts[2];
+          const status = parts[3];
+          if (!planId || !stepId || !status) {
+            context.emit("text", `Usage: /plans set <planId> <stepId> <todo|doing|done|blocked>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const plan = project.plans.find((item) => item.id === planId);
+          if (!plan) {
+            context.emit("text", `Plan not found: ${planId}
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          if (!plan.steps.some((step) => step.id === stepId)) {
+            context.emit("text", `Step not found: ${stepId}
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const allowed = ["todo", "doing", "done", "blocked"];
+          if (!allowed.includes(status)) {
+            context.emit("text", `Invalid status. Use todo, doing, done, or blocked.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const now2 = Date.now();
+          const updated = await updateProject(context.cwd, project.id, (current) => ({
+            ...current,
+            plans: current.plans.map((plan2) => plan2.id === planId ? {
+              ...plan2,
+              steps: plan2.steps.map((step) => step.id === stepId ? { ...step, status, updatedAt: now2 } : step),
+              updatedAt: now2
+            } : plan2),
+            updatedAt: now2
+          }));
+          if (updated) {
+            await this.applyProjectContext(context, updated);
+            context.emit("text", `Updated step ${stepId} to ${status}.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+        }
+        if (sub === "remove") {
+          const planId = parts[1];
+          const stepId = parts[2];
+          if (!planId || !stepId) {
+            context.emit("text", `Usage: /plans remove <planId> <stepId>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const plan = project.plans.find((item) => item.id === planId);
+          if (!plan) {
+            context.emit("text", `Plan not found: ${planId}
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          if (!plan.steps.some((step) => step.id === stepId)) {
+            context.emit("text", `Step not found: ${stepId}
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const now2 = Date.now();
+          const updated = await updateProject(context.cwd, project.id, (current) => ({
+            ...current,
+            plans: current.plans.map((plan2) => plan2.id === planId ? { ...plan2, steps: plan2.steps.filter((step) => step.id !== stepId), updatedAt: now2 } : plan2),
+            updatedAt: now2
+          }));
+          if (updated) {
+            await this.applyProjectContext(context, updated);
+            context.emit("text", `Removed step ${stepId} from plan ${planId}.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+        }
+        if (sub === "delete" || sub === "rm") {
+          const planId = parts[1];
+          if (!planId) {
+            context.emit("text", `Usage: /plans delete <planId>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          if (!project.plans.some((plan) => plan.id === planId)) {
+            context.emit("text", `Plan not found: ${planId}
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const now2 = Date.now();
+          const updated = await updateProject(context.cwd, project.id, (current) => ({
+            ...current,
+            plans: current.plans.filter((plan) => plan.id !== planId),
+            updatedAt: now2
+          }));
+          if (updated) {
+            await this.applyProjectContext(context, updated);
+            context.emit("text", `Deleted plan ${planId}.
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+        }
+        context.emit("text", `Unknown /plans command. Use /plans help.
+`);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  summarizeCommand() {
+    return {
+      name: "summarize",
+      description: "Summarize and compress the current conversation",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        if (!context.summarizeContext) {
+          context.emit("text", `
+Context summarization is not available.
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        const result = await context.summarizeContext();
+        if (!result.summarized) {
+          context.emit("text", `
+Nothing to summarize right now.
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        let message = `
+**Context Summary Generated**
+
+`;
+        message += `Summarized ${result.summarizedCount} message(s).
+`;
+        message += `Tokens: ${result.tokensBefore.toLocaleString()} -> ${result.tokensAfter.toLocaleString()}
+
+`;
+        if (result.summary) {
+          message += `${result.summary}
+`;
+        }
+        context.emit("text", message);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  restCommand() {
+    return {
+      name: "rest",
+      description: "Recharge assistant energy",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        if (!context.restEnergy) {
+          context.emit("text", `
+Energy system is not available.
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        const parsed = parseInt(args.trim(), 10);
+        const amount = Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+        context.restEnergy(amount);
+        const state = context.getEnergyState?.();
+        if (state) {
+          const percent = Math.round(state.current / Math.max(1, state.max) * 100);
+          context.emit("text", `
+Energy restored. Current level: ${percent}% (${state.current}/${state.max}).
+`);
+        } else {
+          context.emit("text", `
+Energy restored.
+`);
+        }
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  skillsCommand(loader) {
+    return {
+      name: "skills",
+      description: "List available skills",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        let message = `
+**Available Skills**
+
+`;
+        message += `Skills are invoked with $skill-name [arguments] or /skill-name [arguments]
+
+`;
+        if (context.skills.length === 0) {
+          message += `No skills loaded.
 `;
           message += `
 Add skills to ~/.assistants/assistants-shared/skills/ or .assistants/skills/
@@ -40557,7 +41413,7 @@ ${context.skills.length} skill(s) available.
   statusCommand() {
     return {
       name: "status",
-      description: "Show current session status and token usage",
+      description: "Show current session status, energy, identity, and token usage",
       builtin: true,
       selfHandled: true,
       content: "",
@@ -40567,11 +41423,46 @@ ${context.skills.length} skill(s) available.
         let message = `
 **Session Status**
 
+`;
+        message += `**Session ID:** ${context.sessionId}
 `;
         message += `**Working Directory:** ${context.cwd}
 `;
-        message += `**Session ID:** ${context.sessionId}
+        const assistant = context.getAssistantManager?.()?.getActive();
+        const identity = context.getIdentityManager?.()?.getActive();
+        if (assistant) {
+          message += `**Assistant:** ${assistant.name}`;
+          if (identity) {
+            message += ` \xB7 ${identity.name}`;
+          }
+          message += `
+`;
+        }
+        const energyState = context.getEnergyState?.();
+        if (energyState) {
+          const energyPercent = Math.round(energyState.current / Math.max(1, energyState.max) * 100);
+          const energyBar = "\u2588".repeat(Math.round(energyPercent / 10)) + "\u2591".repeat(10 - Math.round(energyPercent / 10));
+          const energyEmoji = energyPercent > 70 ? "\u26A1" : energyPercent > 30 ? "\uD83D\uDD0B" : "\uD83E\uDEAB";
+          message += `**Energy:** ${energyEmoji} [${energyBar}] ${energyPercent}% (${energyState.current}/${energyState.max})
+`;
+        }
+        const voiceState = context.getVoiceState?.();
+        if (voiceState?.enabled) {
+          const voiceActivity = voiceState.isSpeaking ? "speaking" : voiceState.isListening ? "listening" : "idle";
+          message += `**Voice:** ${voiceActivity}`;
+          if (voiceState.sttProvider || voiceState.ttsProvider) {
+            message += ` (STT: ${voiceState.sttProvider || "n/a"}, TTS: ${voiceState.ttsProvider || "n/a"})`;
+          }
+          message += `
+`;
+        }
+        if (context.getActiveProjectId) {
+          const projectId = context.getActiveProjectId();
+          if (projectId) {
+            message += `**Active Project:** ${projectId}
 `;
+          }
+        }
         message += `**Messages:** ${context.messages.length}
 `;
         message += `**Available Tools:** ${context.tools.length}
@@ -40658,9 +41549,9 @@ Format the summary as a brief bullet-point list. This summary will replace the c
       content: "",
       handler: async (args, context) => {
         const configPaths = [
-          join10(context.cwd, ".assistants", "config.json"),
-          join10(context.cwd, ".assistants", "config.local.json"),
-          join10(getConfigDir(), "config.json")
+          join11(context.cwd, ".assistants", "config.json"),
+          join11(context.cwd, ".assistants", "config.local.json"),
+          join11(getConfigDir(), "config.json")
         ];
         let message = `
 **Configuration**
@@ -40678,9 +41569,9 @@ Format the summary as a brief bullet-point list. This summary will replace the c
         message += `
 **Commands Directories:**
 `;
-        message += `  - Project: ${join10(context.cwd, ".assistants", "commands")}
+        message += `  - Project: ${join11(context.cwd, ".assistants", "commands")}
 `;
-        message += `  - Global: ${join10(homeDir, ".assistants", "commands")}
+        message += `  - Global: ${join11(homeDir, ".assistants", "commands")}
 `;
         context.emit("text", message);
         context.emit("done");
@@ -40696,7 +41587,7 @@ Format the summary as a brief bullet-point list. This summary will replace the c
       selfHandled: true,
       content: "",
       handler: async (args, context) => {
-        const commandsDir = join10(context.cwd, ".assistants", "commands");
+        const commandsDir = join11(context.cwd, ".assistants", "commands");
         mkdirSync2(commandsDir, { recursive: true });
         const exampleCommand = `---
 name: reflect
@@ -40712,7 +41603,7 @@ Please summarize the last interaction and suggest 2-3 next steps.
 - Focus on clarity
 - Ask a follow-up question if needed
 `;
-        const examplePath = join10(commandsDir, "reflect.md");
+        const examplePath = join11(commandsDir, "reflect.md");
         if (!existsSync6(examplePath)) {
           writeFileSync3(examplePath, exampleCommand);
         }
@@ -40862,6 +41753,7 @@ Keep it concise but comprehensive.`
           createdAt: now2,
           updatedAt: now2,
           createdBy: "user",
+          sessionId: context.sessionId,
           command,
           status: "active",
           schedule: {
@@ -41032,8 +41924,8 @@ Connector "${connectorName}" not found.
 `;
           try {
             let timeoutId = null;
-            const timeoutPromise = new Promise((resolve4) => {
-              timeoutId = setTimeout(resolveAuthTimeout, 1000, resolve4);
+            const timeoutPromise = new Promise((resolve5) => {
+              timeoutId = setTimeout(resolveAuthTimeout, 1000, resolve5);
             });
             const result = await Promise.race([
               Bun.$`${connector.cli} auth status --format json`.quiet().nothrow(),
@@ -41095,8 +41987,8 @@ Connector "${connectorName}" not found.
             let status = "\u25CB";
             let timeoutId = null;
             try {
-              const timeoutPromise = new Promise((resolve4) => {
-                timeoutId = setTimeout(resolveAuthTimeout, 1000, resolve4);
+              const timeoutPromise = new Promise((resolve5) => {
+                timeoutId = setTimeout(resolveAuthTimeout, 1000, resolve5);
               });
               const result = await Promise.race([
                 Bun.$`${connector.cli} auth status --format json`.quiet().nothrow(),
@@ -41371,6 +42263,35 @@ ${repoUrl}/issues/new
       }
     };
   }
+  async resolveProject(context, target) {
+    const byId = await readProject(context.cwd, target);
+    if (byId)
+      return byId;
+    return findProjectByName(context.cwd, target);
+  }
+  async ensureActiveProject(context, createIfMissing) {
+    const activeId = context.getActiveProjectId?.();
+    if (activeId) {
+      const project2 = await readProject(context.cwd, activeId);
+      if (project2)
+        return project2;
+    }
+    if (!createIfMissing)
+      return null;
+    const project = await ensureDefaultProject(context.cwd);
+    context.setActiveProjectId?.(project.id);
+    await this.applyProjectContext(context, project);
+    return project;
+  }
+  async applyProjectContext(context, project) {
+    if (!context.setProjectContext)
+      return;
+    const projectContext = await buildProjectContext(project, {
+      cwd: context.cwd,
+      connectors: context.connectors
+    });
+    context.setProjectContext(projectContext);
+  }
 }
 // packages/core/src/llm/client.ts
 async function createLLMClient(config) {
@@ -41384,7 +42305,7 @@ async function createLLMClient(config) {
 // packages/core/src/heartbeat/manager.ts
 import { dirname as dirname5 } from "path";
 import { mkdirSync as mkdirSync3 } from "fs";
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 
 class HeartbeatManager {
   config;
@@ -41463,12 +42384,12 @@ class HeartbeatManager {
   }
   async persist(heartbeat) {
     try {
-      await writeFile2(this.config.persistPath, JSON.stringify(heartbeat, null, 2));
+      await writeFile3(this.config.persistPath, JSON.stringify(heartbeat, null, 2));
     } catch {}
   }
   static async checkStale(path2, thresholdMs) {
     try {
-      const content = await readFile2(path2, "utf-8");
+      const content = await readFile4(path2, "utf-8");
       const heartbeat = JSON.parse(content);
       const age = Date.now() - new Date(heartbeat.timestamp).getTime();
       return { isStale: age > thresholdMs, lastHeartbeat: heartbeat };
@@ -41480,7 +42401,7 @@ class HeartbeatManager {
 // packages/core/src/heartbeat/persistence.ts
 import { dirname as dirname6 } from "path";
 import { mkdirSync as mkdirSync4 } from "fs";
-import { readFile as readFile3, writeFile as writeFile3, unlink as unlink2 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile4, unlink as unlink3 } from "fs/promises";
 
 class StatePersistence {
   path;
@@ -41490,12 +42411,12 @@ class StatePersistence {
   }
   async save(state) {
     try {
-      await writeFile3(this.path, JSON.stringify(state, null, 2));
+      await writeFile4(this.path, JSON.stringify(state, null, 2));
     } catch {}
   }
   async load() {
     try {
-      const content = await readFile3(this.path, "utf-8");
+      const content = await readFile5(this.path, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -41503,7 +42424,7 @@ class StatePersistence {
   }
   async clear() {
     try {
-      await unlink2(this.path);
+      await unlink3(this.path);
     } catch {}
   }
 }
@@ -41707,7 +42628,7 @@ class EnergyManager {
 // packages/core/src/energy/storage.ts
 import { dirname as dirname7 } from "path";
 import { mkdirSync as mkdirSync5 } from "fs";
-import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
 
 class EnergyStorage {
   path;
@@ -41717,12 +42638,12 @@ class EnergyStorage {
   }
   async save(state) {
     try {
-      await writeFile4(this.path, JSON.stringify(state, null, 2));
+      await writeFile5(this.path, JSON.stringify(state, null, 2));
     } catch {}
   }
   async load() {
     try {
-      const content = await readFile4(this.path, "utf-8");
+      const content = await readFile6(this.path, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -41782,12 +42703,12 @@ function validateToolCalls(toolCalls, tools) {
 // packages/core/src/voice/utils.ts
 import { existsSync as existsSync8, readFileSync as readFileSync3 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } 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 = join12(homeDir, ".secrets");
+  const secretsPath = join13(homeDir, ".secrets");
   if (!existsSync8(secretsPath))
     return;
   try {
@@ -41861,7 +42782,7 @@ class SystemSTT {
 // packages/core/src/voice/tts.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import { readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "fs";
 class ElevenLabsTTS {
   apiKey;
@@ -41965,7 +42886,7 @@ class SystemTTS {
       if (!say) {
         throw new Error('System TTS not available: missing "say" command.');
       }
-      const output = join13(tmpdir2(), `assistants-tts-${Date.now()}.aiff`);
+      const output = join14(tmpdir2(), `assistants-tts-${Date.now()}.aiff`);
       const args = [];
       if (this.voiceId) {
         args.push("-v", this.voiceId);
@@ -41987,7 +42908,7 @@ class SystemTTS {
     }
     const espeak = findExecutable("espeak") || findExecutable("espeak-ng");
     if (espeak) {
-      const output = join13(tmpdir2(), `assistants-tts-${Date.now()}.wav`);
+      const output = join14(tmpdir2(), `assistants-tts-${Date.now()}.wav`);
       const args = ["-w", output];
       if (this.voiceId) {
         args.push("-v", this.voiceId);
@@ -42014,32 +42935,32 @@ class SystemTTS {
 // packages/core/src/voice/player.ts
 import { spawn } from "child_process";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join14 } from "path";
-import { unlink as unlink3, writeFileSync as writeFileSync4 } from "fs";
+import { join as join15 } from "path";
+import { unlink as unlink4, writeFileSync as writeFileSync4 } from "fs";
 class AudioPlayer {
   currentProcess = null;
   playing = false;
   async play(audio, options = {}) {
     const format = options.format ?? "mp3";
-    const tempFile = join14(tmpdir3(), `assistants-audio-${Date.now()}.${format}`);
+    const tempFile = join15(tmpdir3(), `assistants-audio-${Date.now()}.${format}`);
     writeFileSync4(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.");
     }
-    await new Promise((resolve4, reject) => {
+    await new Promise((resolve5, reject) => {
       this.playing = true;
       this.currentProcess = spawn(player.command, [...player.args, tempFile], { stdio: "ignore" });
       this.currentProcess.on("close", () => {
         this.playing = false;
         this.currentProcess = null;
-        unlink3(tempFile, () => {});
-        resolve4();
+        unlink4(tempFile, () => {});
+        resolve5();
       });
       this.currentProcess.on("error", (error) => {
         this.playing = false;
         this.currentProcess = null;
-        unlink3(tempFile, () => {});
+        unlink4(tempFile, () => {});
         reject(error);
       });
     });
@@ -42089,8 +43010,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 join15 } from "path";
-import { readFileSync as readFileSync5, unlink as unlink4 } from "fs";
+import { join as join16 } from "path";
+import { readFileSync as readFileSync5, unlink as unlink5 } from "fs";
 class AudioRecorder {
   currentProcess = null;
   async record(options = {}) {
@@ -42100,17 +43021,17 @@ class AudioRecorder {
     const duration = options.durationSeconds ?? 5;
     const sampleRate = options.sampleRate ?? 16000;
     const channels = options.channels ?? 1;
-    const output = join15(tmpdir4(), `assistants-record-${Date.now()}.wav`);
+    const output = join16(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.");
     }
-    await new Promise((resolve4, reject) => {
+    await new Promise((resolve5, reject) => {
       this.currentProcess = spawn2(recorder.command, recorder.args, { stdio: "ignore" });
       this.currentProcess.on("close", (code) => {
         this.currentProcess = null;
         if (code === 0) {
-          resolve4();
+          resolve5();
         } else {
           reject(new Error("Audio recording failed."));
         }
@@ -42121,7 +43042,7 @@ class AudioRecorder {
       });
     });
     const data = readFileSync5(output);
-    unlink4(output, () => {});
+    unlink5(output, () => {});
     return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
   }
   stop() {
@@ -42293,14 +43214,14 @@ class VoiceManager {
 // packages/core/src/identity/assistant-manager.ts
 init_src();
 import { existsSync as existsSync10 } from "fs";
-import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile6, rm as rm2 } from "fs/promises";
-import { join as join17 } from "path";
+import { mkdir as mkdir5, readFile as readFile8, writeFile as writeFile7, rm as rm2 } from "fs/promises";
+import { join as join18 } from "path";
 
 // packages/core/src/identity/identity-manager.ts
 init_src();
 import { existsSync as existsSync9 } from "fs";
-import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile5, rm } from "fs/promises";
-import { join as join16 } from "path";
+import { mkdir as mkdir4, readFile as readFile7, writeFile as writeFile6, rm } from "fs/promises";
+import { join as join17 } from "path";
 var DEFAULT_PROFILE = {
   displayName: "Assistant",
   timezone: "UTC",
@@ -42330,22 +43251,22 @@ class IdentityManager {
     this.basePath = basePath;
   }
   get identitiesRoot() {
-    return join16(this.basePath, "assistants", this.assistantId, "identities");
+    return join17(this.basePath, "assistants", this.assistantId, "identities");
   }
   get indexPath() {
-    return join16(this.identitiesRoot, "index.json");
+    return join17(this.identitiesRoot, "index.json");
   }
   get activePath() {
-    return join16(this.identitiesRoot, "active.json");
+    return join17(this.identitiesRoot, "active.json");
   }
   identityPath(id) {
-    return join16(this.identitiesRoot, `${id}.json`);
+    return join17(this.identitiesRoot, `${id}.json`);
   }
   assistantConfigPath() {
-    return join16(this.basePath, "assistants", this.assistantId, "config.json");
+    return join17(this.basePath, "assistants", this.assistantId, "config.json");
   }
   async initialize() {
-    await mkdir3(this.identitiesRoot, { recursive: true });
+    await mkdir4(this.identitiesRoot, { recursive: true });
     const index = await this.readIndex();
     for (const id of index.identities) {
       const identity = await this.readIdentity(id);
@@ -42452,7 +43373,7 @@ class IdentityManager {
       return { identities: [] };
     }
     try {
-      const raw = await readFile5(this.indexPath, "utf-8");
+      const raw = await readFile7(this.indexPath, "utf-8");
       const data = JSON.parse(raw);
       return { identities: Array.isArray(data.identities) ? data.identities : [] };
     } catch {
@@ -42464,33 +43385,33 @@ class IdentityManager {
     if (!index.identities.includes(id)) {
       index.identities.push(id);
     }
-    await writeFile5(this.indexPath, JSON.stringify(index, null, 2));
+    await writeFile6(this.indexPath, JSON.stringify(index, null, 2));
   }
   async removeFromIndex(id) {
     const index = await this.readIndex();
     index.identities = index.identities.filter((identityId) => identityId !== id);
-    await writeFile5(this.indexPath, JSON.stringify(index, null, 2));
+    await writeFile6(this.indexPath, JSON.stringify(index, null, 2));
   }
   async readIdentity(id) {
     const path2 = this.identityPath(id);
     if (!existsSync9(path2))
       return null;
     try {
-      const raw = await readFile5(path2, "utf-8");
+      const raw = await readFile7(path2, "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
     }
   }
   async persistIdentity(identity) {
-    await mkdir3(this.identitiesRoot, { recursive: true });
-    await writeFile5(this.identityPath(identity.id), JSON.stringify(identity, null, 2));
+    await mkdir4(this.identitiesRoot, { recursive: true });
+    await writeFile6(this.identityPath(identity.id), JSON.stringify(identity, null, 2));
   }
   async readActive() {
     if (!existsSync9(this.activePath))
       return null;
     try {
-      const raw = await readFile5(this.activePath, "utf-8");
+      const raw = await readFile7(this.activePath, "utf-8");
       const data = JSON.parse(raw);
       return data.id || null;
     } catch {
@@ -42499,13 +43420,13 @@ class IdentityManager {
   }
   async setActive(id) {
     this.activeId = id;
-    await writeFile5(this.activePath, JSON.stringify({ id }, null, 2));
+    await writeFile6(this.activePath, JSON.stringify({ id }, null, 2));
   }
   async loadAssistant() {
     if (!existsSync9(this.assistantConfigPath()))
       return null;
     try {
-      const raw = await readFile5(this.assistantConfigPath(), "utf-8");
+      const raw = await readFile7(this.assistantConfigPath(), "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -42526,19 +43447,19 @@ class AssistantManager {
     this.basePath = basePath;
   }
   get assistantsRoot() {
-    return join17(this.basePath, "assistants");
+    return join18(this.basePath, "assistants");
   }
   get indexPath() {
-    return join17(this.assistantsRoot, "index.json");
+    return join18(this.assistantsRoot, "index.json");
   }
   get activePath() {
-    return join17(this.basePath, "active.json");
+    return join18(this.basePath, "active.json");
   }
   assistantConfigPath(id) {
-    return join17(this.assistantsRoot, id, "config.json");
+    return join18(this.assistantsRoot, id, "config.json");
   }
   async initialize() {
-    await mkdir4(this.assistantsRoot, { recursive: true });
+    await mkdir5(this.assistantsRoot, { recursive: true });
     const index = await this.readIndex();
     for (const id of index.assistants) {
       const assistant = await this.readAssistant(id);
@@ -42589,7 +43510,7 @@ class AssistantManager {
     if (!this.assistants.has(id)) {
       throw new Error(`Assistant ${id} not found`);
     }
-    await rm2(join17(this.assistantsRoot, id), { recursive: true, force: true });
+    await rm2(join18(this.assistantsRoot, id), { recursive: true, force: true });
     this.assistants.delete(id);
     await this.removeFromIndex(id);
     if (this.activeId === id) {
@@ -42624,7 +43545,7 @@ class AssistantManager {
       return { assistants: [] };
     }
     try {
-      const raw = await readFile6(this.indexPath, "utf-8");
+      const raw = await readFile8(this.indexPath, "utf-8");
       const data = JSON.parse(raw);
       return { assistants: Array.isArray(data.assistants) ? data.assistants : [] };
     } catch {
@@ -42636,34 +43557,34 @@ class AssistantManager {
     if (!index.assistants.includes(id)) {
       index.assistants.push(id);
     }
-    await writeFile6(this.indexPath, JSON.stringify(index, null, 2));
+    await writeFile7(this.indexPath, JSON.stringify(index, null, 2));
   }
   async removeFromIndex(id) {
     const index = await this.readIndex();
     index.assistants = index.assistants.filter((assistantId) => assistantId !== id);
-    await writeFile6(this.indexPath, JSON.stringify(index, null, 2));
+    await writeFile7(this.indexPath, JSON.stringify(index, null, 2));
   }
   async readAssistant(id) {
     const configPath = this.assistantConfigPath(id);
     if (!existsSync10(configPath))
       return null;
     try {
-      const raw = await readFile6(configPath, "utf-8");
+      const raw = await readFile8(configPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
     }
   }
   async persistAssistant(assistant) {
-    const dir = join17(this.assistantsRoot, assistant.id);
-    await mkdir4(dir, { recursive: true });
-    await writeFile6(this.assistantConfigPath(assistant.id), JSON.stringify(assistant, null, 2));
+    const dir = join18(this.assistantsRoot, assistant.id);
+    await mkdir5(dir, { recursive: true });
+    await writeFile7(this.assistantConfigPath(assistant.id), JSON.stringify(assistant, null, 2));
   }
   async readActive() {
     if (!existsSync10(this.activePath))
       return null;
     try {
-      const raw = await readFile6(this.activePath, "utf-8");
+      const raw = await readFile8(this.activePath, "utf-8");
       const data = JSON.parse(raw);
       return data.id || null;
     } catch {
@@ -42672,7 +43593,7 @@ class AssistantManager {
   }
   async setActive(id) {
     this.activeId = id;
-    await writeFile6(this.activePath, JSON.stringify({ id }, null, 2));
+    await writeFile7(this.activePath, JSON.stringify({ id }, null, 2));
   }
 }
 // packages/core/src/agent/loop.ts
@@ -42717,6 +43638,8 @@ class AgentLoop {
   assistantManager = null;
   identityManager = null;
   identityContext = null;
+  projectContext = null;
+  activeProjectId = null;
   assistantId = null;
   onChunk;
   onToolStart;
@@ -42729,7 +43652,7 @@ class AgentLoop {
     this.context = new AgentContext;
     this.toolRegistry = new ToolRegistry;
     this.toolRegistry.setErrorAggregator(this.errorAggregator);
-    this.connectorBridge = new ConnectorBridge;
+    this.connectorBridge = new ConnectorBridge(this.cwd);
     this.skillLoader = new SkillLoader;
     this.skillExecutor = new SkillExecutor;
     this.hookLoader = new HookLoader;
@@ -43032,9 +43955,13 @@ class AgentLoop {
       });
       if (preHookResult?.updatedInput) {
         toolCall.input = { ...preHookResult.updatedInput };
-        if (toolCall.input.cwd === undefined) {
-          toolCall.input.cwd = this.cwd;
-        }
+      }
+      const input = toolCall.input;
+      if (input.cwd === undefined) {
+        input.cwd = this.cwd;
+      }
+      if (input.sessionId === undefined) {
+        input.sessionId = this.sessionId;
       }
       if (preHookResult?.continue === false || preHookResult?.permissionDecision === "deny") {
         const blockedResult = {
@@ -43158,6 +44085,13 @@ class AgentLoop {
       switchIdentity: async (identityId) => {
         await this.switchIdentity(identityId);
       },
+      getActiveProjectId: () => this.activeProjectId,
+      setActiveProjectId: (projectId) => {
+        this.activeProjectId = projectId;
+      },
+      setProjectContext: (content) => {
+        this.setProjectContext(content);
+      },
       getVoiceState: () => this.getVoiceState(),
       enableVoice: () => {
         if (!this.voiceManager) {
@@ -43345,6 +44279,22 @@ class AgentLoop {
   getSessionId() {
     return this.sessionId;
   }
+  getActiveProjectId() {
+    return this.activeProjectId;
+  }
+  setActiveProjectId(projectId) {
+    this.activeProjectId = projectId;
+  }
+  setProjectContext(content) {
+    const tag = "[Project Context]";
+    this.projectContext = content;
+    this.context.removeSystemMessages((message) => message.startsWith(tag));
+    if (content && content.trim()) {
+      this.context.addSystemMessage(`${tag}
+${content.trim()}`);
+    }
+    this.contextManager?.refreshState(this.context.getMessages());
+  }
   clearConversation() {
     this.resetContext();
   }
@@ -43356,7 +44306,7 @@ class AgentLoop {
     const heartbeatConfig = this.buildHeartbeatConfig(this.config);
     if (!heartbeatConfig)
       return;
-    const statePath = join18(getConfigDir(), "state", `${this.sessionId}.json`);
+    const statePath = join19(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, {
@@ -43405,7 +44355,7 @@ class AgentLoop {
   async startEnergySystem() {
     if (!this.config || this.config.energy?.enabled === false)
       return;
-    const statePath = join18(getConfigDir(), "energy", "state.json");
+    const statePath = join19(getConfigDir(), "energy", "state.json");
     this.energyManager = new EnergyManager(this.config.energy, new EnergyStorage(statePath));
     await this.energyManager.initialize();
     this.refreshEnergyEffects();
@@ -43434,7 +44384,7 @@ ${effects.message}
     const delay = this.energyEffects?.processingDelayMs ?? 0;
     if (delay <= 0)
       return;
-    await new Promise((resolve4) => setTimeout(resolve4, delay));
+    await new Promise((resolve5) => setTimeout(resolve5, delay));
   }
   applyEnergyPersonality(systemPrompt) {
     if (!systemPrompt)
@@ -43461,6 +44411,9 @@ ${effects.message}
       const now2 = Date.now();
       const due = await getDueSchedules(this.cwd, now2);
       for (const schedule of due) {
+        if (schedule.sessionId && schedule.sessionId !== this.sessionId) {
+          continue;
+        }
         const locked = await acquireScheduleLock(this.cwd, schedule.id, this.sessionId);
         if (!locked)
           continue;
@@ -43490,7 +44443,7 @@ ${effects.message}
         if (!schedule)
           break;
         const current = await readSchedule(this.cwd, schedule.id);
-        if (!current || current.status !== "active" || !current.nextRunAt || current.nextRunAt > Date.now()) {
+        if (!current || current.status !== "active" || !current.nextRunAt || current.nextRunAt > Date.now() || current.sessionId && current.sessionId !== this.sessionId) {
           await releaseScheduleLock(this.cwd, schedule.id, this.sessionId);
           continue;
         }
@@ -43542,6 +44495,9 @@ ${effects.message}
     if (this.extraSystemPrompt) {
       this.context.addSystemMessage(this.extraSystemPrompt);
     }
+    if (this.projectContext) {
+      this.setProjectContext(this.projectContext);
+    }
     this.contextManager?.refreshState(this.context.getMessages());
   }
   buildSystemPrompt(messages) {
@@ -43628,7 +44584,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 ?? join18(getConfigDir(), "heartbeats", `${this.sessionId}.json`);
+    const persistPath = config.heartbeat?.persistPath ?? join19(getConfigDir(), "heartbeats", `${this.sessionId}.json`);
     return {
       intervalMs,
       staleThresholdMs,
@@ -43720,17 +44676,17 @@ function parseErrorCode(message) {
 init_src();
 // packages/core/src/migration/migrate-to-assistants.ts
 import { existsSync as existsSync11 } from "fs";
-import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile7, rename, cp } from "fs/promises";
-import { join as join19 } from "path";
+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 mkdir5(path2, { recursive: true });
+  await mkdir6(path2, { recursive: true });
 }
 async function copyIfExists(source, destination) {
   if (!existsSync11(source))
     return false;
-  await ensureDir(join19(destination, ".."));
+  await ensureDir(join20(destination, ".."));
   await cp(source, destination, { recursive: true });
   return true;
 }
@@ -43738,7 +44694,7 @@ async function readJson(path2) {
   if (!existsSync11(path2))
     return null;
   try {
-    const raw = await readFile7(path2, "utf-8");
+    const raw = await readFile9(path2, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -43751,14 +44707,14 @@ async function migrateFromOldpal() {
     errors: []
   };
   const home = homedir10();
-  const oldPath = join19(home, ".oldpal");
-  const newPath = join19(home, ".assistants");
+  const oldPath = join20(home, ".oldpal");
+  const newPath = join20(home, ".assistants");
   if (!existsSync11(oldPath)) {
     result.success = true;
     return result;
   }
   if (existsSync11(newPath)) {
-    const marker = join19(newPath, "migration", MIGRATION_MARKER);
+    const marker = join20(newPath, "migration", MIGRATION_MARKER);
     if (existsSync11(marker)) {
       result.success = true;
       return result;
@@ -43768,31 +44724,31 @@ async function migrateFromOldpal() {
   }
   try {
     await ensureDir(newPath);
-    await ensureDir(join19(newPath, "assistants"));
-    await ensureDir(join19(newPath, "shared", "skills"));
-    await ensureDir(join19(newPath, "logs"));
-    await ensureDir(join19(newPath, "migration"));
-    const config = await readJson(join19(oldPath, "settings.json"));
+    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 writeFile7(join19(newPath, "config.json"), JSON.stringify(config, null, 2));
+      await writeFile8(join20(newPath, "config.json"), JSON.stringify(config, null, 2));
       result.migrated.push("config.json");
     }
-    if (await copyIfExists(join19(oldPath, "settings.local.json"), join19(newPath, "config.local.json"))) {
+    if (await copyIfExists(join20(oldPath, "settings.local.json"), join20(newPath, "config.local.json"))) {
       result.migrated.push("config.local.json");
     }
-    if (await copyIfExists(join19(oldPath, "hooks.json"), join19(newPath, "hooks.json"))) {
+    if (await copyIfExists(join20(oldPath, "hooks.json"), join20(newPath, "hooks.json"))) {
       result.migrated.push("hooks.json");
     }
-    if (await copyIfExists(join19(oldPath, "commands"), join19(newPath, "commands"))) {
+    if (await copyIfExists(join20(oldPath, "commands"), join20(newPath, "commands"))) {
       result.migrated.push("commands");
     }
-    if (await copyIfExists(join19(oldPath, "OLDPAL.md"), join19(newPath, "ASSISTANTS.md"))) {
+    if (await copyIfExists(join20(oldPath, "OLDPAL.md"), join20(newPath, "ASSISTANTS.md"))) {
       result.migrated.push("ASSISTANTS.md");
     }
-    if (await copyIfExists(join19(oldPath, "skills"), join19(newPath, "shared", "skills"))) {
+    if (await copyIfExists(join20(oldPath, "skills"), join20(newPath, "shared", "skills"))) {
       result.migrated.push("skills");
     }
-    if (await copyIfExists(join19(oldPath, "logs"), join19(newPath, "logs"))) {
+    if (await copyIfExists(join20(oldPath, "logs"), join20(newPath, "logs"))) {
       result.migrated.push("logs");
     }
     const manager = new AssistantManager(newPath);
@@ -43807,10 +44763,10 @@ async function migrateFromOldpal() {
     const identityManager = manager.getIdentityManager(assistant.id);
     await identityManager.initialize();
     await identityManager.createIdentity({ name: "Default" });
-    if (await copyIfExists(join19(oldPath, "sessions"), join19(newPath, "assistants", assistant.id, "sessions"))) {
+    if (await copyIfExists(join20(oldPath, "sessions"), join20(newPath, "assistants", assistant.id, "sessions"))) {
       result.migrated.push("sessions");
     }
-    await writeFile7(join19(newPath, "migration", MIGRATION_MARKER), JSON.stringify({ migratedAt: new Date().toISOString() }, null, 2));
+    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;
@@ -43828,17 +44784,17 @@ init_src();
 
 // packages/core/src/logger.ts
 import { existsSync as existsSync12, mkdirSync as mkdirSync6, appendFileSync, readdirSync as readdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 class Logger {
   logDir;
   logFile;
   sessionId;
   constructor(sessionId, basePath) {
     this.sessionId = sessionId;
-    this.logDir = join20(basePath || getConfigDir(), "logs");
+    this.logDir = join21(basePath || getConfigDir(), "logs");
     this.ensureDir(this.logDir);
     const date = new Date().toISOString().split("T")[0];
-    this.logFile = join20(this.logDir, `${date}.log`);
+    this.logFile = join21(this.logDir, `${date}.log`);
   }
   ensureDir(dir) {
     if (!existsSync12(dir)) {
@@ -43882,9 +44838,9 @@ class SessionStorage {
   constructor(sessionId, basePath, assistantId) {
     this.sessionId = sessionId;
     const root = basePath || getConfigDir();
-    this.sessionsDir = assistantId ? join20(root, "assistants", assistantId, "sessions") : join20(root, "sessions");
+    this.sessionsDir = assistantId ? join21(root, "assistants", assistantId, "sessions") : join21(root, "sessions");
     this.ensureDir(this.sessionsDir);
-    this.sessionFile = join20(this.sessionsDir, `${sessionId}.json`);
+    this.sessionFile = join21(this.sessionsDir, `${sessionId}.json`);
   }
   ensureDir(dir) {
     if (!existsSync12(dir)) {
@@ -43910,7 +44866,7 @@ class SessionStorage {
   }
   static getActiveAssistantId() {
     try {
-      const activePath = join20(getConfigDir(), "active.json");
+      const activePath = join21(getConfigDir(), "active.json");
       if (!existsSync12(activePath))
         return null;
       const raw = readFileSync6(activePath, "utf-8");
@@ -43924,12 +44880,12 @@ class SessionStorage {
     const root = getConfigDir();
     const resolvedId = assistantId ?? SessionStorage.getActiveAssistantId();
     if (resolvedId) {
-      const assistantDir = join20(root, "assistants", resolvedId, "sessions");
+      const assistantDir = join21(root, "assistants", resolvedId, "sessions");
       if (existsSync12(assistantDir)) {
         return assistantDir;
       }
     }
-    return join20(root, "sessions");
+    return join21(root, "sessions");
   }
   static listSessions(assistantId) {
     const sessionsDir = SessionStorage.resolveSessionsDir(assistantId);
@@ -43941,7 +44897,7 @@ class SessionStorage {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const filePath = join20(sessionsDir, file);
+        const filePath = join21(sessionsDir, file);
         const stat = Bun.file(filePath);
         const content = JSON.parse(readFileSync6(filePath, "utf-8"));
         sessions.push({
@@ -43961,7 +44917,7 @@ class SessionStorage {
   }
   static loadSession(sessionId, assistantId) {
     const sessionsDir = SessionStorage.resolveSessionsDir(assistantId);
-    const sessionFile = join20(sessionsDir, `${sessionId}.json`);
+    const sessionFile = join21(sessionsDir, `${sessionId}.json`);
     try {
       if (!existsSync12(sessionFile))
         return null;
@@ -43975,15 +44931,15 @@ function initAssistantsDir() {
   const baseDir = getConfigDir();
   const dirs = [
     baseDir,
-    join20(baseDir, "logs"),
-    join20(baseDir, "assistants"),
-    join20(baseDir, "shared", "skills"),
-    join20(baseDir, "commands"),
-    join20(baseDir, "temp"),
-    join20(baseDir, "heartbeats"),
-    join20(baseDir, "state"),
-    join20(baseDir, "energy"),
-    join20(baseDir, "migration")
+    join21(baseDir, "logs"),
+    join21(baseDir, "assistants"),
+    join21(baseDir, "shared", "skills"),
+    join21(baseDir, "commands"),
+    join21(baseDir, "temp"),
+    join21(baseDir, "heartbeats"),
+    join21(baseDir, "state"),
+    join21(baseDir, "energy"),
+    join21(baseDir, "migration")
   ];
   for (const dir of dirs) {
     if (!existsSync12(dir)) {
@@ -44026,6 +44982,11 @@ class EmbeddedClient {
         for (const callback of this.chunkCallbacks) {
           callback(chunk);
         }
+        if (chunk.type === "done" || chunk.type === "error") {
+          queueMicrotask(() => {
+            this.drainQueue();
+          });
+        }
       },
       onToolStart: (toolCall) => {
         this.logger.info("Tool started", { tool: toolCall.name, input: toolCall.input });
@@ -44068,12 +45029,11 @@ class EmbeddedClient {
     if (!this.initialized) {
       await this.initialize();
     }
-    if (this.agent.isProcessing()) {
-      this.logger.info("Queuing message (agent busy)", { message, queueLength: this.messageQueue.length + 1 });
-      this.messageQueue.push(message);
+    this.messageQueue.push(message);
+    if (this.agent.isProcessing() || this.processingQueue) {
+      this.logger.info("Queuing message (agent busy)", { message, queueLength: this.messageQueue.length });
       return;
     }
-    await this.processMessage(message);
     await this.drainQueue();
   }
   async processMessage(message) {
@@ -44464,10 +45424,13 @@ var COMMANDS = [
   { name: "/model", description: "show model information" },
   { name: "/skills", description: "list available skills" },
   { name: "/config", description: "show configuration" },
+  { name: "/projects", description: "manage projects in this folder" },
+  { name: "/plans", description: "manage project plans" },
   { name: "/connectors", description: "list available connectors" },
   { name: "/init", description: "initialize assistants in project" },
   { name: "/compact", description: "summarize to save context" },
   { name: "/memory", description: "show what AI remembers" },
+  { name: "/context", description: "manage injected project context" },
   { name: "/feedback", description: "submit feedback on GitHub" },
   { name: "/schedule", description: "schedule a command" },
   { name: "/schedules", description: "list scheduled commands" },
@@ -44513,15 +45476,23 @@ function Input({ onSubmit, isProcessing, queueLength = 0, commands, skills = []
   }, [value, autocompleteMode, skills]);
   const autocompleteItems = autocompleteMode === "skill" ? filteredSkills : filteredCommands;
   use_input_default((input, key) => {
-    if (key.tab && autocompleteItems.length > 0) {
-      const selected = autocompleteItems[selectedIndex] || autocompleteItems[0];
-      if (autocompleteMode === "skill") {
-        setValue("$" + selected.name + " ");
-      } else {
-        setValue(selected.name + " ");
+    if (key.tab) {
+      if (autocompleteItems.length > 0) {
+        const selected = autocompleteItems[selectedIndex] || autocompleteItems[0];
+        if (autocompleteMode === "skill") {
+          setValue("$" + selected.name + " ");
+        } else {
+          setValue(selected.name + " ");
+        }
+        setSelectedIndex(0);
+        return;
+      }
+      if (value.trim()) {
+        onSubmit(value, "queue");
+        setValue("");
+        setSelectedIndex(0);
+        return;
       }
-      setSelectedIndex(0);
-      return;
     }
     if (autocompleteItems.length > 0) {
       if (key.downArrow) {
@@ -44555,18 +45526,14 @@ function Input({ onSubmit, isProcessing, queueLength = 0, commands, skills = []
     if (autocompleteMode === "command" && filteredCommands.length > 0 && !submittedValue.includes(" ")) {
       const selected = filteredCommands[selectedIndex] || filteredCommands[0];
       if (selected) {
-        if (isProcessing) {
-          onSubmit(selected.name, "queue");
-        } else {
-          onSubmit(selected.name, "normal");
-        }
+        onSubmit(selected.name, isProcessing ? "inline" : "normal");
         setValue("");
         setSelectedIndex(0);
         return;
       }
     }
     if (isProcessing) {
-      onSubmit(submittedValue, "queue");
+      onSubmit(submittedValue, "inline");
     } else {
       onSubmit(submittedValue, "normal");
     }
@@ -44577,7 +45544,7 @@ function Input({ onSubmit, isProcessing, queueLength = 0, commands, skills = []
   let placeholder = "Type a message...";
   if (isProcessing) {
     prompt = "\u22EF";
-    placeholder = queueLength > 0 ? "Type to queue another..." : "Type to queue (Enter) or interrupt (Shift+Enter)...";
+    placeholder = queueLength > 0 ? "Type to send (Enter) or queue (Tab) \xB7 Shift+Enter to interrupt..." : "Type to send (Enter) or queue (Tab) \xB7 Shift+Enter to interrupt...";
   }
   const truncateDescription = (desc, maxLen = 60) => {
     if (desc.length <= maxLen)
@@ -44718,7 +45685,12 @@ var import_react24 = __toESM(require_react(), 1);
 
 // packages/terminal/src/components/Markdown.tsx
 var jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
-function Markdown({ content }) {
+function Markdown({ content, preRendered = false }) {
+  if (preRendered) {
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+      children: content
+    }, undefined, false, undefined, this);
+  }
   const { columns } = use_stdout_default();
   const maxWidth = columns ? Math.max(20, columns - 2) : undefined;
   const rendered = parseMarkdown(content, { maxWidth });
@@ -44726,6 +45698,9 @@ function Markdown({ content }) {
     children: rendered
   }, undefined, false, undefined, this);
 }
+function renderMarkdown(text, options) {
+  return parseMarkdown(text, { maxWidth: options?.maxWidth });
+}
 function parseMarkdown(text, options) {
   let result = text;
   const codeBlocks = [];
@@ -44751,7 +45726,7 @@ function parseMarkdown(text, options) {
   result = result.replace(/\b(Building|Running|Working|Queued|Pending|Connecting)\b/gi, (match) => source_default.yellow(match));
   result = result.replace(/\b(Success|Succeeded|Done|Complete|Completed|Connected|Authenticated)\b/gi, (match) => source_default.green(match));
   result = result.replace(/\b(Error|Failed|Failure|Denied|Blocked)\b/gi, (match) => source_default.red(match));
-  result = formatMarkdownTables(result);
+  result = formatMarkdownTables(result, options?.maxWidth);
   result = result.replace(/@@BLOCKSECTION(\d+)@@/g, (_, index) => {
     const section = blockSections[parseInt(index, 10)];
     if (!section)
@@ -44765,6 +45740,7 @@ function parseMarkdown(text, options) {
   });
   return result.trimEnd();
 }
+var ALLOWED_BLOCK_TYPES = new Set(["info", "success", "warning", "error", "note", "command"]);
 function extractBlockSections(text, blocks) {
   const lines = text.split(`
 `);
@@ -44793,6 +45769,9 @@ function extractBlockSections(text, blocks) {
         i += 1;
         continue;
       }
+      if (parsed.warning) {
+        output.push(createMalformedBlock(blocks, indent, "grid", parsed.warning));
+      }
       const bodyLines = stripIndent(parsed.bodyLines, indent);
       const body = bodyLines.join(`
 `);
@@ -44806,7 +45785,7 @@ function extractBlockSections(text, blocks) {
       const indent = blockMatch[1] ?? "";
       const header = blockMatch[2] ?? "";
       const attrs = parseAttributes(header);
-      const type = String(attrs.type || "info");
+      let type = String(attrs.type || "info");
       const title = attrs.title ? String(attrs.title) : undefined;
       const parsed = parseDelimitedBlock(lines, i, indent);
       if (!parsed) {
@@ -44815,6 +45794,14 @@ function extractBlockSections(text, blocks) {
         i += 1;
         continue;
       }
+      const normalizedType = type.toLowerCase();
+      if (!ALLOWED_BLOCK_TYPES.has(normalizedType)) {
+        output.push(createMalformedBlock(blocks, indent, "block", `Unknown block type "${type}". Using info.`));
+        type = "info";
+      }
+      if (parsed.warning) {
+        output.push(createMalformedBlock(blocks, indent, "block", parsed.warning));
+      }
       const body = stripIndent(parsed.bodyLines, indent).join(`
 `);
       blocks.push({ kind: "block", type, title, body, indent });
@@ -44831,6 +45818,9 @@ function extractBlockSections(text, blocks) {
         i += 1;
         continue;
       }
+      if (parsed.warning) {
+        output.push(createMalformedBlock(blocks, indent, "report", parsed.warning));
+      }
       const body = stripIndent(parsed.bodyLines, indent).join(`
 `);
       blocks.push({ kind: "report", body, indent });
@@ -44862,10 +45852,14 @@ function extractCards(body) {
     const title = attrs.title ? String(attrs.title) : undefined;
     const bodyLines = [];
     let closed = false;
+    let indentWarning;
     i += 1;
     while (i < lines.length) {
       const current = lines[i];
-      if (current.trim() === ":::" && current.startsWith(indent)) {
+      if (current.trim() === ":::") {
+        if (indent.length > 0 && !current.startsWith(indent)) {
+          indentWarning = "Card closing ::: indentation did not match opening.";
+        }
         closed = true;
         i += 1;
         break;
@@ -44882,6 +45876,13 @@ function extractCards(body) {
       break;
     }
     const stripped = stripIndent(bodyLines, indent);
+    if (indentWarning) {
+      cards.push({
+        type: "warning",
+        title: "Malformed card",
+        body: indentWarning
+      });
+    }
     cards.push({ type, title, body: stripped.join(`
 `) });
   }
@@ -44890,6 +45891,7 @@ function extractCards(body) {
 function parseDelimitedBlock(lines, startIndex, indent) {
   const bodyLines = [];
   let openCards = 0;
+  let warning;
   let i = startIndex + 1;
   while (i < lines.length) {
     const current = lines[i];
@@ -44900,14 +45902,18 @@ function parseDelimitedBlock(lines, startIndex, indent) {
       i += 1;
       continue;
     }
-    if (trimmed === ":::" && current.startsWith(indent)) {
+    if (trimmed === ":::") {
+      const indentMismatch = indent.length > 0 && !current.startsWith(indent);
       if (openCards > 0) {
         openCards -= 1;
         bodyLines.push(current);
         i += 1;
         continue;
       }
-      return { bodyLines, nextIndex: i + 1 };
+      if (indentMismatch) {
+        warning = "Closing ::: indentation did not match opening. Adjust indentation for consistency.";
+      }
+      return { bodyLines, nextIndex: i + 1, warning };
     }
     bodyLines.push(current);
     i += 1;
@@ -45074,7 +46080,7 @@ function formatBoxRow(line, width) {
   const padded = len < width ? line + " ".repeat(width - len) : line;
   return `\u2502 ${padded} \u2502`;
 }
-function formatMarkdownTables(text) {
+function formatMarkdownTables(text, maxWidth) {
   const lines = text.split(`
 `);
   const output = [];
@@ -45092,7 +46098,7 @@ function formatMarkdownTables(text) {
         rows.push(parseTableRow(lines[i]));
         i += 1;
       }
-      const table = renderTable(header, rows);
+      const table = renderTable(header, rows, maxWidth);
       output.push(...table);
       continue;
     }
@@ -45107,7 +46113,7 @@ function parseTableRow(line) {
   const withoutEdges = trimmed.replace(/^\|/, "").replace(/\|$/, "");
   return withoutEdges.split("|").map((cell) => cell.trim());
 }
-function renderTable(header, rows) {
+function renderTable(header, rows, maxWidth) {
   const colCount = Math.max(header.length, ...rows.map((r) => r.length));
   const widths = new Array(colCount).fill(0);
   const allRows = [header, ...rows];
@@ -45119,11 +46125,29 @@ function renderTable(header, rows) {
         widths[i] = len;
     }
   }
+  const minCellWidth = 4;
+  const availableCellWidth = maxWidth ? Math.max(colCount * minCellWidth, maxWidth - (colCount - 1) * 3 - 4) : undefined;
+  if (availableCellWidth) {
+    const total = widths.reduce((sum, width) => sum + width, 0);
+    if (total > availableCellWidth) {
+      const minWidth = Math.max(1, Math.floor(availableCellWidth / colCount));
+      while (widths.reduce((sum, width) => sum + width, 0) > availableCellWidth) {
+        const maxWidthValue = Math.max(...widths);
+        const idx = widths.findIndex((width) => width === maxWidthValue);
+        if (idx === -1)
+          break;
+        if (widths[idx] <= minWidth)
+          break;
+        widths[idx] -= 1;
+      }
+    }
+  }
   const pad = (value, width) => {
-    const len = stripAnsi2(value).length;
+    const rendered = width > 0 ? truncateAnsi(value, width) : value;
+    const len = stripAnsi2(rendered).length;
     if (len >= width)
-      return value;
-    return value + " ".repeat(width - len);
+      return rendered;
+    return rendered + " ".repeat(width - len);
   };
   const top = "\u250C" + widths.map((w) => "\u2500".repeat(w + 2)).join("\u252C") + "\u2510";
   const mid = "\u251C" + widths.map((w) => "\u2500".repeat(w + 2)).join("\u253C") + "\u2524";
@@ -45201,7 +46225,8 @@ function renderReport(body, maxWidth, indent = "") {
   }
   if (tableLines.length > 0) {
     output.push(indent + source_default.bold("Detailed Status Table"));
-    const rendered = renderReportTable(tableLines, indent);
+    const adjustedWidth = maxWidth ? Math.max(20, maxWidth - indent.length) : undefined;
+    const rendered = renderReportTable(tableLines, indent, adjustedWidth);
     output.push(...rendered);
   }
   return output.join(`
@@ -45230,7 +46255,7 @@ function renderProgressLine(label, value, labelWidth, barWidth) {
   const bar = source_default.gray("\u2591".repeat(empty));
   return `${label.padEnd(labelWidth)} [${fill}${bar}] ${value}%`;
 }
-function renderReportTable(lines, indent) {
+function renderReportTable(lines, indent, maxWidth) {
   const tableLines = lines.map((line) => line.trim()).filter(Boolean);
   if (tableLines.length < 2)
     return [];
@@ -45254,7 +46279,7 @@ function renderReportTable(lines, indent) {
     }
     return next;
   });
-  return renderTable(header, styledRows).map((line) => indent + line);
+  return renderTable(header, styledRows, maxWidth).map((line) => indent + line);
 }
 function decoratePriority(value) {
   const normalized = value.toLowerCase();
@@ -45324,6 +46349,23 @@ function wrapAnsiLine(line, width) {
 function truncateAnsi(line, width) {
   if (stripAnsi2(line).length <= width)
     return line;
+  if (width <= 3) {
+    let result = "";
+    let visible2 = 0;
+    let i2 = 0;
+    while (i2 < line.length && visible2 < width) {
+      const match = line.slice(i2).match(/^\x1b\[[0-9;]*m/);
+      if (match) {
+        result += match[0];
+        i2 += match[0].length;
+        continue;
+      }
+      result += line[i2];
+      visible2 += 1;
+      i2 += 1;
+    }
+    return result;
+  }
   const suffix = "...";
   const target = Math.max(0, width - suffix.length);
   let current = "";
@@ -45343,6 +46385,42 @@ function truncateAnsi(line, width) {
   return current + suffix;
 }
 
+// packages/terminal/src/components/messageLines.ts
+function estimateToolPanelLines(toolCalls, toolResults, hasContent) {
+  if (!toolCalls || toolCalls.length === 0) {
+    return 0;
+  }
+  const resultMap = new Set;
+  for (const result of toolResults || []) {
+    resultMap.add(result.toolCallId);
+  }
+  let lines = 3;
+  if (hasContent) {
+    lines += 1;
+  }
+  for (const call of toolCalls) {
+    lines += 3;
+    if (resultMap.has(call.id)) {
+      lines += 1;
+    }
+  }
+  return lines;
+}
+function estimateMessageLines(message) {
+  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);
+  if (message.role === "assistant" && message.toolCalls?.length) {
+    lines += estimateToolPanelLines(message.toolCalls, message.toolResults, hasContent);
+  }
+  return lines;
+}
+
 // packages/terminal/src/components/Messages.tsx
 var jsx_dev_runtime3 = __toESM(require_jsx_dev_runtime(), 1);
 function Messages4({
@@ -45352,19 +46430,28 @@ function Messages4({
   currentToolCall,
   lastToolResult,
   activityLog = [],
-  scrollOffset = 0,
-  maxVisible = 10,
+  scrollOffsetLines = 0,
+  maxVisibleLines = 10,
   queuedMessageIds
 }) {
   const [now2, setNow] = import_react24.useState(Date.now());
   const combinedMessages = import_react24.useMemo(() => [...messages, ...streamingMessages], [messages, streamingMessages]);
-  const endIndex = combinedMessages.length - scrollOffset;
-  const startIndex = Math.max(0, endIndex - maxVisible);
-  const visibleCombined = combinedMessages.slice(startIndex, endIndex);
+  const lineSpans = import_react24.useMemo(() => {
+    let cursor = 0;
+    return combinedMessages.map((message, index) => {
+      const lines = estimateMessageLines(message);
+      const start = cursor;
+      cursor += lines;
+      return { message, index, start, end: cursor, lines };
+    });
+  }, [combinedMessages]);
+  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);
+  const visibleSpans = lineSpans.filter((span) => span.end > startLine && span.start < endLine);
   const historicalCount = messages.length;
-  const splitIndex = Math.max(0, Math.min(visibleCombined.length, historicalCount - startIndex));
-  const visibleMessages = visibleCombined.slice(0, splitIndex);
-  const visibleStreaming = visibleCombined.slice(splitIndex);
+  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 groupedMessages = groupConsecutiveToolMessages(visibleMessages);
   const historicalItems = groupedMessages.map((group) => {
     if (group.type === "single") {
@@ -45612,13 +46699,13 @@ function MessageBubble({ message, queuedMessageIds }) {
           /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
             flexGrow: 1,
             children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Markdown, {
-              content: message.content
+              content: message.content,
+              preRendered: Boolean(message.__rendered)
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
       toolCalls.length > 0 && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
-        marginLeft: hasContent ? 2 : 0,
         marginTop: hasContent ? 1 : 0,
         children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ToolCallPanel, {
           toolCalls,
@@ -45634,6 +46721,8 @@ function ToolCallPanel({
 }) {
   if (toolCalls.length === 0)
     return null;
+  const { columns } = use_stdout_default();
+  const panelWidth = columns ? Math.max(24, columns - 4) : undefined;
   const resultMap = new Map;
   for (const result of toolResults || []) {
     resultMap.set(result.toolCallId, result);
@@ -45646,7 +46735,7 @@ function ToolCallPanel({
     borderStyle: "round",
     borderColor,
     paddingX: 1,
-    width: "100%",
+    width: panelWidth ?? "100%",
     children: [
       /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
         justifyContent: "space-between",
@@ -45672,6 +46761,8 @@ function ToolCallPanel({
         const statusColor = result ? result.isError ? "red" : "green" : "yellow";
         const displayName = getToolDisplayName(toolCall);
         const context2 = getToolContext(toolCall);
+        const maxLine = panelWidth ? Math.max(20, panelWidth - 8) : 80;
+        const summaryLine = truncate(formatToolCall(toolCall), maxLine);
         return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
           flexDirection: "column",
           marginTop: 1,
@@ -45701,7 +46792,7 @@ function ToolCallPanel({
             }, undefined, true, undefined, this),
             /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
               dimColor: true,
-              children: formatToolCall(toolCall)
+              children: summaryLine
             }, undefined, false, undefined, this),
             result && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
               marginLeft: 2,
@@ -45736,7 +46827,7 @@ function getToolContext(toolCall) {
       return truncate(String(input.pattern || ""), 20);
     case "schedule":
       return String(input.action || "");
-    case "feedback":
+    case "submit_feedback":
       return String(input.type || "feedback");
     case "web_search":
       return truncate(String(input.query || ""), 20);
@@ -46017,46 +47108,7 @@ function formatSearchResult(content) {
 
 // packages/terminal/src/components/Status.tsx
 var import_react25 = __toESM(require_react(), 1);
-
-// packages/terminal/src/components/EnergyBar.tsx
 var jsx_dev_runtime4 = __toESM(require_jsx_dev_runtime(), 1);
-function EnergyBar({ current, max }) {
-  const safeMax = Math.max(1, max);
-  const percentage = Math.round(current / safeMax * 100);
-  const barWidth = 16;
-  const filled = Math.round(current / safeMax * barWidth);
-  const empty = Math.max(0, barWidth - filled);
-  const color = percentage > 50 ? "green" : percentage > 20 ? "yellow" : "red";
-  const emoji = percentage > 70 ? "\u26A1" : percentage > 30 ? "\uD83D\uDD0B" : "\uD83E\uDEAB";
-  return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
-    children: [
-      /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-        children: [
-          emoji,
-          " "
-        ]
-      }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-        color,
-        children: "\u2588".repeat(filled)
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-        color: "gray",
-        children: "\u2591".repeat(empty)
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-        children: [
-          " ",
-          percentage,
-          "%"
-        ]
-      }, undefined, true, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-
-// packages/terminal/src/components/Status.tsx
-var jsx_dev_runtime5 = __toESM(require_jsx_dev_runtime(), 1);
 function Status({
   isProcessing,
   cwd: cwd2,
@@ -46094,74 +47146,51 @@ function Status({
   let contextInfo = "";
   if (tokenUsage && tokenUsage.maxContextTokens > 0) {
     const percent = Math.round(tokenUsage.totalTokens / tokenUsage.maxContextTokens * 100);
-    contextInfo = `${percent}% context`;
+    contextInfo = `${percent}%`;
   }
-  const sessionInfo = sessionIndex && sessionCount ? `Session ${sessionIndex}/${sessionCount}` : "";
-  const bgIndicator = backgroundProcessingCount > 0 ? ` (${backgroundProcessingCount} processing)` : "";
-  const voiceInfo = voiceState?.enabled ? `voice ${voiceState.isListening ? "listening" : voiceState.isSpeaking ? "speaking" : "on"}` : "";
-  const identityLabel = identityInfo?.assistant && identityInfo?.identity ? `${identityInfo.assistant.name} \xB7 ${identityInfo.identity.name}` : "";
-  return /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Box_default, {
+  const sessionInfo = sessionIndex && sessionCount && sessionCount > 1 ? `${sessionIndex}/${sessionCount}` : "";
+  const bgIndicator = backgroundProcessingCount > 0 ? ` +${backgroundProcessingCount}` : "";
+  const voiceIcon = voiceState?.enabled ? voiceState.isListening ? "\uD83C\uDFA4" : voiceState.isSpeaking ? "\uD83D\uDD0A" : "\uD83C\uDF99" : "";
+  return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
     marginTop: 1,
     justifyContent: "space-between",
     children: [
-      /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
         dimColor: true,
         children: [
-          "/help for commands",
-          sessionCount && sessionCount > 1 ? " | Ctrl+S sessions" : ""
+          "/help",
+          sessionCount && sessionCount > 1 ? " \xB7 Ctrl+S" : ""
         ]
       }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Box_default, {
+      /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
         children: [
-          energyState && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Box_default, {
-            marginRight: 2,
-            children: /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(EnergyBar, {
-              current: energyState.current,
-              max: energyState.max
-            }, undefined, false, undefined, this)
-          }, undefined, false, undefined, this),
-          identityLabel && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
-            dimColor: true,
-            children: [
-              identityLabel,
-              " \xB7 "
-            ]
-          }, undefined, true, undefined, this),
-          voiceInfo && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
+          voiceIcon && /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
             dimColor: true,
             children: [
-              voiceInfo,
-              " \xB7 "
+              voiceIcon,
+              " "
             ]
           }, undefined, true, undefined, this),
-          isProcessing && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
+          isProcessing && /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
             dimColor: true,
-            children: "esc to stop \xB7 "
+            children: "esc \xB7 "
           }, undefined, false, undefined, this),
-          sessionInfo && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
+          sessionInfo && /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
             dimColor: true,
             children: [
               sessionInfo,
               bgIndicator,
-              contextInfo ? " \xB7 " : ""
+              " \xB7 "
             ]
           }, undefined, true, undefined, this),
-          contextInfo && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
+          contextInfo && /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
             dimColor: true,
             children: contextInfo
           }, undefined, false, undefined, this),
-          sessionId && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
-            dimColor: true,
-            children: [
-              sessionInfo || contextInfo ? " \xB7 " : "",
-              "id ",
-              sessionId
-            ]
-          }, undefined, true, undefined, this),
-          isProcessing && processingStartTime && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
+          isProcessing && processingStartTime && /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
             dimColor: true,
             children: [
-              " \xB7 \u273B Worked for ",
+              " \xB7 ",
               formatDuration2(elapsed)
             ]
           }, undefined, true, undefined, this)
@@ -46193,17 +47222,17 @@ function Spinner({ type = "dots" }) {
 var build_default2 = Spinner;
 
 // packages/terminal/src/components/Spinner.tsx
-var jsx_dev_runtime6 = __toESM(require_jsx_dev_runtime(), 1);
+var jsx_dev_runtime5 = __toESM(require_jsx_dev_runtime(), 1);
 function Spinner2({ label }) {
-  return /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Box_default, {
     children: [
-      /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
         dimColor: true,
-        children: /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(build_default2, {
+        children: /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(build_default2, {
           type: "dots"
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
-      label && /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
+      label && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
         dimColor: true,
         children: [
           " ",
@@ -46216,7 +47245,7 @@ function Spinner2({ label }) {
 
 // packages/terminal/src/components/ProcessingIndicator.tsx
 var import_react27 = __toESM(require_react(), 1);
-var jsx_dev_runtime7 = __toESM(require_jsx_dev_runtime(), 1);
+var jsx_dev_runtime6 = __toESM(require_jsx_dev_runtime(), 1);
 function ProcessingIndicator({
   isProcessing,
   startTime,
@@ -46260,14 +47289,14 @@ function ProcessingIndicator({
     parts.push("thinking");
   }
   const label = isThinking ? "Metamorphosing" : "Working";
-  return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
     marginY: 1,
     children: [
-      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
         dimColor: true,
         children: "\u2736 "
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
         dimColor: true,
         children: [
           " ",
@@ -46275,7 +47304,7 @@ function ProcessingIndicator({
           "... "
         ]
       }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+      /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
         dimColor: true,
         children: [
           "(",
@@ -46288,31 +47317,31 @@ function ProcessingIndicator({
 }
 
 // packages/terminal/src/components/WelcomeBanner.tsx
-var jsx_dev_runtime8 = __toESM(require_jsx_dev_runtime(), 1);
+var jsx_dev_runtime7 = __toESM(require_jsx_dev_runtime(), 1);
 function WelcomeBanner({ version, model, directory }) {
   const homeDir = process.env.HOME || "";
   const displayDir = directory.startsWith(homeDir) ? "~" + directory.slice(homeDir.length) : directory;
-  return /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
     flexDirection: "column",
     marginBottom: 1,
     children: [
-      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
         children: [
-          /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
             color: "cyan",
             bold: true,
             children: ">"
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
             color: "cyan",
             bold: true,
             children: "_ "
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
             bold: true,
             children: "assistants"
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
             dimColor: true,
             children: [
               " (v",
@@ -46322,29 +47351,29 @@ function WelcomeBanner({ version, model, directory }) {
           }, undefined, true, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
         marginTop: 1,
         children: [
-          /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
             dimColor: true,
             children: "model:     "
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
             children: model
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
             dimColor: true,
             children: "     /model to change"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+      /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
         children: [
-          /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
             dimColor: true,
             children: "directory: "
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
             children: displayDir
           }, undefined, false, undefined, this)
         ]
@@ -46355,7 +47384,7 @@ function WelcomeBanner({ version, model, directory }) {
 
 // packages/terminal/src/components/SessionSelector.tsx
 var import_react28 = __toESM(require_react(), 1);
-var jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
+var jsx_dev_runtime8 = __toESM(require_jsx_dev_runtime(), 1);
 function formatSessionTime(timestamp) {
   const date = new Date(timestamp);
   const now2 = new Date;
@@ -46421,13 +47450,13 @@ function SessionSelector({
       return;
     }
   });
-  return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
     flexDirection: "column",
     paddingY: 1,
     children: [
-      /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
+      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
         marginBottom: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+        children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
           bold: true,
           children: "Sessions"
         }, undefined, false, undefined, this)
@@ -46439,8 +47468,8 @@ function SessionSelector({
         const time = formatSessionTime(session.updatedAt);
         const path2 = formatPath(session.cwd);
         const processing = session.isProcessing ? " (processing)" : "";
-        return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
-          children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+        return /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+          children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
             inverse: isSelected,
             color: isActive ? "green" : undefined,
             dimColor: !isSelected && !isActive,
@@ -46457,17 +47486,17 @@ function SessionSelector({
           }, undefined, true, undefined, this)
         }, session.id, false, undefined, this);
       }),
-      /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
+      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
         marginTop: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+        children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
           inverse: selectedIndex === sessions.length,
           dimColor: selectedIndex !== sessions.length,
           children: "+ New session (n)"
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
+      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
         marginTop: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+        children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
           dimColor: true,
           children: [
             "Enter to select | Esc to cancel | 1-",
@@ -46481,32 +47510,8 @@ function SessionSelector({
 }
 
 // packages/terminal/src/components/App.tsx
-var jsx_dev_runtime10 = __toESM(require_jsx_dev_runtime(), 1);
+var jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
 var SHOW_ERROR_CODES = process.env.ASSISTANTS_DEBUG === "1" || process.env.OLDPAL_DEBUG === "1";
-function formatToolName(toolCall) {
-  const { name, input } = toolCall;
-  switch (name) {
-    case "bash":
-      return `bash`;
-    case "read":
-      const path2 = String(input.path || input.file_path || "");
-      return `read ${path2.split("/").pop() || ""}`;
-    case "write":
-      const writePath = String(input.filename || input.path || input.file_path || "");
-      return `write ${writePath.split("/").pop() || ""}`;
-    case "glob":
-      return `glob`;
-    case "grep":
-      return `grep`;
-    case "web_search":
-      return `search`;
-    case "web_fetch":
-    case "curl":
-      return `fetch`;
-    default:
-      return name;
-  }
-}
 function parseErrorMessage(error) {
   const lines = error.split(`
 `);
@@ -46528,7 +47533,65 @@ function parseErrorMessage(error) {
 }
 var MESSAGE_CHUNK_LINES = 12;
 var MESSAGE_WRAP_CHARS = 120;
-function buildDisplayMessages(messages, chunkLines, wrapChars) {
+function wrapTextLines(text, wrapChars) {
+  const rawLines = text.split(`
+`);
+  const lines = [];
+  for (const line of rawLines) {
+    if (line.length <= wrapChars) {
+      lines.push(line);
+      continue;
+    }
+    for (let i = 0;i < line.length; i += wrapChars) {
+      lines.push(line.slice(i, i + wrapChars));
+    }
+  }
+  return lines;
+}
+function stripAnsi3(text) {
+  return text.replace(/\x1B\[[0-9;]*m/g, "");
+}
+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");
+  while (i < lines.length) {
+    const line = lines[i];
+    if (isBoxStart(line)) {
+      let end = i + 1;
+      while (end < lines.length && !isBoxEnd(lines[end])) {
+        end += 1;
+      }
+      if (end < lines.length)
+        end += 1;
+      const boxLines = lines.slice(i, end);
+      if (current.length > 0 && current.length + boxLines.length > chunkLines) {
+        chunks.push(current);
+        current = [];
+      }
+      if (boxLines.length >= chunkLines) {
+        chunks.push(boxLines);
+      } else {
+        current.push(...boxLines);
+      }
+      i = end;
+      continue;
+    }
+    if (current.length >= chunkLines) {
+      chunks.push(current);
+      current = [];
+    }
+    current.push(line);
+    i += 1;
+  }
+  if (current.length > 0) {
+    chunks.push(current);
+  }
+  return chunks;
+}
+function buildDisplayMessages(messages, chunkLines, wrapChars, options) {
   const display = [];
   for (const msg of messages) {
     const content = msg.content ?? "";
@@ -46537,32 +47600,34 @@ function buildDisplayMessages(messages, chunkLines, wrapChars) {
       display.push(msg);
       continue;
     }
-    const rawLines = content.split(`
-`);
-    const lines = [];
-    for (const line of rawLines) {
-      if (line.length <= wrapChars) {
-        lines.push(line);
-        continue;
-      }
-      for (let i = 0;i < line.length; i += wrapChars) {
-        lines.push(line.slice(i, i + wrapChars));
-      }
-    }
+    const lines = wrapTextLines(content, wrapChars);
     if (lines.length <= chunkLines) {
-      display.push(msg);
+      if (msg.role === "assistant") {
+        const rendered2 = renderMarkdown(lines.join(`
+`), { maxWidth: options?.maxWidth });
+        display.push({ ...msg, content: rendered2, __rendered: true });
+      } else {
+        display.push(msg);
+      }
       continue;
     }
-    const totalChunks = Math.ceil(lines.length / chunkLines);
-    for (let i = 0;i < totalChunks; i++) {
-      const chunkContent = lines.slice(i * chunkLines, (i + 1) * chunkLines).join(`
+    const baseContent = lines.join(`
+`);
+    const renderAssistant = msg.role === "assistant";
+    const rendered = renderAssistant ? renderMarkdown(baseContent, { maxWidth: options?.maxWidth }) : baseContent;
+    const renderedLines = rendered.split(`
+`);
+    const chunks = chunkRenderedLines(renderedLines, chunkLines);
+    for (let i = 0;i < chunks.length; i++) {
+      const chunkContent = chunks[i].join(`
 `);
       display.push({
         ...msg,
         id: `${msg.id}::chunk-${i}`,
         content: chunkContent,
-        toolCalls: i === totalChunks - 1 ? msg.toolCalls : undefined,
-        toolResults: i === totalChunks - 1 ? msg.toolResults : undefined
+        __rendered: renderAssistant,
+        toolCalls: i === chunks.length - 1 ? msg.toolCalls : undefined,
+        toolResults: i === chunks.length - 1 ? msg.toolResults : undefined
       });
     }
   }
@@ -46597,7 +47662,7 @@ function App2({ cwd: cwd2, version }) {
   const toolCallsRef = import_react29.useRef([]);
   const toolResultsRef = import_react29.useRef([]);
   const activityLogRef = import_react29.useRef([]);
-  const prevDisplayCountRef = import_react29.useRef(0);
+  const prevDisplayLineCountRef = import_react29.useRef(0);
   const skipNextDoneRef = import_react29.useRef(false);
   const isProcessingRef = import_react29.useRef(isProcessing);
   import_react29.useEffect(() => {
@@ -46919,9 +47984,10 @@ function App2({ cwd: cwd2, version }) {
     await activeSession2.client.send(nextMessage.content);
   }, [activeSessionId]);
   const activeQueue = activeSessionId ? messageQueue.filter((msg) => msg.sessionId === activeSessionId) : [];
-  const queuedMessageIds = import_react29.useMemo(() => new Set(activeQueue.map((msg) => msg.id)), [activeQueue]);
+  const queuedMessageIds = import_react29.useMemo(() => new Set(activeQueue.filter((msg) => msg.mode === "queued").map((msg) => msg.id)), [activeQueue]);
   const wrapChars = columns ? Math.max(40, columns - 4) : MESSAGE_WRAP_CHARS;
-  const displayMessages = import_react29.useMemo(() => buildDisplayMessages(messages, MESSAGE_CHUNK_LINES, wrapChars), [messages, wrapChars]);
+  const renderWidth = columns ? Math.max(20, columns - 2) : undefined;
+  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())
       return [];
@@ -46931,9 +47997,12 @@ function App2({ cwd: cwd2, version }) {
       content: currentResponse,
       timestamp: now()
     };
-    return buildDisplayMessages([streamingMessage], MESSAGE_CHUNK_LINES, wrapChars);
-  }, [currentResponse, isProcessing, wrapChars]);
-  const displayCount = displayMessages.length + streamingMessages.length;
+    return buildDisplayMessages([streamingMessage], MESSAGE_CHUNK_LINES, wrapChars, { maxWidth: renderWidth });
+  }, [currentResponse, isProcessing, wrapChars, renderWidth]);
+  const displayLineCount = import_react29.useMemo(() => {
+    const combined = [...displayMessages, ...streamingMessages];
+    return combined.reduce((sum, msg) => sum + estimateMessageLines(msg), 0);
+  }, [displayMessages, streamingMessages]);
   import_react29.useEffect(() => {
     if (!isProcessing && activeQueue.length > 0) {
       processQueue();
@@ -46943,23 +48012,21 @@ function App2({ cwd: cwd2, version }) {
     if (autoScroll) {
       setScrollOffset(0);
     }
-  }, [displayCount, autoScroll]);
+  }, [displayLineCount, autoScroll]);
   import_react29.useEffect(() => {
-    const prevCount = prevDisplayCountRef.current;
-    if (!autoScroll && displayCount > prevCount) {
-      const delta = displayCount - prevCount;
+    const prevCount = prevDisplayLineCountRef.current;
+    if (!autoScroll && displayLineCount > prevCount) {
+      const delta = displayLineCount - prevCount;
       setScrollOffset((prev) => prev + delta);
     }
-    prevDisplayCountRef.current = displayCount;
-  }, [displayCount, autoScroll]);
+    prevDisplayLineCountRef.current = displayLineCount;
+  }, [displayLineCount, autoScroll]);
   const reservedLines = 8;
-  const baseMaxVisible = rows ? Math.max(3, rows - reservedLines) : 10;
-  const toolCallsHeight = isProcessing ? Math.min(toolCallsRef.current.length, 5) : 0;
-  const maxVisibleMessages = Math.max(3, baseMaxVisible - toolCallsHeight);
+  const maxVisibleLines = rows ? Math.max(6, rows - reservedLines) : 20;
   import_react29.useEffect(() => {
-    const maxOffset = Math.max(0, displayCount - maxVisibleMessages);
+    const maxOffset = Math.max(0, displayLineCount - maxVisibleLines);
     setScrollOffset((prev) => Math.min(prev, maxOffset));
-  }, [displayCount, maxVisibleMessages]);
+  }, [displayLineCount, maxVisibleLines]);
   const sessions = registry2.listSessions();
   const activeSession = registry2.getActiveSession();
   const sessionIndex = activeSessionId ? registry2.getSessionIndex(activeSessionId) : 0;
@@ -47038,8 +48105,9 @@ function App2({ cwd: cwd2, version }) {
     }
     if (key.pageUp || key.shift && key.upArrow) {
       setScrollOffset((prev) => {
-        const maxOffset = Math.max(0, displayCount - maxVisibleMessages);
-        const newOffset = Math.min(prev + 3, maxOffset);
+        const maxOffset = Math.max(0, displayLineCount - maxVisibleLines);
+        const step = Math.max(3, Math.floor(maxVisibleLines / 2));
+        const newOffset = Math.min(prev + step, maxOffset);
         if (newOffset > 0)
           setAutoScroll(false);
         return newOffset;
@@ -47047,14 +48115,15 @@ function App2({ cwd: cwd2, version }) {
     }
     if (key.pageDown || key.shift && key.downArrow) {
       setScrollOffset((prev) => {
-        const newOffset = Math.max(0, prev - 3);
+        const step = Math.max(3, Math.floor(maxVisibleLines / 2));
+        const newOffset = Math.max(0, prev - step);
         if (newOffset === 0)
           setAutoScroll(true);
         return newOffset;
       });
     }
     if (key.ctrl && input === "u") {
-      const maxOffset = Math.max(0, displayCount - maxVisibleMessages);
+      const maxOffset = Math.max(0, displayLineCount - maxVisibleLines);
       setScrollOffset(maxOffset);
       setAutoScroll(false);
     }
@@ -47085,13 +48154,19 @@ function App2({ cwd: cwd2, version }) {
       setShowSessionSelector(true);
       return;
     }
-    if (mode === "queue" || isProcessing && mode === "normal") {
+    if (mode === "queue" || mode === "inline") {
       if (!activeSessionId)
         return;
       const queuedId = generateId();
       setMessageQueue((prev) => [
         ...prev,
-        { id: queuedId, sessionId: activeSessionId, content: trimmedInput, queuedAt: now() }
+        {
+          id: queuedId,
+          sessionId: activeSessionId,
+          content: trimmedInput,
+          queuedAt: now(),
+          mode: mode === "inline" ? "inline" : "queued"
+        }
       ]);
       setMessages((prev) => [
         ...prev,
@@ -47155,19 +48230,19 @@ function App2({ cwd: cwd2, version }) {
     activeSessionId
   ]);
   if (isInitializing) {
-    return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Spinner2, {
+      children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Spinner2, {
         label: "Initializing..."
       }, undefined, false, undefined, this)
     }, undefined, false, undefined, this);
   }
   if (showSessionSelector) {
-    return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Box_default, {
+    return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
       flexDirection: "column",
       padding: 1,
-      children: /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(SessionSelector, {
+      children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(SessionSelector, {
         sessions,
         activeSessionId,
         onSelect: handleSessionSwitch,
@@ -47187,19 +48262,21 @@ function App2({ cwd: cwd2, version }) {
       return text;
     return text.slice(0, maxLen - 3) + "...";
   };
+  const queuedCount = activeQueue.filter((msg) => msg.mode === "queued").length;
+  const inlineCount = activeQueue.filter((msg) => msg.mode === "inline").length;
   const showWelcome = messages.length === 0 && !isProcessing;
-  return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Box_default, {
+  return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
     flexDirection: "column",
     padding: 1,
     children: [
-      showWelcome && /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(WelcomeBanner, {
-        version: version ?? "0.6.13",
+      showWelcome && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(WelcomeBanner, {
+        version: version ?? "unknown",
         model: "claude-sonnet-4",
         directory: activeSession?.cwd || cwd2
       }, undefined, false, undefined, this),
-      backgroundProcessingCount > 0 && /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Box_default, {
+      backgroundProcessingCount > 0 && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
         marginBottom: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Text, {
+        children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
           color: "yellow",
           children: [
             backgroundProcessingCount,
@@ -47209,17 +48286,17 @@ function App2({ cwd: cwd2, version }) {
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      scrollOffset > 0 && /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Box_default, {
-        children: /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Text, {
+      scrollOffset > 0 && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
+        children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
           dimColor: true,
           children: [
             "\u2191 ",
             scrollOffset,
-            " more messages above (Shift+\u2193 or Page Down to scroll down)"
+            " more lines above (Shift+\u2193 or Page Down to scroll down)"
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Messages4, {
+      /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Messages4, {
         messages: displayMessages,
         currentResponse: undefined,
         streamingMessages,
@@ -47227,61 +48304,34 @@ function App2({ cwd: cwd2, version }) {
         lastToolResult: undefined,
         activityLog: isProcessing ? activityLog : [],
         queuedMessageIds,
-        scrollOffset,
-        maxVisible: maxVisibleMessages
+        scrollOffsetLines: scrollOffset,
+        maxVisibleLines
       }, activeSessionId || "default", false, undefined, this),
-      isProcessing && toolCallEntries.length > 0 && /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Box_default, {
-        marginY: 1,
-        flexDirection: "column",
-        children: [
-          toolCallEntries.slice(-3).map(({ toolCall, result }) => /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Box_default, {
-            children: /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Text, {
-              dimColor: true,
-              children: [
-                result ? "\u2713" : "\u2699",
-                " ",
-                formatToolName(toolCall),
-                result?.isError && /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Text, {
-                  color: "red",
-                  children: " (error)"
-                }, undefined, false, undefined, this)
-              ]
-            }, undefined, true, undefined, this)
-          }, toolCall.id, false, undefined, this)),
-          toolCallEntries.length > 3 && /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Text, {
-            dimColor: true,
-            children: [
-              "  ... and ",
-              toolCallEntries.length - 3,
-              " more tools"
-            ]
-          }, undefined, true, undefined, this)
-        ]
-      }, undefined, true, undefined, this),
-      activeQueue.length > 0 && /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Box_default, {
+      activeQueue.length > 0 && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
         marginY: 1,
         flexDirection: "column",
         children: [
-          /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Text, {
+          /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
             dimColor: true,
             children: [
               activeQueue.length,
-              " message",
+              " pending message",
               activeQueue.length > 1 ? "s" : "",
-              " queued"
+              inlineCount > 0 || queuedCount > 0 ? ` \xB7 ${inlineCount} in-stream \xB7 ${queuedCount} queued` : ""
             ]
           }, undefined, true, undefined, this),
-          activeQueue.slice(0, MAX_QUEUED_PREVIEW).map((queued) => /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Box_default, {
+          activeQueue.slice(0, MAX_QUEUED_PREVIEW).map((queued) => /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
             marginLeft: 2,
-            children: /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Text, {
+            children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
               dimColor: true,
               children: [
-                "\u276F ",
+                queued.mode === "inline" ? "\u21B3" : "\u23F3",
+                " ",
                 truncateQueued(queued.content)
               ]
             }, undefined, true, undefined, this)
           }, queued.id, false, undefined, this)),
-          activeQueue.length > MAX_QUEUED_PREVIEW && /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Text, {
+          activeQueue.length > MAX_QUEUED_PREVIEW && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
             dimColor: true,
             children: [
               "  ... and ",
@@ -47295,18 +48345,18 @@ function App2({ cwd: cwd2, version }) {
         const parsed = parseErrorMessage(error);
         const severity = parsed.code && /TIMEOUT|RATE_LIMITED/.test(parsed.code) ? "yellow" : "red";
         const prefix = SHOW_ERROR_CODES && parsed.code ? `${parsed.code}: ` : "";
-        return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Box_default, {
+        return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
           marginY: 1,
           flexDirection: "column",
           children: [
-            /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Text, {
+            /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
               color: severity,
               children: [
                 prefix,
                 parsed.message
               ]
             }, undefined, true, undefined, this),
-            parsed.suggestion && /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Text, {
+            parsed.suggestion && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
               color: severity,
               children: [
                 "Suggestion: ",
@@ -47316,19 +48366,19 @@ function App2({ cwd: cwd2, version }) {
           ]
         }, undefined, true, undefined, this);
       })(),
-      /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(ProcessingIndicator, {
+      /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(ProcessingIndicator, {
         isProcessing,
         startTime: processingStartTime,
         tokenCount: currentTurnTokens,
         isThinking
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Input, {
+      /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Input, {
         onSubmit: handleSubmit,
         isProcessing,
         queueLength: activeQueue.length,
         skills
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Status, {
+      /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Status, {
         isProcessing,
         cwd: activeSession?.cwd || cwd2,
         queueLength: activeQueue.length,
@@ -47520,8 +48570,9 @@ function formatStreamEvent(chunk) {
 }
 
 // packages/terminal/src/index.tsx
-var jsx_dev_runtime11 = __toESM(require_jsx_dev_runtime(), 1);
-var VERSION3 = "0.6.18";
+var jsx_dev_runtime10 = __toESM(require_jsx_dev_runtime(), 1);
+var VERSION3 = "0.6.20";
+process.env.ASSISTANTS_VERSION ??= VERSION3;
 function parseArgs(argv) {
   const args = argv.slice(2);
   const options = {
@@ -47675,7 +48726,7 @@ if (options.print !== null) {
     process.exit(1);
   });
 } else {
-  const { waitUntilExit } = render_default(/* @__PURE__ */ jsx_dev_runtime11.jsxDEV(App2, {
+  const { waitUntilExit } = render_default(/* @__PURE__ */ jsx_dev_runtime10.jsxDEV(App2, {
     cwd: options.cwd,
     version: VERSION3
   }, undefined, false, undefined, this));
@@ -47684,4 +48735,4 @@ if (options.print !== null) {
   });
 }
 
-//# debugId=EED40350F624F85864756E2164756E21
+//# debugId=F2C1A670F9E8793164756E2164756E21