@hasna/assistants 0.6.32 → 0.6.35

package/dist/index.js

@@ -17712,14 +17712,13 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function parseFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
   if (!match) {
     return { frontmatter: {}, content };
   }
   const [, yamlContent, markdownContent] = match;
   const frontmatter = {};
-  const lines = yamlContent.split(`
-`);
+  const lines = yamlContent.split(/\r?\n/);
   for (const line of lines) {
     const colonIndex = line.indexOf(":");
     if (colonIndex === -1)
@@ -28327,14 +28326,14 @@ var exports_anthropic = {};
 __export(exports_anthropic, {
   AnthropicClient: () => AnthropicClient
 });
-import { readFileSync as readFileSync4, existsSync as existsSync8 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync9 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join14 } from "path";
 function loadApiKeyFromSecrets() {
   const envHome = process.env.HOME || process.env.USERPROFILE;
-  const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir8();
-  const secretsPath = join13(homeDir, ".secrets");
-  if (existsSync8(secretsPath)) {
+  const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir11();
+  const secretsPath = join14(homeDir, ".secrets");
+  if (existsSync9(secretsPath)) {
     try {
       const content = readFileSync4(secretsPath, "utf-8");
       const match = content.match(/export\s+ANTHROPIC_API_KEY\s*=\s*["']?([^"'\n]+)["']?/);
@@ -36578,7 +36577,7 @@ var import_react29 = __toESM(require_react(), 1);
 
 // packages/core/src/agent/loop.ts
 init_src();
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 
 // packages/core/src/agent/context.ts
 init_src();
@@ -36650,6 +36649,9 @@ class AgentContext {
     try {
       const parsed = JSON.parse(content);
       if (parsed && parsed.__pdf_attachment__ === true) {
+        if (!parsed.data || typeof parsed.data !== "string") {
+          return null;
+        }
         return {
           type: "pdf",
           source: {
@@ -36701,8 +36703,11 @@ class AgentContext {
     if (this.messages.length <= this.maxMessages) {
       return;
     }
-    const systemMessages = this.messages.filter((m) => m.role === "system");
+    let systemMessages = this.messages.filter((m) => m.role === "system");
     const nonSystemMessages = this.messages.filter((m) => m.role !== "system");
+    if (systemMessages.length > this.maxMessages) {
+      systemMessages = systemMessages.slice(-this.maxMessages);
+    }
     const targetCount = Math.max(0, this.maxMessages - systemMessages.length);
     let recentMessages = targetCount > 0 ? nonSystemMessages.slice(-targetCount) : [];
     while (recentMessages.length > 0 && recentMessages[0].toolResults) {
@@ -36871,7 +36876,33 @@ class ContextManager {
         summarizedCount: 0
       };
     }
-    const summary = await this.summarizer.summarize(toSummarize);
+    let summary = "";
+    try {
+      summary = await this.summarizer.summarize(toSummarize);
+    } catch {
+      const tokens = this.tokenCounter.countMessages(messages);
+      this.state.totalTokens = tokens;
+      this.state.messageCount = messages.length;
+      return {
+        messages,
+        summarized: false,
+        tokensBefore: tokens,
+        tokensAfter: tokens,
+        summarizedCount: 0
+      };
+    }
+    if (!summary.trim()) {
+      const tokens = this.tokenCounter.countMessages(messages);
+      this.state.totalTokens = tokens;
+      this.state.messageCount = messages.length;
+      return {
+        messages,
+        summarized: false,
+        tokensBefore: tokens,
+        tokensAfter: tokens,
+        summarizedCount: 0
+      };
+    }
     const summaryMessage = {
       id: generateId(),
       role: "system",
@@ -37715,7 +37746,7 @@ function isErrorResult(result) {
 // packages/core/src/tools/connector.ts
 init_errors();
 import { homedir as homedir2 } from "os";
-import { join as join3, delimiter, dirname as dirname2 } from "path";
+import { join as join3, delimiter, dirname as dirname2, extname } from "path";
 import { readdirSync, statSync, existsSync as existsSync2, mkdirSync, writeFileSync, readFileSync as readFileSync2 } from "fs";
 function resolveTimeout(resolve) {
   resolve({ exitCode: 1 });
@@ -37803,7 +37834,11 @@ class ConnectorBridge {
           if (!stats.isFile()) {
             continue;
           }
-          const name = file.replace("connect-", "");
+          const ext = extname(file);
+          let name = file.replace("connect-", "");
+          if (ext && [".exe", ".cmd", ".bat", ".ps1"].includes(ext.toLowerCase())) {
+            name = name.slice(0, -ext.length);
+          }
           if (name && !name.includes(".") && name.length > 1) {
             connectorNames.add(name);
           }
@@ -37857,6 +37892,7 @@ class ConnectorBridge {
   async discover(connectorNames) {
     const names = connectorNames && connectorNames.length > 0 ? connectorNames : this.autoDiscoverConnectorNames();
     if (names.length === 0) {
+      this.connectors = new Map;
       return [];
     }
     const uncached = [];
@@ -37900,16 +37936,17 @@ class ConnectorBridge {
     };
   }
   async populateCache(name) {
-    const cli = `connect-${name}`;
+    const cli = await this.resolveConnectorCli(name);
     try {
       let timeoutId = null;
       const timeoutPromise = new Promise((resolve) => {
         timeoutId = setTimeout(resolveTimeout, 500, resolve);
       });
-      const result = await Promise.race([
-        Bun.$`which ${cli}`.quiet().nothrow(),
-        timeoutPromise
-      ]);
+      if (!cli) {
+        ConnectorBridge.cache.set(name, null);
+        return;
+      }
+      const result = await Promise.race([Bun.$`which ${cli}`.quiet().nothrow(), timeoutPromise]);
       if (timeoutId) {
         clearTimeout(timeoutId);
       }
@@ -37923,6 +37960,30 @@ class ConnectorBridge {
       ConnectorBridge.cache.set(name, null);
     }
   }
+  async resolveConnectorCli(name) {
+    const base2 = `connect-${name}`;
+    const candidates = [base2];
+    const extCandidates = [".exe", ".cmd", ".bat", ".ps1"];
+    for (const ext of extCandidates) {
+      candidates.push(`${base2}${ext}`);
+    }
+    for (const candidate of candidates) {
+      try {
+        let timeoutId = null;
+        const timeoutPromise = new Promise((resolve) => {
+          timeoutId = setTimeout(resolveTimeout, 500, resolve);
+        });
+        const result = await Promise.race([Bun.$`which ${candidate}`.quiet().nothrow(), timeoutPromise]);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        if (result.exitCode === 0) {
+          return candidate;
+        }
+      } catch {}
+    }
+    return null;
+  }
   async discoverConnector(name, cli) {
     try {
       const helpResult = await Bun.$`${cli} --help`.quiet();
@@ -38462,14 +38523,16 @@ ${stderr || stdout}`.trim(), {
 
 // packages/core/src/tools/filesystem.ts
 import { join as join4, resolve as resolve3, dirname as dirname3, sep } from "path";
+import { homedir as homedir5 } from "os";
 init_errors();
 var {Glob } = globalThis.Bun;
 
 // packages/core/src/validation/paths.ts
-import { resolve, normalize } from "path";
+import { resolve, normalize, relative, isAbsolute } from "path";
+import { homedir as homedir3 } from "os";
 import { lstat, realpath } from "fs/promises";
 async function validatePath(inputPath, options = {}) {
-  const normalized = normalize(inputPath);
+  const normalized = normalize(expandHome(inputPath));
   const resolved = resolve(normalized);
   const allowedPaths = options.allowedPaths?.map((p) => resolve(p));
   const blockedPaths = options.blockedPaths?.map((p) => resolve(p));
@@ -38490,7 +38553,7 @@ async function validatePath(inputPath, options = {}) {
       }
     } catch {}
   }
-  if (blockedPaths && blockedPaths.some((blocked) => resolved.startsWith(blocked))) {
+  if (blockedPaths && blockedPaths.some((blocked) => isWithinPath(resolved, blocked))) {
     return { valid: false, resolved, error: "Path is in blocked list" };
   }
   if (!isWithinAllowed(resolved, allowedPaths)) {
@@ -38498,15 +38561,35 @@ async function validatePath(inputPath, options = {}) {
   }
   return { valid: true, resolved };
 }
+function expandHome(value) {
+  if (value === "~")
+    return homedir3();
+  if (value.startsWith("~/")) {
+    return resolve(homedir3(), value.slice(2));
+  }
+  return value;
+}
 function isWithinAllowed(path, allowed) {
   if (!allowed || allowed.length === 0)
     return true;
   return allowed.some((allowedPath) => path === allowedPath || path.startsWith(`${allowedPath}/`));
 }
+function isWithinPath(target, base2) {
+  if (target === base2)
+    return true;
+  const rel = relative(base2, target);
+  if (!rel || rel === "")
+    return true;
+  if (rel.startsWith(".."))
+    return false;
+  if (isAbsolute(rel))
+    return false;
+  return true;
+}
 
 // packages/core/src/security/path-validator.ts
-import { homedir as homedir3 } from "os";
-import { resolve as resolve2 } from "path";
+import { homedir as homedir4 } from "os";
+import { resolve as resolve2, relative as relative2, isAbsolute as isAbsolute2 } from "path";
 import { lstat as lstat2, realpath as realpath2 } from "fs/promises";
 var PROTECTED_PATHS = [
   "/etc/passwd",
@@ -38518,17 +38601,16 @@ var PROTECTED_PATHS = [
   "~/.kube/config"
 ];
 async function isPathSafe(targetPath, operation, options = {}) {
-  const resolved = resolve2(targetPath);
-  const home = homedir3();
+  const expandedTarget = expandHome2(targetPath);
+  const resolved = resolve2(expandedTarget);
+  const home = homedir4();
   for (const protectedPath of PROTECTED_PATHS) {
     const expanded = protectedPath.replace("~", home);
-    if (resolved.startsWith(expanded)) {
-      if (operation === "write" || operation === "delete") {
-        return {
-          safe: false,
-          reason: `Cannot ${operation} protected path: ${protectedPath}`
-        };
-      }
+    if (isWithinPath2(resolved, expanded)) {
+      return {
+        safe: false,
+        reason: `Cannot ${operation} protected path: ${protectedPath}`
+      };
     }
   }
   try {
@@ -38546,6 +38628,24 @@ async function isPathSafe(targetPath, operation, options = {}) {
   } catch {}
   return { safe: true };
 }
+function expandHome2(value) {
+  if (value === "~")
+    return homedir4();
+  if (value.startsWith("~/")) {
+    return resolve2(homedir4(), value.slice(2));
+  }
+  return value;
+}
+function isWithinPath2(target, base2) {
+  const rel = relative2(base2, target);
+  if (rel === "")
+    return true;
+  if (rel.startsWith(".."))
+    return false;
+  if (isAbsolute2(rel))
+    return false;
+  return true;
+}
 
 // packages/core/src/tools/filesystem.ts
 var currentSessionId = "default";
@@ -38562,6 +38662,17 @@ function isInScriptsFolder(path, cwd2, sessionId) {
 }
 
 class FilesystemTools {
+  static resolveInputPath(baseCwd, inputPath) {
+    const envHome = process.env.HOME || process.env.USERPROFILE;
+    const home = envHome && envHome.trim().length > 0 ? envHome : homedir5();
+    if (inputPath === "~") {
+      return home;
+    }
+    if (inputPath.startsWith("~/")) {
+      return resolve3(home, inputPath.slice(2));
+    }
+    return resolve3(baseCwd, inputPath);
+  }
   static registerAll(registry, sessionId) {
     if (sessionId) {
       currentSessionId = sessionId;
@@ -38603,9 +38714,21 @@ class FilesystemTools {
   };
   static readExecutor = async (input) => {
     const baseCwd = input.cwd || process.cwd();
-    const path = resolve3(baseCwd, input.path);
+    const rawPath = String(input.path || "").trim();
+    if (!rawPath) {
+      throw new ToolExecutionError("File path is required", {
+        toolName: "read",
+        toolInput: input,
+        code: ErrorCodes.VALIDATION_OUT_OF_RANGE,
+        recoverable: false,
+        retryable: false,
+        suggestion: "Provide a valid file path."
+      });
+    }
+    const path = FilesystemTools.resolveInputPath(baseCwd, rawPath);
     const offset = (input.offset || 1) - 1;
-    const limit = input.limit;
+    const limitRaw = input.limit;
+    const limit = typeof limitRaw === "number" && limitRaw > 0 ? Math.floor(limitRaw) : undefined;
     try {
       const safety = await isPathSafe(path, "read", { cwd: baseCwd });
       if (!safety.safe) {
@@ -38661,7 +38784,10 @@ class FilesystemTools {
         });
       }
       const content = await file.text();
-      const lines = content.split(`
+      const normalized = content.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+      const lines = normalized.split(`
 `);
       const startLine = Math.max(0, offset);
       const endLine = limit ? startLine + limit : lines.length;
@@ -38711,6 +38837,16 @@ class FilesystemTools {
     const filename = input.filename || input.path;
     const content = input.content;
     const baseCwd = input.cwd || process.cwd();
+    if (typeof content !== "string") {
+      throw new ToolExecutionError("Content must be a string", {
+        toolName: "write",
+        toolInput: input,
+        code: ErrorCodes.VALIDATION_OUT_OF_RANGE,
+        recoverable: false,
+        retryable: false,
+        suggestion: "Provide string content to write."
+      });
+    }
     const scriptsFolder = getScriptsFolder(baseCwd, input.sessionId);
     if (!filename || !filename.trim()) {
       throw new ToolExecutionError("Filename is required", {
@@ -38805,13 +38941,55 @@ class FilesystemTools {
     }
   };
   static globExecutor = async (input) => {
-    const pattern = input.pattern;
+    const pattern = String(input.pattern || "").trim();
     const baseCwd = input.cwd || process.cwd();
-    const searchPath = resolve3(baseCwd, input.path || ".");
+    const searchPath = FilesystemTools.resolveInputPath(baseCwd, input.path || ".");
     try {
+      if (!pattern) {
+        throw new ToolExecutionError("Pattern is required", {
+          toolName: "glob",
+          toolInput: input,
+          code: ErrorCodes.VALIDATION_OUT_OF_RANGE,
+          recoverable: false,
+          retryable: false
+        });
+      }
+      const safety = await isPathSafe(searchPath, "read", { cwd: baseCwd });
+      if (!safety.safe) {
+        getSecurityLogger().log({
+          eventType: "path_violation",
+          severity: "high",
+          details: {
+            tool: "glob",
+            path: searchPath,
+            reason: safety.reason || "Blocked path"
+          },
+          sessionId: input.sessionId || "unknown"
+        });
+        throw new ToolExecutionError(safety.reason || "Blocked path", {
+          toolName: "glob",
+          toolInput: input,
+          code: ErrorCodes.TOOL_PERMISSION_DENIED,
+          recoverable: false,
+          retryable: false
+        });
+      }
+      const validated = await validatePath(searchPath, {
+        allowSymlinks: true,
+        allowedPaths: [baseCwd, searchPath]
+      });
+      if (!validated.valid) {
+        throw new ToolExecutionError(validated.error || "Invalid path", {
+          toolName: "glob",
+          toolInput: input,
+          code: ErrorCodes.VALIDATION_OUT_OF_RANGE,
+          recoverable: false,
+          retryable: false
+        });
+      }
       const glob = new Glob(pattern);
       const matches = [];
-      for await (const file of glob.scan({ cwd: searchPath })) {
+      for await (const file of glob.scan({ cwd: validated.resolved })) {
         matches.push(file);
         if (matches.length >= 1000)
           break;
@@ -38864,18 +39042,60 @@ class FilesystemTools {
     }
   };
   static grepExecutor = async (input) => {
-    const pattern = input.pattern;
+    const pattern = String(input.pattern || "").trim();
     const baseCwd = input.cwd || process.cwd();
-    const searchPath = resolve3(baseCwd, input.path || ".");
+    const searchPath = FilesystemTools.resolveInputPath(baseCwd, input.path || ".");
     const globPattern = input.glob || "**/*";
     const caseSensitive = input.caseSensitive || false;
     try {
+      if (!pattern) {
+        throw new ToolExecutionError("Pattern is required", {
+          toolName: "grep",
+          toolInput: input,
+          code: ErrorCodes.VALIDATION_OUT_OF_RANGE,
+          recoverable: false,
+          retryable: false
+        });
+      }
+      const safety = await isPathSafe(searchPath, "read", { cwd: baseCwd });
+      if (!safety.safe) {
+        getSecurityLogger().log({
+          eventType: "path_violation",
+          severity: "high",
+          details: {
+            tool: "grep",
+            path: searchPath,
+            reason: safety.reason || "Blocked path"
+          },
+          sessionId: input.sessionId || "unknown"
+        });
+        throw new ToolExecutionError(safety.reason || "Blocked path", {
+          toolName: "grep",
+          toolInput: input,
+          code: ErrorCodes.TOOL_PERMISSION_DENIED,
+          recoverable: false,
+          retryable: false
+        });
+      }
+      const validated = await validatePath(searchPath, {
+        allowSymlinks: true,
+        allowedPaths: [baseCwd, searchPath]
+      });
+      if (!validated.valid) {
+        throw new ToolExecutionError(validated.error || "Invalid path", {
+          toolName: "grep",
+          toolInput: input,
+          code: ErrorCodes.VALIDATION_OUT_OF_RANGE,
+          recoverable: false,
+          retryable: false
+        });
+      }
       const flags = caseSensitive ? "" : "i";
       const regex2 = new RegExp(pattern, flags);
       const results = [];
       const glob = new Glob(globPattern);
-      for await (const file of glob.scan({ cwd: searchPath })) {
-        const filePath = join4(searchPath, file);
+      for await (const file of glob.scan({ cwd: validated.resolved })) {
+        const filePath = join4(validated.resolved, file);
         try {
           const content = await Bun.file(filePath).text();
           const lines = content.split(`
@@ -38928,7 +39148,7 @@ class FilesystemTools {
   };
   static readPdfExecutor = async (input) => {
     const baseCwd = input.cwd || process.cwd();
-    const path = resolve3(baseCwd, input.path);
+    const path = FilesystemTools.resolveInputPath(baseCwd, String(input.path || ""));
     try {
       const safety = await isPathSafe(path, "read", { cwd: baseCwd });
       if (!safety.safe) {
@@ -39847,13 +40067,19 @@ function getNextCronRun(expression, fromTime, timeZone) {
 
 // packages/core/src/scheduler/store.ts
 var DEFAULT_LOCK_TTL_MS = 10 * 60 * 1000;
+var SAFE_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
 function schedulesDir(cwd2) {
   return join6(getProjectConfigDir(cwd2), "schedules");
 }
 function locksDir(cwd2) {
   return join6(schedulesDir(cwd2), "locks");
 }
+function isSafeId(id) {
+  return SAFE_ID_PATTERN.test(id);
+}
 function schedulePath(cwd2, id) {
+  if (!isSafeId(id))
+    return null;
   return join6(schedulesDir(cwd2), `${id}.json`);
 }
 function lockPath(cwd2, id) {
@@ -39886,11 +40112,17 @@ async function listSchedules(cwd2) {
 async function saveSchedule(cwd2, schedule) {
   await ensureDirs(cwd2);
   const path = schedulePath(cwd2, schedule.id);
+  if (!path) {
+    throw new Error(`Invalid schedule id: ${schedule.id}`);
+  }
   await writeFile(path, JSON.stringify(schedule, null, 2), "utf-8");
 }
 async function deleteSchedule(cwd2, id) {
   try {
-    await unlink(schedulePath(cwd2, id));
+    const path = schedulePath(cwd2, id);
+    if (!path)
+      return false;
+    await unlink(path);
     return true;
   } catch {
     return false;
@@ -39902,7 +40134,10 @@ function computeNextRun(schedule, fromTime) {
   if (schedule.schedule.kind === "once") {
     if (!schedule.schedule.at)
       return;
-    return parseScheduledTime(schedule.schedule.at, validTimezone);
+    const next = parseScheduledTime(schedule.schedule.at, validTimezone);
+    if (!next || next <= fromTime)
+      return;
+    return next;
   }
   if (schedule.schedule.kind === "cron") {
     if (!schedule.schedule.cron)
@@ -39918,12 +40153,17 @@ async function getDueSchedules(cwd2, nowTime) {
       return false;
     if (!schedule.nextRunAt)
       return false;
+    if (!Number.isFinite(schedule.nextRunAt))
+      return false;
     return schedule.nextRunAt <= nowTime;
   });
 }
 async function updateSchedule(cwd2, id, updater) {
   try {
-    const raw = await readFile(schedulePath(cwd2, id), "utf-8");
+    const path = schedulePath(cwd2, id);
+    if (!path)
+      return null;
+    const raw = await readFile(path, "utf-8");
     const schedule = JSON.parse(raw);
     const updated = updater(schedule);
     await saveSchedule(cwd2, updated);
@@ -39933,6 +40173,8 @@ async function updateSchedule(cwd2, id, updater) {
   }
 }
 async function acquireScheduleLock(cwd2, id, ownerId, ttlMs = DEFAULT_LOCK_TTL_MS, allowRetry = true) {
+  if (!isSafeId(id))
+    return false;
   await ensureDirs(cwd2);
   const path = lockPath(cwd2, id);
   const now2 = Date.now();
@@ -39965,6 +40207,8 @@ async function acquireScheduleLock(cwd2, id, ownerId, ttlMs = DEFAULT_LOCK_TTL_M
   return false;
 }
 async function releaseScheduleLock(cwd2, id, ownerId) {
+  if (!isSafeId(id))
+    return;
   const path = lockPath(cwd2, id);
   try {
     const raw = await readFile(path, "utf-8");
@@ -39975,6 +40219,8 @@ async function releaseScheduleLock(cwd2, id, ownerId) {
   } catch {}
 }
 async function refreshScheduleLock(cwd2, id, ownerId) {
+  if (!isSafeId(id))
+    return;
   const path = lockPath(cwd2, id);
   try {
     const raw = await readFile(path, "utf-8");
@@ -39987,7 +40233,10 @@ async function refreshScheduleLock(cwd2, id, ownerId) {
 }
 async function readSchedule(cwd2, id) {
   try {
-    const raw = await readFile(schedulePath(cwd2, id), "utf-8");
+    const path = schedulePath(cwd2, id);
+    if (!path)
+      return null;
+    const raw = await readFile(path, "utf-8");
     const schedule = JSON.parse(raw);
     if (!schedule?.id)
       return null;
@@ -40033,6 +40282,9 @@ function parseDateTime(value) {
   if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day) || !Number.isFinite(hour) || !Number.isFinite(minute) || !Number.isFinite(second)) {
     return null;
   }
+  if (month < 1 || month > 12 || day < 1 || day > 31 || hour < 0 || hour > 23 || minute < 0 || minute > 59 || second < 0 || second > 59) {
+    return null;
+  }
   return { year, month, day, hour, minute, second };
 }
 function hasTimeZoneOffset(value) {
@@ -40171,11 +40423,21 @@ class SchedulerTool {
       const id = String(input.id || "").trim();
       if (!id)
         return "Error: id is required.";
+      let nextRunAt;
+      if (action === "resume") {
+        const schedule = await readSchedule(cwd2, id);
+        if (!schedule)
+          return `Schedule ${id} not found.`;
+        nextRunAt = computeNextRun(schedule, Date.now());
+        if (!nextRunAt) {
+          return `Error: unable to compute next run for schedule ${id}.`;
+        }
+      }
       const updated = await updateSchedule(cwd2, id, (s) => ({
         ...s,
         status: action === "pause" ? "paused" : "active",
         updatedAt: Date.now(),
-        nextRunAt: action === "resume" ? computeNextRun(s, Date.now()) : s.nextRunAt
+        nextRunAt: action === "resume" ? nextRunAt : s.nextRunAt
       }));
       if (!updated)
         return `Schedule ${id} not found.`;
@@ -40190,7 +40452,7 @@ init_src();
 import { existsSync as existsSync4, writeFileSync as writeFileSync3, unlinkSync } from "fs";
 import { tmpdir } from "os";
 import { join as join7 } from "path";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir6 } from "os";
 async function getViuPath() {
   const explicitPath = process.env.ASSISTANTS_VIU_PATH || process.env.VIU_PATH;
   if (explicitPath) {
@@ -40202,7 +40464,7 @@ async function getViuPath() {
     } catch {}
   }
   const envHome = process.env.HOME || process.env.USERPROFILE;
-  const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir4();
+  const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir6();
   const locations = [
     "viu",
     join7(homeDir, ".cargo", "bin", "viu"),
@@ -40351,14 +40613,14 @@ Respond with ALLOW or DENY on the first line, followed by a short reason.`,
 // packages/core/src/skills/loader.ts
 init_src();
 import { join as join8, basename, dirname as dirname4 } from "path";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir7 } from "os";
 var {Glob: Glob2 } = globalThis.Bun;
 
 class SkillLoader {
   skills = new Map;
   async loadAll(projectDir = process.cwd()) {
     const envHome = process.env.HOME || process.env.USERPROFILE;
-    const userHome = envHome && envHome.trim().length > 0 ? envHome : homedir5();
+    const userHome = envHome && envHome.trim().length > 0 ? envHome : homedir7();
     const userSkillsDir = join8(userHome, ".assistants", "shared", "skills");
     await this.loadFromDirectory(userSkillsDir);
     const projectSkillsDir = join8(projectDir, ".assistants", "skills");
@@ -40574,6 +40836,7 @@ class HookLoader {
 }
 // packages/core/src/hooks/executor.ts
 init_src();
+import { existsSync as existsSync5 } from "fs";
 function killSpawnedProcess(proc) {
   proc.kill();
 }
@@ -40659,7 +40922,9 @@ class HookExecutor {
     if (!hook.command)
       return null;
     try {
+      const cwd2 = input.cwd && existsSync5(input.cwd) ? input.cwd : process.cwd();
       const proc = Bun.spawn(["bash", "-c", hook.command], {
+        cwd: cwd2,
         stdin: "pipe",
         stdout: "pipe",
         stderr: "pipe"
@@ -41036,7 +41301,7 @@ init_src();
 // packages/core/src/sessions/verification.ts
 init_src();
 import { join as join9 } from "path";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4, readdirSync as readdirSync2 } from "fs";
 
 class VerificationSessionStore {
   basePath;
@@ -41047,7 +41312,7 @@ class VerificationSessionStore {
     this.ensureDirectory();
   }
   ensureDirectory() {
-    if (!existsSync5(this.basePath)) {
+    if (!existsSync6(this.basePath)) {
       mkdirSync3(this.basePath, { recursive: true });
     }
   }
@@ -41073,7 +41338,7 @@ class VerificationSessionStore {
   }
   get(id) {
     const filePath = join9(this.basePath, `${id}.json`);
-    if (!existsSync5(filePath)) {
+    if (!existsSync6(filePath)) {
       return null;
     }
     try {
@@ -41121,7 +41386,7 @@ class VerificationSessionStore {
     this.save(session);
   }
   listFiles() {
-    if (!existsSync5(this.basePath)) {
+    if (!existsSync6(this.basePath)) {
       return [];
     }
     return readdirSync2(this.basePath).filter((f) => f.endsWith(".json"));
@@ -41312,9 +41577,9 @@ function createScopeVerificationHook() {
   };
 }
 // packages/core/src/commands/loader.ts
-import { existsSync as existsSync6, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { join as join10, basename as basename2, extname } from "path";
-import { homedir as homedir6 } from "os";
+import { existsSync as existsSync7, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join10, basename as basename2, extname as extname2 } from "path";
+import { homedir as homedir8 } from "os";
 
 class CommandLoader {
   commands = new Map;
@@ -41325,14 +41590,14 @@ class CommandLoader {
   async loadAll() {
     this.commands.clear();
     const envHome = process.env.HOME || process.env.USERPROFILE;
-    const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir6();
+    const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir8();
     const globalDir = join10(homeDir, ".assistants", "commands");
     await this.loadFromDirectory(globalDir, "global");
     const projectDir = join10(this.cwd, ".assistants", "commands");
     await this.loadFromDirectory(projectDir, "project");
   }
   async loadFromDirectory(dir, source, prefix = "") {
-    if (!existsSync6(dir))
+    if (!existsSync7(dir))
       return;
     const entries = readdirSync3(dir);
     for (const entry of entries) {
@@ -41341,7 +41606,7 @@ class CommandLoader {
       if (stat.isDirectory()) {
         const newPrefix = prefix ? `${prefix}:${entry}` : entry;
         await this.loadFromDirectory(fullPath, source, newPrefix);
-      } else if (stat.isFile() && extname(entry) === ".md") {
+      } else if (stat.isFile() && extname2(entry) === ".md") {
         const command = await this.loadCommandFile(fullPath, prefix);
         if (command) {
           this.commands.set(command.name, command);
@@ -41372,15 +41637,14 @@ class CommandLoader {
     }
   }
   parseFrontmatter(content) {
-    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+    const frontmatterRegex = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?([\s\S]*)$/;
     const match = content.match(frontmatterRegex);
     if (!match) {
       return { frontmatter: {}, body: content };
     }
     const [, yamlContent, body] = match;
     const frontmatter = {};
-    const lines = yamlContent.split(`
-`);
+    const lines = yamlContent.split(/\r?\n/);
     let currentListKey = null;
     for (const rawLine of lines) {
       const line = rawLine.trimEnd();
@@ -41512,10 +41776,16 @@ Use /help to see available commands.
       }
       if (!inCodeBlock && trimmed.startsWith("!")) {
         const command = trimmed.slice(1).trim();
+        if (!command) {
+          processedLines.push(line);
+          continue;
+        }
         const output = await this.executeShell(command, cwd2);
-        processedLines.push(`\`\`\`
-${output}
-\`\`\``);
+        const indent = line.match(/^\s*/)?.[0] ?? "";
+        const fenced = [`${indent}\`\`\``, ...output.split(`
+`).map((o) => `${indent}${o}`), `${indent}\`\`\``];
+        processedLines.push(fenced.join(`
+`));
       } else {
         processedLines.push(line);
       }
@@ -41567,19 +41837,25 @@ ${stderr}`;
   }
 }
 // packages/core/src/commands/builtin.ts
-import { join as join12 } from "path";
-import { homedir as homedir7, platform as platform2, release, arch } from "os";
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
+import { join as join13 } from "path";
+import { homedir as homedir10, platform as platform2, release, arch } from "os";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
 init_src();
 
 // packages/core/src/projects/store.ts
 init_src();
 import { join as join11 } from "path";
 import { mkdir as mkdir3, readdir as readdir2, readFile as readFile2, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
+var SAFE_ID_PATTERN2 = /^[a-zA-Z0-9_-]+$/;
 function projectsDir(cwd2) {
   return join11(cwd2, ".assistants", "projects");
 }
+function isSafeId2(id) {
+  return SAFE_ID_PATTERN2.test(id);
+}
 function projectPath(cwd2, id) {
+  if (!isSafeId2(id))
+    return null;
   return join11(projectsDir(cwd2), `${id}.json`);
 }
 async function ensureProjectsDir(cwd2) {
@@ -41611,7 +41887,10 @@ async function listProjects(cwd2) {
 }
 async function readProject(cwd2, id) {
   try {
-    const raw = await readFile2(projectPath(cwd2, id), "utf-8");
+    const path = projectPath(cwd2, id);
+    if (!path)
+      return null;
+    const raw = await readFile2(path, "utf-8");
     const project = JSON.parse(raw);
     if (!project?.id || !project?.name)
       return null;
@@ -41627,11 +41906,18 @@ async function findProjectByName(cwd2, name) {
 }
 async function saveProject(cwd2, project) {
   await ensureProjectsDir(cwd2);
-  await writeFile2(projectPath(cwd2, project.id), JSON.stringify(project, null, 2), "utf-8");
+  const path = projectPath(cwd2, project.id);
+  if (!path) {
+    throw new Error(`Invalid project id: ${project.id}`);
+  }
+  await writeFile2(path, JSON.stringify(project, null, 2), "utf-8");
 }
 async function deleteProject(cwd2, id) {
   try {
-    await unlink2(projectPath(cwd2, id));
+    const path = projectPath(cwd2, id);
+    if (!path)
+      return false;
+    await unlink2(path);
     return true;
   } catch {
     return false;
@@ -41672,23 +41958,28 @@ function hasProjectNameConflict(projects, name) {
 
 // packages/core/src/projects/context.ts
 import { readFile as readFile3 } from "fs/promises";
-import { resolve as resolve4 } from "path";
+import { homedir as homedir9 } from "os";
+import { resolve as resolve4, join as join12 } from "path";
 var DEFAULT_MAX_FILE_BYTES = 12000;
+function singleLine(value) {
+  return value.replace(/[\r\n]+/g, " ").trim();
+}
 function formatPlan(plan) {
   const lines = [];
-  lines.push(`- ${plan.title} (${plan.steps.length} steps)`);
+  lines.push(`- ${singleLine(plan.title)} (${plan.steps.length} steps)`);
   for (const step of plan.steps) {
-    lines.push(`  - [${step.status}] ${step.text}`);
+    lines.push(`  - [${step.status}] ${singleLine(step.text)}`);
   }
   return lines.join(`
 `);
 }
 function normalizeEntryLabel(entry) {
-  return entry.label ? entry.label.trim() : entry.value.trim();
+  return entry.label ? singleLine(entry.label) : singleLine(entry.value);
 }
 async function renderFileEntry(entry, options) {
   const rawPath = entry.value.trim();
-  const resolved = resolve4(options.cwd, rawPath);
+  const expandedPath = rawPath === "~" ? homedir9() : rawPath.startsWith("~/") ? join12(homedir9(), rawPath.slice(2)) : rawPath;
+  const resolved = resolve4(options.cwd, expandedPath);
   const validation = await validatePath(resolved, { allowedPaths: [options.cwd] });
   if (!validation.valid) {
     return `- File: ${rawPath} (unavailable: ${validation.error || "invalid path"})`;
@@ -41820,7 +42111,7 @@ function splitArgs(input) {
     args.push(current);
   return args;
 }
-function singleLine(value) {
+function singleLine2(value) {
   return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
 }
 
@@ -42659,12 +42950,12 @@ No context entries for project "${project.name}".
             return { handled: true };
           }
           let output = `
-**Context Entries (${singleLine(project.name)})**
+**Context Entries (${singleLine2(project.name)})**
 
 `;
           for (const entry of project.context) {
-            const label = entry.label ? ` (${singleLine(entry.label)})` : "";
-            output += `- ${entry.id} [${entry.type}] ${singleLine(entry.value)}${label}
+            const label = entry.label ? ` (${singleLine2(entry.label)})` : "";
+            output += `- ${entry.id} [${entry.type}] ${singleLine2(entry.value)}${label}
 `;
           }
           context.emit("text", output);
@@ -42811,7 +43102,7 @@ No projects found. Use /projects new <name>.
 `;
           for (const project of projects) {
             const marker = project.id === activeId ? "*" : " ";
-            output += `${marker} ${singleLine(project.name)} (${project.id})
+            output += `${marker} ${singleLine2(project.name)} (${project.id})
 `;
           }
           context.emit("text", output);
@@ -42873,13 +43164,13 @@ No projects found. Use /projects new <name>.
             return { handled: true };
           }
           let output = `
-**Project: ${singleLine(project.name)}**
+**Project: ${singleLine2(project.name)}**
 
 `;
           output += `ID: ${project.id}
 `;
           if (project.description) {
-            output += `Description: ${singleLine(project.description)}
+            output += `Description: ${singleLine2(project.description)}
 `;
           }
           output += `Context entries: ${project.context.length}
@@ -43005,11 +43296,11 @@ No plans for project "${project.name}".
             return { handled: true };
           }
           let output = `
-**Plans (${singleLine(project.name)})**
+**Plans (${singleLine2(project.name)})**
 
 `;
           for (const plan of project.plans) {
-            output += `- ${plan.id} ${singleLine(plan.title)} (${plan.steps.length} steps)
+            output += `- ${plan.id} ${singleLine2(plan.title)} (${plan.steps.length} steps)
 `;
           }
           context.emit("text", output);
@@ -43065,7 +43356,7 @@ No plans for project "${project.name}".
             return { handled: true };
           }
           let output = `
-**Plan: ${singleLine(plan.title)}**
+**Plan: ${singleLine2(plan.title)}**
 
 `;
           output += `ID: ${plan.id}
@@ -43075,7 +43366,7 @@ No plans for project "${project.name}".
 `;
           } else {
             for (const step of plan.steps) {
-              output += `- ${step.id} [${step.status}] ${singleLine(step.text)}
+              output += `- ${step.id} [${step.status}] ${singleLine2(step.text)}
 `;
             }
           }
@@ -43508,9 +43799,9 @@ Format the summary as a brief bullet-point list. This summary will replace the c
       content: "",
       handler: async (args, context) => {
         const configPaths = [
-          join12(context.cwd, ".assistants", "config.json"),
-          join12(context.cwd, ".assistants", "config.local.json"),
-          join12(getConfigDir(), "config.json")
+          join13(context.cwd, ".assistants", "config.json"),
+          join13(context.cwd, ".assistants", "config.local.json"),
+          join13(getConfigDir(), "config.json")
         ];
         let message = `
 **Configuration**
@@ -43519,18 +43810,18 @@ Format the summary as a brief bullet-point list. This summary will replace the c
         message += `**Config File Locations:**
 `;
         for (const path of configPaths) {
-          const exists = existsSync7(path);
+          const exists = existsSync8(path);
           message += `  ${exists ? "\u2713" : "\u25CB"} ${path}
 `;
         }
         const envHome = process.env.HOME || process.env.USERPROFILE;
-        const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir7();
+        const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir10();
         message += `
 **Commands Directories:**
 `;
-        message += `  - Project: ${join12(context.cwd, ".assistants", "commands")}
+        message += `  - Project: ${join13(context.cwd, ".assistants", "commands")}
 `;
-        message += `  - Global: ${join12(homeDir, ".assistants", "commands")}
+        message += `  - Global: ${join13(homeDir, ".assistants", "commands")}
 `;
         context.emit("text", message);
         context.emit("done");
@@ -43546,7 +43837,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 = join12(context.cwd, ".assistants", "commands");
+        const commandsDir = join13(context.cwd, ".assistants", "commands");
         mkdirSync4(commandsDir, { recursive: true });
         const exampleCommand = `---
 name: reflect
@@ -43562,8 +43853,8 @@ Please summarize the last interaction and suggest 2-3 next steps.
 - Focus on clarity
 - Ask a follow-up question if needed
 `;
-        const examplePath = join12(commandsDir, "reflect.md");
-        if (!existsSync7(examplePath)) {
+        const examplePath = join13(commandsDir, "reflect.md");
+        if (!existsSync8(examplePath)) {
           writeFileSync5(examplePath, exampleCommand);
         }
         let message = `
@@ -44727,15 +45018,15 @@ function validateToolCalls(toolCalls, tools) {
 }
 
 // packages/core/src/voice/utils.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join14 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir12 } from "os";
+import { join as join15 } 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 = join14(homeDir, ".secrets");
-  if (!existsSync9(secretsPath))
+  const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir12();
+  const secretsPath = join15(homeDir, ".secrets");
+  if (!existsSync10(secretsPath))
     return;
   try {
     const content = readFileSync5(secretsPath, "utf-8");
@@ -44808,7 +45099,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 join15 } from "path";
+import { join as join16 } from "path";
 import { readFileSync as readFileSync6, unlinkSync as unlinkSync2 } from "fs";
 class ElevenLabsTTS {
   apiKey;
@@ -44912,7 +45203,7 @@ class SystemTTS {
       if (!say) {
         throw new Error('System TTS not available: missing "say" command.');
       }
-      const output = join15(tmpdir2(), `assistants-tts-${Date.now()}.aiff`);
+      const output = join16(tmpdir2(), `assistants-tts-${Date.now()}.aiff`);
       const args = [];
       if (this.voiceId) {
         args.push("-v", this.voiceId);
@@ -44934,7 +45225,7 @@ class SystemTTS {
     }
     const espeak = findExecutable("espeak") || findExecutable("espeak-ng");
     if (espeak) {
-      const output = join15(tmpdir2(), `assistants-tts-${Date.now()}.wav`);
+      const output = join16(tmpdir2(), `assistants-tts-${Date.now()}.wav`);
       const args = ["-w", output];
       if (this.voiceId) {
         args.push("-v", this.voiceId);
@@ -44961,14 +45252,14 @@ class SystemTTS {
 // packages/core/src/voice/player.ts
 import { spawn } from "child_process";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 import { unlink as unlink4, writeFileSync as writeFileSync6 } from "fs";
 class AudioPlayer {
   currentProcess = null;
   playing = false;
   async play(audio, options = {}) {
     const format = options.format ?? "mp3";
-    const tempFile = join16(tmpdir3(), `assistants-audio-${Date.now()}.${format}`);
+    const tempFile = join17(tmpdir3(), `assistants-audio-${Date.now()}.${format}`);
     writeFileSync6(tempFile, Buffer.from(audio));
     const player = this.resolvePlayer(format);
     if (!player) {
@@ -45036,7 +45327,7 @@ class AudioPlayer {
 // packages/core/src/voice/recorder.ts
 import { spawn as spawn2 } from "child_process";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { readFileSync as readFileSync7, unlink as unlink5 } from "fs";
 class AudioRecorder {
   currentProcess = null;
@@ -45047,7 +45338,7 @@ class AudioRecorder {
     const duration = options.durationSeconds ?? 5;
     const sampleRate = options.sampleRate ?? 16000;
     const channels = options.channels ?? 1;
-    const output = join17(tmpdir4(), `assistants-record-${Date.now()}.wav`);
+    const output = join18(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.");
@@ -45239,15 +45530,15 @@ class VoiceManager {
 }
 // packages/core/src/identity/assistant-manager.ts
 init_src();
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { mkdir as mkdir5, readFile as readFile8, writeFile as writeFile7, rm as rm2 } from "fs/promises";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 
 // packages/core/src/identity/identity-manager.ts
 init_src();
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { mkdir as mkdir4, readFile as readFile7, writeFile as writeFile6, rm } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 var DEFAULT_PROFILE = {
   displayName: "Assistant",
   timezone: "UTC",
@@ -45277,19 +45568,19 @@ class IdentityManager {
     this.basePath = basePath;
   }
   get identitiesRoot() {
-    return join18(this.basePath, "assistants", this.assistantId, "identities");
+    return join19(this.basePath, "assistants", this.assistantId, "identities");
   }
   get indexPath() {
-    return join18(this.identitiesRoot, "index.json");
+    return join19(this.identitiesRoot, "index.json");
   }
   get activePath() {
-    return join18(this.identitiesRoot, "active.json");
+    return join19(this.identitiesRoot, "active.json");
   }
   identityPath(id) {
-    return join18(this.identitiesRoot, `${id}.json`);
+    return join19(this.identitiesRoot, `${id}.json`);
   }
   assistantConfigPath() {
-    return join18(this.basePath, "assistants", this.assistantId, "config.json");
+    return join19(this.basePath, "assistants", this.assistantId, "config.json");
   }
   async initialize() {
     await mkdir4(this.identitiesRoot, { recursive: true });
@@ -45395,7 +45686,7 @@ class IdentityManager {
 `);
   }
   async readIndex() {
-    if (!existsSync10(this.indexPath)) {
+    if (!existsSync11(this.indexPath)) {
       return { identities: [] };
     }
     try {
@@ -45420,7 +45711,7 @@ class IdentityManager {
   }
   async readIdentity(id) {
     const path2 = this.identityPath(id);
-    if (!existsSync10(path2))
+    if (!existsSync11(path2))
       return null;
     try {
       const raw = await readFile7(path2, "utf-8");
@@ -45434,7 +45725,7 @@ class IdentityManager {
     await writeFile6(this.identityPath(identity.id), JSON.stringify(identity, null, 2));
   }
   async readActive() {
-    if (!existsSync10(this.activePath))
+    if (!existsSync11(this.activePath))
       return null;
     try {
       const raw = await readFile7(this.activePath, "utf-8");
@@ -45449,7 +45740,7 @@ class IdentityManager {
     await writeFile6(this.activePath, JSON.stringify({ id }, null, 2));
   }
   async loadAssistant() {
-    if (!existsSync10(this.assistantConfigPath()))
+    if (!existsSync11(this.assistantConfigPath()))
       return null;
     try {
       const raw = await readFile7(this.assistantConfigPath(), "utf-8");
@@ -45473,16 +45764,16 @@ class AssistantManager {
     this.basePath = basePath;
   }
   get assistantsRoot() {
-    return join19(this.basePath, "assistants");
+    return join20(this.basePath, "assistants");
   }
   get indexPath() {
-    return join19(this.assistantsRoot, "index.json");
+    return join20(this.assistantsRoot, "index.json");
   }
   get activePath() {
-    return join19(this.basePath, "active.json");
+    return join20(this.basePath, "active.json");
   }
   assistantConfigPath(id) {
-    return join19(this.assistantsRoot, id, "config.json");
+    return join20(this.assistantsRoot, id, "config.json");
   }
   async initialize() {
     await mkdir5(this.assistantsRoot, { recursive: true });
@@ -45536,7 +45827,7 @@ class AssistantManager {
     if (!this.assistants.has(id)) {
       throw new Error(`Assistant ${id} not found`);
     }
-    await rm2(join19(this.assistantsRoot, id), { recursive: true, force: true });
+    await rm2(join20(this.assistantsRoot, id), { recursive: true, force: true });
     this.assistants.delete(id);
     await this.removeFromIndex(id);
     if (this.activeId === id) {
@@ -45567,7 +45858,7 @@ class AssistantManager {
     return new IdentityManager(assistantId, this.basePath);
   }
   async readIndex() {
-    if (!existsSync11(this.indexPath)) {
+    if (!existsSync12(this.indexPath)) {
       return { assistants: [] };
     }
     try {
@@ -45592,7 +45883,7 @@ class AssistantManager {
   }
   async readAssistant(id) {
     const configPath = this.assistantConfigPath(id);
-    if (!existsSync11(configPath))
+    if (!existsSync12(configPath))
       return null;
     try {
       const raw = await readFile8(configPath, "utf-8");
@@ -45602,12 +45893,12 @@ class AssistantManager {
     }
   }
   async persistAssistant(assistant) {
-    const dir = join19(this.assistantsRoot, assistant.id);
+    const dir = join20(this.assistantsRoot, assistant.id);
     await mkdir5(dir, { recursive: true });
     await writeFile7(this.assistantConfigPath(assistant.id), JSON.stringify(assistant, null, 2));
   }
   async readActive() {
-    if (!existsSync11(this.activePath))
+    if (!existsSync12(this.activePath))
       return null;
     try {
       const raw = await readFile8(this.activePath, "utf-8");
@@ -46062,7 +46353,7 @@ class AgentLoop {
       if (toolInput.cwd === undefined) {
         toolInput.cwd = this.cwd;
       }
-      if (toolInput.sessionId === undefined) {
+      if (typeof toolInput.sessionId !== "string" || toolInput.sessionId.length === 0) {
         toolInput.sessionId = this.sessionId;
       }
       toolCall.input = toolInput;
@@ -46098,7 +46389,7 @@ class AgentLoop {
       if (input.cwd === undefined) {
         input.cwd = this.cwd;
       }
-      if (input.sessionId === undefined) {
+      if (typeof input.sessionId !== "string" || input.sessionId.length === 0) {
         input.sessionId = this.sessionId;
       }
       if (preHookResult?.continue === false || preHookResult?.permissionDecision === "deny") {
@@ -46444,7 +46735,7 @@ ${content.trim()}`);
     const heartbeatConfig = this.buildHeartbeatConfig(this.config);
     if (!heartbeatConfig)
       return;
-    const statePath = join20(getConfigDir(), "state", `${this.sessionId}.json`);
+    const statePath = join21(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, {
@@ -46493,7 +46784,7 @@ ${content.trim()}`);
   async startEnergySystem() {
     if (!this.config || this.config.energy?.enabled === false)
       return;
-    const statePath = join20(getConfigDir(), "energy", "state.json");
+    const statePath = join21(getConfigDir(), "energy", "state.json");
     this.energyManager = new EnergyManager(this.config.energy, new EnergyStorage(statePath));
     await this.energyManager.initialize();
     this.refreshEnergyEffects();
@@ -46739,7 +47030,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 ?? join20(getConfigDir(), "heartbeats", `${this.sessionId}.json`);
+    const persistPath = config.heartbeat?.persistPath ?? join21(getConfigDir(), "heartbeats", `${this.sessionId}.json`);
     return {
       intervalMs,
       staleThresholdMs,
@@ -46835,21 +47126,21 @@ init_anthropic();
 init_src();
 
 // packages/core/src/logger.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, appendFileSync, readdirSync as readdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, appendFileSync, readdirSync as readdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { join as join22 } from "path";
 class Logger {
   logDir;
   logFile;
   sessionId;
   constructor(sessionId, basePath) {
     this.sessionId = sessionId;
-    this.logDir = join21(basePath || getConfigDir(), "logs");
+    this.logDir = join22(basePath || getConfigDir(), "logs");
     this.ensureDir(this.logDir);
     const date = new Date().toISOString().split("T")[0];
-    this.logFile = join21(this.logDir, `${date}.log`);
+    this.logFile = join22(this.logDir, `${date}.log`);
   }
   ensureDir(dir) {
-    if (!existsSync12(dir)) {
+    if (!existsSync13(dir)) {
       mkdirSync8(dir, { recursive: true });
     }
   }
@@ -46890,12 +47181,12 @@ class SessionStorage {
   constructor(sessionId, basePath, assistantId) {
     this.sessionId = sessionId;
     const root = basePath || getConfigDir();
-    this.sessionsDir = assistantId ? join21(root, "assistants", assistantId, "sessions") : join21(root, "sessions");
+    this.sessionsDir = assistantId ? join22(root, "assistants", assistantId, "sessions") : join22(root, "sessions");
     this.ensureDir(this.sessionsDir);
-    this.sessionFile = join21(this.sessionsDir, `${sessionId}.json`);
+    this.sessionFile = join22(this.sessionsDir, `${sessionId}.json`);
   }
   ensureDir(dir) {
-    if (!existsSync12(dir)) {
+    if (!existsSync13(dir)) {
       mkdirSync8(dir, { recursive: true });
     }
   }
@@ -46909,7 +47200,7 @@ class SessionStorage {
   }
   load() {
     try {
-      if (!existsSync12(this.sessionFile))
+      if (!existsSync13(this.sessionFile))
         return null;
       return JSON.parse(readFileSync8(this.sessionFile, "utf-8"));
     } catch {
@@ -46918,8 +47209,8 @@ class SessionStorage {
   }
   static getActiveAssistantId() {
     try {
-      const activePath = join21(getConfigDir(), "active.json");
-      if (!existsSync12(activePath))
+      const activePath = join22(getConfigDir(), "active.json");
+      if (!existsSync13(activePath))
         return null;
       const raw = readFileSync8(activePath, "utf-8");
       const data = JSON.parse(raw);
@@ -46932,16 +47223,16 @@ class SessionStorage {
     const root = getConfigDir();
     const resolvedId = assistantId ?? SessionStorage.getActiveAssistantId();
     if (resolvedId) {
-      const assistantDir = join21(root, "assistants", resolvedId, "sessions");
-      if (existsSync12(assistantDir)) {
+      const assistantDir = join22(root, "assistants", resolvedId, "sessions");
+      if (existsSync13(assistantDir)) {
         return assistantDir;
       }
     }
-    return join21(root, "sessions");
+    return join22(root, "sessions");
   }
   static listSessions(assistantId) {
     const sessionsDir = SessionStorage.resolveSessionsDir(assistantId);
-    if (!existsSync12(sessionsDir))
+    if (!existsSync13(sessionsDir))
       return [];
     const sessions = [];
     const files = readdirSync4(sessionsDir);
@@ -46949,7 +47240,7 @@ class SessionStorage {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const filePath = join21(sessionsDir, file);
+        const filePath = join22(sessionsDir, file);
         const stat = Bun.file(filePath);
         const content = JSON.parse(readFileSync8(filePath, "utf-8"));
         sessions.push({
@@ -46969,9 +47260,9 @@ class SessionStorage {
   }
   static loadSession(sessionId, assistantId) {
     const sessionsDir = SessionStorage.resolveSessionsDir(assistantId);
-    const sessionFile = join21(sessionsDir, `${sessionId}.json`);
+    const sessionFile = join22(sessionsDir, `${sessionId}.json`);
     try {
-      if (!existsSync12(sessionFile))
+      if (!existsSync13(sessionFile))
         return null;
       return JSON.parse(readFileSync8(sessionFile, "utf-8"));
     } catch {
@@ -46983,18 +47274,18 @@ function initAssistantsDir() {
   const baseDir = getConfigDir();
   const dirs = [
     baseDir,
-    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")
+    join22(baseDir, "logs"),
+    join22(baseDir, "assistants"),
+    join22(baseDir, "shared", "skills"),
+    join22(baseDir, "commands"),
+    join22(baseDir, "temp"),
+    join22(baseDir, "heartbeats"),
+    join22(baseDir, "state"),
+    join22(baseDir, "energy"),
+    join22(baseDir, "migration")
   ];
   for (const dir of dirs) {
-    if (!existsSync12(dir)) {
+    if (!existsSync13(dir)) {
       mkdirSync8(dir, { recursive: true });
     }
   }
@@ -47647,7 +47938,7 @@ function Input({ onSubmit, isProcessing, queueLength = 0, commands, skills = []
   const visibleSkills = getVisibleItems(filteredSkills);
   const visibleCommands = getVisibleItems(filteredCommands);
   const { stdout } = use_stdout_default();
-  const terminalWidth = stdout?.columns ?? 80;
+  const terminalWidth = Math.max(10, (stdout?.columns ?? 80) - 2);
   const lines = value.split(`
 `);
   const lineCount = lines.length;
@@ -47657,8 +47948,8 @@ function Input({ onSubmit, isProcessing, queueLength = 0, commands, skills = []
     children: [
       /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Box_default, {
         children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
-          color: "gray",
-          children: "\u2500".repeat(terminalWidth)
+          color: "#666666",
+          children: "-".repeat(terminalWidth)
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Box_default, {
@@ -47692,8 +47983,8 @@ function Input({ onSubmit, isProcessing, queueLength = 0, commands, skills = []
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Box_default, {
         children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
-          color: "gray",
-          children: "\u2500".repeat(terminalWidth)
+          color: "#666666",
+          children: "-".repeat(terminalWidth)
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
       isProcessing && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Box_default, {
@@ -47818,14 +48109,19 @@ function parseMarkdown(text, options) {
     codeBlocks.push(match);
     return `@@CODEBLOCK${codeBlocks.length - 1}@@`;
   });
+  const inlineCodeBlocks = [];
+  result = result.replace(/`([^`\n]+)`/g, (_, code) => {
+    inlineCodeBlocks.push(code);
+    return `@@INLINECODE${inlineCodeBlocks.length - 1}@@`;
+  });
   const blockSections = [];
   if (!options?.skipBlocks) {
     result = extractBlockSections(result, blockSections);
   }
-  result = result.replace(/\*\*(.+?)\*\*/g, (_, text2) => source_default.bold(text2));
-  result = result.replace(/__(.+?)__/g, (_, text2) => source_default.bold(text2));
-  result = result.replace(/\*(.+?)\*/g, (_, text2) => source_default.italic(text2));
-  result = result.replace(/_(.+?)_/g, (_, text2) => source_default.italic(text2));
+  result = result.replace(/(^|[\s([{>])\*\*([^*]+?)\*\*(?=[\s)\]}<.,!?;:]|$)/gm, (_, lead, text2) => `${lead}${source_default.bold(text2)}`);
+  result = result.replace(/(^|[\s([{>])__([^_]+?)__(?=[\s)\]}<.,!?;:]|$)/gm, (_, lead, text2) => `${lead}${source_default.bold(text2)}`);
+  result = result.replace(/(^|[\s([{>])\*([^*\n]+?)\*(?=[\s)\]}<.,!?;:]|$)/gm, (_, lead, text2) => `${lead}${source_default.italic(text2)}`);
+  result = result.replace(/(^|[\s([{>])_([^_\n]+?)_(?=[\s)\]}<.,!?;:]|$)/gm, (_, lead, text2) => `${lead}${source_default.italic(text2)}`);
   result = result.replace(/`([^`]+)`/g, (_, code) => source_default.dim(code));
   result = result.replace(/^### (.+)$/gm, (_, text2) => source_default.bold(text2));
   result = result.replace(/^## (.+)$/gm, (_, text2) => source_default.bold(text2));
@@ -47848,6 +48144,10 @@ function parseMarkdown(text, options) {
     const code = block.replace(/```\w*\n?/g, "").replace(/```$/g, "").trim();
     return source_default.dim(code);
   });
+  result = result.replace(/@@INLINECODE(\d+)@@/g, (_, index) => {
+    const code = inlineCodeBlocks[parseInt(index, 10)] ?? "";
+    return source_default.dim(code);
+  });
   return result.trimEnd();
 }
 var ALLOWED_BLOCK_TYPES = new Set(["info", "success", "warning", "error", "note", "command"]);
@@ -48083,7 +48383,7 @@ function renderBlockSection(section, maxWidth) {
   if (section.kind === "grid") {
     const adjustedWidth2 = maxWidth ? Math.max(20, maxWidth - section.indent.length) : undefined;
     if (section.cards.length === 0) {
-      return renderCard({ type: "note", title: "Grid", body: section.body }, adjustedWidth2, section.indent).join(`
+      return renderCard({ type: "note", title: "Grid", body: section.body }, adjustedWidth2, section.indent, Boolean(adjustedWidth2)).join(`
 `);
     }
     return renderCardGrid(section.cards, section.columns, adjustedWidth2, section.indent);
@@ -48215,7 +48515,15 @@ function formatMarkdownTables(text, maxWidth) {
   const lines = text.split(`
 `);
   const output = [];
-  const isSeparator = (line) => /^\s*\|?[\s:-]+\|?[\s:-]*$/.test(line);
+  const isSeparator = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return false;
+    const withoutPipes = trimmed.replace(/\|/g, "");
+    if (!withoutPipes)
+      return false;
+    return /^[\s:-]+$/.test(withoutPipes);
+  };
   const hasPipes = (line) => line.includes("|");
   let i = 0;
   while (i < lines.length) {
@@ -48242,7 +48550,31 @@ function formatMarkdownTables(text, maxWidth) {
 function parseTableRow(line) {
   const trimmed = line.trim();
   const withoutEdges = trimmed.replace(/^\|/, "").replace(/\|$/, "");
-  return withoutEdges.split("|").map((cell) => cell.trim());
+  const cells = [];
+  let current = "";
+  let escaping = false;
+  for (let i = 0;i < withoutEdges.length; i += 1) {
+    const ch = withoutEdges[i];
+    if (escaping) {
+      current += ch;
+      escaping = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (ch === "|") {
+      cells.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (escaping)
+    current += "\\";
+  cells.push(current);
+  return cells.map((cell) => cell.replace(/[\r\n]+/g, " ").trim());
 }
 function renderTable(header, rows, maxWidth) {
   const colCount = Math.max(header.length, ...rows.map((r) => r.length));
@@ -48456,11 +48788,17 @@ function wrapAnsiLine(line, width) {
   const result = [];
   let current = "";
   let visible = 0;
+  let activeAnsi = "";
   let i = 0;
   while (i < line.length) {
     const match = line.slice(i).match(/^\x1b\[[0-9;]*m/);
     if (match) {
       current += match[0];
+      if (match[0] === "\x1B[0m") {
+        activeAnsi = "";
+      } else {
+        activeAnsi += match[0];
+      }
       i += match[0].length;
       continue;
     }
@@ -48469,7 +48807,7 @@ function wrapAnsiLine(line, width) {
     i += 1;
     if (visible >= width) {
       result.push(current);
-      current = "";
+      current = activeAnsi;
       visible = 0;
     }
   }
@@ -48480,6 +48818,7 @@ function wrapAnsiLine(line, width) {
 function truncateAnsi(line, width) {
   if (stripAnsi2(line).length <= width)
     return line;
+  const hasAnsi = /\x1b\[[0-9;]*m/.test(line);
   if (width <= 3) {
     let result = "";
     let visible2 = 0;
@@ -48495,7 +48834,7 @@ function truncateAnsi(line, width) {
       visible2 += 1;
       i2 += 1;
     }
-    return result;
+    return hasAnsi && !result.endsWith("\x1B[0m") ? result + "\x1B[0m" : result;
   }
   const suffix = "...";
   const target = Math.max(0, width - suffix.length);
@@ -48513,7 +48852,8 @@ function truncateAnsi(line, width) {
     visible += 1;
     i += 1;
   }
-  return current + suffix;
+  const truncated = current + suffix;
+  return hasAnsi && !truncated.endsWith("\x1B[0m") ? truncated + "\x1B[0m" : truncated;
 }
 
 // packages/terminal/src/components/toolDisplay.ts
@@ -48537,7 +48877,7 @@ function truncateToolResult(toolResult, maxLines = 15, maxChars = 3000) {
   if (content.length > maxChars) {
     content = content.slice(0, maxChars) + "...";
   }
-  return prefix + content.trim();
+  return prefix + content.trimEnd();
 }
 function formatToolResultNicely(toolName, content, isError) {
   if (isError) {
@@ -48706,7 +49046,7 @@ function estimateMessageLines(message, maxWidth) {
   const hasContent = contentLines.length > 0;
   const prefixWidth = message.role === "user" || message.role === "assistant" ? 2 : 0;
   const effectiveWidth = maxWidth ? Math.max(1, maxWidth - prefixWidth) : maxWidth;
-  const wrappedLines = contentLines.length > 0 ? countWrappedLines(contentLines, effectiveWidth) : 0;
+  const wrappedLines = typeof message.__lineCount === "number" ? message.__lineCount : contentLines.length > 0 ? countWrappedLines(contentLines, effectiveWidth) : 0;
   let lines = hasContent ? Math.max(1, wrappedLines) : 0;
   if (message.role === "assistant" && message.toolCalls?.length) {
     lines += estimateToolPanelLines(message.toolCalls, message.toolResults, hasContent);
@@ -48786,11 +49126,13 @@ function Messages3({
   const columns = stdout?.columns ?? 80;
   const messageWidth = Math.max(1, columns - 2);
   const wrapWidth = messageWidth;
+  const messageGroups = import_react24.useMemo(() => groupConsecutiveToolMessages(messages), [messages]);
+  const messageItems = import_react24.useMemo(() => {
+    return messageGroups.map((group) => group.type === "single" ? { kind: "message", message: group.message } : { kind: "grouped", messages: group.messages });
+  }, [messageGroups]);
   const items = import_react24.useMemo(() => {
     const output = [];
-    for (const message of messages) {
-      output.push({ kind: "message", message });
-    }
+    output.push(...messageItems);
     for (const entry of activityLog) {
       output.push({ kind: "activity", entry });
     }
@@ -48802,7 +49144,7 @@ function Messages3({
   const lineSpans = import_react24.useMemo(() => {
     let cursor = 0;
     return items.map((item, index) => {
-      const lines = item.kind === "activity" ? estimateActivityEntryLines(item.entry, wrapWidth, messageWidth) : estimateMessageLines(item.message, messageWidth);
+      const lines = item.kind === "activity" ? estimateActivityEntryLines(item.entry, wrapWidth, messageWidth) : item.kind === "grouped" ? estimateGroupedToolLines(item.messages, messageWidth) : estimateMessageLines(item.message, messageWidth);
       const start = cursor;
       cursor += lines;
       return { item, index, start, end: cursor, lines };
@@ -48812,16 +49154,15 @@ function Messages3({
   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 visibleMessages = visibleSpans.filter((span) => span.item.kind === "message").map((span) => span.item.message);
+  const visibleMessageItems = visibleSpans.filter((span) => span.item.kind === "message" || span.item.kind === "grouped").map((span) => span.item);
   const visibleActivity = visibleSpans.filter((span) => span.item.kind === "activity").map((span) => span.item.entry);
   const visibleStreaming = visibleSpans.filter((span) => span.item.kind === "streaming").map((span) => span.item.message);
   const showCurrentResponse = Boolean(currentResponse) && streamingMessages.length === 0;
-  const groupedMessages = groupConsecutiveToolMessages(visibleMessages);
-  const historicalItems = groupedMessages.map((group) => {
-    if (group.type === "single") {
-      return { id: group.message.id, group };
+  const historicalItems = visibleMessageItems.map((item) => {
+    if (item.kind === "message") {
+      return { id: item.message.id, item };
     }
-    return { id: group.messages[0].id, group };
+    return { id: item.messages[0].id, item };
   });
   const toolResultMap = import_react24.useMemo(() => {
     const map = new Map;
@@ -48855,14 +49196,14 @@ function Messages3({
     width: "100%",
     children: [
       historicalItems.map((item) => {
-        if (item.group.type === "single") {
+        if (item.item.kind === "message") {
           return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(MessageBubble, {
-            message: item.group.message,
+            message: item.item.message,
             queuedMessageIds
           }, item.id, false, undefined, this);
         }
         return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(CombinedToolMessage, {
-          messages: item.group.messages
+          messages: item.item.messages
         }, item.id, false, undefined, this);
       }),
       visibleActivity.map((entry) => {
@@ -49006,11 +49347,35 @@ function CombinedToolMessage({ messages }) {
       allToolResults.push(...msg.toolResults);
     }
   }
-  return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ToolCallPanel, {
-    toolCalls: allToolCalls,
-    toolResults: allToolResults
+  return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+    marginY: 1,
+    children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ToolCallPanel, {
+      toolCalls: allToolCalls,
+      toolResults: allToolResults
+    }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
 }
+function estimateGroupedToolLines(messages, messageWidth) {
+  const toolCalls = [];
+  const toolResults = [];
+  for (const msg of messages) {
+    if (msg.toolCalls)
+      toolCalls.push(...msg.toolCalls);
+    if (msg.toolResults)
+      toolResults.push(...msg.toolResults);
+  }
+  if (toolCalls.length === 0)
+    return 0;
+  const synthetic = {
+    id: "grouped-tool-call",
+    role: "assistant",
+    content: "",
+    timestamp: 0,
+    toolCalls,
+    toolResults: toolResults.length > 0 ? toolResults : undefined
+  };
+  return estimateMessageLines(synthetic, messageWidth);
+}
 function MessageBubble({ message, queuedMessageIds }) {
   const isUser = message.role === "user";
   const isSystem = message.role === "system";
@@ -49157,7 +49522,7 @@ function ToolCallPanel({
         const statusColor = result ? result.isError ? "red" : "green" : "yellow";
         const displayName = getToolDisplayName(toolCall);
         const context2 = getToolContext(toolCall);
-        const maxLine = Math.max(16, innerWidth - 2);
+        const maxLine = Math.max(1, innerWidth - 2);
         const summaryLine = truncate(formatToolCall(toolCall), maxLine);
         const resultText = result ? indentMultiline(truncateToolResult(result, 4, 400), "  ") : "";
         return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
@@ -49333,8 +49698,9 @@ function formatScheduleCall(input) {
       return "Listing scheduled tasks";
     case "create":
       const cmd = truncate(String(input.command || ""), 30);
-      const schedule = String(input.schedule || "");
-      return `Creating schedule: "${cmd}" (${schedule})`;
+      const when = input.cron ? `cron ${input.cron}` : String(input.at || "");
+      const schedule = when ? ` (${truncate(String(when), 40)})` : "";
+      return `Creating schedule: "${cmd}"${schedule}`;
     case "update":
       return `Updating schedule: ${input.id || "unknown"}`;
     case "delete":
@@ -49589,7 +49955,7 @@ function ProcessingIndicator({
 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;
+  const displayDir = homeDir && directory.startsWith(homeDir) ? "~" + directory.slice(homeDir.length) : directory;
   return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
     flexDirection: "column",
     marginBottom: 1,
@@ -49675,7 +50041,7 @@ function formatSessionTime(timestamp) {
 }
 function formatPath(cwd2) {
   const home = process.env.HOME || "";
-  if (cwd2.startsWith(home)) {
+  if (home && cwd2.startsWith(home)) {
     return "~" + cwd2.slice(home.length);
   }
   return cwd2;
@@ -49831,6 +50197,16 @@ function wrapTextLines(text, wrapChars) {
 function stripAnsi6(text) {
   return text.replace(/\x1B\[[0-9;]*m/g, "");
 }
+function countWrappedLines2(lines, maxWidth) {
+  if (!maxWidth || maxWidth <= 0)
+    return lines.length;
+  let total = 0;
+  for (const line of lines) {
+    const visible = stripAnsi6(line).length;
+    total += Math.max(1, Math.ceil(visible / maxWidth));
+  }
+  return total;
+}
 function chunkRenderedLines(lines, chunkLines) {
   const chunks = [];
   let current = [];
@@ -49881,31 +50257,36 @@ function buildDisplayMessages(messages, chunkLines, wrapChars, options) {
       continue;
     }
     if (msg.role === "assistant") {
-      const rendered = renderMarkdown(content, { maxWidth: options?.maxWidth });
+      const assistantWidth = options?.maxWidth ? Math.max(1, options.maxWidth - 2) : undefined;
+      const rendered = renderMarkdown(content, { maxWidth: assistantWidth });
       const renderedLines = rendered.split(`
 `);
       if (renderedLines.length <= chunkLines) {
-        display.push({ ...msg, content: rendered, __rendered: true });
+        const lineCount = countWrappedLines2(renderedLines, assistantWidth);
+        display.push({ ...msg, content: rendered, __rendered: true, __lineCount: lineCount });
         continue;
       }
       const chunks2 = chunkRenderedLines(renderedLines, chunkLines);
       for (let i = 0;i < chunks2.length; i++) {
         const chunkContent = chunks2[i].join(`
 `);
+        const lineCount = countWrappedLines2(chunks2[i], assistantWidth);
         display.push({
           ...msg,
           id: `${msg.id}::chunk-${i}`,
           content: chunkContent,
           __rendered: true,
+          __lineCount: lineCount,
           toolCalls: i === chunks2.length - 1 ? msg.toolCalls : undefined,
           toolResults: i === chunks2.length - 1 ? msg.toolResults : undefined
         });
       }
       continue;
     }
-    const lines = wrapTextLines(content, wrapChars);
+    const effectiveWrap = msg.role === "user" ? Math.max(1, wrapChars - 2) : wrapChars;
+    const lines = wrapTextLines(content, effectiveWrap);
     if (lines.length <= chunkLines) {
-      display.push(msg);
+      display.push({ ...msg, __lineCount: lines.length });
       continue;
     }
     const chunks = chunkRenderedLines(lines, chunkLines);
@@ -49916,6 +50297,7 @@ function buildDisplayMessages(messages, chunkLines, wrapChars, options) {
         ...msg,
         id: `${msg.id}::chunk-${i}`,
         content: chunkContent,
+        __lineCount: chunks[i].length,
         toolCalls: i === chunks.length - 1 ? msg.toolCalls : undefined,
         toolResults: i === chunks.length - 1 ? msg.toolResults : undefined
       });
@@ -49951,6 +50333,7 @@ function App2({ cwd: cwd2, version }) {
   const [scrollOffset, setScrollOffset] = import_react29.useState(0);
   const [autoScroll, setAutoScroll] = import_react29.useState(true);
   const [skills, setSkills] = import_react29.useState([]);
+  const [commands, setCommands] = import_react29.useState([]);
   const responseRef = import_react29.useRef("");
   const toolCallsRef = import_react29.useRef([]);
   const toolResultsRef = import_react29.useRef([]);
@@ -49979,6 +50362,25 @@ function App2({ cwd: cwd2, version }) {
     return parts.join(`
 `).trim();
   }, []);
+  const loadSessionMetadata = import_react29.useCallback(async (session) => {
+    try {
+      const [loadedSkills, loadedCommands] = await Promise.all([
+        session.client.getSkills(),
+        session.client.getCommands()
+      ]);
+      setSkills(loadedSkills.map((s) => ({
+        name: s.name,
+        description: s.description || "",
+        argumentHint: s.argumentHint
+      })));
+      setCommands(loadedCommands.map((cmd) => ({
+        name: cmd.name.startsWith("/") ? cmd.name : `/${cmd.name}`,
+        description: cmd.description || ""
+      })));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    }
+  }, []);
   const finalizeResponse = import_react29.useCallback((status) => {
     const baseContent = buildFullResponse();
     const hasContent = baseContent.length > 0;
@@ -50247,12 +50649,7 @@ function App2({ cwd: cwd2, version }) {
         });
         const session = await registry.createSession(cwd2);
         setActiveSessionId(session.id);
-        const loadedSkills = await session.client.getSkills();
-        setSkills(loadedSkills.map((s) => ({
-          name: s.name,
-          description: s.description || "",
-          argumentHint: s.argumentHint
-        })));
+        await loadSessionMetadata(session);
         setEnergyState(session.client.getEnergyState() ?? undefined);
         setVoiceState(session.client.getVoiceState() ?? undefined);
         setIdentityInfo(session.client.getIdentityInfo() ?? undefined);
@@ -50266,7 +50663,7 @@ function App2({ cwd: cwd2, version }) {
     return () => {
       registry.closeAll();
     };
-  }, [cwd2, registry, handleChunk, finalizeResponse, resetTurnState]);
+  }, [cwd2, registry, handleChunk, finalizeResponse, resetTurnState, loadSessionMetadata]);
   const processQueue = import_react29.useCallback(async () => {
     const activeSession2 = registryRef.current.getActiveSession();
     if (!activeSession2 || !activeSessionId)
@@ -50336,6 +50733,7 @@ function App2({ cwd: cwd2, version }) {
   }, [activityLog, renderWidth, wrapChars]);
   const reservedLines = import_react29.useMemo(() => {
     let lines = 0;
+    lines += 2;
     if (showWelcome) {
       lines += 4;
     }
@@ -50367,9 +50765,9 @@ function App2({ cwd: cwd2, version }) {
       lines += 3;
     }
     lines += 1;
-    lines += 1;
+    lines += 3;
     if (isProcessing) {
-      lines += 2;
+      lines += 1;
     }
     lines += 2;
     return lines;
@@ -50436,6 +50834,7 @@ function App2({ cwd: cwd2, version }) {
       setEnergyState(session.client.getEnergyState() ?? undefined);
       setVoiceState(session.client.getVoiceState() ?? undefined);
       setIdentityInfo(session.client.getIdentityInfo() ?? undefined);
+      await loadSessionMetadata(session);
     }
     await registry.switchSession(sessionId);
     setActiveSessionId(sessionId);
@@ -50453,6 +50852,7 @@ function App2({ cwd: cwd2, version }) {
       setEnergyState(newSession.client.getEnergyState() ?? undefined);
       setVoiceState(newSession.client.getVoiceState() ?? undefined);
       setIdentityInfo(newSession.client.getIdentityInfo() ?? undefined);
+      await loadSessionMetadata(newSession);
     } catch (err) {
       setError(err instanceof Error ? err.message : "Failed to create session");
     }
@@ -50783,6 +51183,7 @@ function App2({ cwd: cwd2, version }) {
         onSubmit: handleSubmit,
         isProcessing,
         queueLength: activeQueue.length + inlineCount,
+        commands,
         skills
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Status, {
@@ -50978,7 +51379,7 @@ function formatStreamEvent(chunk) {
 
 // packages/terminal/src/index.tsx
 var jsx_dev_runtime10 = __toESM(require_jsx_dev_runtime(), 1);
-var VERSION3 = "0.6.32";
+var VERSION3 = "0.6.35";
 process.env.ASSISTANTS_VERSION ??= VERSION3;
 function parseArgs(argv) {
   const args = argv.slice(2);
@@ -51134,4 +51535,4 @@ if (options.print !== null) {
   });
 }
 
-//# debugId=E7E53BFBEA38084764756E2164756E21
+//# debugId=2F2CC5B1781D557164756E2164756E21