@hasna/assistants 0.6.54 → 0.6.55

package/dist/index.js

@@ -280,7 +280,34 @@ function substituteVariables(template, args, env = {}) {
   });
   return result;
 }
-var init_utils = () => {};
+function getRandomLoadingWord() {
+  return LOADING_WORDS[Math.floor(Math.random() * LOADING_WORDS.length)];
+}
+var LOADING_WORDS;
+var init_utils = __esm(() => {
+  LOADING_WORDS = [
+    "Metamorphosing",
+    "Conjuring",
+    "Transmuting",
+    "Alchemizing",
+    "Manifesting",
+    "Brewing",
+    "Summoning",
+    "Cogitating",
+    "Ruminating",
+    "Percolating",
+    "Incubating",
+    "Gestating",
+    "Synthesizing",
+    "Crystallizing",
+    "Catalyzing",
+    "Distilling",
+    "Fermenting",
+    "Marinating",
+    "Simmering",
+    "Concocting"
+  ];
+});
 
 // packages/shared/src/index.ts
 var init_src2 = __esm(() => {
@@ -9662,8 +9689,8 @@ var require_pattern2 = __commonJS((exports) => {
   }
   exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
   function isAffectDepthOfReadingPattern(pattern) {
-    const basename = path.basename(pattern);
-    return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
+    const basename2 = path.basename(pattern);
+    return endsWithSlashGlobStar(pattern) || isStaticPattern(basename2);
   }
   exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
   function expandPatternsWithBraceExpansion(patterns) {
@@ -113535,6 +113562,118 @@ function validateBashCommand(command) {
   return { valid: true };
 }
 
+// packages/core/src/security/network-validator.ts
+import { lookup as dnsLookup } from "dns/promises";
+var lookupFn = dnsLookup;
+async function isPrivateHostOrResolved(hostname) {
+  if (isPrivateHost(hostname)) {
+    return true;
+  }
+  const host = normalizeHostname(hostname);
+  if (host === "" || isIpLiteral(host)) {
+    return isPrivateHost(host);
+  }
+  try {
+    const results = await lookupFn(host, { all: true });
+    for (const result of results) {
+      if (isPrivateHost(result.address)) {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+function isIpLiteral(host) {
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(host))
+    return true;
+  if (host.includes(":"))
+    return true;
+  return false;
+}
+function normalizeHostname(hostname) {
+  let host = hostname.toLowerCase().trim();
+  if (host.startsWith("[")) {
+    const idx = host.indexOf("]:");
+    if (idx > 0)
+      host = host.slice(1, idx);
+    else if (host.endsWith("]"))
+      host = host.slice(1, -1);
+  } else {
+    const idx = host.lastIndexOf(":");
+    const beforeColon = host.slice(0, idx);
+    if (idx > 0 && !beforeColon.includes(":")) {
+      host = beforeColon;
+    }
+  }
+  host = host.replace(/\.$/, "");
+  return host;
+}
+function isPrivateHost(hostname) {
+  let host = normalizeHostname(hostname);
+  if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local"))
+    return true;
+  if (host === "127.0.0.1" || host === "::1" || host === "::" || host === "0:0:0:0:0:0:0:0")
+    return true;
+  if (/^\d+$/.test(host))
+    return true;
+  if (host.startsWith("::ffff:")) {
+    const mapped = host.slice("::ffff:".length);
+    if (mapped.includes(".")) {
+      return isPrivateHost(mapped);
+    }
+    const hexMatch = mapped.match(/^([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i);
+    if (hexMatch) {
+      const high = Number.parseInt(hexMatch[1], 16);
+      const low = Number.parseInt(hexMatch[2], 16);
+      const octets2 = [
+        high >> 8 & 255,
+        high & 255,
+        low >> 8 & 255,
+        low & 255
+      ];
+      return isPrivateIPv4(octets2);
+    }
+    return false;
+  }
+  if (host.includes(":")) {
+    return host === "::1" || host === "::" || host === "0:0:0:0:0:0:0:0";
+  }
+  const match = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (!match)
+    return false;
+  const octets = [];
+  for (let i = 1;i <= 4; i++) {
+    const value = Number.parseInt(match[i], 10);
+    if (Number.isNaN(value))
+      return false;
+    octets.push(value);
+  }
+  return isPrivateIPv4(octets);
+}
+function isPrivateIPv4(octets) {
+  if (octets[0] === 0)
+    return true;
+  if (octets[0] === 10)
+    return true;
+  if (octets[0] === 100 && octets[1] >= 64 && octets[1] <= 127)
+    return true;
+  if (octets[0] === 169 && octets[1] === 254)
+    return true;
+  if (octets[0] === 192 && octets[1] === 168)
+    return true;
+  if (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31)
+    return true;
+  if (octets[0] === 127)
+    return true;
+  if (octets[0] >= 224 && octets[0] <= 239)
+    return true;
+  if (octets[0] >= 240)
+    return true;
+  return false;
+}
+
 // packages/core/src/tools/bash.ts
 function killProcess(proc) {
   proc.kill();
@@ -113664,7 +113803,8 @@ class BashTool {
     "node --version",
     "bun --version",
     "npm --version",
-    "pnpm --version"
+    "pnpm --version",
+    "jq"
   ];
   static BLOCKED_PATTERNS = [
     /\brm\b/,
@@ -113695,8 +113835,7 @@ class BashTool {
     /\|\s*(bash|sh|zsh|fish)\b/,
     /curl.*\|\s*(bash|sh)/,
     /wget.*\|\s*(bash|sh)/,
-    /[;&]/,
-    /[|]/,
+    /;/,
     /[\r\n]/,
     />\s*[^|]/,
     />>/,
@@ -113716,6 +113855,110 @@ class BashTool {
     /\bcmake\b/,
     /\bdocker\s+(run|exec|build|push)\b/
   ];
+  static isCommandPartAllowed(commandPart, allowlist) {
+    const trimmed = commandPart.trim().toLowerCase();
+    for (const allowed of allowlist) {
+      if (trimmed.startsWith(allowed.toLowerCase())) {
+        return true;
+      }
+    }
+    return false;
+  }
+  static areAllCommandPartsAllowed(command, allowlist) {
+    const parts = this.splitCommandByOperators(command);
+    if (parts.length === 0)
+      return false;
+    for (const part of parts) {
+      if (!this.isCommandPartAllowed(part, allowlist)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  static extractCurlUrls(command) {
+    const urls = [];
+    const curlMatch = command.match(/^curl\s+(.+)$/i);
+    if (!curlMatch)
+      return urls;
+    const args = curlMatch[1];
+    const urlMatches = args.match(/https?:\/\/[^\s'"]+/gi);
+    if (urlMatches) {
+      for (const url of urlMatches) {
+        const cleanUrl = url.replace(/[;|&<>]+$/, "");
+        if (cleanUrl)
+          urls.push(cleanUrl);
+      }
+    }
+    return urls;
+  }
+  static async validateCurlSsrf(command) {
+    const trimmed = command.trim().toLowerCase();
+    if (!trimmed.startsWith("curl ")) {
+      return { valid: true };
+    }
+    const urls = this.extractCurlUrls(command.trim());
+    for (const urlStr of urls) {
+      try {
+        const url = new URL(urlStr);
+        if (await isPrivateHostOrResolved(url.hostname)) {
+          return { valid: false, blockedUrl: urlStr };
+        }
+      } catch {
+        continue;
+      }
+    }
+    return { valid: true };
+  }
+  static splitCommandByOperators(command) {
+    const parts = [];
+    let current = "";
+    let quote = null;
+    let escaped = false;
+    let i = 0;
+    while (i < command.length) {
+      const char = command[i];
+      if (quote === '"' && !escaped && char === "\\") {
+        escaped = true;
+        current += char;
+        i++;
+        continue;
+      }
+      if (!quote && (char === '"' || char === "'")) {
+        quote = char;
+        current += char;
+        i++;
+        continue;
+      }
+      if (quote && !escaped && char === quote) {
+        quote = null;
+        current += char;
+        i++;
+        continue;
+      }
+      escaped = false;
+      if (!quote) {
+        if (char === "&" && command[i + 1] === "&" || char === "|" && command[i + 1] === "|") {
+          if (current.trim())
+            parts.push(current.trim());
+          current = "";
+          i += 2;
+          continue;
+        }
+        if (char === "|") {
+          if (current.trim())
+            parts.push(current.trim());
+          current = "";
+          i++;
+          continue;
+        }
+      }
+      current += char;
+      i++;
+    }
+    if (current.trim())
+      parts.push(current.trim());
+    return parts;
+  }
   static executor = async (input) => {
     const command = input.command;
     const cwd = input.cwd || process.cwd();
@@ -113799,14 +114042,8 @@ class BashTool {
         suggestion: "Enable validation.perTool.bash.allowEnv to allow env/printenv."
       });
     }
-    let isAllowed = false;
     const allowlist = allowEnv ? this.ALLOWED_COMMANDS : this.ALLOWED_COMMANDS.filter((allowed) => allowed !== "env" && allowed !== "printenv");
-    for (const allowed of allowlist) {
-      if (commandTrimmed.startsWith(allowed.toLowerCase())) {
-        isAllowed = true;
-        break;
-      }
-    }
+    const isAllowed = this.areAllCommandPartsAllowed(commandForChecks, allowlist);
     if (!isAllowed) {
       getSecurityLogger().log({
         eventType: "blocked_command",
@@ -113827,6 +114064,27 @@ class BashTool {
         suggestion: "Use a permitted read-only command."
       });
     }
+    const ssrfCheck = await this.validateCurlSsrf(commandForChecks);
+    if (!ssrfCheck.valid) {
+      getSecurityLogger().log({
+        eventType: "blocked_command",
+        severity: "high",
+        details: {
+          tool: "bash",
+          command,
+          reason: `SSRF protection: curl to private/internal network blocked (${ssrfCheck.blockedUrl})`
+        },
+        sessionId: input.sessionId || "unknown"
+      });
+      throw new ToolExecutionError(`Cannot fetch from local/private network addresses for security reasons: ${ssrfCheck.blockedUrl}`, {
+        toolName: "bash",
+        toolInput: input,
+        code: ErrorCodes.TOOL_PERMISSION_DENIED,
+        recoverable: false,
+        retryable: false,
+        suggestion: "Use a public URL instead of localhost or internal network addresses."
+      });
+    }
     try {
       const runtime = getRuntime();
       const isWindows = process.platform === "win32";
@@ -113937,22 +114195,86 @@ function isWithinPath(target, base) {
 
 // packages/core/src/security/path-validator.ts
 import { homedir as homedir4 } from "os";
-import { resolve as resolve2, relative as relative2, isAbsolute as isAbsolute2 } from "path";
+import { resolve as resolve2, relative as relative2, isAbsolute as isAbsolute2, basename } from "path";
 import { lstat as lstat2, realpath as realpath2 } from "fs/promises";
 var PROTECTED_PATHS = [
   "/etc/passwd",
   "/etc/shadow",
   "/etc/sudoers",
+  "/etc/master.passwd",
+  "/etc/security",
   "~/.secrets",
   "~/.ssh",
   "~/.gnupg",
+  "~/.pgp",
+  "~/.gpg",
   "~/.aws/credentials",
-  "~/.kube/config"
-];
+  "~/.aws/config",
+  "~/.azure/credentials",
+  "~/.config/gcloud",
+  "~/.kube/config",
+  "~/.docker/config.json",
+  "~/.npmrc",
+  "~/.yarnrc",
+  "~/.pypirc",
+  "~/.gem/credentials",
+  "~/.bash_history",
+  "~/.zsh_history",
+  "~/.history",
+  "~/.pgpass",
+  "~/.my.cnf",
+  "~/.mongocli.yaml",
+  "~/.git-credentials",
+  "~/.gitconfig",
+  "~/.netrc",
+  "~/.authinfo",
+  "~/.config/gh/hosts.yml",
+  "~/.config/hub",
+  "~/.password-store",
+  "~/.vault-token",
+  "~/.anthropic",
+  "~/.openai"
+];
+var PROTECTED_FILENAME_PATTERNS = [
+  /^\.env($|\..*)/,
+  /^\.secret(s)?($|\..*)/,
+  /^credentials(\..*)?$/i,
+  /^secrets?(\..*)?$/i,
+  /^.*_credentials(\..*)?$/i,
+  /^.*_secret(s)?(\..*)?$/i,
+  /^\.?id_rsa(\.pub)?$/,
+  /^\.?id_ed25519(\.pub)?$/,
+  /^\.?id_ecdsa(\.pub)?$/,
+  /^\.?id_dsa(\.pub)?$/,
+  /^authorized_keys$/,
+  /^known_hosts$/,
+  /^.*\.pem$/,
+  /^.*\.key$/,
+  /^.*\.p12$/,
+  /^.*\.pfx$/,
+  /^.*\.keystore$/
+];
+function isProtectedFilename(filename) {
+  for (const pattern of PROTECTED_FILENAME_PATTERNS) {
+    if (pattern.test(filename)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isInAllowedPaths(resolved, allowedPaths) {
+  for (const allowedPath of allowedPaths) {
+    if (isWithinPath2(resolved, allowedPath)) {
+      return true;
+    }
+  }
+  return false;
+}
 async function isPathSafe(targetPath, operation, options = {}) {
   const expandedTarget = expandHome2(targetPath);
   const resolved = resolve2(expandedTarget);
   const home = homedir4();
+  const filename = basename(resolved);
   for (const protectedPath of PROTECTED_PATHS) {
     const expanded = protectedPath.replace("~", home);
     if (isWithinPath2(resolved, expanded)) {
@@ -113962,15 +114284,48 @@ async function isPathSafe(targetPath, operation, options = {}) {
       };
     }
   }
+  if (isProtectedFilename(filename)) {
+    return {
+      safe: false,
+      reason: `Cannot ${operation} file with protected name pattern: ${filename}`
+    };
+  }
+  const enforceAllowlist = options.enforceAllowlist ?? operation === "read";
+  if (enforceAllowlist) {
+    const cwd = options.cwd ? resolve2(options.cwd) : process.cwd();
+    const allowedPaths = [cwd, ...(options.allowedPaths || []).map((p) => resolve2(p))];
+    if (!isInAllowedPaths(resolved, allowedPaths)) {
+      return {
+        safe: false,
+        reason: `Cannot ${operation} files outside project directory. Path must be within: ${cwd}`
+      };
+    }
+  }
   try {
     const stat = await lstat2(resolved);
     if (stat.isSymbolicLink()) {
       const target = await realpath2(resolved);
       const root = options.cwd ? resolve2(options.cwd) : process.cwd();
-      if (!target.startsWith(root)) {
+      const allowedTargets = [root, ...(options.allowedPaths || []).map((p) => resolve2(p))];
+      if (!isInAllowedPaths(target, allowedTargets)) {
         return {
           safe: false,
-          reason: "Symlink points outside working directory"
+          reason: "Symlink points outside allowed directories"
+        };
+      }
+      for (const protectedPath of PROTECTED_PATHS) {
+        const expanded = protectedPath.replace("~", home);
+        if (isWithinPath2(target, expanded)) {
+          return {
+            safe: false,
+            reason: `Symlink points to protected path: ${protectedPath}`
+          };
+        }
+      }
+      if (isProtectedFilename(basename(target))) {
+        return {
+          safe: false,
+          reason: `Symlink points to file with protected name pattern`
         };
       }
     }
@@ -114611,10 +114966,48 @@ class FilesystemTools {
 
 // packages/core/src/tools/web.ts
 init_errors();
-import { lookup as dnsLookup } from "dns/promises";
+import { lookup as dnsLookup2 } from "dns/promises";
 function abortController(controller) {
   controller.abort();
 }
+var MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+async function readResponseWithLimit(response, maxBytes = MAX_RESPONSE_BYTES) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    return { text: "", truncated: false };
+  }
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+  const chunks = [];
+  let totalBytes = 0;
+  let truncated = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maxBytes) {
+        const excess = totalBytes - maxBytes;
+        const trimmed = value.slice(0, value.byteLength - excess);
+        chunks.push(decoder.decode(trimmed, { stream: false }));
+        truncated = true;
+        break;
+      }
+      chunks.push(decoder.decode(value, { stream: true }));
+    }
+    if (!truncated) {
+      chunks.push(decoder.decode());
+    }
+  } finally {
+    reader.releaseLock();
+    if (truncated && response.body) {
+      try {
+        await response.body.cancel();
+      } catch {}
+    }
+  }
+  return { text: chunks.join(""), truncated };
+}
 
 class WebFetchTool {
   static tool = {
@@ -114663,7 +115056,7 @@ class WebFetchTool {
           });
         }
         const hostname = parsedUrl.hostname;
-        if (await isPrivateHostOrResolved(hostname)) {
+        if (await isPrivateHostOrResolved2(hostname)) {
           throw new ToolExecutionError("Cannot fetch from local/private network addresses for security reasons", {
             toolName: "web_fetch",
             toolInput: input,
@@ -114727,9 +115120,21 @@ class WebFetchTool {
       const contentType = response.headers.get("content-type") || "";
       if (extractType === "json") {
         try {
-          const json = await response.json();
+          const { text: jsonText, truncated } = await readResponseWithLimit(response);
+          if (truncated) {
+            throw new ToolExecutionError("JSON response exceeds size limit", {
+              toolName: "web_fetch",
+              toolInput: input,
+              code: ErrorCodes.TOOL_EXECUTION_FAILED,
+              recoverable: false,
+              retryable: false
+            });
+          }
+          const json = JSON.parse(jsonText);
           return JSON.stringify(json, null, 2);
-        } catch {
+        } catch (e) {
+          if (e instanceof ToolExecutionError)
+            throw e;
           throw new ToolExecutionError("Response is not valid JSON", {
             toolName: "web_fetch",
             toolInput: input,
@@ -114739,13 +115144,18 @@ class WebFetchTool {
           });
         }
       }
-      const html = await response.text();
+      const { text: html, truncated: htmlTruncated } = await readResponseWithLimit(response);
       if (extractType === "html") {
         const maxLength2 = 50000;
         if (html.length > maxLength2) {
           return html.slice(0, maxLength2) + `
 
 [Content truncated...]`;
+        }
+        if (htmlTruncated) {
+          return html + `
+
+[Content truncated due to size limit...]`;
         }
         return html;
       }
@@ -114755,6 +115165,11 @@ class WebFetchTool {
         return text.slice(0, maxLength) + `
 
 [Content truncated...]`;
+      }
+      if (htmlTruncated) {
+        return (text || "No readable content found on page") + `
+
+[Content truncated due to size limit...]`;
       }
       return text || "No readable content found on page";
     } catch (error) {
@@ -114848,7 +115263,7 @@ class WebSearchTool {
           retryable: false
         });
       }
-      const html = await response.text();
+      const { text: html } = await readResponseWithLimit(response, 2 * 1024 * 1024);
       const results = parseDuckDuckGoResults(html, maxResults);
       if (results.length === 0) {
         return `No results found for "${query}"`;
@@ -114998,7 +115413,7 @@ class CurlTool {
           });
         }
         const hostname = parsedUrl.hostname;
-        if (await isPrivateHostOrResolved(hostname)) {
+        if (await isPrivateHostOrResolved2(hostname)) {
           throw new ToolExecutionError("Cannot fetch from local/private network addresses for security reasons", {
             toolName: "curl",
             toolInput: input,
@@ -115063,15 +115478,18 @@ class CurlTool {
       }
       const contentType = response.headers.get("content-type") || "";
       let responseBody;
+      let truncatedBySize = false;
+      const { text: rawBody, truncated } = await readResponseWithLimit(response);
+      truncatedBySize = truncated;
       if (contentType.includes("application/json")) {
         try {
-          const json = await response.json();
+          const json = JSON.parse(rawBody);
           responseBody = JSON.stringify(json, null, 2);
         } catch {
-          responseBody = await response.text();
+          responseBody = rawBody;
         }
       } else {
-        responseBody = await response.text();
+        responseBody = rawBody;
         if (contentType.includes("text/html")) {
           responseBody = extractReadableText(responseBody);
         }
@@ -115081,6 +115499,10 @@ class CurlTool {
         responseBody = responseBody.slice(0, maxLength) + `
 
 [Content truncated...]`;
+      } else if (truncatedBySize) {
+        responseBody = responseBody + `
+
+[Content truncated due to size limit...]`;
       }
       const statusLine = `HTTP ${response.status} ${response.statusText}`;
       return `${statusLine}
@@ -115126,33 +115548,35 @@ class WebTools {
     registry.register(CurlTool.tool, CurlTool.executor);
   }
 }
-var lookupFn = dnsLookup;
-async function isPrivateHostOrResolved(hostname) {
-  if (isPrivateHost(hostname)) {
+var lookupFn2 = dnsLookup2;
+async function isPrivateHostOrResolved2(hostname) {
+  if (isPrivateHost2(hostname)) {
     return true;
   }
-  const host = normalizeHostname(hostname);
-  if (host === "" || isIpLiteral(host)) {
+  const host = normalizeHostname2(hostname);
+  if (host === "" || isIpLiteral2(host)) {
     return false;
   }
   try {
-    const results = await lookupFn(host, { all: true });
+    const results = await lookupFn2(host, { all: true });
     for (const result of results) {
-      if (isPrivateHost(result.address)) {
+      if (isPrivateHost2(result.address)) {
         return true;
       }
     }
-  } catch {}
-  return false;
+    return false;
+  } catch {
+    return true;
+  }
 }
-function isIpLiteral(hostname) {
+function isIpLiteral2(hostname) {
   if (hostname.includes(":"))
     return true;
   if (/^\d+$/.test(hostname))
     return true;
   return /^\d+\.\d+\.\d+\.\d+$/.test(hostname);
 }
-function normalizeHostname(hostname) {
+function normalizeHostname2(hostname) {
   let host = hostname.toLowerCase();
   if (host.startsWith("[") && host.endsWith("]")) {
     host = host.slice(1, -1);
@@ -115164,8 +115588,8 @@ function normalizeHostname(hostname) {
   host = host.replace(/\.$/, "");
   return host;
 }
-function isPrivateHost(hostname) {
-  let host = normalizeHostname(hostname);
+function isPrivateHost2(hostname) {
+  let host = normalizeHostname2(hostname);
   if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local"))
     return true;
   if (host === "127.0.0.1" || host === "::1" || host === "::" || host === "0:0:0:0:0:0:0:0")
@@ -115175,7 +115599,7 @@ function isPrivateHost(hostname) {
   if (host.startsWith("::ffff:")) {
     const mapped = host.slice("::ffff:".length);
     if (mapped.includes(".")) {
-      return isPrivateHost(mapped);
+      return isPrivateHost2(mapped);
     }
     const hexMatch = mapped.match(/^([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i);
     if (hexMatch) {
@@ -115187,7 +115611,7 @@ function isPrivateHost(hostname) {
         low >> 8 & 255,
         low & 255
       ];
-      return isPrivateIPv4(octets2);
+      return isPrivateIPv42(octets2);
     }
     return false;
   }
@@ -115207,9 +115631,9 @@ function isPrivateHost(hostname) {
       return false;
     octets.push(value);
   }
-  return isPrivateIPv4(octets);
+  return isPrivateIPv42(octets);
 }
-function isPrivateIPv4(octets) {
+function isPrivateIPv42(octets) {
   if (octets[0] === 0)
     return true;
   if (octets[0] === 10)
@@ -115561,8 +115985,37 @@ function computeNextRun(schedule, fromTime) {
       return;
     return getNextCronRun(schedule.schedule.cron, fromTime, validTimezone);
   }
+  if (schedule.schedule.kind === "random") {
+    return computeRandomNextRun(schedule.schedule, fromTime);
+  }
+  if (schedule.schedule.kind === "interval") {
+    return computeIntervalNextRun(schedule.schedule, fromTime);
+  }
   return;
 }
+function computeRandomNextRun(schedule, fromTime) {
+  const { minInterval, maxInterval, unit = "minutes" } = schedule;
+  if (!minInterval || !maxInterval || minInterval <= 0 || maxInterval <= 0) {
+    return;
+  }
+  if (minInterval > maxInterval) {
+    return;
+  }
+  const multiplier = unit === "seconds" ? 1000 : unit === "hours" ? 3600000 : 60000;
+  const minMs = minInterval * multiplier;
+  const maxMs = maxInterval * multiplier;
+  const randomDelay = Math.floor(Math.random() * (maxMs - minMs + 1)) + minMs;
+  return fromTime + randomDelay;
+}
+function computeIntervalNextRun(schedule, fromTime) {
+  const { interval, unit = "minutes" } = schedule;
+  if (!interval || interval <= 0) {
+    return;
+  }
+  const multiplier = unit === "seconds" ? 1000 : unit === "hours" ? 3600000 : 60000;
+  const intervalMs = interval * multiplier;
+  return fromTime + intervalMs;
+}
 async function getDueSchedules(cwd, nowTime) {
   const schedules = await listSchedules(cwd);
   return schedules.filter((schedule) => {
@@ -115734,7 +116187,7 @@ function getTimeZoneOffsetMs(date, timeZone) {
 class SchedulerTool {
   static tool = {
     name: "schedule",
-    description: "Create and manage scheduled commands (once or cron).",
+    description: "Create and manage scheduled commands (once, cron, or random interval).",
     parameters: {
       type: "object",
       properties: {
@@ -115755,6 +116208,23 @@ class SchedulerTool {
           type: "string",
           description: "Cron expression for recurring schedule (5 fields)"
         },
+        minInterval: {
+          type: "number",
+          description: "Minimum interval for random scheduling (e.g., 1)"
+        },
+        maxInterval: {
+          type: "number",
+          description: "Maximum interval for random scheduling (e.g., 20)"
+        },
+        unit: {
+          type: "string",
+          description: "Time unit for interval/random scheduling: seconds, minutes, or hours",
+          enum: ["seconds", "minutes", "hours"]
+        },
+        every: {
+          type: "number",
+          description: 'Fixed interval for recurring schedule (e.g., every: 15 with unit: "seconds" = every 15 seconds). Minimum 1 second.'
+        },
         timezone: {
           type: "string",
           description: "IANA timezone name (optional, best-effort)"
@@ -115763,6 +116233,15 @@ class SchedulerTool {
           type: "string",
           description: "Optional description for this schedule"
         },
+        actionType: {
+          type: "string",
+          description: 'Type of action: "command" runs the command, "message" injects custom message into agent session. Default: "command"',
+          enum: ["command", "message"]
+        },
+        message: {
+          type: "string",
+          description: 'Custom message to inject when actionType is "message"'
+        },
         sessionId: {
           type: "string",
           description: "Session id to scope the schedule to"
@@ -115789,7 +116268,15 @@ class SchedulerTool {
         return "No schedules found.";
       const rows = schedules.sort((a, b) => (a.nextRunAt || 0) - (b.nextRunAt || 0)).map((s) => {
         const next = s.nextRunAt ? new Date(s.nextRunAt).toISOString() : "n/a";
-        return `- ${s.id} [${s.status}] ${s.command} (next: ${next})`;
+        let scheduleInfo = "";
+        if (s.schedule.kind === "interval" && s.schedule.interval) {
+          scheduleInfo = ` (every ${s.schedule.interval} ${s.schedule.unit || "minutes"})`;
+        } else if (s.schedule.kind === "random" && s.schedule.minInterval && s.schedule.maxInterval) {
+          scheduleInfo = ` (random: ${s.schedule.minInterval}-${s.schedule.maxInterval} ${s.schedule.unit || "minutes"})`;
+        } else if (s.schedule.kind === "cron" && s.schedule.cron) {
+          scheduleInfo = ` (cron: ${s.schedule.cron})`;
+        }
+        return `- ${s.id} [${s.status}] ${s.command}${scheduleInfo} (next: ${next})`;
       });
       return rows.join(`
 `);
@@ -115800,26 +116287,69 @@ class SchedulerTool {
         return "Error: command is required.";
       const at = input.at;
       const cron = input.cron;
-      if (!at && !cron)
-        return "Error: provide either at (ISO time) or cron.";
+      const minInterval = input.minInterval;
+      const maxInterval = input.maxInterval;
+      const every = input.every;
+      const unit = input.unit;
+      const hasRandom = minInterval !== undefined && maxInterval !== undefined;
+      const hasInterval = every !== undefined;
+      if (!at && !cron && !hasRandom && !hasInterval) {
+        return "Error: provide at (ISO time), cron, every (fixed interval), or minInterval+maxInterval for random scheduling.";
+      }
+      if (hasInterval) {
+        if (every <= 0) {
+          return "Error: every must be a positive number.";
+        }
+        const effectiveUnit = unit || "minutes";
+        const intervalSeconds = effectiveUnit === "seconds" ? every : effectiveUnit === "hours" ? every * 3600 : every * 60;
+        if (intervalSeconds < 1) {
+          return "Error: minimum interval is 1 second.";
+        }
+      }
+      if (hasRandom) {
+        if (minInterval <= 0 || maxInterval <= 0) {
+          return "Error: minInterval and maxInterval must be positive numbers.";
+        }
+        if (minInterval > maxInterval) {
+          return "Error: minInterval cannot be greater than maxInterval.";
+        }
+      }
       const timezone = input.timezone;
       if (timezone && !isValidTimeZone(timezone)) {
         return `Error: invalid timezone "${timezone}".`;
       }
+      const actionType = input.actionType;
+      const message = input.message;
+      let scheduleKind;
+      if (hasInterval) {
+        scheduleKind = "interval";
+      } else if (hasRandom) {
+        scheduleKind = "random";
+      } else if (cron) {
+        scheduleKind = "cron";
+      } else {
+        scheduleKind = "once";
+      }
       const schedule = {
         id: generateId(),
         createdAt: now2,
         updatedAt: now2,
         createdBy: "agent",
         sessionId: typeof input.sessionId === "string" ? input.sessionId : undefined,
+        actionType: actionType || "command",
         command,
+        message: actionType === "message" ? message : undefined,
         description: input.description,
         status: "active",
         schedule: {
-          kind: cron ? "cron" : "once",
+          kind: scheduleKind,
           at,
           cron,
-          timezone
+          timezone,
+          minInterval: hasRandom ? minInterval : undefined,
+          maxInterval: hasRandom ? maxInterval : undefined,
+          unit: hasRandom || hasInterval ? unit || "minutes" : undefined,
+          interval: hasInterval ? every : undefined
         }
       };
       schedule.nextRunAt = computeNextRun(schedule, now2);
@@ -115827,6 +116357,12 @@ class SchedulerTool {
         return "Error: unable to compute next run for schedule.";
       }
       await saveSchedule(cwd, schedule);
+      if (scheduleKind === "interval") {
+        return `Scheduled ${schedule.command} (${schedule.id}) every ${every} ${unit || "minutes"}, next run: ${new Date(schedule.nextRunAt).toISOString()}`;
+      }
+      if (scheduleKind === "random") {
+        return `Scheduled ${schedule.command} (${schedule.id}) randomly every ${minInterval}-${maxInterval} ${unit || "minutes"}, next run: ${new Date(schedule.nextRunAt).toISOString()}`;
+      }
       return `Scheduled ${schedule.command} (${schedule.id}) for ${new Date(schedule.nextRunAt).toISOString()}`;
     }
     if (action === "delete") {
@@ -115870,6 +116406,8 @@ import { existsSync as existsSync3, writeFileSync as writeFileSync3, unlinkSync
 import { tmpdir } from "os";
 import { join as join7 } from "path";
 import { homedir as homedir6 } from "os";
+var FETCH_TIMEOUT_MS = 30000;
+var MAX_IMAGE_SIZE_BYTES = 10 * 1024 * 1024;
 async function getViuPath() {
   const runtime = getRuntime();
   const explicitPath = process.env.ASSISTANTS_VIU_PATH || process.env.VIU_PATH;
@@ -115937,7 +116475,18 @@ class ImageDisplayTool {
     let tempFile = null;
     if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
       try {
-        const response = await fetch(imagePath);
+        const url = new URL(imagePath);
+        if (await isPrivateHostOrResolved(url.hostname)) {
+          return "Error: Cannot fetch from local/private network addresses for security reasons";
+        }
+        const controller = new AbortController;
+        const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        let response;
+        try {
+          response = await fetch(imagePath, { signal: controller.signal });
+        } finally {
+          clearTimeout(timeoutId);
+        }
         if (!response.ok) {
           return `Error: Failed to fetch image: HTTP ${response.status}`;
         }
@@ -115945,12 +116494,47 @@ class ImageDisplayTool {
         if (!contentType.startsWith("image/")) {
           return `Error: URL does not point to an image (content-type: ${contentType})`;
         }
-        const buffer = await response.arrayBuffer();
+        const contentLength = response.headers.get("content-length");
+        if (contentLength) {
+          const size = parseInt(contentLength, 10);
+          if (!isNaN(size) && size > MAX_IMAGE_SIZE_BYTES) {
+            return `Error: Image too large (${Math.round(size / 1024 / 1024)}MB exceeds ${MAX_IMAGE_SIZE_BYTES / 1024 / 1024}MB limit)`;
+          }
+        }
+        const chunks = [];
+        let totalSize = 0;
+        const reader = response.body?.getReader();
+        if (!reader) {
+          return "Error: Failed to read image response";
+        }
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            totalSize += value.length;
+            if (totalSize > MAX_IMAGE_SIZE_BYTES) {
+              return `Error: Image too large (exceeds ${MAX_IMAGE_SIZE_BYTES / 1024 / 1024}MB limit)`;
+            }
+            chunks.push(value);
+          }
+        } finally {
+          reader.releaseLock();
+        }
+        const buffer = new Uint8Array(totalSize);
+        let offset = 0;
+        for (const chunk of chunks) {
+          buffer.set(chunk, offset);
+          offset += chunk.length;
+        }
         const ext = contentType.split("/")[1]?.split(";")[0] || "png";
         tempFile = join7(tmpdir(), `assistants-image-${generateId()}.${ext}`);
-        writeFileSync3(tempFile, Buffer.from(buffer));
+        writeFileSync3(tempFile, buffer);
         localPath = tempFile;
       } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          return `Error: Image fetch timed out after ${FETCH_TIMEOUT_MS / 1000} seconds`;
+        }
         return `Error: Failed to fetch image: ${error instanceof Error ? error.message : String(error)}`;
       }
     }
@@ -116592,7 +117176,7 @@ Respond with ALLOW or DENY on the first line, followed by a short reason.`,
 // packages/core/src/skills/loader.ts
 init_src2();
 var import_fast_glob = __toESM(require_out4(), 1);
-import { join as join9, basename, dirname as dirname5 } from "path";
+import { join as join9, basename as basename2, dirname as dirname5 } from "path";
 import { homedir as homedir7 } from "os";
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
 
@@ -116649,7 +117233,7 @@ class SkillLoader {
       const content = await readFile2(filePath, "utf-8");
       const { frontmatter, content: markdownContent } = parseFrontmatter(content);
       const includeContent = options.includeContent ?? true;
-      const dirName = basename(dirname5(filePath));
+      const dirName = basename2(dirname5(filePath));
       const name = frontmatter.name || dirName;
       let description = frontmatter.description || "";
       if (!description && markdownContent) {
@@ -117590,7 +118174,7 @@ function createScopeVerificationHook() {
 }
 // packages/core/src/commands/loader.ts
 import { existsSync as existsSync6, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { join as join11, basename as basename2, extname as extname2 } from "path";
+import { join as join11, basename as basename3, extname as extname2 } from "path";
 import { homedir as homedir8 } from "os";
 class CommandLoader {
   commands = new Map;
@@ -117630,7 +118214,7 @@ class CommandLoader {
       const runtime = getRuntime();
       const content = await runtime.file(filePath).text();
       const { frontmatter, body } = this.parseFrontmatter(content);
-      const fileName = basename2(filePath, ".md");
+      const fileName = basename3(filePath, ".md");
       const name = frontmatter.name || (prefix ? `${prefix}:${fileName}` : fileName);
       const allowedToolsRaw = frontmatter["allowed-tools"];
       const allowedTools = Array.isArray(allowedToolsRaw) ? allowedToolsRaw.map((t) => String(t).trim()).filter(Boolean) : typeof allowedToolsRaw === "string" ? allowedToolsRaw.split(",").map((t) => t.trim()).filter(Boolean) : undefined;
@@ -117723,6 +118307,8 @@ class CommandLoader {
   }
 }
 // packages/core/src/commands/executor.ts
+var MAX_SHELL_OUTPUT_LENGTH = 64 * 1024;
+
 class CommandExecutor {
   loader;
   constructor(loader) {
@@ -117806,6 +118392,20 @@ Use /help to see available commands.
 `);
   }
   async executeShell(command, cwd) {
+    const validation = validateBashCommand(command);
+    if (!validation.valid) {
+      getSecurityLogger().log({
+        eventType: "blocked_command",
+        severity: validation.severity || "high",
+        details: {
+          tool: "custom_command",
+          command,
+          reason: validation.reason || "Command blocked by security policy"
+        },
+        sessionId: "custom-command"
+      });
+      return `Error: ${validation.reason || "Command blocked by security policy"}`;
+    }
     try {
       const runtime = getRuntime();
       const timeoutMs = 5000;
@@ -117833,10 +118433,15 @@ Use /help to see available commands.
         return `Error: command timed out after ${Math.round(timeoutMs / 1000)}s.`;
       }
       if (exitCode !== 0 && stderr) {
+        const truncatedStderr = stderr.length > MAX_SHELL_OUTPUT_LENGTH ? `${stderr.slice(0, MAX_SHELL_OUTPUT_LENGTH)}...(truncated)` : stderr;
         return `Error (exit ${exitCode}):
-${stderr}`;
+${truncatedStderr}`;
+      }
+      const trimmedOutput = stdout.trim();
+      if (trimmedOutput.length > MAX_SHELL_OUTPUT_LENGTH) {
+        return `${trimmedOutput.slice(0, MAX_SHELL_OUTPUT_LENGTH)}...(output truncated at ${MAX_SHELL_OUTPUT_LENGTH} bytes)`;
       }
-      return stdout.trim() || "(no output)";
+      return trimmedOutput || "(no output)";
     } catch (error) {
       return `Error: ${error instanceof Error ? error.message : String(error)}`;
     }
@@ -118690,7 +119295,7 @@ function formatAge(ms) {
   return `${days}d`;
 }
 // packages/core/src/commands/builtin.ts
-var VERSION = "0.6.54";
+var VERSION = "0.6.55";
 function resolveAuthTimeout(resolve5) {
   resolve5({ exitCode: 1, stdout: { toString: () => "{}" } });
 }
@@ -123551,6 +124156,8 @@ import { join as join20 } from "path";
 import { readFileSync as readFileSync6, unlink as unlink6 } from "fs";
 class AudioRecorder {
   currentProcess = null;
+  stoppedIntentionally = false;
+  currentOutputPath = null;
   async record(options = {}) {
     if (this.currentProcess) {
       throw new Error("Audio recorder is already running.");
@@ -123559,6 +124166,8 @@ class AudioRecorder {
     const sampleRate = options.sampleRate ?? 16000;
     const channels = options.channels ?? 1;
     const output = join20(tmpdir4(), `assistants-record-${Date.now()}.wav`);
+    this.currentOutputPath = output;
+    this.stoppedIntentionally = false;
     const recorder = this.resolveRecorder(sampleRate, channels, duration, output);
     if (!recorder) {
       throw new Error("No supported audio recorder found. Install sox or ffmpeg.");
@@ -123567,7 +124176,7 @@ class AudioRecorder {
       this.currentProcess = spawn2(recorder.command, recorder.args, { stdio: "ignore" });
       this.currentProcess.on("close", (code) => {
         this.currentProcess = null;
-        if (code === 0) {
+        if (code === 0 || this.stoppedIntentionally) {
           resolve5();
         } else {
           reject(new Error("Audio recording failed."));
@@ -123580,12 +124189,13 @@ class AudioRecorder {
     });
     const data = readFileSync6(output);
     unlink6(output, () => {});
+    this.currentOutputPath = null;
     return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
   }
   stop() {
     if (this.currentProcess) {
-      this.currentProcess.kill();
-      this.currentProcess = null;
+      this.stoppedIntentionally = true;
+      this.currentProcess.kill("SIGINT");
     }
   }
   resolveRecorder(sampleRate, channels, duration, output) {
@@ -123759,6 +124369,15 @@ init_src2();
 import { existsSync as existsSync10 } from "fs";
 import { mkdir as mkdir8, readFile as readFile9, writeFile as writeFile8, rm } from "fs/promises";
 import { join as join21 } from "path";
+var SAFE_ID_PATTERN4 = /^[a-zA-Z0-9_-]+$/;
+function isValidId(id) {
+  return typeof id === "string" && id.length > 0 && SAFE_ID_PATTERN4.test(id);
+}
+function validateId(id, idType) {
+  if (!isValidId(id)) {
+    throw new Error(`Invalid ${idType}: "${id}" contains invalid characters. Only alphanumeric characters, hyphens, and underscores are allowed.`);
+  }
+}
 var DEFAULT_PROFILE = {
   displayName: "Assistant",
   timezone: "UTC",
@@ -123784,6 +124403,7 @@ class IdentityManager {
   identities = new Map;
   activeId = null;
   constructor(assistantId, basePath) {
+    validateId(assistantId, "assistantId");
     this.assistantId = assistantId;
     this.basePath = basePath;
   }
@@ -123797,6 +124417,7 @@ class IdentityManager {
     return join21(this.identitiesRoot, "active.json");
   }
   identityPath(id) {
+    validateId(id, "identityId");
     return join21(this.identitiesRoot, `${id}.json`);
   }
   assistantConfigPath() {
@@ -123912,7 +124533,8 @@ class IdentityManager {
     try {
       const raw = await readFile9(this.indexPath, "utf-8");
       const data = JSON.parse(raw);
-      return { identities: Array.isArray(data.identities) ? data.identities : [] };
+      const identities = Array.isArray(data.identities) ? data.identities : [];
+      return { identities: identities.filter(isValidId) };
     } catch {
       return { identities: [] };
     }
@@ -123950,7 +124572,11 @@ class IdentityManager {
     try {
       const raw = await readFile9(this.activePath, "utf-8");
       const data = JSON.parse(raw);
-      return data.id || null;
+      const id = data.id || null;
+      if (id && !isValidId(id)) {
+        return null;
+      }
+      return id;
     } catch {
       return null;
     }
@@ -123972,6 +124598,15 @@ class IdentityManager {
 }
 
 // packages/core/src/identity/assistant-manager.ts
+var SAFE_ID_PATTERN5 = /^[a-zA-Z0-9_-]+$/;
+function isValidId2(id) {
+  return typeof id === "string" && id.length > 0 && SAFE_ID_PATTERN5.test(id);
+}
+function validateId2(id, idType) {
+  if (!isValidId2(id)) {
+    throw new Error(`Invalid ${idType}: "${id}" contains invalid characters. Only alphanumeric characters, hyphens, and underscores are allowed.`);
+  }
+}
 var DEFAULT_SETTINGS = {
   model: "claude-opus-4-5"
 };
@@ -123993,6 +124628,7 @@ class AssistantManager {
     return join22(this.basePath, "active.json");
   }
   assistantConfigPath(id) {
+    validateId2(id, "assistantId");
     return join22(this.assistantsRoot, id, "config.json");
   }
   async initialize() {
@@ -124044,6 +124680,7 @@ class AssistantManager {
     return updated;
   }
   async deleteAssistant(id) {
+    validateId2(id, "assistantId");
     if (!this.assistants.has(id)) {
       throw new Error(`Assistant ${id} not found`);
     }
@@ -124084,7 +124721,8 @@ class AssistantManager {
     try {
       const raw = await readFile10(this.indexPath, "utf-8");
       const data = JSON.parse(raw);
-      return { assistants: Array.isArray(data.assistants) ? data.assistants : [] };
+      const assistants = Array.isArray(data.assistants) ? data.assistants : [];
+      return { assistants: assistants.filter(isValidId2) };
     } catch {
       return { assistants: [] };
     }
@@ -124113,6 +124751,7 @@ class AssistantManager {
     }
   }
   async persistAssistant(assistant) {
+    validateId2(assistant.id, "assistantId");
     const dir = join22(this.assistantsRoot, assistant.id);
     await mkdir9(dir, { recursive: true });
     await writeFile9(this.assistantConfigPath(assistant.id), JSON.stringify(assistant, null, 2));
@@ -124123,7 +124762,11 @@ class AssistantManager {
     try {
       const raw = await readFile10(this.activePath, "utf-8");
       const data = JSON.parse(raw);
-      return data.id || null;
+      const id = data.id || null;
+      if (id && !isValidId2(id)) {
+        return null;
+      }
+      return id;
     } catch {
       return null;
     }
@@ -132992,8 +133635,34 @@ class S3InboxClient {
 }
 
 // packages/core/src/inbox/storage/local-cache.ts
-import { join as join24 } from "path";
+import { join as join24, basename as basename4 } from "path";
 import { mkdir as mkdir10, readFile as readFile12, writeFile as writeFile11, rm as rm3, readdir as readdir4, stat as stat3 } from "fs/promises";
+import { createHash as createHash2 } from "crypto";
+var STRICT_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var SAFE_FILENAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function isValidAgentId(id) {
+  return typeof id === "string" && id.length > 0 && STRICT_ID_PATTERN.test(id);
+}
+function validateAgentId(id) {
+  if (!isValidAgentId(id)) {
+    throw new Error(`Invalid agentId: "${id}" contains invalid characters. Only alphanumeric characters, hyphens, and underscores are allowed.`);
+  }
+}
+function emailIdToFilename(emailId) {
+  if (SAFE_FILENAME_PATTERN.test(emailId) && emailId.length <= 100) {
+    return emailId;
+  }
+  const hash = createHash2("sha256").update(emailId).digest("base64url").slice(0, 16);
+  const readable = emailId.replace(/[^a-zA-Z0-9]/g, "").slice(0, 20);
+  return readable ? `${readable}_${hash}` : hash;
+}
+function isValidMappedFilename(filename) {
+  return typeof filename === "string" && filename.length > 0 && SAFE_FILENAME_PATTERN.test(filename);
+}
+function sanitizeFilename(filename) {
+  const base = basename4(filename);
+  return base.replace(/[/\\]/g, "_");
+}
 
 class LocalInboxCache {
   agentId;
@@ -133001,6 +133670,7 @@ class LocalInboxCache {
   cacheDir;
   index = null;
   constructor(options) {
+    validateAgentId(options.agentId);
     this.agentId = options.agentId;
     this.basePath = options.basePath;
     this.cacheDir = join24(this.basePath, this.agentId);
@@ -133030,13 +133700,18 @@ class LocalInboxCache {
     await writeFile11(indexPath, JSON.stringify(this.index, null, 2));
   }
   async saveEmail(email) {
+    const filename = emailIdToFilename(email.id);
+    if (!isValidMappedFilename(filename)) {
+      throw new Error(`Failed to create safe filename for email ID: "${email.id}"`);
+    }
     await this.ensureDirectories();
-    const emailPath = join24(this.cacheDir, "emails", `${email.id}.json`);
+    const emailPath = join24(this.cacheDir, "emails", `${filename}.json`);
     await writeFile11(emailPath, JSON.stringify(email, null, 2));
     const index = await this.loadIndex();
     const existingIdx = index.emails.findIndex((e3) => e3.id === email.id);
     const entry = {
       id: email.id,
+      filename,
       messageId: email.messageId,
       from: email.from.name || email.from.address,
       subject: email.subject,
@@ -133047,6 +133722,7 @@ class LocalInboxCache {
     };
     if (existingIdx >= 0) {
       entry.isRead = index.emails[existingIdx].isRead;
+      entry.filename = index.emails[existingIdx].filename || filename;
       index.emails[existingIdx] = entry;
     } else {
       index.emails.unshift(entry);
@@ -133054,8 +133730,17 @@ class LocalInboxCache {
     await this.saveIndex();
   }
   async loadEmail(id) {
+    const index = await this.loadIndex();
+    const entry = index.emails.find((e3) => e3.id === id);
+    if (!entry) {
+      return null;
+    }
+    const filename = entry.filename || emailIdToFilename(id);
+    if (!isValidMappedFilename(filename)) {
+      return null;
+    }
     try {
-      const emailPath = join24(this.cacheDir, "emails", `${id}.json`);
+      const emailPath = join24(this.cacheDir, "emails", `${filename}.json`);
       const content = await readFile12(emailPath, "utf-8");
       return JSON.parse(content);
     } catch {
@@ -133107,15 +133792,31 @@ class LocalInboxCache {
     return new Set(index.emails.map((e3) => e3.id));
   }
   async saveAttachment(emailId, filename, content) {
-    const attachmentDir = join24(this.cacheDir, "attachments", emailId);
+    const emailFilename = emailIdToFilename(emailId);
+    if (!isValidMappedFilename(emailFilename)) {
+      throw new Error(`Failed to create safe directory name for email ID: "${emailId}"`);
+    }
+    const safeFilename = sanitizeFilename(filename);
+    if (!safeFilename) {
+      throw new Error("Invalid attachment filename");
+    }
+    const attachmentDir = join24(this.cacheDir, "attachments", emailFilename);
     await mkdir10(attachmentDir, { recursive: true });
-    const attachmentPath = join24(attachmentDir, filename);
+    const attachmentPath = join24(attachmentDir, safeFilename);
     await writeFile11(attachmentPath, content);
     return attachmentPath;
   }
   async getAttachmentPath(emailId, filename) {
+    const emailFilename = emailIdToFilename(emailId);
+    if (!isValidMappedFilename(emailFilename)) {
+      return null;
+    }
+    const safeFilename = sanitizeFilename(filename);
+    if (!safeFilename) {
+      return null;
+    }
     try {
-      const attachmentPath = join24(this.cacheDir, "attachments", emailId, filename);
+      const attachmentPath = join24(this.cacheDir, "attachments", emailFilename, safeFilename);
       await stat3(attachmentPath);
       return attachmentPath;
     } catch {
@@ -133134,26 +133835,29 @@ class LocalInboxCache {
   async cleanup(maxAgeDays = 30) {
     const index = await this.loadIndex();
     const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
-    const removed = [];
+    const toRemove = [];
     for (const entry of index.emails) {
       const cachedAt = new Date(entry.cachedAt).getTime();
       if (cachedAt < cutoff) {
-        removed.push(entry.id);
+        const filename = entry.filename || emailIdToFilename(entry.id);
+        if (isValidMappedFilename(filename)) {
+          toRemove.push({ id: entry.id, filename });
+        }
       }
     }
-    for (const id of removed) {
+    for (const { id, filename } of toRemove) {
       index.emails = index.emails.filter((e3) => e3.id !== id);
       try {
-        await rm3(join24(this.cacheDir, "emails", `${id}.json`));
+        await rm3(join24(this.cacheDir, "emails", `${filename}.json`));
       } catch {}
       try {
-        await rm3(join24(this.cacheDir, "attachments", id), { recursive: true });
+        await rm3(join24(this.cacheDir, "attachments", filename), { recursive: true });
       } catch {}
     }
-    if (removed.length > 0) {
+    if (toRemove.length > 0) {
       await this.saveIndex();
     }
-    return removed.length;
+    return toRemove.length;
   }
   async getCacheSize() {
     let totalSize = 0;
@@ -138527,12 +139231,21 @@ function getMessagesBasePath() {
   const home = envOverride && envOverride.trim() ? envOverride : homedir14();
   return join26(home, ".assistants", "messages");
 }
+var SAFE_ID_PATTERN6 = /^[a-zA-Z0-9_-]+$/;
 
 class LocalMessagesStorage {
   basePath;
   constructor(options = {}) {
     this.basePath = options.basePath || getMessagesBasePath();
   }
+  validateSafeId(id, idType) {
+    if (!id || typeof id !== "string") {
+      throw new Error(`Invalid ${idType}: must be a non-empty string`);
+    }
+    if (!SAFE_ID_PATTERN6.test(id)) {
+      throw new Error(`Invalid ${idType}: "${id}" contains invalid characters. Only alphanumeric characters, hyphens, and underscores are allowed.`);
+    }
+  }
   async ensureDirectories(agentId) {
     const agentPath = this.getAgentPath(agentId);
     await Promise.all([
@@ -138542,15 +139255,18 @@ class LocalMessagesStorage {
     ]);
   }
   getAgentPath(agentId) {
+    this.validateSafeId(agentId, "agentId");
     return join26(this.basePath, agentId);
   }
   getIndexPath(agentId) {
     return join26(this.getAgentPath(agentId), "index.json");
   }
   getMessagePath(agentId, messageId) {
+    this.validateSafeId(messageId, "messageId");
     return join26(this.getAgentPath(agentId), "messages", `${messageId}.json`);
   }
   getThreadPath(agentId, threadId) {
+    this.validateSafeId(threadId, "threadId");
     return join26(this.getAgentPath(agentId), "threads", `${threadId}.json`);
   }
   getRegistryPath() {
@@ -140479,7 +141195,9 @@ ${effects.message}
     }
   }
   startHeartbeat() {
-    if (!this.config?.scheduler?.enabled)
+    if (!this.config)
+      return;
+    if (this.config.scheduler?.enabled === false)
       return;
     const interval = this.config.scheduler?.heartbeatIntervalMs ?? 30000;
     if (this.heartbeatTimer)
@@ -140557,7 +141275,8 @@ ${effects.message}
           leaseTimer.unref();
         }
         try {
-          const result = await this.runMessage(current.command, "schedule");
+          const contentToRun = current.actionType === "message" ? current.message || current.command : current.command;
+          const result = await this.runMessage(contentToRun, "schedule");
           const now2 = Date.now();
           await updateSchedule(this.cwd, schedule.id, (live) => {
             const updated = {
@@ -140801,6 +141520,11 @@ init_src2();
 // 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 join28 } from "path";
+var SAFE_ID_PATTERN7 = /^[a-zA-Z0-9_-]+$/;
+function isValidId3(id) {
+  return typeof id === "string" && id.length > 0 && SAFE_ID_PATTERN7.test(id);
+}
+
 class Logger {
   logDir;
   logFile;
@@ -140852,9 +141576,13 @@ class SessionStorage {
   sessionFile;
   sessionId;
   constructor(sessionId, basePath, assistantId) {
+    if (!isValidId3(sessionId)) {
+      throw new Error(`Invalid sessionId: "${sessionId}" contains invalid characters. Only alphanumeric characters, hyphens, and underscores are allowed.`);
+    }
     this.sessionId = sessionId;
     const root = basePath || getConfigDir();
-    this.sessionsDir = assistantId ? join28(root, "assistants", assistantId, "sessions") : join28(root, "sessions");
+    const safeAssistantId = isValidId3(assistantId) ? assistantId : null;
+    this.sessionsDir = safeAssistantId ? join28(root, "assistants", safeAssistantId, "sessions") : join28(root, "sessions");
     this.ensureDir(this.sessionsDir);
     this.sessionFile = join28(this.sessionsDir, `${sessionId}.json`);
   }
@@ -140887,15 +141615,20 @@ class SessionStorage {
         return null;
       const raw = readFileSync8(activePath, "utf-8");
       const data = JSON.parse(raw);
-      return data.id || null;
+      const id = data.id || null;
+      if (id && !isValidId3(id)) {
+        return null;
+      }
+      return id;
     } catch {
       return null;
     }
   }
   static resolveSessionsDir(assistantId) {
     const root = getConfigDir();
-    const resolvedId = assistantId ?? SessionStorage.getActiveAssistantId();
-    if (resolvedId) {
+    const safeAssistantId = isValidId3(assistantId) ? assistantId : null;
+    const resolvedId = safeAssistantId ?? SessionStorage.getActiveAssistantId();
+    if (resolvedId && isValidId3(resolvedId)) {
       const assistantDir = join28(root, "assistants", resolvedId, "sessions");
       if (existsSync12(assistantDir)) {
         return assistantDir;
@@ -140931,6 +141664,9 @@ class SessionStorage {
     return sessions[0] || null;
   }
   static loadSession(sessionId, assistantId) {
+    if (!isValidId3(sessionId)) {
+      return null;
+    }
     const sessionsDir = SessionStorage.resolveSessionsDir(assistantId);
     const sessionFile = join28(sessionsDir, `${sessionId}.json`);
     try {
@@ -147338,7 +148074,7 @@ var COMMANDS = [
   { name: "/help", description: "show available commands" },
   { name: "/clear", description: "clear the conversation" },
   { name: "/new", description: "start a new conversation" },
-  { name: "/session", description: "list/switch sessions (Ctrl+S)" },
+  { name: "/session", description: "list/switch sessions (Ctrl+])" },
   { name: "/status", description: "show session status" },
   { name: "/tokens", description: "show token usage" },
   { name: "/cost", description: "show estimated API cost" },
@@ -147368,10 +148104,23 @@ function Input({
   commands: commands3,
   skills = [],
   isAskingUser = false,
-  askPlaceholder
+  askPlaceholder,
+  allowBlankAnswer = false
 }) {
-  const [value, setValue] = import_react27.useState("");
-  const [cursor, setCursor] = import_react27.useState(0);
+  const [inputState, setInputState] = import_react27.useState({ value: "", cursor: 0 });
+  const { value, cursor } = inputState;
+  const setValue = (newValue) => {
+    setInputState((prev) => ({
+      ...prev,
+      value: typeof newValue === "function" ? newValue(prev.value) : newValue
+    }));
+  };
+  const setCursor = (newCursor) => {
+    setInputState((prev) => ({
+      ...prev,
+      cursor: typeof newCursor === "function" ? newCursor(prev.cursor) : newCursor
+    }));
+  };
   const [preferredColumn, setPreferredColumn] = import_react27.useState(null);
   const [selectedIndex, setSelectedIndex] = import_react27.useState(0);
   const { stdout } = use_stdout_default();
@@ -147399,7 +148148,7 @@ function Input({
       return "command";
     }
     return null;
-  }, [value]);
+  }, [value, isAskingUser]);
   const filteredCommands = import_react27.useMemo(() => {
     if (autocompleteMode !== "command")
       return [];
@@ -147421,14 +148170,13 @@ function Input({
     setSelectedIndex((prev) => Math.min(prev, autocompleteItems.length - 1));
   }, [autocompleteItems.length]);
   const setValueAndCursor = (nextValue, nextCursor = nextValue.length) => {
-    setValue(nextValue);
     const clamped = Math.max(0, Math.min(nextCursor, nextValue.length));
-    setCursor(clamped);
+    setInputState({ value: nextValue, cursor: clamped });
     setPreferredColumn(null);
     setSelectedIndex(0);
   };
   const handleSubmit = (submittedValue) => {
-    if (!submittedValue.trim())
+    if (!submittedValue.trim() && !allowBlankAnswer)
       return;
     if (autocompleteMode === "command" && filteredCommands.length > 0 && !submittedValue.includes(" ")) {
       const selected = filteredCommands[selectedIndex] || filteredCommands[0];
@@ -147465,26 +148213,53 @@ function Input({
   const insertText = (text) => {
     if (!text)
       return;
-    const next = value.slice(0, cursor) + text + value.slice(cursor);
-    setValue(next);
-    setCursor(cursor + text.length);
+    setInputState((prev) => ({
+      value: prev.value.slice(0, prev.cursor) + text + prev.value.slice(prev.cursor),
+      cursor: prev.cursor + text.length
+    }));
     setPreferredColumn(null);
     setSelectedIndex(0);
   };
   const deleteBackward = () => {
-    if (cursor === 0)
-      return;
-    const next = value.slice(0, cursor - 1) + value.slice(cursor);
-    setValue(next);
-    setCursor(cursor - 1);
+    setInputState((prev) => {
+      if (prev.cursor === 0)
+        return prev;
+      return {
+        value: prev.value.slice(0, prev.cursor - 1) + prev.value.slice(prev.cursor),
+        cursor: prev.cursor - 1
+      };
+    });
     setPreferredColumn(null);
     setSelectedIndex(0);
   };
   const deleteForward = () => {
-    if (cursor >= value.length)
-      return;
-    const next = value.slice(0, cursor) + value.slice(cursor + 1);
-    setValue(next);
+    setInputState((prev) => {
+      if (prev.cursor >= prev.value.length)
+        return prev;
+      return {
+        value: prev.value.slice(0, prev.cursor) + prev.value.slice(prev.cursor + 1),
+        cursor: prev.cursor
+      };
+    });
+    setPreferredColumn(null);
+    setSelectedIndex(0);
+  };
+  const deleteWordBackward = () => {
+    setInputState((prev) => {
+      if (prev.cursor === 0)
+        return prev;
+      let start = prev.cursor - 1;
+      while (start >= 0 && /\s/.test(prev.value[start])) {
+        start--;
+      }
+      while (start >= 0 && !/\s/.test(prev.value[start])) {
+        start--;
+      }
+      return {
+        value: prev.value.slice(0, start + 1) + prev.value.slice(prev.cursor),
+        cursor: start + 1
+      };
+    });
     setPreferredColumn(null);
     setSelectedIndex(0);
   };
@@ -147495,6 +148270,10 @@ function Input({
       }
       return;
     }
+    if (key.ctrl && input === "w") {
+      deleteWordBackward();
+      return;
+    }
     if (!isAskingUser) {
       if (key.tab) {
         if (autocompleteItems.length > 0) {
@@ -147547,14 +148326,20 @@ function Input({
       moveCursorTo(line.start + line.text.length, false);
       return;
     }
-    if (key.backspace || input === "\x7F" || input === "\b") {
+    if (input === "\x7F" || input === "\b" || key.backspace || key.delete) {
       deleteBackward();
       return;
     }
-    if (key.delete || input === "\x1B[3~") {
+    if (input === "\x1B[3~") {
       deleteForward();
       return;
     }
+    if (input === "\x1B\r" || input === `\x1B
+`) {
+      insertText(`
+`);
+      return;
+    }
     if (key.return) {
       if ((key.shift || key.ctrl) && value.trim()) {
         onSubmit(value, "interrupt");
@@ -148920,7 +149705,7 @@ function groupConsecutiveToolMessages(messages2) {
 
 // packages/terminal/src/components/Messages.tsx
 var jsx_dev_runtime3 = __toESM(require_jsx_dev_runtime(), 1);
-import { basename as basename3 } from "path";
+import { basename as basename5 } from "path";
 function Messages3({
   messages: messages2,
   currentResponse,
@@ -149431,10 +150216,10 @@ function getToolContext(toolCall) {
       return truncate(String(input.command || ""), 20);
     case "read":
       const path2 = String(input.path || input.file_path || "");
-      return basename3(path2) || path2;
+      return basename5(path2) || path2;
     case "write":
       const writePath = String(input.filename || input.path || input.file_path || "");
-      return basename3(writePath) || writePath;
+      return basename5(writePath) || writePath;
     case "glob":
       return truncate(String(input.pattern || ""), 20);
     case "grep":
@@ -149778,7 +150563,7 @@ function Status({
         dimColor: true,
         children: [
           "/help",
-          sessionCount && sessionCount > 1 ? " \xB7 Ctrl+S" : ""
+          sessionCount && sessionCount > 1 ? " \xB7 Ctrl+]" : ""
         ]
       }, undefined, true, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
@@ -149885,6 +150670,7 @@ function Spinner2({ label }) {
 
 // packages/terminal/src/components/ProcessingIndicator.tsx
 var import_react31 = __toESM(require_react(), 1);
+init_src2();
 var jsx_dev_runtime6 = __toESM(require_jsx_dev_runtime(), 1);
 function ProcessingIndicator({
   isProcessing,
@@ -149893,6 +150679,7 @@ function ProcessingIndicator({
   isThinking = false
 }) {
   const [elapsed, setElapsed] = import_react31.useState(0);
+  const loadingWord = import_react31.useMemo(() => getRandomLoadingWord(), [isProcessing]);
   import_react31.useEffect(() => {
     if (!isProcessing || !startTime) {
       setElapsed(0);
@@ -149930,7 +150717,7 @@ function ProcessingIndicator({
   if (isThinking) {
     parts.push("thinking");
   }
-  const label = isThinking ? "Metamorphosing" : "Working";
+  const label = loadingWord;
   return /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
     marginY: 1,
     children: [
@@ -150319,7 +151106,7 @@ function AskUserPanel({
         marginTop: 1,
         children: /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text3, {
           dimColor: true,
-          children: "Multi-line answer allowed. Paste text and press Enter."
+          children: "Multi-line answer allowed. Use Alt+Enter to insert newlines."
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
@@ -150376,6 +151163,7 @@ function App2({ cwd: cwd2, version: version3 }) {
   const [askUserState, setAskUserState] = import_react33.useState(null);
   const [processingStartTime, setProcessingStartTime] = import_react33.useState();
   const [currentTurnTokens, setCurrentTurnTokens] = import_react33.useState(0);
+  const [lastWorkedFor, setLastWorkedFor] = import_react33.useState();
   const [skills, setSkills] = import_react33.useState([]);
   const [commands3, setCommands] = import_react33.useState([]);
   const responseRef = import_react33.useRef("");
@@ -150448,6 +151236,7 @@ function App2({ cwd: cwd2, version: version3 }) {
   const turnIdRef = import_react33.useRef(0);
   const initStateRef = import_react33.useRef("idle");
   const isMountedRef = import_react33.useRef(true);
+  const handlersRegisteredRef = import_react33.useRef(false);
   import_react33.useEffect(() => {
     isProcessingRef.current = isProcessing;
   }, [isProcessing]);
@@ -150527,9 +151316,7 @@ function App2({ cwd: cwd2, version: version3 }) {
     }
     if (processingStartTimeRef.current) {
       const workedFor = formatElapsedDuration(Date.now() - processingStartTimeRef.current);
-      content = content ? `${content}
-
-\u273B Worked for ${workedFor}` : `\u273B Worked for ${workedFor}`;
+      setLastWorkedFor(workedFor);
     }
     setMessages((prev) => [
       ...prev,
@@ -150569,10 +151356,11 @@ function App2({ cwd: cwd2, version: version3 }) {
         identityInfo,
         processingStartTime,
         currentTurnTokens,
-        error: error2
+        error: error2,
+        lastWorkedFor
       });
     }
-  }, [activeSessionId, messages2, tokenUsage, energyState, voiceState, identityInfo, processingStartTime, currentTurnTokens, error2]);
+  }, [activeSessionId, messages2, tokenUsage, energyState, voiceState, identityInfo, processingStartTime, currentTurnTokens, error2, lastWorkedFor]);
   const loadSessionState = import_react33.useCallback((sessionId) => {
     const state = sessionUIStates.current.get(sessionId);
     const askState = askUserStateRef.current.get(sessionId) || null;
@@ -150592,6 +151380,7 @@ function App2({ cwd: cwd2, version: version3 }) {
       setProcessingStartTime(state.processingStartTime);
       setCurrentTurnTokens(state.currentTurnTokens);
       setError(state.error);
+      setLastWorkedFor(state.lastWorkedFor);
       setAskUserState(askState);
     } else {
       setMessages([]);
@@ -150609,6 +151398,7 @@ function App2({ cwd: cwd2, version: version3 }) {
       setProcessingStartTime(undefined);
       setCurrentTurnTokens(0);
       setError(null);
+      setLastWorkedFor(undefined);
       setAskUserState(askState);
     }
   }, []);
@@ -150751,21 +151541,24 @@ function App2({ cwd: cwd2, version: version3 }) {
     let cancelled = false;
     const initSession = async () => {
       try {
-        registry.onChunk(handleChunk);
-        registry.onError((err) => {
-          const finalized = finalizeResponse("error");
-          if (finalized) {
-            skipNextDoneRef.current = true;
-          }
-          resetTurnState();
-          setError(err.message);
-          setIsProcessing(false);
-          isProcessingRef.current = false;
-          const active = registryRef.current.getActiveSession();
-          if (active) {
-            registryRef.current.setProcessing(active.id, false);
-          }
-        });
+        if (!handlersRegisteredRef.current) {
+          handlersRegisteredRef.current = true;
+          registry.onChunk(handleChunk);
+          registry.onError((err) => {
+            const finalized = finalizeResponse("error");
+            if (finalized) {
+              skipNextDoneRef.current = true;
+            }
+            resetTurnState();
+            setError(err.message);
+            setIsProcessing(false);
+            isProcessingRef.current = false;
+            const active = registryRef.current.getActiveSession();
+            if (active) {
+              registryRef.current.setProcessing(active.id, false);
+            }
+          });
+        }
         const session = await registry.createSession(cwd2);
         setActiveSessionId(session.id);
         session.client.setAskUserHandler((request2) => beginAskUser(session.id, request2));
@@ -150950,7 +151743,7 @@ function App2({ cwd: cwd2, version: version3 }) {
     }
   }, [cwd2, registry, saveCurrentSessionState, loadSessionState, beginAskUser]);
   use_input_default((input, key) => {
-    if (key.ctrl && input === "s") {
+    if (key.ctrl && input === "]") {
       if (sessions.length > 0) {
         setShowSessionSelector(true);
       }
@@ -151113,6 +151906,7 @@ function App2({ cwd: cwd2, version: version3 }) {
       pendingSendsRef.current = pendingSendsRef.current.filter((entry) => entry.sessionId !== activeSession.id);
       setActivityLog([]);
       activityLogRef.current = [];
+      setLastWorkedFor(undefined);
       sessionUIStates.current.set(activeSession.id, {
         messages: [],
         currentResponse: "",
@@ -151125,7 +151919,8 @@ function App2({ cwd: cwd2, version: version3 }) {
         identityInfo,
         processingStartTime: undefined,
         currentTurnTokens: 0,
-        error: null
+        error: null,
+        lastWorkedFor: undefined
       });
     } else {
       const userMessage = {
@@ -151220,7 +152015,7 @@ function App2({ cwd: cwd2, version: version3 }) {
             backgroundProcessingCount,
             " session",
             backgroundProcessingCount > 1 ? "s" : "",
-            " processing in background (Ctrl+S to switch)"
+            " processing in background (Ctrl+] to switch)"
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
@@ -151286,6 +152081,17 @@ function App2({ cwd: cwd2, version: version3 }) {
         tokenCount: currentTurnTokens,
         isThinking
       }, undefined, false, undefined, this),
+      !isProcessing && lastWorkedFor && /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Box_default, {
+        marginBottom: 0,
+        marginLeft: 2,
+        children: /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text3, {
+          color: "gray",
+          children: [
+            "\u273B Worked for ",
+            lastWorkedFor
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Input, {
         onSubmit: handleSubmit,
         isProcessing: isBusy,
@@ -151293,7 +152099,8 @@ function App2({ cwd: cwd2, version: version3 }) {
         commands: commands3,
         skills,
         isAskingUser: Boolean(activeAskQuestion),
-        askPlaceholder
+        askPlaceholder,
+        allowBlankAnswer: activeAskQuestion?.required === false
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Status, {
         isProcessing: isBusy,
@@ -151492,44 +152299,9 @@ function sanitizeTerminalOutput(chunk) {
   return chunk.replace(/\x1b\[2J\x1b\[3J\x1b\[H/g, "\x1B[H").replace(/\x1b\[3J/g, "");
 }
 
-// packages/terminal/src/index.tsx
-var jsx_dev_runtime13 = __toESM(require_jsx_dev_runtime(), 1);
-setRuntime(bunRuntime);
-var VERSION3 = "0.6.54";
-var SYNC_START = "\x1B[?2026h";
-var SYNC_END = "\x1B[?2026l";
-function enableSynchronizedOutput() {
-  const originalWrite = process.stdout.write.bind(process.stdout);
-  let buffer = "";
-  let flushTimeout = null;
-  const flush = () => {
-    if (buffer) {
-      const safe = sanitizeTerminalOutput(buffer);
-      originalWrite(SYNC_START + safe + SYNC_END);
-      buffer = "";
-    }
-    flushTimeout = null;
-  };
-  process.stdout.write = function(chunk, encodingOrCallback, callback) {
-    const raw = typeof chunk === "string" ? chunk : chunk.toString();
-    buffer += raw;
-    if (flushTimeout) {
-      clearTimeout(flushTimeout);
-    }
-    flushTimeout = setTimeout(flush, 0);
-    const cb2 = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
-    if (cb2) {
-      setImmediate(() => cb2());
-    }
-    return true;
-  };
-  return () => {
-    if (flushTimeout) {
-      clearTimeout(flushTimeout);
-    }
-    flush();
-    process.stdout.write = originalWrite;
-  };
+// packages/terminal/src/cli/main.ts
+function isFlag(arg) {
+  return arg !== undefined && arg.startsWith("-") && arg !== "--";
 }
 function parseArgs(argv) {
   const args = argv.slice(2);
@@ -151544,10 +152316,21 @@ function parseArgs(argv) {
     jsonSchema: null,
     continue: false,
     resume: null,
-    cwdProvided: false
+    cwdProvided: false,
+    errors: []
   };
+  let endOfOptions = false;
+  const positionalArgs = [];
   for (let i5 = 0;i5 < args.length; i5++) {
     const arg = args[i5];
+    if (arg === "--") {
+      endOfOptions = true;
+      continue;
+    }
+    if (endOfOptions) {
+      positionalArgs.push(arg);
+      continue;
+    }
     if (arg === "--version" || arg === "-v") {
       options.version = true;
       continue;
@@ -151557,29 +152340,62 @@ function parseArgs(argv) {
       continue;
     }
     if (arg === "--print" || arg === "-p") {
-      options.print = args[++i5] || "";
+      const nextArg = args[i5 + 1];
+      if (nextArg === undefined || isFlag(nextArg) || nextArg === "--") {
+        options.print = "";
+      } else {
+        options.print = nextArg;
+        i5++;
+      }
       continue;
     }
     if (arg === "--output-format") {
-      const format = args[++i5];
-      if (format === "text" || format === "json" || format === "stream-json") {
-        options.outputFormat = format;
+      const nextArg = args[i5 + 1];
+      if (nextArg === undefined || isFlag(nextArg)) {
+        options.errors.push("--output-format requires a value (text, json, or stream-json)");
+      } else if (nextArg === "text" || nextArg === "json" || nextArg === "stream-json") {
+        options.outputFormat = nextArg;
+        i5++;
+      } else {
+        options.errors.push(`Invalid output format "${nextArg}". Valid options: text, json, stream-json`);
+        i5++;
       }
       continue;
     }
     if (arg === "--allowed-tools" || arg === "--allowedTools") {
-      const tools = args[++i5];
-      if (tools) {
-        options.allowedTools = tools.split(",").map((t9) => t9.trim());
+      const nextArg = args[i5 + 1];
+      if (nextArg === undefined || isFlag(nextArg)) {
+        options.errors.push(`${arg} requires a comma-separated list of tool names`);
+      } else {
+        const seen = new Set;
+        options.allowedTools = nextArg.split(",").map((t9) => t9.trim()).filter((t9) => {
+          if (!t9 || seen.has(t9))
+            return false;
+          seen.add(t9);
+          return true;
+        });
+        i5++;
       }
       continue;
     }
     if (arg === "--system-prompt") {
-      options.systemPrompt = args[++i5] || null;
+      const nextArg = args[i5 + 1];
+      if (nextArg === undefined || isFlag(nextArg)) {
+        options.errors.push("--system-prompt requires a value");
+      } else {
+        options.systemPrompt = nextArg;
+        i5++;
+      }
       continue;
     }
     if (arg === "--json-schema") {
-      options.jsonSchema = args[++i5] || null;
+      const nextArg = args[i5 + 1];
+      if (nextArg === undefined || isFlag(nextArg)) {
+        options.errors.push("--json-schema requires a JSON schema string");
+      } else {
+        options.jsonSchema = nextArg;
+        i5++;
+      }
       continue;
     }
     if (arg === "--continue" || arg === "-c") {
@@ -151587,20 +152403,163 @@ function parseArgs(argv) {
       continue;
     }
     if (arg === "--resume" || arg === "-r") {
-      options.resume = args[++i5] || null;
+      const nextArg = args[i5 + 1];
+      if (nextArg === undefined || isFlag(nextArg)) {
+        options.errors.push(`${arg} requires a session ID`);
+      } else {
+        options.resume = nextArg;
+        i5++;
+      }
       continue;
     }
     if (arg === "--cwd") {
-      options.cwd = args[++i5] || process.cwd();
-      options.cwdProvided = true;
+      const nextArg = args[i5 + 1];
+      if (nextArg === undefined || isFlag(nextArg)) {
+        options.errors.push("--cwd requires a path");
+      } else {
+        options.cwd = nextArg;
+        options.cwdProvided = true;
+        i5++;
+      }
       continue;
     }
-    if (options.print === "" && !arg.startsWith("-")) {
-      options.print = arg;
+    if (!arg.startsWith("-")) {
+      positionalArgs.push(arg);
     }
   }
+  if (options.print === "" && positionalArgs.length > 0) {
+    options.print = positionalArgs.join(" ");
+  }
+  if (options.print === null && positionalArgs.length > 0) {
+    options.print = positionalArgs.join(" ");
+  }
   return options;
 }
+async function main(argv, deps) {
+  const options = parseArgs(argv);
+  const { runHeadless: runHeadless2, print, exit, VERSION: VERSION3 } = deps;
+  if (options.errors.length > 0) {
+    for (const error2 of options.errors) {
+      print(`Error: ${error2}`);
+    }
+    exit(1);
+    return;
+  }
+  if (options.version) {
+    print(`assistants v${VERSION3}`);
+    exit(0);
+    return;
+  }
+  if (options.help) {
+    print(`
+assistants - Your personal AI assistant
+
+Usage:
+  assistants [options]                    Start interactive mode
+  assistants -p "<prompt>" [options]      Run in headless mode
+
+Options:
+  -h, --help                   Show this help message
+  -v, --version                Show version number
+
+Headless Mode:
+  -p, --print <prompt>         Run non-interactively with the given prompt
+  --output-format <format>     Output format: text (default), json, stream-json
+  --allowed-tools <tools>      Comma-separated tools to auto-approve (e.g., "Read,Edit,Bash")
+  --system-prompt <prompt>     Custom system prompt
+  --json-schema <schema>       JSON Schema for structured output (use with --output-format json)
+  -c, --continue               Continue the most recent conversation
+  -r, --resume <session_id>    Resume a specific session by ID
+  --cwd <path>                 Set working directory
+
+Examples:
+  # Ask a question
+  assistants -p "What does the auth module do?"
+
+  # Run with JSON output
+  assistants -p "Summarize this project" --output-format json
+
+  # Stream JSON events
+  assistants -p "Explain this code" --output-format stream-json
+
+  # Auto-approve tools
+  assistants -p "Fix the bug in auth.py" --allowed-tools "Read,Edit,Bash"
+
+  # Get structured output
+  assistants -p "List all functions" --output-format json --json-schema '{"type":"array","items":{"type":"string"}}'
+
+  # Continue conversation
+  assistants -p "What else can you tell me?" --continue
+
+Interactive Mode:
+  - Type your message and press Enter to send
+  - Use $skill-name to invoke a skill
+  - Use /command for built-in commands
+  - Press Ctrl+] to switch sessions
+  - Press Ctrl+C to exit
+`);
+    exit(0);
+    return;
+  }
+  if (options.print !== null) {
+    if (!options.print.trim()) {
+      print("Error: Prompt is required with -p/--print flag");
+      exit(1);
+      return;
+    }
+    await runHeadless2({
+      prompt: options.print,
+      cwd: options.cwd,
+      outputFormat: options.outputFormat,
+      allowedTools: options.allowedTools.length > 0 ? options.allowedTools : undefined,
+      systemPrompt: options.systemPrompt || undefined,
+      jsonSchema: options.jsonSchema || undefined,
+      continue: options.continue,
+      resume: options.resume,
+      cwdProvided: options.cwdProvided
+    });
+  }
+}
+
+// packages/terminal/src/index.tsx
+var jsx_dev_runtime13 = __toESM(require_jsx_dev_runtime(), 1);
+setRuntime(bunRuntime);
+var VERSION3 = "0.6.55";
+var SYNC_START = "\x1B[?2026h";
+var SYNC_END = "\x1B[?2026l";
+function enableSynchronizedOutput() {
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  let buffer = "";
+  let flushTimeout = null;
+  const flush = () => {
+    if (buffer) {
+      const safe = sanitizeTerminalOutput(buffer);
+      originalWrite(SYNC_START + safe + SYNC_END);
+      buffer = "";
+    }
+    flushTimeout = null;
+  };
+  process.stdout.write = function(chunk, encodingOrCallback, callback) {
+    const raw = typeof chunk === "string" ? chunk : chunk.toString();
+    buffer += raw;
+    if (flushTimeout) {
+      clearTimeout(flushTimeout);
+    }
+    flushTimeout = setTimeout(flush, 0);
+    const cb2 = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+    if (cb2) {
+      setImmediate(() => cb2());
+    }
+    return true;
+  };
+  return () => {
+    if (flushTimeout) {
+      clearTimeout(flushTimeout);
+    }
+    flush();
+    process.stdout.write = originalWrite;
+  };
+}
 var options = parseArgs(process.argv);
 if (options.version) {
   console.log(`assistants v${VERSION3}`);
@@ -151651,7 +152610,7 @@ Interactive Mode:
   - Type your message and press Enter to send
   - Use $skill-name to invoke a skill
   - Use /command for built-in commands
-  - Press Ctrl+S to switch sessions
+  - Press Ctrl+] to switch sessions
   - Press Ctrl+C to exit
 `);
   process.exit(0);
@@ -151690,5 +152649,9 @@ if (options.print !== null) {
     process.exit(0);
   });
 }
+export {
+  parseArgs,
+  main
+};
 
-//# debugId=779BE5D95D2D703764756E2164756E21
+//# debugId=C7451B3CD4B5E92E64756E2164756E21