nolo-cli 0.33.0-alpha.2 → 0.33.0-alpha.21

package/{chunk-6PO2SYCS.js → chunk-YH3FPBG6.js}

@@ -3,11 +3,10 @@ import {
   buildIdentityBlock,
   buildRuntimeGuidanceBlocks,
   resolveToolGuidedSections
-} from "./chunk-5SBK2MTI.js";
+} from "./chunk-ZKUATCEY.js";
 import {
-  getModelContextWindow,
-  resolveBuiltinPlatformAgentConfig
-} from "./chunk-2H3XIBY4.js";
+  getModelContextWindow
+} from "./chunk-2CNX3CJE.js";
 import {
   COMPACTION_SUMMARY_SYSTEM_PROMPT,
   buildCompactionMetricsFromPlan,
@@ -19,17 +18,17 @@ import {
   formatMessagesForSummaryWithTruncation,
   planCompression,
   planContextUsage
-} from "./chunk-AOXVOC6D.js";
+} from "./chunk-HCOIKLSH.js";
 import {
   findModelConfig,
   getProviderByModelName
-} from "./chunk-DFUPZE6V.js";
+} from "./chunk-7SLMYTSF.js";
 import {
   buildDialogSummaryLayer
-} from "./chunk-2UECQ7RE.js";
+} from "./chunk-3AOLVADY.js";
 import {
   buildUserResponseLanguageContext
-} from "./chunk-FMEVI5TG.js";
+} from "./chunk-7CH6U3FL.js";
 import {
   canonicalizeToolName,
   canonicalizeToolNames
@@ -37,18 +36,18 @@ import {
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
-import {
-  PLATFORM_HOSTED_QWEN_37_FLASH_MODEL
-} from "./chunk-OR2HNLVO.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
 import {
-  PUBLIC_QWEN_37_FLASH_AGENT_KEY
-} from "./chunk-UK5JGQVU.js";
+  asOptionalPositiveFiniteNumber
+} from "./chunk-U6VC4MU4.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
@@ -98,6 +97,283 @@ function readTitleParams(value) {
   return Object.fromEntries(entries);
 }
 
+// packages/agent-runtime/shellCommandPolicy.ts
+var DESTRUCTIVE_NEGATION_PATTERNS = [
+  "\u522B\u5220",
+  "\u522B\u5220\u9664",
+  "\u4E0D\u8981\u5220",
+  "\u4E0D\u8981\u5220\u9664",
+  "\u522B\u4E71\u5220",
+  "\u522B\u52A8",
+  "\u4E0D\u8981\u52A8",
+  "\u4E0D\u8981\u6E05\u7406",
+  "\u4E0D\u8981\u6E05\u7A7A",
+  "\u4E0D\u8981\u91CD\u7F6E",
+  "don't delete",
+  "do not delete",
+  "don't remove",
+  "do not remove",
+  "without deleting"
+];
+var EXPLICIT_DESTRUCTIVE_REQUEST_PATTERNS = [
+  "\u5220\u9664",
+  "\u5220\u6389",
+  "\u79FB\u9664",
+  "\u6E05\u7406",
+  "\u6E05\u7A7A",
+  "\u91CD\u7F6E",
+  "drop",
+  "delete",
+  "remove",
+  "erase",
+  "clean up",
+  "reset"
+];
+var SHELL_DESTRUCTIVE_PATTERNS = [
+  /\brm\s+(-[^\n\r]*\s+)?/i,
+  /\bremove-item\b/i,
+  /\bdel\s+\/?[a-z]*\s+/i,
+  /\berase\s+/i,
+  /\brmdir\s+/i,
+  /\brd\s+\/s\b/i,
+  /\bgit\s+reset\s+(--hard\b|--merge\b|--keep\b)/i,
+  /\bgit\s+clean\s+-[^\n\r]*f/i,
+  /\bgit\s+checkout\s+--\b/i,
+  /\bgit\s+restore\s+--source=/i
+];
+var SHELL_STRING_EXECUTION_PATTERNS = [
+  /\b(?:ba|da|z|k)?sh\b/i,
+  /\beval\b/i,
+  /\bexec\b/i,
+  /\bxargs\b/i,
+  /\bsource\s/i,
+  /\b(?:node|deno|bun)\s+(?:-\S+\s+)*(?:-e|--eval)\b/i,
+  /\bpython[\d.]*\s+(?:-\S+\s+)*-c\b/i,
+  /\b(?:perl|ruby)\s+(?:-\S+\s+)*-e\b/i
+];
+var stripQuotedSegments = (text) => {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "\\") {
+      out += text.slice(i, i + 2);
+      i += 2;
+    } else if (ch === "'") {
+      const end = text.indexOf("'", i + 1);
+      if (end === -1) return out + text.slice(i);
+      out += "''";
+      i = end + 1;
+    } else if (ch === '"') {
+      let j = i + 1;
+      while (j < text.length && text[j] !== '"') {
+        j += text[j] === "\\" ? 2 : 1;
+      }
+      if (j >= text.length) return out + text.slice(i);
+      out += '""';
+      i = j + 1;
+    } else {
+      out += ch;
+      i += 1;
+    }
+  }
+  return out;
+};
+var normalizeUserInput = (value) => asTrimmedLowercaseString(value);
+var containsAny = (text, patterns) => patterns.some((pattern) => text.includes(pattern));
+var hasExplicitDestructivePermission = (userInput) => {
+  const normalized = normalizeUserInput(userInput);
+  if (!normalized) return false;
+  if (containsAny(normalized, DESTRUCTIVE_NEGATION_PATTERNS)) return false;
+  return containsAny(normalized, EXPLICIT_DESTRUCTIVE_REQUEST_PATTERNS);
+};
+var SHELL_COMMAND_ARG_ALIASES = [
+  "command",
+  "runCommand",
+  "run_command",
+  "terminalCommand",
+  "terminal_command",
+  "runInBash",
+  "run_in_bash",
+  "executeCommand",
+  "execute_command",
+  "execShell",
+  "bash",
+  "cmd"
+];
+var resolveShellCommandArg = (args) => {
+  if (!args) return void 0;
+  for (const key of SHELL_COMMAND_ARG_ALIASES) {
+    const value = args[key];
+    if (value != null) return value;
+  }
+  return void 0;
+};
+var buildCombinedShellInput = (args) => {
+  const command = resolveShellCommandArg(args);
+  return [
+    typeof command === "string" ? command : "",
+    typeof args.input === "string" ? args.input : ""
+  ].filter(Boolean).join("\n");
+};
+function resolveScannableShellInput(args) {
+  const combined = buildCombinedShellInput(args);
+  if (!combined.trim()) return void 0;
+  return SHELL_STRING_EXECUTION_PATTERNS.some(
+    (pattern) => pattern.test(combined)
+  ) ? combined : stripQuotedSegments(combined);
+}
+function isDestructiveShellCommand(args) {
+  const scannable = resolveScannableShellInput(args);
+  if (scannable === void 0) return false;
+  return SHELL_DESTRUCTIVE_PATTERNS.some((pattern) => pattern.test(scannable));
+}
+var LONG_RUNNING_COMMAND_PATTERNS = [
+  /\b(run|npm|yarn|pnpm|bun|npx)\s+(run\s+)?(dev|serve|start|watch)\b/i,
+  /(^|[\s=&|;])--watch\b/i,
+  /\bvite\b.*\b(dev|serve)\b/i,
+  /\bwebpack\b.*(?:--watch|serve)\b/i,
+  /\bnodemon\b/i,
+  /\bgatsby\b.*\b(develop|serve)\b/i,
+  /\bnext\b.*\b(dev|start)\b/i,
+  /\belectron\b.*\bdev\b/i,
+  /\bforever\b/i,
+  /\bpm2\b.*\bstart\b/i
+];
+function isLongRunningShellCommand(args) {
+  const scannable = resolveScannableShellInput(args);
+  if (scannable === void 0) return false;
+  return LONG_RUNNING_COMMAND_PATTERNS.some((pattern) => pattern.test(scannable));
+}
+var IMMEDIATE_DETACH_COMMAND_PATTERNS = [
+  /\btail\s+(?:-\S*[fF]\S*|--follow)\b/,
+  /\bwatch\s+\S/,
+  /\bwhile\s+(?:true|:|\[\s*true\s*\])\s*;\s*do\b/
+];
+var IMMEDIATE_DETACH_SLEEP_THRESHOLD_SECONDS = 5;
+var SLEEP_PREFIX_PATTERN = /^(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*(?:nohup\s+|time\s+)*sleep\s+(\S+)/;
+function parseSleepDurationSeconds(token) {
+  const match = /^(\d+(?:\.\d+)?)(s|m|h|d)?$/i.exec(token);
+  if (!match) return void 0;
+  const value = Number(match[1]);
+  if (!Number.isFinite(value)) return void 0;
+  const unit = (match[2] ?? "s").toLowerCase();
+  const factor = unit === "m" ? 60 : unit === "h" ? 3600 : unit === "d" ? 86400 : 1;
+  return value * factor;
+}
+function isLongSleepCommand(scannable) {
+  const match = SLEEP_PREFIX_PATTERN.exec(scannable.trim());
+  if (!match) return false;
+  const durationToken = match[1] ?? "";
+  if (/^inf(inity)?$/i.test(durationToken)) return true;
+  const seconds = parseSleepDurationSeconds(durationToken);
+  if (seconds === void 0) return true;
+  return seconds > IMMEDIATE_DETACH_SLEEP_THRESHOLD_SECONDS;
+}
+function isImmediateDetachShellCommand(args) {
+  const scannable = resolveScannableShellInput(args);
+  if (scannable === void 0) return false;
+  return isLongSleepCommand(scannable) || LONG_RUNNING_COMMAND_PATTERNS.some((pattern) => pattern.test(scannable)) || IMMEDIATE_DETACH_COMMAND_PATTERNS.some(
+    (pattern) => pattern.test(scannable)
+  );
+}
+function evaluateShellCommandPolicy(args) {
+  if (isDestructiveShellCommand(args) && !hasExplicitDestructivePermission(args.userInput)) {
+    return {
+      verdict: "forbidden",
+      permissionDecision: "ask",
+      code: "destructive_action_requires_confirmation",
+      reason: "\u5F53\u524D\u8FD0\u884C\u9ED8\u8BA4\u7981\u6B62\u81EA\u52A8\u6267\u884C\u53EF\u80FD\u5220\u9664\u7528\u6237\u5185\u5BB9\u7684 shell \u547D\u4EE4\u3002\u53EA\u6709\u5F53\u7528\u6237\u5728\u5F53\u524D\u8BF7\u6C42\u91CC\u660E\u786E\u8981\u6C42\u5220\u9664/\u6E05\u7406\u65F6\uFF0C\u624D\u80FD\u7EE7\u7EED\uFF1B\u5426\u5219\u8BF7\u505C\u6B62\u5E76\u5148\u8BF4\u660E\u9650\u5236\u3002",
+      permissionRequest: {
+        id: "permission-shell-destructive-action",
+        tool: "execShell",
+        action: "destructive_shell_command",
+        title: "\u786E\u8BA4\u6267\u884C\u7834\u574F\u6027 shell \u547D\u4EE4",
+        body: "\u8BE5\u547D\u4EE4\u53EF\u80FD\u5220\u9664\u6216\u91CD\u7F6E\u7528\u6237\u5185\u5BB9\uFF0C\u9700\u8981\u7528\u6237\u660E\u786E\u786E\u8BA4\u540E\u624D\u80FD\u6267\u884C\u3002",
+        suggestedRule: {
+          scope: "once",
+          pattern: { capability: "destructive_action", target: "shell_command" }
+        }
+      },
+      policy: {
+        capability: "destructive_action",
+        target: "shell_command",
+        detail: "execShell destructive command"
+      }
+    };
+  }
+  const longRunningHint = isLongRunningShellCommand(args);
+  return {
+    verdict: "allowed",
+    permissionDecision: "allow",
+    ...longRunningHint ? { longRunningHint: true } : {}
+  };
+}
+
+// packages/agent-runtime/processRegistry.ts
+var ProcessRegistry = class {
+  processes = /* @__PURE__ */ new Map();
+  add(proc) {
+    this.processes.set(proc.pid, {
+      pid: proc.pid,
+      pgid: proc.pgid,
+      command: proc.command,
+      label: proc.label,
+      startedAt: Date.now(),
+      status: "running",
+      persist: proc.persist ?? false
+    });
+  }
+  list() {
+    return Array.from(this.processes.values()).map((proc) => ({ ...proc }));
+  }
+  get(pid) {
+    const item = this.processes.get(pid);
+    return item ? { ...item } : void 0;
+  }
+  kill(pid, signal = "SIGTERM") {
+    const item = this.processes.get(pid);
+    if (!item) return false;
+    if (item.status === "running") {
+      try {
+        process.kill(-item.pgid, signal);
+      } catch {
+      }
+      item.status = "stopped";
+      return true;
+    }
+    return false;
+  }
+  stopAll(signal = "SIGTERM", opts) {
+    for (const item of this.processes.values()) {
+      if (item.status === "running" && (opts?.includePersist || !item.persist)) {
+        try {
+          process.kill(-item.pgid, signal);
+        } catch {
+        }
+        item.status = "stopped";
+      }
+    }
+  }
+  markExited(pid, exitCode) {
+    const item = this.processes.get(pid);
+    if (item && item.status === "running") {
+      item.exitCode = exitCode;
+      item.status = exitCode === 0 ? "exited" : "failed";
+    }
+  }
+  clear() {
+    this.processes.clear();
+  }
+};
+var registry = null;
+function getProcessRegistry() {
+  if (!registry) {
+    registry = new ProcessRegistry();
+  }
+  return registry;
+}
+
 // packages/ai/llm/agentCapabilities.ts
 var ANTIGRAVITY_EFFORT_SUFFIXES = [
   "-tiered",
@@ -166,36 +442,6 @@ var resolveAgentImageInputSupport = (agent) => {
 };
 
 // packages/ai/agent/imagePreprocessing.ts
-var DEFAULT_IMAGE_PREPROCESSOR_AGENT_KEY = PUBLIC_QWEN_37_FLASH_AGENT_KEY;
-var DESCRIBE_IMAGE_PROMPT = `\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684\u56FE\u7247\u63CF\u8FF0\u52A9\u624B\u3002\u8BF7\u6781\u5176\u8BE6\u7EC6\u5730\u63CF\u8FF0\u8FD9\u5F20\u56FE\u7247\uFF0C\u76EE\u6807\u662F\u8BA9\u4E00\u4E2A\u770B\u4E0D\u5230\u56FE\u7247\u7684 AI \u52A9\u624B\u80FD\u5B8C\u5168\u7406\u89E3\u56FE\u7247\u5185\u5BB9\u3002
-
-\u8BF7\u6309\u4EE5\u4E0B\u7ED3\u6784\u63CF\u8FF0\uFF1A
-
-1. **\u56FE\u7247\u7C7B\u578B**\uFF1A\u8FD9\u662F\u754C\u9762\u622A\u56FE\u3001\u7167\u7247\u3001\u56FE\u8868\u3001\u6587\u6863\u3001\u8FD8\u662F\u5176\u4ED6\u7C7B\u578B\uFF1F
-
-2. **\u5982\u679C\u662F\u754C\u9762\u622A\u56FE**\uFF1A
-   - \u5217\u51FA\u6240\u6709\u53EF\u89C1\u7684 UI \u5143\u7D20\uFF1A\u6807\u9898\u680F\u3001\u5BFC\u822A\u83DC\u5355\u3001\u6309\u94AE\u3001\u8F93\u5165\u6846\u3001\u5217\u8868\u9879\u7B49
-   - \u9010\u4E2A\u63CF\u8FF0\u6BCF\u4E2A\u5143\u7D20\u7684\u6587\u5B57\u5185\u5BB9\u548C\u4F4D\u7F6E\uFF08\u5982"\u5DE6\u4E0A\u89D2"\u3001"\u53F3\u4FA7\u680F"\uFF09
-   - \u63CF\u8FF0\u989C\u8272\u4E3B\u9898\u3001\u5E03\u5C40\u7ED3\u6784\u3001\u5F53\u524D\u72B6\u6001\uFF08\u5982\u9009\u4E2D\u3001hover\u3001loading\uFF09
-   - \u5982\u679C\u6709\u5F39\u7A97/\u5BF9\u8BDD\u6846/\u901A\u77E5\uFF0C\u5B8C\u6574\u8BB0\u5F55\u5176\u6587\u5B57\u5185\u5BB9
-
-3. **\u5982\u679C\u662F\u751F\u6D3B\u7167\u7247**\uFF1A
-   - \u573A\u666F/\u73AF\u5883\uFF1A\u5BA4\u5185/\u5BA4\u5916\u3001\u5730\u70B9\u7C7B\u578B\u3001\u65F6\u95F4\u611F\uFF08\u767D\u5929/\u591C\u665A\uFF09
-   - \u4EBA\u7269\uFF1A\u4EBA\u6570\u3001\u59FF\u52BF\u3001\u8868\u60C5\u3001\u7A7F\u7740\u3001\u52A8\u4F5C
-   - \u7269\u4F53\uFF1A\u524D\u666F/\u80CC\u666F\u4E2D\u7684\u6240\u6709\u663E\u8457\u7269\u4F53
-   - \u5149\u7EBF\u3001\u5929\u6C14\u3001\u6C1B\u56F4
-
-4. **\u5982\u679C\u662F\u56FE\u8868/\u6570\u636E\u56FE**\uFF1A
-   - \u56FE\u8868\u7C7B\u578B\uFF08\u67F1\u72B6\u56FE/\u6298\u7EBF\u56FE/\u997C\u56FE\u7B49\uFF09
-   - \u5750\u6807\u8F74\u6807\u7B7E\u3001\u6570\u503C\u8303\u56F4\u3001\u5355\u4F4D
-   - \u5173\u952E\u6570\u636E\u70B9\u548C\u8D8B\u52BF
-   - \u56FE\u4F8B\u3001\u6807\u9898
-
-5. **\u6240\u6709\u53EF\u89C1\u6587\u5B57**\uFF1A\u9010\u5B57\u8BB0\u5F55\u56FE\u7247\u4E2D\u51FA\u73B0\u7684\u6240\u6709\u6587\u5B57\uFF08UI \u6587\u5B57\u3001\u8DEF\u724C\u3001\u6807\u7B7E\u3001\u6C34\u5370\u7B49\uFF09\uFF0C\u4FDD\u7559\u539F\u6587\u3002
-
-6. **\u989C\u8272\u548C\u5E03\u5C40**\uFF1A\u4E3B\u8272\u8C03\u3001\u5E03\u5C40\u7ED3\u6784\u3001\u7A7A\u95F4\u5173\u7CFB\u3002
-
-\u8BF7\u5C3D\u53EF\u80FD\u8BE6\u7EC6\uFF0C\u4E0D\u8981\u9057\u6F0F\u4EFB\u4F55\u53EF\u89C1\u4FE1\u606F\u3002`;
 function extractImageUrlsFromMessages(messages) {
   const urls = [];
   for (const msg of messages) {
@@ -211,162 +457,1255 @@ function extractImageUrlsFromMessages(messages) {
 function hasImageInRuntimeMessages(messages) {
   return extractImageUrlsFromMessages(messages).length > 0;
 }
-var IMAGE_DESCRIPTION_CACHE = /* @__PURE__ */ new Map();
-function cacheKeyForUrls(urls) {
-  return urls.slice().sort().join("||");
-}
-async function preprocessImagesForTextOnlyAgent(messages, describeImage) {
-  const imageUrls = extractImageUrlsFromMessages(messages);
-  if (imageUrls.length === 0) return messages;
-  const key = cacheKeyForUrls(imageUrls);
-  let description = IMAGE_DESCRIPTION_CACHE.get(key);
-  if (!description) {
-    const rawDesc = await describeImage(imageUrls);
-    if (rawDesc === null || !rawDesc.trim()) return messages;
-    description = rawDesc.trim();
-    IMAGE_DESCRIPTION_CACHE.set(key, description);
-  }
-  const descriptionText = `[\u56FE\u7247\u63CF\u8FF0] ${description}`;
-  return messages.map((msg) => {
-    if (!Array.isArray(msg.content)) return msg;
-    const hasImage = msg.content.some((p) => p?.type === "image_url");
-    if (!hasImage) return msg;
-    const newContent = msg.content.map((part) => {
-      if (part && typeof part === "object" && part.type === "image_url") {
-        return { type: "text", text: descriptionText };
-      }
-      return part;
-    }).filter((p) => p !== null && p !== void 0);
-    return { ...msg, content: newContent };
-  });
+var IMAGE_OMITTED_PLACEHOLDER = "[Image content omitted: model does not support image input]";
+function stripImagePartsFromContent(content) {
+  if (!Array.isArray(content)) return content;
+  const filtered = content.filter((part) => part?.type !== "image_url");
+  if (filtered.length === 0) return IMAGE_OMITTED_PLACEHOLDER;
+  return filtered;
 }
-async function describeImageWithLocalProvider(adapter, imageUrls, visionAgentConfig) {
-  if (imageUrls.length === 0) return null;
+function stripImagePartsFromMessages(messages) {
+  return messages.map((msg) => ({
+    ...msg,
+    content: stripImagePartsFromContent(msg.content)
+  }));
+}
+async function stripImagePartsForTextOnlyAgent(messages, agentConfig) {
+  const supportsVision = resolveAgentImageInputSupport(agentConfig);
+  const hasImages = hasImageInRuntimeMessages(messages);
+  return { messages: !supportsVision && hasImages ? stripImagePartsFromMessages(messages) : messages };
+}
+
+// packages/agent-runtime/workspaceShell.ts
+import { resolve } from "node:path";
+import { spawn as spawnChildProcess } from "node:child_process";
+
+// packages/agent-runtime/runtimeCompat.ts
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+var IS_WINDOWS = process.platform === "win32";
+function isExecutableFile(candidate) {
+  if (!existsSync(candidate)) return false;
   try {
-    const config = visionAgentConfig ?? resolveBuiltinPlatformAgentConfig(DEFAULT_IMAGE_PREPROCESSOR_AGENT_KEY);
-    if (!config) {
-      console.warn("[imagePreprocessing] vision agent config not found, skipping");
-      return null;
-    }
-    const visionProvider = await adapter.resolveProvider(config);
-    const result = await visionProvider.complete(
-      [{ role: "user", content: buildDescribeContentParts(imageUrls) }],
-      { timeoutMs: 3e4 }
-    );
-    const text = result.content?.trim();
-    if (!text) return null;
-    return text;
-  } catch (error) {
-    console.warn("[imagePreprocessing] vision describe failed, will fallback:", error);
+    return statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveExecutableOnPath(name) {
+  if (IS_WINDOWS && !/\.[a-z]+$/i.test(name)) {
+    const exts = (process.env.PATHEXT || ".EXE;.CMD;.BAT").split(";").filter(Boolean);
+    for (const ext of exts) {
+      const found = resolveExecutableOnPath(name + ext);
+      if (found) return found;
+    }
     return null;
   }
+  const pathEnv = process.env.PATH ?? "";
+  const sep = pathEnv.includes(";") && IS_WINDOWS ? ";" : ":";
+  const pathDirs = pathEnv.split(sep).filter(Boolean);
+  const fallbackDirs = IS_WINDOWS ? [] : [
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+    `${process.env.HOME ?? ""}/.local/bin`
+  ].filter(Boolean);
+  for (const dir of [...pathDirs, ...fallbackDirs]) {
+    const candidate = join(dir, name);
+    if (isExecutableFile(candidate)) return candidate;
+  }
+  return null;
 }
-async function describeImageViaServerProxy(serverUrl, authToken, imageUrls, visionAgentKey) {
-  if (imageUrls.length === 0) return null;
-  const agentKey = visionAgentKey ?? DEFAULT_IMAGE_PREPROCESSOR_AGENT_KEY;
-  const { model: visionModel, provider: visionProvider } = resolveDefaultVisionModelConfig(agentKey);
+function createGlob(pattern) {
+  const regex = globToRegExp(pattern);
+  return {
+    match(path) {
+      return regex.test(path);
+    },
+    scanSync(opts) {
+      const dot = opts.dot ?? false;
+      const results = [];
+      walkDir(opts.cwd, "", dot, results);
+      return results.filter((rel) => regex.test(rel));
+    }
+  };
+}
+function walkDir(dir, prefix, dot, out) {
+  let entries;
   try {
-    const payload = {
-      model: visionModel,
-      messages: [{ role: "user", content: buildDescribeContentParts(imageUrls) }],
-      stream: false,
-      provider: visionProvider,
-      agentKey,
-      // server proxy 需要 url 字段，但 nolo 平台 agent 的上游由 server 端路由，
-      // 这里放一个占位 url，server 端会根据 provider/model 覆盖。
-      url: "https://api.ollama.com/v1/chat/completions"
-    };
-    const response = await fetch(`${serverUrl}/api/chat`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${authToken}`
+    entries = readdirSync(dir, { withFileTypes: true, encoding: "utf8" });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const name = String(entry.name);
+    if (!dot && name.startsWith(".")) continue;
+    const rel = prefix ? `${prefix}/${name}` : name;
+    const full = join(dir, name);
+    if (entry.isDirectory()) {
+      walkDir(full, rel, dot, out);
+    } else if (entry.isFile()) {
+      out.push(rel);
+    }
+  }
+}
+function globToRegExp(pattern) {
+  const trailingDir = pattern.endsWith("/");
+  const src = trailingDir ? pattern.slice(0, -1) : pattern;
+  const anchored = src.startsWith("/");
+  const body = anchored ? src.slice(1) : src;
+  let regex = "^";
+  if (!anchored) regex += "(?:.*/)?";
+  regex += convertBody(body);
+  if (trailingDir) {
+    regex += "(?:/.*)?";
+  }
+  regex += "$";
+  return new RegExp(regex);
+}
+function convertBody(p) {
+  let out = "";
+  let i = 0;
+  while (i < p.length) {
+    const c = p[i];
+    if (c === "*") {
+      if (p[i + 1] === "*") {
+        i += 2;
+        if (p[i] === "/") {
+          out += "(?:.*/)?";
+          i += 1;
+        } else {
+          out += ".*";
+        }
+      } else {
+        out += "[^/]*";
+        i += 1;
+      }
+    } else if (c === "?") {
+      out += "[^/]";
+      i += 1;
+    } else if (c === "[") {
+      out += "[";
+      i += 1;
+      if (p[i] === "!") {
+        out += "^";
+        i += 1;
+      }
+      while (i < p.length && p[i] !== "]") {
+        out += p[i] === "\\" ? "\\\\" : p[i];
+        i += 1;
+      }
+      if (p[i] === "]") {
+        out += "]";
+        i += 1;
+      }
+    } else if (c === "{") {
+      let depth = 1;
+      let j = i + 1;
+      let bodyStr = "";
+      while (j < p.length && depth > 0) {
+        if (p[j] === "{") depth += 1;
+        else if (p[j] === "}") depth -= 1;
+        if (depth > 0) bodyStr += p[j];
+        j += 1;
+      }
+      const alts = bodyStr.split(",").map((alt) => convertBody(alt));
+      out += `(?:${alts.join("|")})`;
+      i = j;
+    } else {
+      out += escapeRegexChar(c);
+      i += 1;
+    }
+  }
+  return out;
+}
+function escapeRegexChar(c) {
+  if ("\\^$.|+()".includes(c)) {
+    return `\\${c}`;
+  }
+  return c;
+}
+function spawnToWebStreams(options) {
+  const [command, ...args] = options.cmd;
+  const child = spawn(command, args, {
+    env: options.env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const exited = new Promise((resolve2) => {
+    child.on("exit", (code) => resolve2(code ?? 1));
+    child.on("error", () => resolve2(127));
+  });
+  const toWeb = (stream) => {
+    if (!stream) return null;
+    return stream.toWeb?.() ?? new ReadableStream({
+      start(controller) {
+        stream.on("data", (chunk) => controller.enqueue(new Uint8Array(chunk)));
+        stream.on("end", () => controller.close());
+        stream.on("error", (e) => controller.error(e));
+      }
+    });
+  };
+  return {
+    stdout: toWeb(child.stdout),
+    stderr: toWeb(child.stderr),
+    exited
+  };
+}
+
+// packages/agent-runtime/workspaceShell.ts
+var EXEC_SHELL_TIMEOUT_ENV = "NOLO_EXEC_SHELL_TIMEOUT_MS";
+var EXEC_SHELL_DETACH_ENV = "NOLO_EXEC_SHELL_DETACH_MS";
+var DEFAULT_EXEC_SHELL_DETACH_MS = 12e4;
+function readTrimmedString(value) {
+  return asOptionalTrimmedString(value);
+}
+function extractActivityRefs(rawRefs) {
+  if (!Array.isArray(rawRefs)) return void 0;
+  const refs = rawRefs.flatMap((entry) => {
+    if (typeof entry === "string" && entry.trim()) {
+      return [{ type: "file", path: entry.trim() }];
+    }
+    if (!isRecord(entry)) return [];
+    const path = readTrimmedString(entry.path);
+    if (path) return [{ type: "file", path }];
+    const terminalId = readTrimmedString(entry.id);
+    const terminalLabel = readTrimmedString(entry.label);
+    if (entry.type === "terminal" || terminalId || terminalLabel) {
+      return [{
+        type: "terminal",
+        ...terminalId ? { id: terminalId } : {},
+        ...terminalLabel ? { label: terminalLabel } : {}
+      }];
+    }
+    if (entry.type === "url" || typeof entry.url === "string") {
+      const url = readTrimmedString(entry.url);
+      const label = readTrimmedString(entry.label);
+      return url ? [{ type: "url", url, ...label ? { label } : {} }] : [];
+    }
+    return [];
+  });
+  return refs.length ? refs : void 0;
+}
+function extractActivityAction(rawAction) {
+  if (!isRecord(rawAction)) return void 0;
+  const title = readTrimmedString(rawAction.title);
+  if (!title) return void 0;
+  const kind = readTrimmedString(rawAction.kind);
+  const detail = readTrimmedString(rawAction.detail);
+  const refs = extractActivityRefs(rawAction.refs);
+  return {
+    title,
+    ...kind ? { kind } : {},
+    ...detail ? { detail } : {},
+    ...refs ? { refs } : {}
+  };
+}
+function extractActivityPhase(rawPhase) {
+  if (!isRecord(rawPhase)) return void 0;
+  const title = readTrimmedString(rawPhase.title);
+  if (!title) return void 0;
+  const id = readTrimmedString(rawPhase.id) || title.toLowerCase().replace(/\s+/g, "-");
+  const index = asOptionalFiniteNumber(rawPhase.index);
+  const total = asOptionalFiniteNumber(rawPhase.total);
+  const status = rawPhase.status === "pending" || rawPhase.status === "running" || rawPhase.status === "success" || rawPhase.status === "failed" ? rawPhase.status : void 0;
+  return {
+    id,
+    title,
+    ...index !== void 0 ? { index } : {},
+    ...total !== void 0 ? { total } : {},
+    ...status ? { status } : {}
+  };
+}
+function extractActivityPlan(rawPlan) {
+  if (!isRecord(rawPlan)) return void 0;
+  if (!Array.isArray(rawPlan.phases)) return void 0;
+  const phases = rawPlan.phases.flatMap((entry, index) => {
+    const phase = extractActivityPhase(entry);
+    if (!phase) return [];
+    return [{
+      id: phase.id,
+      title: phase.title,
+      index: phase.index ?? index + 1,
+      ...phase.status ? { status: phase.status } : {}
+    }];
+  });
+  if (phases.length === 0) return void 0;
+  const title = readTrimmedString(rawPlan.title);
+  return {
+    ...title ? { title } : {},
+    phases
+  };
+}
+function extractActivity(parsed) {
+  const raw = parsed._activity;
+  if (!isRecord(raw)) return void 0;
+  const nestedAction = extractActivityAction(raw.action);
+  const legacyAction = extractActivityAction(raw);
+  const action = nestedAction || legacyAction;
+  const phase = extractActivityPhase(raw.phase);
+  const plan = extractActivityPlan(raw.plan);
+  if (!action && !plan) return void 0;
+  return {
+    ...action ? action : {},
+    ...phase ? { phase } : {},
+    ...nestedAction ? { action: nestedAction } : {},
+    ...plan ? { plan } : {}
+  };
+}
+function tokenizeShellPrefix(command) {
+  const tokens = [];
+  const pattern = /"([^"]*)"|'([^']*)'|([^\s"'|;&<>]+)/g;
+  let match;
+  while (match = pattern.exec(command)) {
+    tokens.push(match[1] ?? match[2] ?? match[3] ?? "");
+  }
+  return tokens;
+}
+function wrapPowerShellCommand(command) {
+  return [
+    "[Console]::InputEncoding=[System.Text.Encoding]::UTF8",
+    "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8",
+    "$OutputEncoding=[System.Text.Encoding]::UTF8",
+    "$PSStyle.OutputRendering='PlainText'",
+    command
+  ].join("; ");
+}
+function findPowerShellExecutable() {
+  return resolveExecutableOnPath("pwsh") || resolveExecutableOnPath("powershell.exe") || resolveExecutableOnPath("powershell");
+}
+function buildPowerShellCommand(command) {
+  const executable = findPowerShellExecutable();
+  if (!executable) throw new Error("PowerShell is not available on this machine.");
+  return [
+    executable,
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-Command",
+    wrapPowerShellCommand(command)
+  ];
+}
+function buildBashCommand(command) {
+  const executable = resolveExecutableOnPath("bash") || resolveExecutableOnPath("sh");
+  if (!executable) throw new Error("bash/sh is not available on this machine.");
+  return [executable, "-lc", command];
+}
+function buildWorkspaceShellCommand(args) {
+  if (args.shell === "powershell") return buildPowerShellCommand(args.command);
+  if (args.shell === "bash") return buildBashCommand(args.command);
+  return process.platform === "win32" ? buildPowerShellCommand(args.command) : buildBashCommand(args.command);
+}
+function findWorkspaceShellEscapeToken(command) {
+  const tokens = tokenizeShellPrefix(command);
+  for (const token of tokens) {
+    if (token === ".." || token.startsWith("../") || token.startsWith("..\\") || token.includes("/../") || token.includes("\\..\\")) {
+      return token;
+    }
+    if (token === "~" || token.startsWith("~/") || token.startsWith("~\\")) {
+      return token;
+    }
+    if (token === "/" || token.startsWith("/") || /^[A-Za-z]:[\\/]/.test(token) || token.startsWith("\\\\")) {
+      return token;
+    }
+  }
+  return null;
+}
+function buildWorkspaceShellEscapeBlockedResult(args) {
+  return {
+    content: [
+      "workspace_shell_escape_blocked",
+      `blockedToken: ${args.token}`,
+      `command: ${args.command}`,
+      "Use paths relative to the authorized folder only.",
+      "exitCode: 126"
+    ].join("\n"),
+    metadata: {
+      exitCode: 126,
+      workspaceShellEscapeBlocked: true,
+      blockedToken: args.token
+    }
+  };
+}
+function extractInteractiveGhAuthCommand(command) {
+  const tokens = tokenizeShellPrefix(command);
+  if (tokens[0] !== "gh" || tokens[1] !== "auth") return null;
+  const subcommand = tokens[2];
+  if (subcommand !== "login" && subcommand !== "refresh") return null;
+  if (tokens.includes("--help")) return null;
+  const result = ["gh", "auth", subcommand];
+  for (let index = 3; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token) continue;
+    if (token === "-h" || token === "--hostname" || token === "-s" || token === "--scopes" || token === "--remove-scopes" || token === "-r") {
+      const value = tokens[index + 1];
+      if (value) {
+        result.push(token, value);
+        index += 1;
+      }
+      continue;
+    }
+    if (token === "--clipboard" || token === "-c" || token === "--insecure-storage" || token === "--reset-scopes") {
+      result.push(token);
+      continue;
+    }
+    if (token.startsWith("--hostname=") || token.startsWith("--scopes=") || token.startsWith("--remove-scopes=")) {
+      result.push(token);
+      continue;
+    }
+  }
+  return result.join(" ");
+}
+function buildInteractiveCommandBlockedResult(command) {
+  const argv = tokenizeShellPrefix(command);
+  return {
+    content: [
+      "action_gate: handoff",
+      `command: ${command}`,
+      "Run this in the current TUI terminal, then resume the agent turn.",
+      "exitCode: 130"
+    ].join("\n"),
+    metadata: {
+      exitCode: 130,
+      timedOut: false,
+      actionGate: {
+        id: `gate-${Date.now().toString(36)}-terminal-handoff`,
+        kind: "handoff",
+        title: "This command requires an interactive terminal.",
+        body: "Complete it in the terminal, then nolo will continue.",
+        payload: {
+          command: argv,
+          displayCommand: command
+        }
       },
-      body: JSON.stringify(payload),
-      signal: AbortSignal.timeout(3e4)
+      reason: "interactive-command-requires-terminal"
+    }
+  };
+}
+function resolveExecShellTimeoutMs(override) {
+  const fromOverride = asOptionalPositiveFiniteNumber(override);
+  if (fromOverride !== void 0) return fromOverride;
+  const raw = process.env[EXEC_SHELL_TIMEOUT_ENV];
+  if (raw === void 0) return void 0;
+  return asOptionalPositiveFiniteNumber(Number(raw));
+}
+function resolveDetachMs(override) {
+  if (typeof override === "number" && Number.isFinite(override) && override >= 0) {
+    return override;
+  }
+  const raw = process.env[EXEC_SHELL_DETACH_ENV];
+  if (raw === void 0) return DEFAULT_EXEC_SHELL_DETACH_MS;
+  const parsed = asOptionalPositiveFiniteNumber(Number(raw));
+  return parsed === void 0 ? DEFAULT_EXEC_SHELL_DETACH_MS : parsed;
+}
+function truncateToolOutput(value, limit = 2e4) {
+  if (value.length <= limit) return value;
+  const approxMarkerLen = 40;
+  if (limit <= approxMarkerLen) return value.slice(0, limit);
+  const remaining = limit - approxMarkerLen;
+  const headSize = Math.floor(remaining * 0.3);
+  const tailSize = remaining - headSize;
+  const head = value.slice(0, headSize);
+  const tail = value.slice(-tailSize);
+  const actualRemoved = value.length - headSize - tailSize;
+  return `${head}
+
+[... truncated ${actualRemoved} chars ...]
+
+${tail}`;
+}
+function readNodeStream(stream) {
+  if (!stream) return Promise.resolve("");
+  return new Promise((resolveStream, rejectStream) => {
+    const chunks = [];
+    stream.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    stream.on("error", rejectStream);
+    stream.on("end", () => {
+      resolveStream(Buffer.concat(chunks).toString("utf8"));
+    });
+  });
+}
+function waitForNodeProcessExit(proc) {
+  return new Promise((resolveExit, rejectExit) => {
+    proc.on("error", rejectExit);
+    proc.on("close", (code) => {
+      resolveExit(code ?? 0);
     });
-    if (!response.ok) {
-      console.warn(`[imagePreprocessing] server proxy vision call failed: ${response.status}`);
-      return null;
+  });
+}
+function deriveLabel(command) {
+  const trimmed = command.trim();
+  if (!trimmed) return "process";
+  const tokens = trimmed.split(/\s+/);
+  const lastToken = tokens[tokens.length - 1] ?? trimmed;
+  const labelCandidate = lastToken.split(/[/\\]/).pop() || lastToken;
+  return labelCandidate || trimmed;
+}
+function isSpawnFailureError(error) {
+  if (!error || typeof error !== "object") return false;
+  const err = error;
+  if (err.code === "ENOENT") return true;
+  const message = toErrorMessage(error).toLowerCase();
+  return message.includes("enoent") || message.includes("executable not found") || message.includes("spawn") && message.includes("not found");
+}
+function spawnFailedCommandResult(error, outputLimit) {
+  const stderr = `spawn failed: ${toErrorMessage(error)}
+`;
+  return {
+    stdout: "",
+    stderr,
+    exitCode: 127,
+    timedOut: false,
+    spawnFailed: true,
+    content: truncateToolOutput(
+      [`stderr:
+${stderr.trim()}`, "exitCode: 127"].filter(Boolean).join("\n\n"),
+      outputLimit
+    )
+  };
+}
+async function runWorkspaceCommand(args) {
+  const timeoutMs = asOptionalPositiveFiniteNumber(args.timeoutMs);
+  const detached = process.platform !== "win32";
+  const command = [
+    ...args.commandPrefix ?? [],
+    ...args.command
+  ];
+  const proc = spawnChildProcess(command[0] ?? "", command.slice(1), {
+    cwd: resolve(args.workspaceRoot),
+    stdio: [
+      args.stdin === void 0 ? "ignore" : "pipe",
+      "pipe",
+      "pipe"
+    ],
+    detached
+  });
+  if (args.stdin !== void 0 && proc.stdin) {
+    proc.stdin.write(args.stdin);
+    proc.stdin.end();
+  }
+  const exitPromise = waitForNodeProcessExit(proc);
+  const cleanupChildOnHostSignal = (signal) => {
+    if (typeof proc.pid === "number") {
+      try {
+        process.kill(-proc.pid, signal);
+      } catch {
+      }
     }
-    const data = await response.json();
-    const text = data?.choices?.[0]?.message?.content;
-    if (typeof text === "string" && text.trim()) {
-      return text.trim();
+  };
+  if (detached) {
+    process.once("SIGHUP", cleanupChildOnHostSignal);
+    process.once("SIGTERM", cleanupChildOnHostSignal);
+    process.once("SIGINT", cleanupChildOnHostSignal);
+  }
+  const detachSignalCleanup = () => {
+    if (!detached) return;
+    process.removeListener("SIGHUP", cleanupChildOnHostSignal);
+    process.removeListener("SIGTERM", cleanupChildOnHostSignal);
+    process.removeListener("SIGINT", cleanupChildOnHostSignal);
+  };
+  exitPromise.then(detachSignalCleanup, detachSignalCleanup);
+  const stdoutPromise = readNodeStream(proc.stdout);
+  const stderrPromise = readNodeStream(proc.stderr);
+  const killChild = (signal) => {
+    if (detached && typeof proc.pid === "number") {
+      try {
+        process.kill(-proc.pid, signal);
+        return;
+      } catch {
+      }
     }
-    return null;
+    try {
+      proc.kill(signal);
+    } catch {
+    }
+  };
+  let timeout;
+  let detachTimer;
+  const timeoutResult = Symbol("timeout");
+  const abortResult = Symbol("abort");
+  const detachResult = Symbol("detach");
+  let abortListener;
+  const abortPromise = args.abortSignal ? new Promise((resolveAbort) => {
+    if (args.abortSignal.aborted) {
+      resolveAbort(abortResult);
+      return;
+    }
+    abortListener = () => resolveAbort(abortResult);
+    args.abortSignal.addEventListener("abort", abortListener, { once: true });
+  }) : null;
+  const effectiveDetachMs = resolveDetachMs(args.detachMs);
+  const detachPromise = new Promise((resolveDetach) => {
+    detachTimer = setTimeout(() => resolveDetach(detachResult), effectiveDetachMs);
+  });
+  const exitOrTimeoutPromise = timeoutMs ? Promise.race([
+    exitPromise,
+    new Promise((resolveTimeout) => {
+      timeout = setTimeout(() => resolveTimeout(timeoutResult), timeoutMs);
+    })
+  ]) : exitPromise;
+  const raceCandidates = [
+    exitOrTimeoutPromise,
+    detachPromise
+  ];
+  if (abortPromise) {
+    raceCandidates.push(abortPromise);
+  }
+  let raceWinner;
+  try {
+    raceWinner = await Promise.race(raceCandidates);
   } catch (error) {
-    console.warn("[imagePreprocessing] server proxy vision describe failed:", error);
-    return null;
+    if (timeout) clearTimeout(timeout);
+    if (detachTimer) clearTimeout(detachTimer);
+    if (abortListener && args.abortSignal) {
+      args.abortSignal.removeEventListener("abort", abortListener);
+    }
+    if (isSpawnFailureError(error)) {
+      return spawnFailedCommandResult(error, args.outputLimit);
+    }
+    throw error;
+  }
+  if (timeout) clearTimeout(timeout);
+  if (detachTimer) clearTimeout(detachTimer);
+  if (abortListener && args.abortSignal) {
+    args.abortSignal.removeEventListener("abort", abortListener);
+  }
+  const timedOut = raceWinner === timeoutResult;
+  const aborted = raceWinner === abortResult;
+  const detachedProcess = raceWinner === detachResult;
+  if (timedOut || aborted) {
+    killChild("SIGTERM");
+    const forceKillTimer = setTimeout(() => {
+      killChild("SIGKILL");
+    }, 500);
+    try {
+      await exitPromise;
+    } catch {
+    } finally {
+      clearTimeout(forceKillTimer);
+    }
+  }
+  if (detachedProcess) {
+    exitPromise.catch(() => {
+    });
+    const pid = typeof proc.pid === "number" ? proc.pid : 0;
+    const label = deriveLabel(args.command.join(" "));
+    const pgid = pid;
+    const registry2 = getProcessRegistry();
+    registry2.add({ pid, pgid, command: args.command.join(" "), label });
+    proc.on("close", (code) => {
+      detachSignalCleanup();
+      registry2.markExited(pid, code ?? 1);
+    });
+    const immediate = effectiveDetachMs === 0;
+    const reason = immediate ? `command looks long-running; moved to background immediately (pid=${pid}, label=${label})` : `command detached to background after ${effectiveDetachMs}ms (pid=${pid}, label=${label})`;
+    return {
+      stdout: "",
+      stderr: `${reason}
+Use listProcesses to inspect or stop it.`,
+      exitCode: 0,
+      timedOut: false,
+      detached: true,
+      pid,
+      label,
+      content: JSON.stringify({
+        detached: true,
+        pid,
+        label,
+        status: "running",
+        ...immediate ? { reason: "long-running-command" } : {}
+      })
+    };
   }
+  const [stdout, rawStderr] = await Promise.all([
+    stdoutPromise,
+    stderrPromise
+  ]);
+  const exitCode = aborted ? 130 : timedOut ? 124 : Number(raceWinner);
+  const stderr = aborted ? `${rawStderr.trim() ? `${rawStderr.trim()}
+` : ""}command aborted by signal
+` : timedOut ? `${rawStderr.trim() ? `${rawStderr.trim()}
+` : ""}command timed out after ${timeoutMs ?? "unknown"}ms
+` : rawStderr;
+  return {
+    stdout,
+    stderr,
+    exitCode,
+    timedOut,
+    aborted,
+    content: truncateToolOutput([
+      stdout.trim() ? `stdout:
+${stdout.trim()}` : "",
+      stderr.trim() ? `stderr:
+${stderr.trim()}` : "",
+      `exitCode: ${exitCode}`
+    ].filter(Boolean).join("\n\n"), args.outputLimit)
+  };
+}
+
+// packages/agent-runtime/capabilities/execShellCapability.ts
+function buildLocalExecShellContext(args) {
+  return {
+    workspaceRoot: args.workspaceRoot,
+    ...args.commandTimeoutMs !== void 0 ? { commandTimeoutMs: args.commandTimeoutMs } : {},
+    ...args.commandOutputLimit !== void 0 ? { commandOutputLimit: args.commandOutputLimit } : {},
+    ...args.commandPrefix ? { commandPrefix: args.commandPrefix } : {},
+    ...args.restrictToWorkspace !== void 0 ? { restrictToWorkspace: args.restrictToWorkspace } : {},
+    ...args.abortSignal ? { abortSignal: args.abortSignal } : {},
+    ...args.detachMs !== void 0 ? { detachMs: args.detachMs } : {},
+    ...args.confirmed !== void 0 ? { confirmed: args.confirmed } : {},
+    ...args.enableDestructiveShellGuard !== void 0 ? { enableDestructiveShellGuard: args.enableDestructiveShellGuard } : {},
+    ...args.confirmDestructiveAction ? { confirmDestructiveAction: args.confirmDestructiveAction } : {},
+    ...args.blockDestructiveWithoutConfirmation !== void 0 ? { blockDestructiveWithoutConfirmation: args.blockDestructiveWithoutConfirmation } : {},
+    ...args.onInvoke ? { onInvoke: args.onInvoke } : {}
+  };
+}
+function buildExecShellToolDefinition(toolName = "execShell") {
+  return {
+    type: "function",
+    function: {
+      name: toolName,
+      description: `Execute a shell command from the workspace root. Prefer one compound command (e.g. 'git status && git diff --stat') to perform complete verification in one step instead of multiple small roundtrips. Do not cd into guessed paths; commands already run from the workspace root. Commands block until exit. Long-running commands (sleep over ${IMMEDIATE_DETACH_SLEEP_THRESHOLD_SECONDS}s, dev servers, watchers) automatically detach to background returning {detached: true, pid, label}; for persistent services, prefer launchProcess.`,
+      parameters: {
+        type: "object",
+        properties: {
+          command: {
+            type: "string",
+            description: "Shell command to run (non-empty)."
+          },
+          cmd: {
+            type: "string",
+            description: "Compatibility alias for command."
+          }
+        }
+      }
+    }
+  };
 }
-function buildDescribeContentParts(imageUrls) {
-  const parts = [{ type: "text", text: DESCRIBE_IMAGE_PROMPT }];
-  for (const url of imageUrls) {
-    parts.push({ type: "image_url", image_url: { url } });
+function normalizeExecShellInput(input) {
+  if (input === null || input === void 0) {
+    throw new Error("execShell requires a non-empty command.");
   }
-  return parts;
+  if (typeof input === "string") {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      throw new Error("execShell requires a non-empty command.");
+    }
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === "object") {
+          return normalizeExecShellInput(parsed);
+        }
+      } catch {
+      }
+    }
+    return { command: trimmed };
+  }
+  if (typeof input === "object") {
+    const record = input;
+    let rawCommand = resolveShellCommandArg(record);
+    if (typeof rawCommand !== "string" || !rawCommand.trim()) {
+      const fallback = record.command ?? record.cmd;
+      if (typeof fallback === "string" && fallback.trim()) {
+        rawCommand = fallback;
+      }
+    }
+    const command = typeof rawCommand === "string" ? rawCommand.trim() : "";
+    if (!command) {
+      throw new Error("execShell requires a non-empty command.");
+    }
+    const activity = extractActivity(record);
+    return {
+      command,
+      ...record.shell !== void 0 ? { shell: record.shell } : {},
+      ...activity ? { activity } : {},
+      ...record.input !== void 0 ? { input: record.input } : {}
+    };
+  }
+  throw new Error("execShell requires a non-empty command.");
+}
+var execShellCapability = {
+  name: "execShell",
+  getToolDefinition(toolName = "execShell") {
+    return buildExecShellToolDefinition(toolName);
+  },
+  normalizeInput(input) {
+    return normalizeExecShellInput(input);
+  },
+  async invoke(ctx, normalized) {
+    const workspaceRoot = ctx.workspaceRoot || process.cwd();
+    const command = normalized.command;
+    if (ctx.restrictToWorkspace) {
+      const escapeToken = findWorkspaceShellEscapeToken(command);
+      if (escapeToken) {
+        return buildWorkspaceShellEscapeBlockedResult({ command, token: escapeToken });
+      }
+    }
+    const interactiveAuthCommand = extractInteractiveGhAuthCommand(command);
+    if (interactiveAuthCommand) {
+      const blocked = buildInteractiveCommandBlockedResult(interactiveAuthCommand);
+      return {
+        ...blocked,
+        metadata: {
+          ...blocked.metadata,
+          ...normalized.activity ? { activity: normalized.activity } : {}
+        }
+      };
+    }
+    const result = await runWorkspaceCommand({
+      workspaceRoot,
+      command: buildWorkspaceShellCommand({
+        toolName: "execShell",
+        command,
+        shell: normalized.shell
+      }),
+      timeoutMs: resolveExecShellTimeoutMs(ctx.commandTimeoutMs),
+      outputLimit: ctx.commandOutputLimit,
+      commandPrefix: ctx.commandPrefix,
+      abortSignal: ctx.abortSignal,
+      detachMs: isImmediateDetachShellCommand({ command }) ? 0 : ctx.detachMs,
+      stdin: typeof normalized.input === "string" ? normalized.input : void 0
+    });
+    return {
+      content: result.content,
+      metadata: {
+        command,
+        exitCode: result.exitCode,
+        timedOut: result.timedOut,
+        ...result.aborted ? { aborted: true } : {},
+        ...result.detached ? { detached: true, pid: result.pid, label: result.label, status: "running" } : {},
+        ...normalized.activity ? { activity: normalized.activity } : {}
+      }
+    };
+  }
+};
+
+// packages/agent-runtime/capabilities/capabilityPolicy.ts
+function toDisplayCommand(command) {
+  if (typeof command === "string") {
+    const trimmed = command.trim();
+    return trimmed ? trimmed : void 0;
+  }
+  if (Array.isArray(command)) {
+    const joined = command.map((item) => typeof item === "string" ? item : String(item)).filter((item) => item.length > 0).join(" ").trim();
+    return joined ? joined : void 0;
+  }
+  return void 0;
 }
-function resolveDefaultVisionModelConfig(agentKey) {
-  const key = agentKey ?? DEFAULT_IMAGE_PREPROCESSOR_AGENT_KEY;
-  const config = resolveBuiltinPlatformAgentConfig(key);
+function buildDestructiveShellPermissionRequest(command) {
   return {
-    model: config?.model ?? PLATFORM_HOSTED_QWEN_37_FLASH_MODEL,
-    provider: config?.provider ?? "nolo",
-    config
+    id: "permission-shell-destructive-action",
+    tool: "execShell",
+    action: "destructive_shell_command",
+    title: "\u786E\u8BA4\u6267\u884C\u7834\u574F\u6027 shell \u547D\u4EE4",
+    body: "\u8BE5\u547D\u4EE4\u53EF\u80FD\u5220\u9664\u6216\u91CD\u7F6E\u7528\u6237\u5185\u5BB9\uFF0C\u9700\u8981\u7528\u6237\u660E\u786E\u786E\u8BA4\u540E\u624D\u80FD\u6267\u884C\u3002",
+    ...command ? { command } : {},
+    suggestedRule: {
+      scope: "once",
+      pattern: { capability: "destructive_action", target: "shell_command" }
+    }
   };
 }
-var IMAGE_OMITTED_PLACEHOLDER = "[Image content omitted: model does not support image input]";
-function stripImagePartsFromContent(content) {
-  if (!Array.isArray(content)) return content;
-  const filtered = content.filter((part) => part?.type !== "image_url");
-  if (filtered.length === 0) return IMAGE_OMITTED_PLACEHOLDER;
-  return filtered;
+function buildDestructiveShellBlockedError(reason, request) {
+  const error = new Error(reason);
+  error.code = "destructive_action_requires_confirmation";
+  error.policy = {
+    capability: "destructive_action",
+    target: "shell_command",
+    detail: "execShell destructive command"
+  };
+  error.permissionRequest = request;
+  return error;
 }
-function stripImagePartsFromMessages(messages) {
-  return messages.map((msg) => ({
-    ...msg,
-    content: stripImagePartsFromContent(msg.content)
-  }));
+async function evaluateExecShellDestructiveGuard(input, ctx) {
+  const guardEnabled = ctx.enableDestructiveShellGuard !== false;
+  if (!guardEnabled || ctx.confirmed) {
+    return;
+  }
+  const rawCommand = resolveShellCommandArg(
+    typeof input === "object" && input !== null ? input : { command: input }
+  );
+  const extraInput = typeof input === "object" && input !== null ? input.input : void 0;
+  if (!isDestructiveShellCommand({ command: rawCommand, input: extraInput })) {
+    return;
+  }
+  const displayCommand = toDisplayCommand(rawCommand);
+  const request = buildDestructiveShellPermissionRequest(displayCommand);
+  if (!ctx.confirmDestructiveAction) {
+    if (ctx.blockDestructiveWithoutConfirmation) {
+      throw buildDestructiveShellBlockedError(
+        "destructive shell command blocked: no confirmation channel available",
+        request
+      );
+    }
+    return;
+  }
+  const confirmed = await ctx.confirmDestructiveAction(request);
+  if (!confirmed) {
+    throw buildDestructiveShellBlockedError(
+      "destructive shell command blocked: user declined confirmation",
+      request
+    );
+  }
 }
-async function tryPreprocessWebImageOrReject(messages, agentConfig, initialHistoryIds, serverUrl, authToken) {
-  const supportsVision = resolveAgentImageInputSupport(agentConfig);
-  const hasImages = hasImageInRuntimeMessages(messages);
-  const needsPreprocessing = !supportsVision && hasImages;
-  if (!needsPreprocessing) {
-    const firstDynamicIdx = messages.findIndex((m) => m.id && !initialHistoryIds.has(m.id));
-    const splitIdx2 = firstDynamicIdx === -1 ? messages.length : firstDynamicIdx;
+async function evaluateCapabilityPolicy(capability, normalizedInput, ctx) {
+  if (capability.name === "execShell") {
+    await evaluateExecShellDestructiveGuard(normalizedInput, ctx);
+  }
+}
+
+// packages/agent-runtime/capabilities/agentRunService.ts
+var activityCounter = 0;
+function generateActivityId(prefix = "act") {
+  activityCounter = (activityCounter + 1) % 1e6;
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}-${activityCounter}`;
+}
+function combineSignals(signals) {
+  const activeSignals = signals.filter((s) => Boolean(s));
+  if (activeSignals.length === 0) return void 0;
+  if (activeSignals.length === 1) return activeSignals[0];
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any(activeSignals);
+  }
+  const controller = new AbortController();
+  for (const s of activeSignals) {
+    if (s.aborted) {
+      controller.abort(s.reason);
+      return controller.signal;
+    }
+    s.addEventListener("abort", () => controller.abort(s.reason), { once: true });
+  }
+  return controller.signal;
+}
+async function executeAgentRunLifecycle(service, input, ctx = {}) {
+  const agentKey = input.agentKey ?? input.agentId;
+  if (!agentKey || typeof agentKey !== "string" || !agentKey.trim()) {
+    throw new Error("agents.run: \u7F3A\u5C11\u6709\u6548\u7684 agentId \u6216 agentKey\u3002");
+  }
+  if (!input.task || typeof input.task !== "string" || !input.task.trim()) {
+    throw new Error("agents.run: \u7F3A\u5C11\u6709\u6548\u7684 task \u6587\u672C\u63CF\u8FF0\u3002");
+  }
+  const effectiveSignal = combineSignals([input.signal, ctx.abortSignal]);
+  if (effectiveSignal?.aborted) {
+    const abortErr = new Error("Agent run was aborted before starting");
+    abortErr.name = "AbortError";
+    throw abortErr;
+  }
+  const activityId = generateActivityId("act-run");
+  const parentActivityId = input.parentActivityId ?? ctx.activityContext?.parentActivityId ?? ctx.parentActivityId;
+  const startedAt = Date.now();
+  const activity = {
+    activityId,
+    ...parentActivityId ? { parentActivityId } : {},
+    kind: "agent-run",
+    agentId: agentKey,
+    ...input.agentName ? { agentName: input.agentName } : {},
+    task: input.task,
+    status: "starting",
+    startedAt
+  };
+  const emit = async (type) => {
+    if (ctx.onActivity) {
+      try {
+        await ctx.onActivity({
+          type,
+          activity: { ...activity }
+        });
+      } catch {
+      }
+    }
+  };
+  await emit("activity-started");
+  let startResult;
+  try {
+    startResult = await service.start(
+      {
+        agentId: agentKey,
+        agentKey,
+        task: input.task,
+        input: input.input,
+        agentName: input.agentName,
+        ephemeral: input.ephemeral,
+        batchId: input.batchId,
+        parentActivityId,
+        signal: effectiveSignal
+      },
+      ctx
+    );
+  } catch (err) {
+    const errorMsg = err?.message || String(err);
+    const finishedAt2 = Date.now();
+    activity.status = "failed";
+    activity.finishedAt = finishedAt2;
+    activity.durationMs = finishedAt2 - startedAt;
+    activity.error = errorMsg;
+    await emit("activity-finished");
+    throw err;
+  }
+  const runId = startResult.runId;
+  activity.runId = runId;
+  if (startResult.status === "done" || startResult.status === "completed") {
+    const finishedAt2 = Date.now();
+    activity.status = "completed";
+    activity.finishedAt = finishedAt2;
+    activity.durationMs = finishedAt2 - startedAt;
+    activity.result = startResult.content;
+    await emit("activity-finished");
     return {
-      kind: "ok",
-      messages,
-      stableMessages: messages.slice(0, splitIdx2),
-      dynamicMessages: messages.slice(splitIdx2)
+      runId,
+      status: "completed",
+      content: startResult.content ?? "",
+      activityId,
+      durationMs: activity.durationMs
     };
   }
-  let finalMessages = messages;
-  if (serverUrl && authToken) {
-    try {
-      const preprocessed = await preprocessImagesForTextOnlyAgent(
-        messages,
-        (urls) => describeImageViaServerProxy(serverUrl, authToken, urls)
-      );
-      if (preprocessed !== messages) {
-        finalMessages = preprocessed;
+  if (startResult.status === "failed") {
+    const finishedAt2 = Date.now();
+    activity.status = "failed";
+    activity.finishedAt = finishedAt2;
+    activity.durationMs = finishedAt2 - startedAt;
+    activity.error = "Agent run start failed";
+    await emit("activity-finished");
+    throw new Error(`Agent run ${runId} failed on start.`);
+  }
+  activity.status = "running";
+  await emit("activity-updated");
+  let abortCleanup;
+  if (effectiveSignal && service.cancel) {
+    const onAbort = () => {
+      service.cancel?.({ runId, signal: effectiveSignal }, ctx).catch(() => {
+      });
+    };
+    if (effectiveSignal.aborted) {
+      onAbort();
+    } else {
+      effectiveSignal.addEventListener("abort", onAbort, { once: true });
+      abortCleanup = () => effectiveSignal.removeEventListener("abort", onAbort);
+    }
+  }
+  let waitResult;
+  try {
+    waitResult = await service.wait(
+      {
+        runId,
+        timeoutMs: input.timeoutMs ?? ctx.agentRunTimeoutMs,
+        signal: effectiveSignal
+      },
+      ctx
+    );
+  } catch (err) {
+    abortCleanup?.();
+    const errorMsg = err?.message || String(err);
+    const finishedAt2 = Date.now();
+    activity.status = effectiveSignal?.aborted ? "cancelled" : "failed";
+    activity.finishedAt = finishedAt2;
+    activity.durationMs = finishedAt2 - startedAt;
+    activity.error = errorMsg;
+    await emit("activity-finished");
+    throw err;
+  } finally {
+    abortCleanup?.();
+  }
+  const finishedAt = Date.now();
+  activity.finishedAt = finishedAt;
+  activity.durationMs = finishedAt - startedAt;
+  if (waitResult.status === "done" || waitResult.status === "completed") {
+    activity.status = "completed";
+    activity.result = waitResult.content;
+    await emit("activity-finished");
+    return {
+      runId,
+      status: "completed",
+      content: waitResult.content ?? "",
+      activityId,
+      durationMs: activity.durationMs,
+      raw: waitResult.raw
+    };
+  }
+  if (waitResult.status === "cancelled" || waitResult.status === "killed" || effectiveSignal?.aborted) {
+    activity.status = "cancelled";
+    await emit("activity-finished");
+    return {
+      runId,
+      status: "cancelled",
+      content: waitResult.content ?? "",
+      activityId,
+      durationMs: activity.durationMs,
+      raw: waitResult.raw
+    };
+  }
+  if (waitResult.status === "timeout") {
+    activity.status = "failed";
+    activity.error = "Agent run timed out";
+    if (service.cancel) {
+      service.cancel({ runId }, ctx).catch(() => {
+      });
+    }
+    await emit("activity-finished");
+    return {
+      runId,
+      status: "timeout",
+      content: waitResult.content ?? "",
+      activityId,
+      durationMs: activity.durationMs,
+      error: "Agent run timed out",
+      raw: waitResult.raw
+    };
+  }
+  activity.status = "failed";
+  activity.error = waitResult.errorMessage ?? `Agent run finished with status "${waitResult.status}"`;
+  await emit("activity-finished");
+  throw new Error(activity.error);
+}
+function createToolBridgeAgentRunService(options) {
+  return {
+    start: async (opts) => {
+      const res = await options.startRunner(opts);
+      const raw = res.rawData;
+      if (typeof raw === "string") {
+        return {
+          runId: generateActivityId("sync-run"),
+          status: "done",
+          content: raw
+        };
+      }
+      return {
+        runId: raw?.runId ?? generateActivityId("run"),
+        status: raw?.status ?? "pending",
+        agentKey: raw?.agentKey,
+        agentName: raw?.agentName,
+        batchId: raw?.batchId,
+        taskPreview: raw?.taskPreview,
+        content: raw?.content
+      };
+    },
+    wait: async (opts) => {
+      const res = await options.waitRunner(opts);
+      const raw = res.rawData;
+      return {
+        runId: raw?.runId ?? opts.runId,
+        status: raw?.status ?? "done",
+        content: typeof raw === "string" ? raw : raw?.content ?? res.displayData,
+        errorMessage: raw?.errorMessage ?? raw?.error,
+        raw
+      };
+    },
+    cancel: options.cancelRunner ? async (opts) => {
+      const res = await options.cancelRunner({ runId: opts.runId });
+      return {
+        runId: res.rawData?.runId ?? opts.runId,
+        status: res.rawData?.status ?? "cancelled",
+        wasActive: res.rawData?.wasActive
+      };
+    } : void 0,
+    inspect: options.inspectRunner ? async (opts) => {
+      const res = await options.inspectRunner({ runId: opts.runId, tailLines: opts.tailLines });
+      return {
+        runId: res.rawData?.runId ?? opts.runId,
+        found: res.rawData?.found ?? true,
+        status: res.rawData?.status,
+        logLines: res.rawData?.logLines
+      };
+    } : void 0
+  };
+}
+var toolCallSeq = 0;
+function createHostToolAgentRunService(hostExecuteTool) {
+  const execTool = async (name, args, opts) => {
+    const id = `sdk-${Date.now().toString(36)}-${(++toolCallSeq).toString(36)}`;
+    const res = await hostExecuteTool({ id, name, arguments: JSON.stringify(args) }, opts);
+    let rawData = res.content;
+    if (typeof res.content === "string" && res.content.length) {
+      try {
+        rawData = JSON.parse(res.content);
+      } catch {
+        rawData = res.content;
       }
-    } catch (e) {
-      console.warn("[imagePreprocessing] web vision describe error:", e);
     }
+    if (rawData && typeof rawData === "object" && typeof rawData.error === "string") {
+      throw new Error(rawData.error);
+    }
+    return {
+      rawData,
+      displayData: typeof res.metadata?.displayData === "string" ? res.metadata.displayData : String(res.content ?? "")
+    };
+  };
+  return createToolBridgeAgentRunService({
+    startRunner: async (opts) => execTool("startAgentRun", {
+      agentKey: opts.agentKey ?? opts.agentId,
+      task: opts.task,
+      input: opts.input,
+      agentName: opts.agentName,
+      ephemeral: opts.ephemeral,
+      batchId: opts.batchId,
+      parentDialogId: opts.parentDialogId,
+      wait: false
+    }),
+    waitRunner: async (opts) => execTool(
+      "controlAgentRun",
+      {
+        action: "wait",
+        runId: opts.runId,
+        timeoutMs: opts.timeoutMs
+      },
+      // Forward the per-run abort signal so the host wait loop can be
+      // cancelled (CLI controlAgentRun wait reads opts.abortSignal).
+      { abortSignal: opts.signal }
+    ),
+    cancelRunner: async ({ runId }) => execTool("controlAgentRun", { action: "stop", runId }),
+    inspectRunner: async ({ runId, tailLines }) => execTool("controlAgentRun", {
+      action: "status",
+      runId,
+      tailLines: tailLines ?? 0
+    })
+  });
+}
+
+// packages/agent-runtime/capabilities/capabilitySdk.ts
+var BUILTIN_CAPABILITIES = [
+  execShellCapability
+];
+async function invokeCapability(capabilityOrName, input, ctx = {}) {
+  const capability = typeof capabilityOrName === "string" ? BUILTIN_CAPABILITIES.find((c) => c.name === capabilityOrName) : capabilityOrName;
+  if (!capability) {
+    throw new Error(`Capability "${String(capabilityOrName)}" not found.`);
   }
-  if (finalMessages === messages) {
-    finalMessages = stripImagePartsFromMessages(messages);
+  const normalizedInput = capability.normalizeInput(input);
+  await evaluateCapabilityPolicy(capability, normalizedInput, ctx);
+  if (ctx.onInvoke) {
+    await ctx.onInvoke(capability.name, normalizedInput);
   }
-  const newFirstDynamicIdx = finalMessages.findIndex((m) => m.id && !initialHistoryIds.has(m.id));
-  const splitIdx = newFirstDynamicIdx === -1 ? finalMessages.length : newFirstDynamicIdx;
+  return capability.invoke(ctx, normalizedInput);
+}
+function createCapabilitySdk(args) {
+  const registry2 = /* @__PURE__ */ new Map();
+  for (const cap of args.capabilities ?? BUILTIN_CAPABILITIES) {
+    registry2.set(cap.name, cap);
+  }
+  const invoke = async (name, input) => {
+    const capability = registry2.get(name);
+    if (!capability) {
+      throw new Error(`Capability "${name}" not found.`);
+    }
+    return invokeCapability(capability, input, args.context);
+  };
   return {
-    kind: "ok",
-    messages: finalMessages,
-    stableMessages: finalMessages.slice(0, splitIdx),
-    dynamicMessages: finalMessages.slice(splitIdx)
+    execShell: (input) => invoke("execShell", input),
+    agents: {
+      run: async (input) => {
+        if (!args.context.agentRunService) {
+          throw new Error("CapabilityExecutionContext missing agentRunService for agents.run()");
+        }
+        return executeAgentRunLifecycle(args.context.agentRunService, input, args.context);
+      }
+    },
+    invoke
   };
 }
 
@@ -1213,19 +2552,9 @@ function prepareHistoryForNextTurn(history, contextReferenceResolver) {
     };
   });
 }
-var IMAGE_OMITTED_PLACEHOLDER2 = "[Image content omitted: model does not support image input]";
-function stripImagePartsFromContent2(content) {
-  if (!Array.isArray(content)) return content;
-  const filtered = content.filter((part) => part?.type !== "image_url");
-  if (filtered.length === 0) return IMAGE_OMITTED_PLACEHOLDER2;
-  return filtered;
-}
 function filterImagePartsFromMessages(messages, supportsImages) {
   if (supportsImages) return messages;
-  return messages.map((msg) => ({
-    ...msg,
-    content: stripImagePartsFromContent2(msg.content)
-  }));
+  return stripImagePartsFromMessages(messages);
 }
 function buildMessages(args) {
   if (args.contextBlockScopes?.length) {
@@ -1357,6 +2686,18 @@ function applyPersistedTurnInput(messages, persistedInput, persistedInputReferen
     };
   });
 }
+function createLocalCapabilitySdk(adapter, execShellContext) {
+  return createCapabilitySdk({
+    context: {
+      agentRunService: createHostToolAgentRunService(adapter.executeTool),
+      // Inject the SAME local execution context the host uses for execShell,
+      // so PTC tools.execShell() is no more permissive than normal local tool
+      // calling. Caller supplies the real values (workspaceRoot, restrictToWorkspace,
+      // timeout/output limits, destructive-shell guard semantics, abortSignal).
+      ...execShellContext
+    }
+  });
+}
 async function runLocalAgentTurn(input) {
   const agentConfig = await input.adapter.loadAgentConfig(input.agentRef);
   if (!agentConfig) {
@@ -1367,6 +2708,22 @@ async function runLocalAgentTurn(input) {
     error.agentRef = input.agentRef;
     throw error;
   }
+  const execShellContext = buildLocalExecShellContext({
+    workspaceRoot: typeof input.runtimeContext?.workspaceRoot === "string" ? input.runtimeContext.workspaceRoot : typeof input.runtimeContext?.cwd === "string" ? input.runtimeContext.cwd : process.cwd(),
+    ...typeof input.runtimeContext?.restrictToWorkspace === "boolean" ? { restrictToWorkspace: input.runtimeContext.restrictToWorkspace } : typeof input.runtimeContext?.restrictShellToWorkspace === "boolean" ? { restrictToWorkspace: input.runtimeContext.restrictShellToWorkspace } : {},
+    ...typeof input.runtimeContext?.commandTimeoutMs === "number" ? { commandTimeoutMs: input.runtimeContext.commandTimeoutMs } : {},
+    ...typeof input.runtimeContext?.commandOutputLimit === "number" ? { commandOutputLimit: input.runtimeContext.commandOutputLimit } : {},
+    ...Array.isArray(input.runtimeContext?.commandPrefix) ? { commandPrefix: input.runtimeContext.commandPrefix } : {},
+    ...input.abortSignal ? { abortSignal: input.abortSignal } : {},
+    ...typeof input.runtimeContext?.detachMs === "number" ? { detachMs: input.runtimeContext.detachMs } : {},
+    ...typeof input.runtimeContext?.enableDestructiveShellGuard === "boolean" ? { enableDestructiveShellGuard: input.runtimeContext.enableDestructiveShellGuard } : {},
+    ...typeof input.runtimeContext?.confirmDestructiveAction === "function" ? { confirmDestructiveAction: input.runtimeContext.confirmDestructiveAction } : {},
+    ...typeof input.runtimeContext?.blockDestructiveWithoutConfirmation === "boolean" ? { blockDestructiveWithoutConfirmation: input.runtimeContext.blockDestructiveWithoutConfirmation } : {}
+  });
+  const tools = createLocalCapabilitySdk(input.adapter, execShellContext);
+  if (input.__testProgram) {
+    await input.__testProgram(tools);
+  }
   const rawBillingConfig = agentConfig.rawRecord ?? {};
   const billingConfig = {
     model: agentConfig.model || "unknown",
@@ -1468,26 +2825,12 @@ async function runLocalAgentTurn(input) {
     hasVision: agentConfig.hasVision
   });
   if (!supportsImages && hasImageInRuntimeMessages(messages)) {
-    const imageUrls = extractImageUrlsFromMessages(messages);
-    const preprocessed = await preprocessImagesForTextOnlyAgent(
-      messages,
-      (urls) => describeImageWithLocalProvider(input.adapter, urls)
-    );
-    if (preprocessed !== messages) {
-      messages = preprocessed;
-      emitLoopEvent(input, {
-        kind: "image-preprocessed",
-        atMs: Date.now(),
-        imageCount: imageUrls.length
-      });
-    } else {
-      messages = filterImagePartsFromMessages(messages, false);
-      emitLoopEvent(input, {
-        kind: "image-downgraded",
-        reason: "no-vision",
-        atMs: Date.now()
-      });
-    }
+    messages = filterImagePartsFromMessages(messages, false);
+    emitLoopEvent(input, {
+      kind: "image-downgraded",
+      reason: "no-vision",
+      atMs: Date.now()
+    });
   }
   const userInputText = extractUserInputText(input.input);
   let toolCallCount = 0;
@@ -1528,6 +2871,10 @@ async function runLocalAgentTurn(input) {
         messages: requestMessages,
         options: {
           ...typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {},
+          // 用户取消信号穿进 provider options：providerStreamRetry 据此在
+          // 取消后跳过重试，provider 分支（如 antigravity/openai-compatible）
+          // 也可把 fetch 绑定到同一信号，实现真正的传输层取消。
+          ...input.abortSignal ? { signal: input.abortSignal } : {},
           // 计费归因：续聊轮次带上 dialogId，platform proxy 才能把 token 记录
           // 归到具体对话而不是 chat-proxy 兜底桶。新对话首轮 id 尚未分配。
           ...input.continueDialogId ? { dialogId: input.continueDialogId } : {},
@@ -1788,9 +3135,27 @@ async function runLocalAgentTurn(input) {
 export {
   readCommandActionGatePayload,
   readActionGate,
-  parseToolArgumentsJson,
+  isDestructiveShellCommand,
+  evaluateShellCommandPolicy,
+  resolveExecutableOnPath,
+  createGlob,
+  spawnToWebStreams,
+  getProcessRegistry,
+  extractActivity,
+  buildWorkspaceShellCommand,
+  findWorkspaceShellEscapeToken,
+  buildWorkspaceShellEscapeBlockedResult,
+  truncateToolOutput,
+  readNodeStream,
+  waitForNodeProcessExit,
+  deriveLabel,
+  isSpawnFailureError,
+  runWorkspaceCommand,
+  buildExecShellToolDefinition,
+  evaluateExecShellDestructiveGuard,
+  invokeCapability,
   summarizeToolArguments,
-  tryPreprocessWebImageOrReject,
+  stripImagePartsForTextOnlyAgent,
   resolveHistoricalToolContentCap,
   projectToolMessageContent,
   LOCAL_AGENT_CONFIG_MISSING_CODE,