@atlasharness/atlascode 0.1.62 → 0.1.64

package/dist/cli.js

@@ -26901,7 +26901,39 @@ function llmTimeoutRemediationHint(error, currentTimeoutMs) {
   const head = typeof currentTimeoutMs === "number" && currentTimeoutMs > 0 ? `当前超时 ${Math.round(currentTimeoutMs / 1000)}s` : "慢模型长生成可能超过缺省超时";
   return `LLM 请求超时（${head}）。可调大：env ATLAS_LLM_TIMEOUT=<毫秒> 或 settings.json llmTimeoutMs 键（上限 ${Math.round(LLM_TIMEOUT_CAP_MS / 60000)}min）。`;
 }
-function gatewayUnreachableRemediationHint(error) {
+function describeEndpointFailure(baseURL) {
+  if (!baseURL)
+    return "LLM 端点";
+  let host;
+  let port;
+  try {
+    const u = new URL(baseURL);
+    host = u.hostname;
+    port = u.port;
+  } catch {
+    return "LLM 端点";
+  }
+  if (host === "localhost" || host === "0.0.0.0" || host === "[::1]" || host.startsWith("127.")) {
+    return port ? `本地端口 ${port}` : "本地网关";
+  }
+  const knownProviders = [
+    [/api\.deepseek\.com$/i, "DeepSeek"],
+    [/api\.openai\.com$/i, "OpenAI"],
+    [/^(dashscope|api)\.aliyuncs\.com$/i, "阿里百炼"],
+    [/api\.moonshot\.cn$/i, "Kimi"],
+    [/api\.minimax\.chat$/i, "MiniMax"],
+    [/api\.baichuan-ai\.com$/i, "百川"],
+    [/api\.01\.ai$/i, "零一万物"],
+    [/api\.siliconflow\.cn$/i, "硅基流动"],
+    [/api\.lkeap\.com$/i, "腾讯混元"]
+  ];
+  for (const [re, name] of knownProviders) {
+    if (re.test(host))
+      return `${name} 服务`;
+  }
+  return host;
+}
+function gatewayUnreachableRemediationHint(error, endpointLabel) {
   if (!error || typeof error !== "object")
     return null;
   const e = error;
@@ -26918,7 +26950,7 @@ function gatewayUnreachableRemediationHint(error) {
   const isNetworkErrno = /ECONNREFUSED|ECONNRESET|ENOTFOUND|ENETUNREACH|EHOSTUNREACH|EAI_AGAIN|fetch failed|socket hang up/i.test(haystack);
   if (!isSdkConnection && !isNetworkErrno)
     return null;
-  return "IFF 不可达：已切人工确认 —— /doctor 排查";
+  return `${endpointLabel ?? "LLM 端点"} 不可达：已切人工确认 —— /doctor 排查`;
 }
 function modelRetryBackoffMs(attempt, baseMs = MODEL_RETRY_BACKOFF_BASE_MS, capMs = MODEL_RETRY_BACKOFF_CAP_MS) {
   const base = Math.max(0, baseMs);
@@ -27824,6 +27856,18 @@ function setLlmTimeoutSettingsSource(next) {
 function getCurrentLlmTimeoutMs() {
   return resolveLlmTimeoutMs(process.env.ATLAS_LLM_TIMEOUT, llmTimeoutSettingsSource?.());
 }
+function getCurrentEndpointLabel(modelRef) {
+  let baseURL;
+  if (modelRef) {
+    const resolved = resolveModel(modelRef);
+    if (resolved?.baseURL)
+      baseURL = resolved.baseURL;
+  }
+  if (!baseURL) {
+    baseURL = getRoleConfig("small").baseURL;
+  }
+  return describeEndpointFailure(baseURL);
+}
 function resolveLlmTimeoutMs(envRaw = process.env.ATLAS_LLM_TIMEOUT, settingsMs) {
   const fromSettings = () => typeof settingsMs === "number" && Number.isInteger(settingsMs) && settingsMs >= 1 ? Math.min(settingsMs, LLM_TIMEOUT_CAP_MS) : LLM_TIMEOUT_DEFAULT_MS;
   if (envRaw === undefined || envRaw === "")
@@ -27847,6 +27891,7 @@ var init_modelprovider2 = __esm(() => {
   init_modelprovider();
   init_constants2();
   init_shared();
+  init_roles7();
   init_constants2();
   init_modelprovider();
   init_types2();
@@ -27966,11 +28011,31 @@ function armGoal(condition) {
       reason: `Goal condition exceeds ${MAX_GOAL_CONDITION_CHARS} characters (got ${trimmed.length}).`
     };
   }
-  goalState = { armed: true, condition: trimmed };
+  goalState = { armed: true, condition: trimmed, paused: false, pausedReason: undefined };
   return { ok: true };
 }
 function clearGoal() {
-  goalState = { armed: false, condition: undefined };
+  goalState = { armed: false, condition: undefined, paused: false, pausedReason: undefined };
+}
+function pauseGoal(reason) {
+  if (!goalState.armed)
+    return;
+  goalState = { ...goalState, paused: true, pausedReason: reason };
+}
+function resumeGoal() {
+  if (!goalState.paused)
+    return;
+  goalState = { ...goalState, paused: false, pausedReason: undefined };
+}
+function isGoalPaused() {
+  return goalState.armed && goalState.paused;
+}
+function getGoalPausedReason() {
+  return goalState.armed && goalState.paused ? goalState.pausedReason : undefined;
+}
+function goalPausedNotification(reason) {
+  return `Goal paused: ${reason}
+The goal will resume when the condition recovers.`;
 }
 function isGoalArmed() {
   return goalState.armed;
@@ -27986,13 +28051,27 @@ function getGoalStateForPersistence() {
 }
 function restoreGoalState(snapshot) {
   if (snapshot && snapshot.armed && snapshot.condition.trim() !== "") {
-    goalState = { armed: true, condition: snapshot.condition.trim() };
+    goalState = { armed: true, condition: snapshot.condition.trim(), paused: false, pausedReason: undefined };
   } else {
-    goalState = { armed: false, condition: undefined };
+    goalState = { armed: false, condition: undefined, paused: false, pausedReason: undefined };
   }
 }
 function resetGoalStateForTesting() {
-  goalState = { armed: false, condition: undefined };
+  goalState = { armed: false, condition: undefined, paused: false, pausedReason: undefined };
+}
+function classifyGoalError(err) {
+  const msg = (err instanceof Error ? err.message : String(err ?? "")).toLowerCase();
+  if (/\b401\b/.test(msg) || /\b403\b/.test(msg) || msg.includes("unauthorized") || msg.includes("forbidden")) {
+    return "unrecoverable";
+  }
+  if (msg.includes("context length exceeded") || msg.includes("prompt too long") || msg.includes("context window")) {
+    return "unrecoverable";
+  }
+  return "recoverable";
+}
+function goalUnrecoverableNotification(reason) {
+  return `Goal cleared (unrecoverable): ${reason}
+The goal can no longer be pursued. Set a new goal if needed.`;
 }
 function extractConversationEvidence(messages, maxMessages = 12) {
   const recent = messages.slice(-maxMessages);
@@ -28070,297 +28149,146 @@ The goal has been auto-cleared.`;
 function goalClearedNotification() {
   return "Goal cleared.";
 }
+function goalHookGateNotification() {
+  return "Goal cleared: hooks are disabled (disableAllHooks). Goals require hooks to continue.";
+}
 var MAX_GOAL_CONDITION_CHARS = 500, DEFAULT_MAX_GOAL_TURNS = 10, goalState, EVALUATOR_SYSTEM_PROMPT = `You are a goal-condition evaluator. You are given a goal condition and the recent conversation. Determine whether the goal condition has been MET based solely on the conversation evidence — do not run commands, do not read files, do not make assumptions beyond what is shown.
 
 Respond on the first line with exactly "MET" or "UNMET". On the following line, give a one-sentence reason citing the conversation evidence.`;
 var init_goalState = __esm(() => {
-  goalState = { armed: false, condition: undefined };
+  goalState = { armed: false, condition: undefined, paused: false, pausedReason: undefined };
 });
 
-// src/engine/pipeline/errorClassification.ts
-function classifyToolError(error) {
-  if (error instanceof Error) {
-    const errnoCode = error.code;
-    if (typeof errnoCode === "string") {
-      return `Error:${errnoCode}`;
-    }
-    if (error.name && error.name !== "Error" && error.name.length > 3) {
-      return error.name.slice(0, 60);
-    }
-    return "Error";
-  }
-  return "UnknownError";
+// src/engine/config/settingsCache.ts
+function getSessionSettingsCache() {
+  return sessionSettingsCache;
 }
-
-// src/engine/pipeline/schemaValidation.ts
-function typeName(v) {
-  if (v === null)
-    return "null";
-  if (Array.isArray(v))
-    return "array";
-  return typeof v;
+function setSessionSettingsCache(value) {
+  sessionSettingsCache = value;
 }
-function checkBasicType(value, type) {
-  switch (type) {
-    case "string":
-      return typeof value === "string" ? null : `expected string, got ${typeName(value)}`;
-    case "number":
-      if (typeof value === "number") {
-        return Number.isFinite(value) ? null : "expected number, got non-finite number";
-      }
-      return `expected number, got ${typeName(value)}`;
-    case "integer":
-      if (typeof value === "number") {
-        return Number.isInteger(value) ? null : "expected integer, got non-integer number";
-      }
-      return `expected integer, got ${typeName(value)}`;
-    case "boolean":
-      return typeof value === "boolean" ? null : `expected boolean, got ${typeName(value)}`;
-    case "array":
-      return Array.isArray(value) ? null : `expected array, got ${typeName(value)}`;
-    case "object":
-      return typeof value === "object" && value !== null && !Array.isArray(value) ? null : `expected object, got ${typeName(value)}`;
-    case "null":
-      return value === null ? null : `expected null, got ${typeName(value)}`;
-    default:
-      return null;
-  }
+function getCachedSettingsForSource(source) {
+  return perSourceCache.has(source) ? perSourceCache.get(source) : undefined;
 }
-function validateInputBySchema(input, schema) {
-  if (!schema) {
-    return { valid: true };
-  }
-  if (input === null || typeof input !== "object" || Array.isArray(input)) {
-    return { valid: false, message: "expected object input" };
-  }
-  const record = input;
-  const errors = [];
-  const required = schema.required;
-  if (Array.isArray(required)) {
-    for (const rawKey of required) {
-      const key = String(rawKey);
-      if (!(key in record) || record[key] === undefined) {
-        errors.push(`missing required field "${key}"`);
-      }
-    }
-  }
-  const properties = schema.properties;
-  if (properties) {
-    for (const [key, value] of Object.entries(record)) {
-      if (value === undefined)
-        continue;
-      const propSchema = properties[key];
-      if (!propSchema || typeof propSchema !== "object")
-        continue;
-      const type = propSchema.type;
-      if (typeof type !== "string")
-        continue;
-      const err = checkBasicType(value, type);
-      if (err)
-        errors.push(`field "${key}": ${err}`);
-    }
-  }
-  return errors.length > 0 ? { valid: false, message: errors.join("; ") } : { valid: true };
+function setCachedSettingsForSource(source, value) {
+  perSourceCache.set(source, value);
 }
-function buildSchemaNotSentHint(tool, discoveredToolNames) {
-  if (!tool.shouldDefer)
-    return null;
-  if (discoveredToolNames.has(tool.name))
-    return null;
-  return `
-
-This tool's schema was not sent to the API — it was not in the discovered-tool set derived from message history. ` + `Without the schema in your prompt, typed parameters (arrays, numbers, booleans) get emitted as strings and the client-side parser rejects them. ` + `Re-issue the call with correctly-typed parameters (arrays/numbers/booleans, not their string forms).`;
+function getCachedParsedFile(path) {
+  return parseFileCache.get(path);
+}
+function setCachedParsedFile(path, value) {
+  parseFileCache.set(path, value);
 }
+function resetSettingsCache() {
+  sessionSettingsCache = null;
+  perSourceCache.clear();
+  parseFileCache.clear();
+}
+function getPluginSettingsBase() {
+  return pluginSettingsBase;
+}
+function setPluginSettingsBase(settings) {
+  pluginSettingsBase = settings;
+}
+function clearPluginSettingsBase() {
+  pluginSettingsBase = undefined;
+}
+var sessionSettingsCache = null, perSourceCache, parseFileCache, pluginSettingsBase;
+var init_settingsCache = __esm(() => {
+  perSourceCache = new Map;
+  parseFileCache = new Map;
+});
 
-// src/engine/pipeline/toolExecution.ts
-function mergeHookPermission(hookBehavior, gate, hookReason) {
-  if (hookBehavior === "defer") {
-    return {
-      allowed: false,
-      deferred: true,
-      reason: hookReason ?? "deferred by hook"
-    };
-  }
-  if (hookBehavior === "deny") {
-    return { allowed: false, reason: "blocked by hook" };
-  }
-  if (!gate.allowed)
-    return gate;
-  if (hookBehavior === "ask") {
-    return { allowed: false, ask: true, reason: "hook requested confirmation" };
-  }
-  return gate;
+// node_modules/zod/index.js
+var init_zod = __esm(() => {
+  init_external();
+  init_external();
+});
+
+// src/engine/config/configRoot.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function getAtlasConfigHomeDir() {
+  return (process.env.ATLAS_CONFIG_DIR ?? join2(homedir2(), getConfigDirName())).normalize("NFC");
 }
-function findTool(tools, name) {
-  return tools.find((t) => t.name === name || (t.aliases?.includes(name) ?? false));
+var init_configRoot = __esm(() => {
+  init_shared();
+});
+
+// src/engine/config/constants.ts
+function getEnabledSettingSources() {
+  const result = new Set(ALLOWED_SETTING_SOURCES);
+  result.add("policySettings");
+  result.add("flagSettings");
+  return Array.from(result);
 }
-async function executeToolUse(tu, assistantMsg, deps) {
-  const tool = findTool(deps.tools, tu.name);
-  if (!tool) {
-    return {
-      block: {
-        type: "tool_result",
-        tool_use_id: tu.id,
-        content: `unknown tool: ${tu.name}`,
-        is_error: true
-      },
-      isError: true
-    };
-  }
-  const toolCallContext = deps.toolContext !== undefined ? { ...deps.toolContext, signal: deps.signal, checkPermission: deps.checkPermission } : { signal: deps.signal, checkPermission: deps.checkPermission };
-  const schemaResult = validateInputBySchema(tu.input, tool.inputSchema);
-  if (schemaResult.valid === false) {
-    const discovered = deps.discoveredToolNames ?? new Set(deps.tools.map((t) => t.name));
-    const schemaHint = buildSchemaNotSentHint(tool, discovered);
-    const errorContent = schemaHint ? `${schemaResult.message}${schemaHint}` : schemaResult.message;
-    return {
-      block: {
-        type: "tool_result",
-        tool_use_id: tu.id,
-        content: `<tool_use_error>InputValidationError: ${errorContent}</tool_use_error>`,
-        is_error: true
-      },
-      isError: true
-    };
-  }
-  const validation = await tool.validateInput?.(tu.input, toolCallContext);
-  if (validation && validation.result === false) {
-    return {
-      block: {
-        type: "tool_result",
-        tool_use_id: tu.id,
-        content: `<tool_use_error>InputValidationError: ${validation.message}</tool_use_error>`,
-        is_error: true
-      },
-      isError: true
-    };
-  }
-  const preOutcome = await deps.hooks?.preToolUse?.(tool, tu.input, tu.id);
-  if (preOutcome?.blockingError) {
-    return {
-      block: {
-        type: "tool_result",
-        tool_use_id: tu.id,
-        content: `<tool_use_error>hook blocked: ${preOutcome.blockingError}</tool_use_error>`,
-        is_error: true
-      },
-      isError: true
-    };
-  }
-  if (preOutcome?.preventContinuation) {
-    return {
-      block: {
-        type: "tool_result",
-        tool_use_id: tu.id,
-        content: `<tool_use_error>Execution stopped by PreToolUse hook${preOutcome.stopReason ? `: ${preOutcome.stopReason}` : ""}</tool_use_error>`,
-        is_error: true
-      },
-      isError: true
-    };
-  }
-  const effectiveInput = preOutcome?.updatedInput ?? tu.input;
-  const gateVerdict = deps.checkPermission ? await deps.checkPermission(tool, effectiveInput, {
-    toolUseId: tu.id,
-    assistantMessage: assistantMsg
-  }) : { allowed: true };
-  const verdict = mergeHookPermission(preOutcome?.hookBehavior, gateVerdict, preOutcome?.hookPermissionDecisionReason);
-  if (verdict.deferred) {
-    return { deferred: true, deferReason: verdict.reason, isError: false };
-  }
-  if (!verdict.allowed) {
-    const content = verdict.ask ? `<tool_use_error>permission confirmation required (prompt 面残留守): ${verdict.reason ?? tu.name}</tool_use_error>` : `<tool_use_error>permission denied: ${verdict.reason ?? tu.name}</tool_use_error>`;
-    return {
-      block: {
-        type: "tool_result",
-        tool_use_id: tu.id,
-        content,
-        is_error: true
-      },
-      isError: true
-    };
-  }
-  const callInput = verdict.updatedInput ?? effectiveInput;
-  let block;
-  let isError = false;
-  let toolUseResult;
-  try {
-    const res = await tool.call(callInput, toolCallContext, undefined, assistantMsg);
-    block = tool.mapToolResultToToolResultBlockParam(res.data, tu.id);
-    toolUseResult = res.data;
-  } catch (error) {
-    const errorText = `tool error [${classifyToolError(error)}]: ${String(error?.message ?? error)}`;
-    block = {
-      type: "tool_result",
-      tool_use_id: tu.id,
-      content: `<tool_use_error>${errorText}</tool_use_error>`,
-      is_error: true
-    };
-    isError = true;
-    toolUseResult = errorText;
-  }
-  const postOutcome = await deps.hooks?.postToolUse?.(tool, callInput, block, tu.id);
-  if (postOutcome?.updatedToolOutput !== undefined) {
-    block = { ...block, content: postOutcome.updatedToolOutput };
-    toolUseResult = postOutcome.updatedToolOutput;
-  }
-  return { block, isError, toolUseResult };
+function isSettingSourceEnabled(source) {
+  const enabled = getEnabledSettingSources();
+  return enabled.includes(source);
 }
-var init_toolExecution = () => {};
+var SETTING_SOURCES, ALLOWED_SETTING_SOURCES;
+var init_constants3 = __esm(() => {
+  SETTING_SOURCES = [
+    "userSettings",
+    "projectSettings",
+    "localSettings",
+    "flagSettings",
+    "policySettings"
+  ];
+  ALLOWED_SETTING_SOURCES = ["userSettings"];
+});
 
-// src/engine/pipeline/toolOrchestration.ts
-function partitionToolCalls(toolUses, tools) {
-  return toolUses.reduce((acc, tu) => {
-    const tool = findTool(tools, tu.name);
-    let safe = false;
-    try {
-      safe = tool ? tool.isConcurrencySafe(tu.input) : false;
-    } catch {
-      safe = false;
+// src/engine/config/merge.ts
+function isPlainObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function mergeWith(target, source, customizer) {
+  for (const key of Object.keys(source)) {
+    const srcValue = source[key];
+    const objValue = target[key];
+    if (customizer) {
+      const customized = customizer(objValue, srcValue, key, target);
+      if (customized !== undefined) {
+        target[key] = customized;
+        continue;
+      }
     }
-    if (safe && acc[acc.length - 1]?.isConcurrencySafe) {
-      acc[acc.length - 1].blocks.push(tu);
+    if (srcValue === undefined)
+      continue;
+    if (isPlainObject2(objValue) && isPlainObject2(srcValue)) {
+      mergeWith(objValue, srcValue, customizer);
     } else {
-      acc.push({ isConcurrencySafe: safe, blocks: [tu] });
+      target[key] = srcValue;
     }
-    return acc;
-  }, []);
+  }
+  return target;
 }
-async function runToolBatch(toolUses, assistantMsg, deps) {
-  const outcomes = [];
-  for (const batch of partitionToolCalls(toolUses, deps.tools)) {
-    for (const tu of batch.blocks) {
-      const r = await executeToolUse(tu, assistantMsg, deps);
-      outcomes.push({
-        toolUseId: tu.id,
-        name: tu.name,
-        block: r.block,
-        isError: r.isError,
-        toolUseResult: r.toolUseResult,
-        deferred: r.deferred,
-        deferReason: r.deferReason
-      });
-      if (r.deferred) {
-        return outcomes;
-      }
+function uniq(arr) {
+  const seen = new Set;
+  const out = [];
+  for (const x of arr) {
+    if (!seen.has(x)) {
+      seen.add(x);
+      out.push(x);
     }
   }
-  return outcomes;
+  return out;
+}
+function settingsMergeCustomizer(objValue, srcValue) {
+  if (Array.isArray(objValue) && Array.isArray(srcValue)) {
+    return uniq([...objValue, ...srcValue]);
+  }
+  return;
 }
-var init_toolOrchestration = __esm(() => {
-  init_toolExecution();
-});
-
-// src/engine/pipeline/index.ts
-var init_pipeline = __esm(() => {
-  init_toolExecution();
-  init_toolOrchestration();
-});
 
-// node_modules/zod/index.js
-var init_zod = __esm(() => {
-  init_external();
-  init_external();
-});
+// src/engine/config/managedPath.ts
+import { join as join3 } from "path";
+function getManagedSettingsDir() {
+  return "/etc/atlas";
+}
+function getManagedSettingsDropInDir() {
+  return join3(getManagedSettingsDir(), "managed-settings.d");
+}
+var init_managedPath = () => {};
 
 // src/hooks/hookEvents.ts
 var HOOK_EVENTS;
@@ -28950,131 +28878,6 @@ var init_types3 = __esm(() => {
   init_hooksSchema();
 });
 
-// src/engine/config/constants.ts
-function getEnabledSettingSources() {
-  const result = new Set(ALLOWED_SETTING_SOURCES);
-  result.add("policySettings");
-  result.add("flagSettings");
-  return Array.from(result);
-}
-function isSettingSourceEnabled(source) {
-  const enabled = getEnabledSettingSources();
-  return enabled.includes(source);
-}
-var SETTING_SOURCES, ALLOWED_SETTING_SOURCES;
-var init_constants3 = __esm(() => {
-  SETTING_SOURCES = [
-    "userSettings",
-    "projectSettings",
-    "localSettings",
-    "flagSettings",
-    "policySettings"
-  ];
-  ALLOWED_SETTING_SOURCES = ["userSettings"];
-});
-
-// src/engine/config/settingsCache.ts
-function getSessionSettingsCache() {
-  return sessionSettingsCache;
-}
-function setSessionSettingsCache(value) {
-  sessionSettingsCache = value;
-}
-function getCachedSettingsForSource(source) {
-  return perSourceCache.has(source) ? perSourceCache.get(source) : undefined;
-}
-function setCachedSettingsForSource(source, value) {
-  perSourceCache.set(source, value);
-}
-function getCachedParsedFile(path) {
-  return parseFileCache.get(path);
-}
-function setCachedParsedFile(path, value) {
-  parseFileCache.set(path, value);
-}
-function resetSettingsCache() {
-  sessionSettingsCache = null;
-  perSourceCache.clear();
-  parseFileCache.clear();
-}
-function getPluginSettingsBase() {
-  return pluginSettingsBase;
-}
-function setPluginSettingsBase(settings) {
-  pluginSettingsBase = settings;
-}
-function clearPluginSettingsBase() {
-  pluginSettingsBase = undefined;
-}
-var sessionSettingsCache = null, perSourceCache, parseFileCache, pluginSettingsBase;
-var init_settingsCache = __esm(() => {
-  perSourceCache = new Map;
-  parseFileCache = new Map;
-});
-
-// src/engine/config/managedPath.ts
-import { join as join2 } from "path";
-function getManagedSettingsDir() {
-  return "/etc/atlas";
-}
-function getManagedSettingsDropInDir() {
-  return join2(getManagedSettingsDir(), "managed-settings.d");
-}
-var init_managedPath = () => {};
-
-// src/engine/config/configRoot.ts
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
-function getAtlasConfigHomeDir() {
-  return (process.env.ATLAS_CONFIG_DIR ?? join3(homedir2(), getConfigDirName())).normalize("NFC");
-}
-var init_configRoot = __esm(() => {
-  init_shared();
-});
-
-// src/engine/config/merge.ts
-function isPlainObject2(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function mergeWith(target, source, customizer) {
-  for (const key of Object.keys(source)) {
-    const srcValue = source[key];
-    const objValue = target[key];
-    if (customizer) {
-      const customized = customizer(objValue, srcValue, key, target);
-      if (customized !== undefined) {
-        target[key] = customized;
-        continue;
-      }
-    }
-    if (srcValue === undefined)
-      continue;
-    if (isPlainObject2(objValue) && isPlainObject2(srcValue)) {
-      mergeWith(objValue, srcValue, customizer);
-    } else {
-      target[key] = srcValue;
-    }
-  }
-  return target;
-}
-function uniq(arr) {
-  const seen = new Set;
-  const out = [];
-  for (const x of arr) {
-    if (!seen.has(x)) {
-      seen.add(x);
-      out.push(x);
-    }
-  }
-  return out;
-}
-function settingsMergeCustomizer(objValue, srcValue) {
-  if (Array.isArray(objValue) && Array.isArray(srcValue)) {
-    return uniq([...objValue, ...srcValue]);
-  }
-  return;
-}
-
 // src/permissions/PermissionRule.ts
 var permissionBehaviorSchema, permissionRuleValueSchema;
 var init_PermissionRule = __esm(() => {
@@ -31706,6 +31509,285 @@ var init_hooksConfig = __esm(() => {
   init_settings();
 });
 
+// src/engine/pipeline/errorClassification.ts
+function classifyToolError(error) {
+  if (error instanceof Error) {
+    const errnoCode = error.code;
+    if (typeof errnoCode === "string") {
+      return `Error:${errnoCode}`;
+    }
+    if (error.name && error.name !== "Error" && error.name.length > 3) {
+      return error.name.slice(0, 60);
+    }
+    return "Error";
+  }
+  return "UnknownError";
+}
+
+// src/engine/pipeline/schemaValidation.ts
+function typeName(v) {
+  if (v === null)
+    return "null";
+  if (Array.isArray(v))
+    return "array";
+  return typeof v;
+}
+function checkBasicType(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string" ? null : `expected string, got ${typeName(value)}`;
+    case "number":
+      if (typeof value === "number") {
+        return Number.isFinite(value) ? null : "expected number, got non-finite number";
+      }
+      return `expected number, got ${typeName(value)}`;
+    case "integer":
+      if (typeof value === "number") {
+        return Number.isInteger(value) ? null : "expected integer, got non-integer number";
+      }
+      return `expected integer, got ${typeName(value)}`;
+    case "boolean":
+      return typeof value === "boolean" ? null : `expected boolean, got ${typeName(value)}`;
+    case "array":
+      return Array.isArray(value) ? null : `expected array, got ${typeName(value)}`;
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value) ? null : `expected object, got ${typeName(value)}`;
+    case "null":
+      return value === null ? null : `expected null, got ${typeName(value)}`;
+    default:
+      return null;
+  }
+}
+function validateInputBySchema(input, schema) {
+  if (!schema) {
+    return { valid: true };
+  }
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    return { valid: false, message: "expected object input" };
+  }
+  const record = input;
+  const errors = [];
+  const required = schema.required;
+  if (Array.isArray(required)) {
+    for (const rawKey of required) {
+      const key = String(rawKey);
+      if (!(key in record) || record[key] === undefined) {
+        errors.push(`missing required field "${key}"`);
+      }
+    }
+  }
+  const properties = schema.properties;
+  if (properties) {
+    for (const [key, value] of Object.entries(record)) {
+      if (value === undefined)
+        continue;
+      const propSchema = properties[key];
+      if (!propSchema || typeof propSchema !== "object")
+        continue;
+      const type = propSchema.type;
+      if (typeof type !== "string")
+        continue;
+      const err = checkBasicType(value, type);
+      if (err)
+        errors.push(`field "${key}": ${err}`);
+    }
+  }
+  return errors.length > 0 ? { valid: false, message: errors.join("; ") } : { valid: true };
+}
+function buildSchemaNotSentHint(tool, discoveredToolNames) {
+  if (!tool.shouldDefer)
+    return null;
+  if (discoveredToolNames.has(tool.name))
+    return null;
+  return `
+
+This tool's schema was not sent to the API — it was not in the discovered-tool set derived from message history. ` + `Without the schema in your prompt, typed parameters (arrays, numbers, booleans) get emitted as strings and the client-side parser rejects them. ` + `Re-issue the call with correctly-typed parameters (arrays/numbers/booleans, not their string forms).`;
+}
+
+// src/engine/pipeline/toolExecution.ts
+function mergeHookPermission(hookBehavior, gate, hookReason) {
+  if (hookBehavior === "defer") {
+    return {
+      allowed: false,
+      deferred: true,
+      reason: hookReason ?? "deferred by hook"
+    };
+  }
+  if (hookBehavior === "deny") {
+    return { allowed: false, reason: "blocked by hook" };
+  }
+  if (!gate.allowed)
+    return gate;
+  if (hookBehavior === "ask") {
+    return { allowed: false, ask: true, reason: "hook requested confirmation" };
+  }
+  return gate;
+}
+function findTool(tools, name) {
+  return tools.find((t) => t.name === name || (t.aliases?.includes(name) ?? false));
+}
+async function executeToolUse(tu, assistantMsg, deps) {
+  const tool = findTool(deps.tools, tu.name);
+  if (!tool) {
+    return {
+      block: {
+        type: "tool_result",
+        tool_use_id: tu.id,
+        content: `unknown tool: ${tu.name}`,
+        is_error: true
+      },
+      isError: true
+    };
+  }
+  const toolCallContext = deps.toolContext !== undefined ? { ...deps.toolContext, signal: deps.signal, checkPermission: deps.checkPermission } : { signal: deps.signal, checkPermission: deps.checkPermission };
+  const schemaResult = validateInputBySchema(tu.input, tool.inputSchema);
+  if (schemaResult.valid === false) {
+    const discovered = deps.discoveredToolNames ?? new Set(deps.tools.map((t) => t.name));
+    const schemaHint = buildSchemaNotSentHint(tool, discovered);
+    const errorContent = schemaHint ? `${schemaResult.message}${schemaHint}` : schemaResult.message;
+    return {
+      block: {
+        type: "tool_result",
+        tool_use_id: tu.id,
+        content: `<tool_use_error>InputValidationError: ${errorContent}</tool_use_error>`,
+        is_error: true
+      },
+      isError: true
+    };
+  }
+  const validation = await tool.validateInput?.(tu.input, toolCallContext);
+  if (validation && validation.result === false) {
+    return {
+      block: {
+        type: "tool_result",
+        tool_use_id: tu.id,
+        content: `<tool_use_error>InputValidationError: ${validation.message}</tool_use_error>`,
+        is_error: true
+      },
+      isError: true
+    };
+  }
+  const preOutcome = await deps.hooks?.preToolUse?.(tool, tu.input, tu.id);
+  if (preOutcome?.blockingError) {
+    return {
+      block: {
+        type: "tool_result",
+        tool_use_id: tu.id,
+        content: `<tool_use_error>hook blocked: ${preOutcome.blockingError}</tool_use_error>`,
+        is_error: true
+      },
+      isError: true
+    };
+  }
+  if (preOutcome?.preventContinuation) {
+    return {
+      block: {
+        type: "tool_result",
+        tool_use_id: tu.id,
+        content: `<tool_use_error>Execution stopped by PreToolUse hook${preOutcome.stopReason ? `: ${preOutcome.stopReason}` : ""}</tool_use_error>`,
+        is_error: true
+      },
+      isError: true
+    };
+  }
+  const effectiveInput = preOutcome?.updatedInput ?? tu.input;
+  const gateVerdict = deps.checkPermission ? await deps.checkPermission(tool, effectiveInput, {
+    toolUseId: tu.id,
+    assistantMessage: assistantMsg
+  }) : { allowed: true };
+  const verdict = mergeHookPermission(preOutcome?.hookBehavior, gateVerdict, preOutcome?.hookPermissionDecisionReason);
+  if (verdict.deferred) {
+    return { deferred: true, deferReason: verdict.reason, isError: false };
+  }
+  if (!verdict.allowed) {
+    const content = verdict.ask ? `<tool_use_error>permission confirmation required (prompt 面残留守): ${verdict.reason ?? tu.name}</tool_use_error>` : `<tool_use_error>permission denied: ${verdict.reason ?? tu.name}</tool_use_error>`;
+    return {
+      block: {
+        type: "tool_result",
+        tool_use_id: tu.id,
+        content,
+        is_error: true
+      },
+      isError: true
+    };
+  }
+  const callInput = verdict.updatedInput ?? effectiveInput;
+  let block;
+  let isError = false;
+  let toolUseResult;
+  try {
+    const res = await tool.call(callInput, toolCallContext, undefined, assistantMsg);
+    block = tool.mapToolResultToToolResultBlockParam(res.data, tu.id);
+    toolUseResult = res.data;
+  } catch (error) {
+    const errorText = `tool error [${classifyToolError(error)}]: ${String(error?.message ?? error)}`;
+    block = {
+      type: "tool_result",
+      tool_use_id: tu.id,
+      content: `<tool_use_error>${errorText}</tool_use_error>`,
+      is_error: true
+    };
+    isError = true;
+    toolUseResult = errorText;
+  }
+  const postOutcome = await deps.hooks?.postToolUse?.(tool, callInput, block, tu.id);
+  if (postOutcome?.updatedToolOutput !== undefined) {
+    block = { ...block, content: postOutcome.updatedToolOutput };
+    toolUseResult = postOutcome.updatedToolOutput;
+  }
+  return { block, isError, toolUseResult };
+}
+var init_toolExecution = () => {};
+
+// src/engine/pipeline/toolOrchestration.ts
+function partitionToolCalls(toolUses, tools) {
+  return toolUses.reduce((acc, tu) => {
+    const tool = findTool(tools, tu.name);
+    let safe = false;
+    try {
+      safe = tool ? tool.isConcurrencySafe(tu.input) : false;
+    } catch {
+      safe = false;
+    }
+    if (safe && acc[acc.length - 1]?.isConcurrencySafe) {
+      acc[acc.length - 1].blocks.push(tu);
+    } else {
+      acc.push({ isConcurrencySafe: safe, blocks: [tu] });
+    }
+    return acc;
+  }, []);
+}
+async function runToolBatch(toolUses, assistantMsg, deps) {
+  const outcomes = [];
+  for (const batch of partitionToolCalls(toolUses, deps.tools)) {
+    for (const tu of batch.blocks) {
+      const r = await executeToolUse(tu, assistantMsg, deps);
+      outcomes.push({
+        toolUseId: tu.id,
+        name: tu.name,
+        block: r.block,
+        isError: r.isError,
+        toolUseResult: r.toolUseResult,
+        deferred: r.deferred,
+        deferReason: r.deferReason
+      });
+      if (r.deferred) {
+        return outcomes;
+      }
+    }
+  }
+  return outcomes;
+}
+var init_toolOrchestration = __esm(() => {
+  init_toolExecution();
+});
+
+// src/engine/pipeline/index.ts
+var init_pipeline = __esm(() => {
+  init_toolExecution();
+  init_toolOrchestration();
+});
+
 // src/engine/config/managedEnv.ts
 function applySafeConfigEnvironmentVariables() {
   for (const source of TRUSTED_SETTING_SOURCES) {
@@ -33876,7 +33958,7 @@ var init_project = __esm(() => {
 var AGENT_TOOL_NAME = "Agent", MAX_WORKER_SPAWN_DEPTH = 2;
 
 // src/engine/tools/toolNames.ts
-var FILE_READ_TOOL_NAME = "Read", WEB_SEARCH_TOOL_NAME = "WebSearch", TODO_WRITE_TOOL_NAME = "TodoWrite", GREP_TOOL_NAME = "Grep", WEB_FETCH_TOOL_NAME = "WebFetch", GLOB_TOOL_NAME = "Glob", BASH_TOOL_NAME2 = "Bash", POWERSHELL_TOOL_NAME = "PowerShell", FILE_EDIT_TOOL_NAME = "Edit", FILE_WRITE_TOOL_NAME = "Write", NOTEBOOK_EDIT_TOOL_NAME = "NotebookEdit", SKILL_TOOL_NAME = "Skill", SYNTHETIC_OUTPUT_TOOL_NAME = "StructuredOutput", TOOL_SEARCH_TOOL_NAME = "ToolSearch", ENTER_WORKTREE_TOOL_NAME = "EnterWorktree", EXIT_WORKTREE_TOOL_NAME = "ExitWorktree", TEAM_CREATE_TOOL_NAME = "TeamCreate", TEAM_DELETE_TOOL_NAME = "TeamDelete", SNIP_TOOL_NAME = "Snip", SEND_MESSAGE_TOOL_NAME = "SendMessage", TASK_STOP_TOOL_NAME = "TaskStop", TASK_OUTPUT_TOOL_NAME = "TaskOutput", ENTER_PLAN_MODE_TOOL_NAME = "EnterPlanMode", EXIT_PLAN_MODE_V2_TOOL_NAME = "ExitPlanMode", ASK_USER_QUESTION_TOOL_NAME = "AskUserQuestion", TASK_CREATE_TOOL_NAME = "TaskCreate", TASK_GET_TOOL_NAME = "TaskGet", TASK_LIST_TOOL_NAME = "TaskList", TASK_UPDATE_TOOL_NAME = "TaskUpdate", CRON_CREATE_TOOL_NAME = "CronCreate", CRON_DELETE_TOOL_NAME = "CronDelete", CRON_LIST_TOOL_NAME = "CronList", CONFIG_TOOL_NAME = "Config", WORKFLOW_TOOL_NAME = "Workflow", REPL_TOOL_NAME = "REPL", LIST_MCP_RESOURCES_TOOL_NAME = "ListMcpResourcesTool", READ_MCP_RESOURCE_TOOL_NAME = "ReadMcpResourceTool", LSP_TOOL_NAME = "LSP", SHELL_TOOL_NAMES, ASYNC_AGENT_ALLOWED_TOOLS, INTERNAL_WORKER_TOOLS, ALL_AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, IN_PROCESS_TEAMMATE_ALLOWED_TOOLS, COORDINATOR_MODE_ALLOWED_TOOLS;
+var FILE_READ_TOOL_NAME = "Read", WEB_SEARCH_TOOL_NAME = "WebSearch", TODO_WRITE_TOOL_NAME = "TodoWrite", GREP_TOOL_NAME = "Grep", WEB_FETCH_TOOL_NAME = "WebFetch", GLOB_TOOL_NAME = "Glob", BASH_TOOL_NAME2 = "Bash", POWERSHELL_TOOL_NAME = "PowerShell", FILE_EDIT_TOOL_NAME = "Edit", FILE_WRITE_TOOL_NAME = "Write", NOTEBOOK_EDIT_TOOL_NAME = "NotebookEdit", SKILL_TOOL_NAME = "Skill", SYNTHETIC_OUTPUT_TOOL_NAME = "StructuredOutput", TOOL_SEARCH_TOOL_NAME = "ToolSearch", ENTER_WORKTREE_TOOL_NAME = "EnterWorktree", EXIT_WORKTREE_TOOL_NAME = "ExitWorktree", TEAM_CREATE_TOOL_NAME = "TeamCreate", TEAM_DELETE_TOOL_NAME = "TeamDelete", SNIP_TOOL_NAME = "Snip", SEND_MESSAGE_TOOL_NAME = "SendMessage", TASK_STOP_TOOL_NAME = "TaskStop", TASK_OUTPUT_TOOL_NAME = "TaskOutput", ENTER_PLAN_MODE_TOOL_NAME = "EnterPlanMode", EXIT_PLAN_MODE_V2_TOOL_NAME = "ExitPlanMode", ASK_USER_QUESTION_TOOL_NAME = "AskUserQuestion", TASK_CREATE_TOOL_NAME = "TaskCreate", TASK_GET_TOOL_NAME = "TaskGet", TASK_LIST_TOOL_NAME = "TaskList", TASK_UPDATE_TOOL_NAME = "TaskUpdate", CRON_CREATE_TOOL_NAME = "CronCreate", CRON_DELETE_TOOL_NAME = "CronDelete", CRON_LIST_TOOL_NAME = "CronList", CONFIG_TOOL_NAME = "Config", WORKFLOW_TOOL_NAME = "Workflow", REPL_TOOL_NAME = "REPL", LIST_MCP_RESOURCES_TOOL_NAME = "ListMcpResourcesTool", READ_MCP_RESOURCE_TOOL_NAME = "ReadMcpResourceTool", LSP_TOOL_NAME = "LSP", PROPOSE_GOAL_TOOL_NAME = "ProposeGoal", SHELL_TOOL_NAMES, ASYNC_AGENT_ALLOWED_TOOLS, INTERNAL_WORKER_TOOLS, ALL_AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, IN_PROCESS_TEAMMATE_ALLOWED_TOOLS, COORDINATOR_MODE_ALLOWED_TOOLS;
 var init_toolNames = __esm(() => {
   SHELL_TOOL_NAMES = [BASH_TOOL_NAME2, POWERSHELL_TOOL_NAME];
   ASYNC_AGENT_ALLOWED_TOOLS = new Set([
@@ -82033,6 +82115,18 @@ async function queryAgentLoop(deps, args) {
           effectiveDeps = { ...deps, sessionModel: nextRef };
           continue;
         }
+        if (isGoalArmed() && !deps.signal?.aborted) {
+          const goalCondition = getGoalCondition();
+          const errorReason = errorMessage(err);
+          if (classifyGoalError(err) === "unrecoverable") {
+            clearGoal();
+            deps.transcript?.saveGoalState?.(null);
+            deps.emit?.({ type: "goal_unrecoverable", condition: goalCondition, reason: errorReason });
+          } else {
+            pauseGoal(errorReason);
+            deps.emit?.({ type: "goal_paused", condition: goalCondition, reason: errorReason });
+          }
+        }
         throw err;
       }
       messages = lastRound.messages;
@@ -82050,7 +82144,7 @@ async function queryAgentLoop(deps, args) {
       break;
     }
     if (lastRound.toolResults.length === 0) {
-      if (isGoalArmed()) {
+      if (isGoalArmed() && !isGoalPaused()) {
         const condition = getGoalCondition();
         if (goalTurns >= maxGoalTurns) {
           clearGoal();
@@ -82058,13 +82152,45 @@ async function queryAgentLoop(deps, args) {
           terminated = true;
           break;
         }
+        if (shouldDisableAllHooksIncludingManaged()) {
+          clearGoal();
+          deps.transcript?.saveGoalState?.(null);
+          deps.emit?.({
+            type: "goal_unrecoverable",
+            condition,
+            reason: goalHookGateNotification()
+          });
+          terminated = true;
+          break;
+        }
+        if (deps.hasPendingBackgroundTasks?.()) {
+          terminated = true;
+          break;
+        }
         goalTurns++;
-        const evalResult = await evaluateGoal({
-          modelProvider: deps.modelProvider,
-          signal: deps.signal,
-          messages,
-          condition
-        });
+        let evalResult;
+        try {
+          evalResult = await evaluateGoal({
+            modelProvider: deps.modelProvider,
+            signal: deps.signal,
+            messages,
+            condition
+          });
+        } catch (evalErr) {
+          if (deps.signal?.aborted)
+            throw evalErr;
+          const errorReason = errorMessage(evalErr);
+          if (classifyGoalError(evalErr) === "unrecoverable") {
+            clearGoal();
+            deps.transcript?.saveGoalState?.(null);
+            deps.emit?.({ type: "goal_unrecoverable", condition, reason: errorReason });
+          } else {
+            pauseGoal(errorReason);
+            deps.emit?.({ type: "goal_paused", condition, reason: errorReason });
+          }
+          terminated = true;
+          break;
+        }
         if (evalResult.met) {
           clearGoal();
           deps.transcript?.saveGoalState?.(null);
@@ -82083,6 +82209,9 @@ async function queryAgentLoop(deps, args) {
           turn: turns,
           reason: evalResult.reason
         });
+      } else if (isGoalPaused()) {
+        terminated = true;
+        break;
       } else {
         const stop = deps.hooks?.stopHooks;
         const preventStop = stop ? (await stop(deps.signal)).preventContinuation : false;
@@ -82115,6 +82244,7 @@ var init_loop = __esm(() => {
   init_modelprovider2();
   init_turnRecovery();
   init_goalState();
+  init_hooksConfig();
   init_pipeline();
   init_context();
   init_reactiveCompactError();
@@ -82192,6 +82322,105 @@ var init_toolHooks = __esm(() => {
   init_hooks();
 });
 
+// src/engine/tools/proposeGoal/proposeGoalPrompt.ts
+var PROPOSE_GOAL_PROMPT = `Propose a goal condition that can be verified across multiple turns of conversation. The goal will be armed and the agent will continue working until an evaluator determines the condition has been met based solely on conversation evidence.
+
+Parameters:
+- condition (string, required): A single testable end-state condition, maximum 500 characters. The condition should describe a verifiable outcome, not a process.
+- ask_user (boolean, default true): Whether to ask the user to approve the goal.
+
+ask_user semantics:
+- ask_user=true (default): Present the goal to the user for single-key approval. If the user approves, the goal is armed. If the user declines, no goal is armed and no notification is sent.
+- ask_user=false: Arm the goal directly without asking. Use this ONLY when the user's own words explicitly stated the desired outcome and they want the agent to pursue it as a goal. Setting ask_user=false when the user did not explicitly request this outcome is a misuse of the tool.
+
+Evaluator behavior: A separate evaluator checks whether the goal condition has been met based only on the conversation. It does not run commands, does not read files, and does not make assumptions beyond what is shown in the conversation.
+
+One goal at a time: If a goal is already armed, proposing a new goal replaces the previous one (after approval if ask_user=true).
+
+Use this tool when the user describes an outcome they want achieved that can be verified from the conversation, and that may require multiple turns of work.`;
+
+// src/engine/tools/proposeGoal/ProposeGoal.ts
+var PROPOSE_GOAL_INPUT_SCHEMA, ProposeGoalTool;
+var init_ProposeGoal = __esm(() => {
+  init_json();
+  init_toolNames();
+  init_goalState();
+  PROPOSE_GOAL_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+      condition: {
+        type: "string",
+        description: `A single testable end-state condition (maximum ${MAX_GOAL_CONDITION_CHARS} characters). Describes a verifiable outcome, not a process.`
+      },
+      ask_user: {
+        type: "boolean",
+        description: "Whether to ask the user to approve the goal (default true). Set to false ONLY when the user explicitly requested this outcome."
+      }
+    },
+    required: ["condition"],
+    additionalProperties: false
+  };
+  ProposeGoalTool = {
+    name: PROPOSE_GOAL_TOOL_NAME,
+    inputSchema: PROPOSE_GOAL_INPUT_SCHEMA,
+    inputJSONSchema: PROPOSE_GOAL_INPUT_SCHEMA,
+    searchHint: "propose a verifiable goal condition to pursue across multiple turns",
+    maxResultSizeChars: 2000,
+    isEnabled: () => true,
+    isReadOnly: () => false,
+    isConcurrencySafe: () => false,
+    isDestructive: () => false,
+    userFacingName: () => "ProposeGoal",
+    toAutoClassifierInput: () => "",
+    async checkPermissions(input) {
+      const { condition, ask_user = true } = input;
+      if (ask_user) {
+        return {
+          behavior: "ask",
+          message: `Approve goal: "${condition}"?`,
+          updatedInput: input
+        };
+      }
+      return {
+        behavior: "allow",
+        updatedInput: input
+      };
+    },
+    async description() {
+      return PROPOSE_GOAL_PROMPT;
+    },
+    mapToolResultToToolResultBlockParam(data, toolUseID) {
+      return {
+        tool_use_id: toolUseID,
+        type: "tool_result",
+        content: jsonStringify2(data)
+      };
+    },
+    async call(args, _context) {
+      const { condition } = args ?? { condition: "" };
+      const result = armGoal(condition);
+      if (result.ok === true) {
+        return {
+          data: {
+            armed: true,
+            condition: condition.trim()
+          }
+        };
+      }
+      return {
+        data: {
+          armed: false,
+          condition: condition ?? "",
+          reason: result.reason
+        }
+      };
+    },
+    renderToolUseMessage() {
+      return null;
+    }
+  };
+});
+
 // src/engine/loopDeps.ts
 function setAgentLoopDepsTeammatePoolSync(fn) {
   teammatePoolSync = fn;
@@ -82208,7 +82437,8 @@ async function createAgentLoopDeps(config = {}) {
       ...config.toolRegistryDeps?.baseTools ?? [],
       SnipTool,
       TeamCreateTool,
-      TeamDeleteTool
+      TeamDeleteTool,
+      ProposeGoalTool
     ],
     mcpTools: [...config.toolRegistryDeps?.mcpTools ?? [], ...mcpTools],
     ascendTools: getDomainMount()?.tools
@@ -82293,6 +82523,7 @@ var init_loopDeps = __esm(() => {
   init_snipTool();
   init_teamCreateTool();
   init_teamDeleteTool();
+  init_ProposeGoal();
   init_context();
 });
 
@@ -82343,6 +82574,62 @@ var init_hooks2 = __esm(() => {
   init_hooks();
 });
 
+// src/engine/goal/goalCheckIn.ts
+function getGoalCheckInMinutes() {
+  const raw = process.env.ATLAS_GOAL_CHECKIN_MINUTES;
+  if (raw === undefined || raw === "")
+    return DEFAULT_GOAL_CHECKIN_MINUTES;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0)
+    return DEFAULT_GOAL_CHECKIN_MINUTES;
+  return parsed;
+}
+function getCheckInDelayMs(checkInIndex, baseMinutes) {
+  const multiplier = GOAL_CHECKIN_BACKOFF_MULTIPLIERS[checkInIndex];
+  if (multiplier === undefined)
+    return Infinity;
+  return baseMinutes * MS_PER_MINUTE * multiplier;
+}
+function resetCheckInState() {
+  checkInState = { checkInCount: 0 };
+}
+function recordCheckIn() {
+  checkInState = { checkInCount: checkInState.checkInCount + 1 };
+}
+function refreshOnUserMessage() {
+  checkInState = { checkInCount: 0 };
+}
+function getRemainingCheckIns() {
+  return Math.max(0, MAX_GOAL_CHECKINS - checkInState.checkInCount);
+}
+function canCheckIn() {
+  if (getGoalCheckInMinutes() === 0)
+    return false;
+  return checkInState.checkInCount < MAX_GOAL_CHECKINS;
+}
+function getCheckInStateForTesting() {
+  return { ...checkInState };
+}
+function goalCheckInPrompt(condition) {
+  return `This is an automated goal check-in. A goal is still active and the session appears idle or blocked by background work.
+
+Goal condition: ${condition}
+
+Review the progress toward this goal based on the conversation so far:
+- If work toward the goal is unfinished, continue it.
+- If background tasks are still running, wait for them and then reassess.
+- If the goal appears unachievable, explain why and what was attempted.
+
+Do not start new unrelated work. Focus on the goal condition above. Assess whether meaningful progress has been made since the last check-in.`;
+}
+var DEFAULT_GOAL_CHECKIN_MINUTES = 30, GOAL_CHECKIN_BACKOFF_MULTIPLIERS, MAX_GOAL_CHECKINS, CHECKIN_REFRESH_AMOUNT, MS_PER_MINUTE = 60000, checkInState;
+var init_goalCheckIn = __esm(() => {
+  GOAL_CHECKIN_BACKOFF_MULTIPLIERS = [1, 2, 4];
+  MAX_GOAL_CHECKINS = GOAL_CHECKIN_BACKOFF_MULTIPLIERS.length;
+  CHECKIN_REFRESH_AMOUNT = MAX_GOAL_CHECKINS;
+  checkInState = { checkInCount: 0 };
+});
+
 // src/engine/index.ts
 var init_engine = __esm(() => {
   init_query2();
@@ -82379,6 +82666,7 @@ var init_engine = __esm(() => {
   init_tasks2();
   init_messaging();
   init_goalState();
+  init_goalCheckIn();
 });
 
 // src/cli/entryInit.ts
@@ -179712,6 +180000,7 @@ __export(exports_engineCompat, {
   BASH_TOOL_NAME: () => BASH_TOOL_NAME2,
   BING_DEFAULT_ENDPOINT: () => BING_DEFAULT_ENDPOINT,
   BashTool: () => BashTool,
+  CHECKIN_REFRESH_AMOUNT: () => CHECKIN_REFRESH_AMOUNT,
   COMMAND_NAME_TAG: () => COMMAND_NAME_TAG,
   COMPACT_MAX_OUTPUT_TOKENS: () => COMPACT_MAX_OUTPUT_TOKENS,
   CONFIG_TOOL_NAME: () => CONFIG_TOOL_NAME,
@@ -179726,6 +180015,7 @@ __export(exports_engineCompat, {
   CronListTool: () => CronListTool,
   DEFAULT_AGENT_LOOP_MAX_TURNS: () => DEFAULT_AGENT_LOOP_MAX_TURNS,
   DEFAULT_CRON_JITTER_CONFIG: () => DEFAULT_CRON_JITTER_CONFIG,
+  DEFAULT_GOAL_CHECKIN_MINUTES: () => DEFAULT_GOAL_CHECKIN_MINUTES,
   DEFAULT_MAX_GOAL_TURNS: () => DEFAULT_MAX_GOAL_TURNS,
   DEFAULT_SESSION_MEMORY_CONFIG: () => DEFAULT_SESSION_MEMORY_CONFIG,
   DEFAULT_TASKS_MODE_TASK_LIST_ID: () => DEFAULT_TASKS_MODE_TASK_LIST_ID,
@@ -179754,6 +180044,7 @@ __export(exports_engineCompat, {
   GENERAL_PURPOSE_AGENT: () => GENERAL_PURPOSE_AGENT,
   GIT_NO_PROMPT_ENV: () => GIT_NO_PROMPT_ENV,
   GLOB_TOOL_NAME: () => GLOB_TOOL_NAME,
+  GOAL_CHECKIN_BACKOFF_MULTIPLIERS: () => GOAL_CHECKIN_BACKOFF_MULTIPLIERS,
   GREP_TOOL_NAME: () => GREP_TOOL_NAME,
   GlobTool: () => GlobTool,
   GrepTool: () => GrepTool,
@@ -179773,6 +180064,7 @@ __export(exports_engineCompat, {
   LocalShellTask: () => LocalShellTask,
   MANUAL_COMPACT_BUFFER_TOKENS: () => MANUAL_COMPACT_BUFFER_TOKENS,
   MAX_CONSECUTIVE_AUTOCOMPACT_FAILURES: () => MAX_CONSECUTIVE_AUTOCOMPACT_FAILURES,
+  MAX_GOAL_CHECKINS: () => MAX_GOAL_CHECKINS,
   MAX_GOAL_CONDITION_CHARS: () => MAX_GOAL_CONDITION_CHARS,
   MAX_PTL_RETRIES: () => MAX_PTL_RETRIES,
   MAX_TRANSCRIPT_READ_BYTES: () => MAX_TRANSCRIPT_READ_BYTES,
@@ -179870,9 +180162,11 @@ __export(exports_engineCompat, {
   builtInCommandNames: () => builtInCommandNames2,
   cacheSessionTitle: () => cacheSessionTitle,
   calculateTokenWarningState: () => calculateTokenWarningState,
+  canCheckIn: () => canCheckIn,
   captureHooksConfigSnapshot: () => captureHooksConfigSnapshot,
   check: () => check,
   claimTask: () => claimTask,
+  classifyGoalError: () => classifyGoalError,
   classifyToolError: () => classifyToolError,
   cleanMessagesForLogging: () => cleanMessagesForLogging,
   cleanupStaleAgentWorktrees: () => cleanupStaleAgentWorktrees,
@@ -180000,6 +180294,8 @@ __export(exports_engineCompat, {
   getCachedMCModulePort: () => getCachedMCModulePort,
   getCachedParsedFile: () => getCachedParsedFile,
   getCachedSettingsForSource: () => getCachedSettingsForSource,
+  getCheckInDelayMs: () => getCheckInDelayMs,
+  getCheckInStateForTesting: () => getCheckInStateForTesting,
   getCommandQueue: () => getCommandQueue,
   getCommandQueueLength: () => getCommandQueueLength,
   getCommandQueueSnapshot: () => getCommandQueueSnapshot,
@@ -180024,7 +180320,9 @@ __export(exports_engineCompat, {
   getEntrypoint: () => getEntrypoint,
   getFirstMeaningfulUserMessageTextContent: () => getFirstMeaningfulUserMessageTextContent,
   getGitBranch: () => getGitBranch,
+  getGoalCheckInMinutes: () => getGoalCheckInMinutes,
   getGoalCondition: () => getGoalCondition,
+  getGoalPausedReason: () => getGoalPausedReason,
   getGoalStateForPersistence: () => getGoalStateForPersistence,
   getHooksConfigFromSnapshot: () => getHooksConfigFromSnapshot,
   getInboxPath: () => getInboxPath,
@@ -180048,6 +180346,7 @@ __export(exports_engineCompat, {
   getPrompt: () => getPrompt,
   getPromptTooLongTokenGap: () => getPromptTooLongTokenGap,
   getRelativeSettingsFilePathForSource: () => getRelativeSettingsFilePathForSource,
+  getRemainingCheckIns: () => getRemainingCheckIns,
   getRunningTasks: () => getRunningTasks,
   getSchedulerEnv: () => getSchedulerEnv,
   getSessionContextPort: () => getSessionContextPort,
@@ -180086,9 +180385,13 @@ __export(exports_engineCompat, {
   getUserType: () => getUserType,
   getVersion: () => getVersion2,
   gitExe: () => gitExe,
+  goalCheckInPrompt: () => goalCheckInPrompt,
   goalClearedNotification: () => goalClearedNotification,
   goalContinuationReminder: () => goalContinuationReminder,
+  goalHookGateNotification: () => goalHookGateNotification,
   goalMetNotification: () => goalMetNotification,
+  goalPausedNotification: () => goalPausedNotification,
+  goalUnrecoverableNotification: () => goalUnrecoverableNotification,
   groupMessagesByApiRound: () => groupMessagesByApiRound,
   hasActiveInProcessTeammates: () => hasActiveInProcessTeammates,
   hasAutoModeOptIn: () => hasAutoModeOptIn,
@@ -180117,6 +180420,7 @@ __export(exports_engineCompat, {
   isEphemeralToolProgress: () => isEphemeralToolProgress,
   isForkSubagentEnabled: () => isForkSubagentEnabled,
   isGoalArmed: () => isGoalArmed,
+  isGoalPaused: () => isGoalPaused,
   isHumanTurn: () => isHumanTurn,
   isIdleNotification: () => isIdleNotification,
   isInForkChild: () => isInForkChild,
@@ -180231,6 +180535,7 @@ __export(exports_engineCompat, {
   parseWorktreeListPorcelain: () => parseWorktreeListPorcelain,
   partialCompactConversation: () => partialCompactConversation,
   partitionToolCalls: () => partitionToolCalls,
+  pauseGoal: () => pauseGoal,
   peek: () => peek,
   persistPermissionUpdate: () => persistPermissionUpdate,
   persistPermissionUpdates: () => persistPermissionUpdates,
@@ -180255,10 +180560,12 @@ __export(exports_engineCompat, {
   readWorktreeHeadSha: () => readWorktreeHeadSha,
   recheckCommandQueue: () => recheckCommandQueue,
   recheckPendingNotifications: () => recheckPendingNotifications,
+  recordCheckIn: () => recordCheckIn,
   recordContentReplacement: () => recordContentReplacement,
   recordExtractionTokenCount: () => recordExtractionTokenCount,
   recordSidechainTranscript: () => recordSidechainTranscript,
   recordTranscript: () => recordTranscript,
+  refreshOnUserMessage: () => refreshOnUserMessage,
   registerAgentForeground: () => registerAgentForeground,
   registerAsyncAgent: () => registerAsyncAgent,
   registerCleanup: () => registerCleanup2,
@@ -180276,6 +180583,7 @@ __export(exports_engineCompat, {
   reportAutoCompactCircuitFailures: () => reportAutoCompactCircuitFailures,
   resetAutoCompactCircuitForTesting: () => resetAutoCompactCircuitForTesting,
   resetBuiltinCommandNamesSourceForTesting: () => resetBuiltinCommandNamesSourceForTesting,
+  resetCheckInState: () => resetCheckInState,
   resetCommandQueue: () => resetCommandQueue,
   resetDomainMountForTests: () => resetDomainMountForTests,
   resetGoalStateForTesting: () => resetGoalStateForTesting,
@@ -180308,6 +180616,7 @@ __export(exports_engineCompat, {
   restoreGoalState: () => restoreGoalState,
   restoreSessionMetadata: () => restoreSessionMetadata,
   restoreWorktreeSession: () => restoreWorktreeSession,
+  resumeGoal: () => resumeGoal,
   roughTokenCountEstimation: () => roughTokenCountEstimation2,
   roughTokenCountEstimationForContent: () => roughTokenCountEstimationForContent,
   roughTokenCountEstimationForMessages: () => roughTokenCountEstimationForMessages,
@@ -366024,6 +366333,25 @@ var init_GlimmerMessage = __esm(() => {
   };
 });
 
+// src/tui/components/Spinner/spinnerGates.ts
+function getSpinnerDisplayGates(input) {
+  const { verbose, hasRunningTeammates, effectiveElapsedMs } = input;
+  const forceShow = verbose || hasRunningTeammates;
+  const wantsTimer = forceShow || effectiveElapsedMs > SHOW_TIMER_AFTER_MS;
+  return {
+    wantsTimer,
+    wantsTokens: forceShow || effectiveElapsedMs > SHOW_TOKENS_AFTER_MS,
+    wantsStatusIndicator: wantsTimer
+  };
+}
+function computeStallState(input) {
+  const { timeSinceLastToken, currentResponseLength, hasActiveTools } = input;
+  const isStalled = timeSinceLastToken > STALL_AFTER_MS && !hasActiveTools && currentResponseLength > 0;
+  const stalledIntensity = isStalled ? Math.min((timeSinceLastToken - STALL_AFTER_MS) / STALL_FADE_MS, 1) : 0;
+  return { isStalled, stalledIntensity };
+}
+var SHOW_TIMER_AFTER_MS = 1000, SHOW_TOKENS_AFTER_MS = 5000, STALL_AFTER_MS = 3000, STALL_FADE_MS = 2000;
+
 // src/tui/components/Spinner/useStalledAnimation.ts
 function useStalledAnimation(time, currentResponseLength, hasActiveTools = false, reducedMotion = false) {
   const lastTokenTime = import_react103.useRef(time);
@@ -366046,8 +366374,11 @@ function useStalledAnimation(time, currentResponseLength, hasActiveTools = false
   } else {
     timeSinceLastToken = time - mountTime.current;
   }
-  const isStalled = timeSinceLastToken > 3000 && !hasActiveTools;
-  const intensity = isStalled ? Math.min((timeSinceLastToken - 3000) / 2000, 1) : 0;
+  const { isStalled, stalledIntensity: intensity } = computeStallState({
+    timeSinceLastToken,
+    currentResponseLength,
+    hasActiveTools
+  });
   if (!reducedMotion && (intensity > 0 || stalledIntensityRef.current > 0)) {
     const dt = time - lastSmoothTime.current;
     if (dt >= 50) {
@@ -366076,17 +366407,6 @@ var init_useStalledAnimation = __esm(() => {
   import_react103 = __toESM(require_react(), 1);
 });
 
-// src/tui/components/Spinner/spinnerGates.ts
-function getSpinnerDisplayGates(input) {
-  const { verbose, hasRunningTeammates, effectiveElapsedMs } = input;
-  const forceShow = verbose || hasRunningTeammates;
-  return {
-    wantsTimer: forceShow || effectiveElapsedMs > SHOW_TIMER_AFTER_MS,
-    wantsTokens: forceShow || effectiveElapsedMs > SHOW_TOKENS_AFTER_MS
-  };
-}
-var SHOW_TIMER_AFTER_MS = 1000, SHOW_TOKENS_AFTER_MS = 5000;
-
 // src/tui/components/Spinner/SpinnerAnimationRow.tsx
 function SpinnerAnimationRow({
   mode,
@@ -366125,7 +366445,8 @@ function SpinnerAnimationRow({
   } = useStalledAnimation(time, currentResponseLength, hasActiveTools || leaderIsIdle, reducedMotion);
   const frame = reducedMotion ? 0 : Math.floor(time / 120);
   const glimmerSpeed = mode === "requesting" ? 50 : 200;
-  const glimmerMessageWidth = import_react104.useMemo(() => stringWidth2(message), [message]);
+  const displayMessage = mode === "requesting" ? message + "…" : message;
+  const glimmerMessageWidth = import_react104.useMemo(() => stringWidth2(displayMessage), [displayMessage]);
   const cycleLength = glimmerMessageWidth + 20;
   const cyclePosition = Math.floor(time / glimmerSpeed);
   const glimmerIndex = reducedMotion ? -100 : isStalled ? -100 : mode === "requesting" ? cyclePosition % cycleLength - 10 : glimmerMessageWidth + 10 - cyclePosition % cycleLength;
@@ -366161,7 +366482,7 @@ function SpinnerAnimationRow({
   const messageWidth = glimmerMessageWidth + 2;
   const sep = SEP_WIDTH;
   const wantsThinking = thinkingStatus !== null;
-  const { wantsTimer, wantsTokens } = getSpinnerDisplayGates({
+  const { wantsTimer, wantsTokens, wantsStatusIndicator } = getSpinnerDisplayGates({
     verbose,
     hasRunningTeammates,
     effectiveElapsedMs
@@ -366179,7 +366500,8 @@ function SpinnerAnimationRow({
   const showTimer = wantsTimer && availableSpace > usedAfterThinking + timerWidth;
   const usedAfterTimer = usedAfterThinking + (showTimer ? timerWidth + sep : 0);
   const showTokens = wantsTokens && totalTokens > 0 && availableSpace > usedAfterTimer + tokensWidth;
-  const thinkingOnly = showThinking && thinkingStatus === "thinking" && !spinnerSuffix && !showTimer && !showTokens && true;
+  const showStatusIndicator = !showTokens && wantsStatusIndicator && mode === "requesting" && !hasRunningTeammates && availableSpace > usedAfterTimer + 2;
+  const thinkingOnly = showThinking && thinkingStatus === "thinking" && !spinnerSuffix && !showTimer && !showTokens && !showStatusIndicator && true;
   const thinkingElapsedSec = (time - THINKING_DELAY_MS) / 1000;
   const thinkingOpacity = time < THINKING_DELAY_MS ? 0 : (Math.sin(thinkingElapsedSec * Math.PI * 2 / THINKING_GLOW_PERIOD_S) + 1) / 2;
   const thinkingShimmerColor = toRGBColor(interpolateColor(THINKING_INACTIVE, THINKING_INACTIVE_SHIMMER, thinkingOpacity));
@@ -366203,7 +366525,9 @@ function SpinnerAnimationRow({
         ]
       }, undefined, true, undefined, this)
     ]
-  }, "tokens", true, undefined, this)] : [], ...showThinking && thinkingText ? [thinkingStatus === "thinking" && !reducedMotion ? /* @__PURE__ */ jsx_dev_runtime184.jsxDEV(ThemedText, {
+  }, "tokens", true, undefined, this)] : [], ...showStatusIndicator ? [/* @__PURE__ */ jsx_dev_runtime184.jsxDEV(SpinnerModeGlyph, {
+    mode
+  }, "statusGlyph", false, undefined, this)] : [], ...showThinking && thinkingText ? [thinkingStatus === "thinking" && !reducedMotion ? /* @__PURE__ */ jsx_dev_runtime184.jsxDEV(ThemedText, {
     color: thinkingShimmerColor,
     children: thinkingOnly ? `(${thinkingText})` : thinkingText
   }, "thinking", false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime184.jsxDEV(ThemedText, {
@@ -366257,7 +366581,7 @@ function SpinnerAnimationRow({
         time
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime184.jsxDEV(GlimmerMessage, {
-        message,
+        message: displayMessage,
         mode,
         messageColor,
         glimmerIndex,
@@ -411296,7 +411620,7 @@ var init_output_style2 = __esm(() => {
 });
 
 // src/tui/components/GoalOverlay.tsx
-function GoalOverlay({
+function GoalOverlayInner({
   armed,
   condition,
   turns,
@@ -411335,11 +411659,13 @@ function GoalOverlay({
     ]
   }, undefined, true, undefined, this);
 }
-var jsx_dev_runtime296;
+var React87, jsx_dev_runtime296, GoalOverlay;
 var init_GoalOverlay = __esm(() => {
   init_ink2();
   init_format2();
+  React87 = __toESM(require_react(), 1);
   jsx_dev_runtime296 = __toESM(require_jsx_dev_runtime(), 1);
+  GoalOverlay = React87.memo(GoalOverlayInner);
 });
 
 // src/tui/commands/goal/goal.tsx
@@ -414009,7 +414335,7 @@ function SetModelAndClose({
 }) {
   const setAppState = useSetAppState();
   const model = args === "default" ? null : args;
-  React90.useEffect(() => {
+  React91.useEffect(() => {
     async function handleModelChange() {
       if (model && !isModelAllowed(model)) {
         onDone(`Model '${model}' is not available. Your organization restricts model selection.`, {
@@ -414096,7 +414422,7 @@ function renderModelLabel(model) {
   const rendered = renderDefaultModelSetting(model ?? getDefaultMainLoopModelSetting());
   return model === null ? `${rendered} (default)` : rendered;
 }
-var import_compiler_runtime237, React90, jsx_dev_runtime309, call57 = async (onDone, _context, args) => {
+var import_compiler_runtime237, React91, jsx_dev_runtime309, call57 = async (onDone, _context, args) => {
   args = args?.trim() || "";
   if (COMMON_INFO_ARGS.includes(args)) {
     return /* @__PURE__ */ jsx_dev_runtime309.jsxDEV(ShowModelAndClose, {
@@ -414131,7 +414457,7 @@ var init_model2 = __esm(() => {
   init_validateModel();
   init_modelSwitchHooks();
   import_compiler_runtime237 = __toESM(require_compiler_runtime(), 1);
-  React90 = __toESM(require_react(), 1);
+  React91 = __toESM(require_react(), 1);
   jsx_dev_runtime309 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
@@ -414239,8 +414565,8 @@ function ToggleTagAndClose(t0) {
     tagName,
     onDone
   } = t0;
-  const [showConfirm, setShowConfirm] = React91.useState(false);
-  const [sessionId, setSessionId] = React91.useState(null);
+  const [showConfirm, setShowConfirm] = React92.useState(false);
+  const [sessionId, setSessionId] = React92.useState(null);
   let t1;
   if ($[0] !== tagName) {
     t1 = recursivelySanitizeUnicode2(tagName).trim();
@@ -414291,7 +414617,7 @@ function ToggleTagAndClose(t0) {
     t2 = $[4];
     t3 = $[5];
   }
-  React91.useEffect(t2, t3);
+  React92.useEffect(t2, t3);
   if (showConfirm && sessionId) {
     let t4;
     if ($[6] !== normalizedTag || $[7] !== onDone || $[8] !== sessionId) {
@@ -414371,7 +414697,7 @@ Examples:
     t1 = $[1];
     t2 = $[2];
   }
-  React91.useEffect(t1, t2);
+  React92.useEffect(t1, t2);
   return null;
 }
 async function call58(onDone, _context, args) {
@@ -414391,7 +414717,7 @@ async function call58(onDone, _context, args) {
     onDone
   }, undefined, false, undefined, this);
 }
-var import_compiler_runtime238, React91, jsx_dev_runtime310;
+var import_compiler_runtime238, React92, jsx_dev_runtime310;
 var init_tag = __esm(() => {
   init_source2();
   init_bootstrap();
@@ -414401,7 +414727,7 @@ var init_tag = __esm(() => {
   init_ink2();
   init_sessionStorage();
   import_compiler_runtime238 = __toESM(require_compiler_runtime(), 1);
-  React91 = __toESM(require_react(), 1);
+  React92 = __toESM(require_react(), 1);
   jsx_dev_runtime310 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
@@ -414592,7 +414918,7 @@ function ApplyEffortAndClose(t0) {
     t1 = $[4];
     t2 = $[5];
   }
-  React92.useEffect(t1, t2);
+  React93.useEffect(t1, t2);
   return null;
 }
 async function call59(onDone, _context, args) {
@@ -414620,14 +414946,14 @@ Effort levels:
     onDone
   }, undefined, false, undefined, this);
 }
-var import_compiler_runtime239, React92, jsx_dev_runtime311, COMMON_HELP_ARGS2;
+var import_compiler_runtime239, React93, jsx_dev_runtime311, COMMON_HELP_ARGS2;
 var init_effort3 = __esm(() => {
   init_useMainLoopModel();
   init_AppState();
   init_effort2();
   init_settings3();
   import_compiler_runtime239 = __toESM(require_compiler_runtime(), 1);
-  React92 = __toESM(require_react(), 1);
+  React93 = __toESM(require_react(), 1);
   jsx_dev_runtime311 = __toESM(require_jsx_dev_runtime(), 1);
   COMMON_HELP_ARGS2 = ["help", "-h", "--help"];
 });
@@ -449960,7 +450286,7 @@ function AutoUpdater({
   }, []);
   const isUpdatingRef = import_react204.useRef(isUpdating);
   isUpdatingRef.current = isUpdating;
-  const checkForUpdates = React109.useCallback(async () => {
+  const checkForUpdates = React110.useCallback(async () => {
     if (isUpdatingRef.current) {
       return;
     }
@@ -450091,7 +450417,7 @@ function AutoUpdater({
     ]
   }, undefined, true, undefined, this);
 }
-var React109, import_react204, jsx_dev_runtime358;
+var React110, import_react204, jsx_dev_runtime358;
 var init_AutoUpdater = __esm(() => {
   init_dist3();
   init_useUpdateNotification();
@@ -450103,7 +450429,7 @@ var init_AutoUpdater = __esm(() => {
   init_localInstaller();
   init_nativeInstaller();
   init_settings3();
-  React109 = __toESM(require_react(), 1);
+  React110 = __toESM(require_react(), 1);
   import_react204 = __toESM(require_react(), 1);
   jsx_dev_runtime358 = __toESM(require_jsx_dev_runtime(), 1);
 });
@@ -450147,7 +450473,7 @@ function NativeAutoUpdater({
   const channel = getInitialSettings2()?.autoUpdatesChannel ?? "latest";
   const isUpdatingRef = import_react205.useRef(isUpdating);
   isUpdatingRef.current = isUpdating;
-  const checkForUpdates = React110.useCallback(async () => {
+  const checkForUpdates = React111.useCallback(async () => {
     if (isUpdatingRef.current) {
       return;
     }
@@ -450243,7 +450569,7 @@ function NativeAutoUpdater({
     ]
   }, undefined, true, undefined, this);
 }
-var React110, import_react205, jsx_dev_runtime359;
+var React111, import_react205, jsx_dev_runtime359;
 var init_NativeAutoUpdater = __esm(() => {
   init_debug();
   init_log5();
@@ -450254,7 +450580,7 @@ var init_NativeAutoUpdater = __esm(() => {
   init_config6();
   init_nativeInstaller();
   init_settings3();
-  React110 = __toESM(require_react(), 1);
+  React111 = __toESM(require_react(), 1);
   import_react205 = __toESM(require_react(), 1);
   jsx_dev_runtime359 = __toESM(require_jsx_dev_runtime(), 1);
 });
@@ -450310,7 +450636,7 @@ function PackageManagerAutoUpdater(t0) {
     t2 = $[1];
     t3 = $[2];
   }
-  React111.useEffect(t2, t3);
+  React112.useEffect(t2, t3);
   useInterval(checkForUpdates, 1800000);
   if (!updateAvailable) {
     return null;
@@ -450365,7 +450691,7 @@ function PackageManagerAutoUpdater(t0) {
   }
   return t6;
 }
-var import_compiler_runtime278, React111, import_react206, jsx_dev_runtime360;
+var import_compiler_runtime278, React112, import_react206, jsx_dev_runtime360;
 var init_PackageManagerAutoUpdater = __esm(() => {
   init_dist3();
   init_ink2();
@@ -450375,7 +450701,7 @@ var init_PackageManagerAutoUpdater = __esm(() => {
   init_packageManagers();
   init_settings3();
   import_compiler_runtime278 = __toESM(require_compiler_runtime(), 1);
-  React111 = __toESM(require_react(), 1);
+  React112 = __toESM(require_react(), 1);
   import_react206 = __toESM(require_react(), 1);
   jsx_dev_runtime360 = __toESM(require_jsx_dev_runtime(), 1);
 });
@@ -450391,8 +450717,8 @@ function AutoUpdaterWrapper(t0) {
     showSuccessMessage,
     verbose
   } = t0;
-  const [useNativeInstaller, setUseNativeInstaller] = React112.useState(null);
-  const [isPackageManager, setIsPackageManager] = React112.useState(null);
+  const [useNativeInstaller, setUseNativeInstaller] = React113.useState(null);
+  const [isPackageManager, setIsPackageManager] = React113.useState(null);
   let t1;
   let t2;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
@@ -450416,7 +450742,7 @@ function AutoUpdaterWrapper(t0) {
     t1 = $[0];
     t2 = $[1];
   }
-  React112.useEffect(t1, t2);
+  React113.useEffect(t1, t2);
   if (useNativeInstaller === null || isPackageManager === null) {
     return null;
   }
@@ -450467,7 +450793,7 @@ function AutoUpdaterWrapper(t0) {
   }
   return t3;
 }
-var import_compiler_runtime279, React112, jsx_dev_runtime361;
+var import_compiler_runtime279, React113, jsx_dev_runtime361;
 var init_AutoUpdaterWrapper = __esm(() => {
   init_shared();
   init_config6();
@@ -450477,7 +450803,7 @@ var init_AutoUpdaterWrapper = __esm(() => {
   init_NativeAutoUpdater();
   init_PackageManagerAutoUpdater();
   import_compiler_runtime279 = __toESM(require_compiler_runtime(), 1);
-  React112 = __toESM(require_react(), 1);
+  React113 = __toESM(require_react(), 1);
   jsx_dev_runtime361 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
@@ -455748,7 +456074,7 @@ function useCoordinatorTaskCount() {
 function _temp164(s) {
   return s.tasks;
 }
-var import_compiler_runtime286, React115;
+var import_compiler_runtime286, React116;
 var init_CoordinatorAgentStatus = __esm(() => {
   init_figures2();
   init_useTerminalSize();
@@ -455761,7 +456087,7 @@ var init_CoordinatorAgentStatus = __esm(() => {
   init_framework2();
   init_taskStatusUtils();
   import_compiler_runtime286 = __toESM(require_compiler_runtime(), 1);
-  React115 = __toESM(require_react(), 1);
+  React116 = __toESM(require_react(), 1);
 });
 
 // src/tui/utils/highlightMatch.tsx
@@ -459535,9 +459861,9 @@ var init_gitStore = __esm(() => {
 });
 
 // src/tui/components/StatusLine/segments/GitBranchSegment.tsx
-var React118, import_react225, jsx_dev_runtime387, GitBranchSegment = () => {
+var React119, import_react225, jsx_dev_runtime387, GitBranchSegment = () => {
   const gitState = import_react225.useSyncExternalStore(subscribeToGitState, getGitSnapshot);
-  const ref = React118.useRef(false);
+  const ref = React119.useRef(false);
   if (!ref.current) {
     ref.current = true;
     refreshGitState();
@@ -459565,15 +459891,15 @@ var React118, import_react225, jsx_dev_runtime387, GitBranchSegment = () => {
 var init_GitBranchSegment = __esm(() => {
   init_ink2();
   init_gitStore();
-  React118 = __toESM(require_react(), 1);
+  React119 = __toESM(require_react(), 1);
   import_react225 = __toESM(require_react(), 1);
   jsx_dev_runtime387 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
 // src/tui/components/StatusLine/segments/GitFilesSegment.tsx
-var React119, import_react226, jsx_dev_runtime388, GitFilesSegment = () => {
+var React120, import_react226, jsx_dev_runtime388, GitFilesSegment = () => {
   const gitState = import_react226.useSyncExternalStore(subscribeToGitState, getGitSnapshot);
-  const ref = React119.useRef(false);
+  const ref = React120.useRef(false);
   if (!ref.current) {
     ref.current = true;
     refreshGitState();
@@ -459595,15 +459921,15 @@ var React119, import_react226, jsx_dev_runtime388, GitFilesSegment = () => {
 var init_GitFilesSegment = __esm(() => {
   init_ink2();
   init_gitStore();
-  React119 = __toESM(require_react(), 1);
+  React120 = __toESM(require_react(), 1);
   import_react226 = __toESM(require_react(), 1);
   jsx_dev_runtime388 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
 // src/tui/components/StatusLine/segments/GitCombinedSegment.tsx
-var React120, import_react227, jsx_dev_runtime389, GitCombinedSegment = () => {
+var React121, import_react227, jsx_dev_runtime389, GitCombinedSegment = () => {
   const gitState = import_react227.useSyncExternalStore(subscribeToGitState, getGitSnapshot);
-  const ref = React120.useRef(false);
+  const ref = React121.useRef(false);
   if (!ref.current) {
     ref.current = true;
     refreshGitState();
@@ -459632,7 +459958,7 @@ var React120, import_react227, jsx_dev_runtime389, GitCombinedSegment = () => {
 var init_GitCombinedSegment = __esm(() => {
   init_ink2();
   init_gitStore();
-  React120 = __toESM(require_react(), 1);
+  React121 = __toESM(require_react(), 1);
   import_react227 = __toESM(require_react(), 1);
   jsx_dev_runtime389 = __toESM(require_jsx_dev_runtime(), 1);
 });
@@ -459780,18 +460106,27 @@ var init_SessionDurationSegment = __esm(() => {
 });
 
 // src/tui/components/StatusLine/segments/GoalSegment.tsx
-var jsx_dev_runtime395, GOAL_PREFIX = "\uD83C\uDFAF ", MAX_GOAL_DISPLAY_CHARS = 40, GoalSegment = () => {
-  if (!isGoalArmed())
-    return null;
-  const condition = getGoalCondition() ?? "";
-  const truncated = truncateToWidth3(condition, MAX_GOAL_DISPLAY_CHARS);
-  return /* @__PURE__ */ jsx_dev_runtime395.jsxDEV(ThemedText, {
-    color: "yellow",
-    children: [
-      GOAL_PREFIX,
-      truncated
-    ]
-  }, undefined, true, undefined, this);
+var jsx_dev_runtime395, GOAL_PREFIX = "\uD83C\uDFAF ", MAX_GOAL_DISPLAY_CHARS = 40, _cachedArmed = false, _cachedCondition, _cachedNode = null, GoalSegment = () => {
+  const armed = isGoalArmed();
+  const condition = getGoalCondition();
+  if (armed === _cachedArmed && condition === _cachedCondition) {
+    return _cachedNode;
+  }
+  _cachedArmed = armed;
+  _cachedCondition = condition;
+  if (!armed) {
+    _cachedNode = null;
+  } else {
+    const truncated = truncateToWidth3(condition ?? "", MAX_GOAL_DISPLAY_CHARS);
+    _cachedNode = /* @__PURE__ */ jsx_dev_runtime395.jsxDEV(ThemedText, {
+      color: "yellow",
+      children: [
+        GOAL_PREFIX,
+        truncated
+      ]
+    }, undefined, true, undefined, this);
+  }
+  return _cachedNode;
 };
 var init_GoalSegment = __esm(() => {
   init_ink2();
@@ -460219,9 +460554,9 @@ function StatusLineInner({
       ]
     }, undefined, true, undefined, this);
   }
-  const handleMouseEnter = React121.useCallback(() => setHover(true), []);
-  const handleMouseLeave = React121.useCallback(() => setHover(false), []);
-  const handleClick = React121.useCallback(() => toggleDensity(), []);
+  const handleMouseEnter = React122.useCallback(() => setHover(true), []);
+  const handleMouseLeave = React122.useCallback(() => setHover(false), []);
+  const handleClick = React122.useCallback(() => toggleDensity(), []);
   const hoverHint = hovered && useChannelB ? /* @__PURE__ */ jsx_dev_runtime396.jsxDEV(ThemedText, {
     dimColor: true,
     children: [
@@ -460250,7 +460585,7 @@ function StatusLineInner({
     ]
   }, undefined, true, undefined, this);
 }
-var React121, import_react228, jsx_dev_runtime396, StatusLine;
+var React122, import_react228, jsx_dev_runtime396, StatusLine;
 var init_StatusLine = __esm(() => {
   init_AppState();
   init_bootstrap();
@@ -460277,7 +460612,7 @@ var init_StatusLine = __esm(() => {
   init_statusLineConfig();
   init_densityStore();
   init_useTerminalSize();
-  React121 = __toESM(require_react(), 1);
+  React122 = __toESM(require_react(), 1);
   import_react228 = __toESM(require_react(), 1);
   jsx_dev_runtime396 = __toESM(require_jsx_dev_runtime(), 1);
   StatusLine = import_react228.memo(StatusLineInner);
@@ -460627,7 +460962,7 @@ function BackgroundTaskStatus(t0) {
     if ($[25] !== selectedIdx || $[26] !== setAppState || $[27] !== viewedIdx || $[28] !== visiblePills) {
       t13 = visiblePills.map((pill_1, i_1) => {
         const needsSeparator = i_1 > 0;
-        return /* @__PURE__ */ jsx_dev_runtime398.jsxDEV(React122.Fragment, {
+        return /* @__PURE__ */ jsx_dev_runtime398.jsxDEV(React123.Fragment, {
           children: [
             needsSeparator && /* @__PURE__ */ jsx_dev_runtime398.jsxDEV(ThemedText, {
               children: " "
@@ -460997,7 +461332,7 @@ function getAgentThemeColor(colorName) {
   }
   return;
 }
-var import_compiler_runtime293, React122, import_react231, jsx_dev_runtime398;
+var import_compiler_runtime293, React123, import_react231, jsx_dev_runtime398;
 var init_BackgroundTaskStatus = __esm(() => {
   init_figures();
   init_useTerminalSize();
@@ -461012,7 +461347,7 @@ var init_BackgroundTaskStatus = __esm(() => {
   init_KeyboardShortcutHint();
   init_taskStatusUtils();
   import_compiler_runtime293 = __toESM(require_compiler_runtime(), 1);
-  React122 = __toESM(require_react(), 1);
+  React123 = __toESM(require_react(), 1);
   import_react231 = __toESM(require_react(), 1);
   jsx_dev_runtime398 = __toESM(require_jsx_dev_runtime(), 1);
 });
@@ -462123,7 +462458,7 @@ function PromptInputQueuedCommandsImpl() {
     }, i, false, undefined, this))
   }, undefined, false, undefined, this);
 }
-var React123, import_react235, jsx_dev_runtime404, EMPTY_SET2, MAX_VISIBLE_NOTIFICATIONS = 3, PromptInputQueuedCommands;
+var React124, import_react235, jsx_dev_runtime404, EMPTY_SET2, MAX_VISIBLE_NOTIFICATIONS = 3, PromptInputQueuedCommands;
 var init_PromptInputQueuedCommands = __esm(() => {
   init_ink2();
   init_AppState();
@@ -462134,11 +462469,11 @@ var init_PromptInputQueuedCommands = __esm(() => {
   init_messages3();
   init_slowOperations();
   init_Message();
-  React123 = __toESM(require_react(), 1);
+  React124 = __toESM(require_react(), 1);
   import_react235 = __toESM(require_react(), 1);
   jsx_dev_runtime404 = __toESM(require_jsx_dev_runtime(), 1);
   EMPTY_SET2 = new Set;
-  PromptInputQueuedCommands = React123.memo(PromptInputQueuedCommandsImpl);
+  PromptInputQueuedCommands = React124.memo(PromptInputQueuedCommandsImpl);
 });
 
 // src/tui/components/PromptInput/PromptInputStashNotice.tsx
@@ -462455,8 +462790,8 @@ function useSwarmBanner() {
   const agent = useAppState((s) => s.agent);
   useAppState((s) => s.viewingAgentTaskId);
   const store = useAppStateStore();
-  const [insideTmux, setInsideTmux] = React124.useState(null);
-  React124.useEffect(() => {
+  const [insideTmux, setInsideTmux] = React125.useState(null);
+  React125.useEffect(() => {
     isInsideTmux3().then(setInsideTmux);
   }, []);
   const state = store.getState();
@@ -462523,7 +462858,7 @@ function useSwarmBanner() {
 function toThemeColor(colorName, fallback = "cyan_FOR_SUBAGENTS_ONLY") {
   return colorName && AGENT_COLORS2.includes(colorName) ? AGENT_COLOR_TO_THEME_COLOR[colorName] : fallback;
 }
-var React124;
+var React125;
 var init_useSwarmBanner = __esm(() => {
   init_AppState();
   init_selectors();
@@ -462533,7 +462868,7 @@ var init_useSwarmBanner = __esm(() => {
   init_registry3();
   init_teammate2();
   init_teammateContext3();
-  React124 = __toESM(require_react(), 1);
+  React125 = __toESM(require_react(), 1);
 });
 
 // src/tui/components/PromptInput/PromptInput.tsx
@@ -462589,12 +462924,12 @@ function PromptInput({
     show: false
   });
   const [cursorOffset, setCursorOffset] = import_react238.useState(input.length);
-  const lastInternalInputRef = React125.useRef(input);
+  const lastInternalInputRef = React126.useRef(input);
   if (input !== lastInternalInputRef.current) {
     setCursorOffset(input.length);
     lastInternalInputRef.current = input;
   }
-  const trackAndSetInput = React125.useCallback((value) => {
+  const trackAndSetInput = React126.useCallback((value) => {
     lastInternalInputRef.current = value;
     onInputChange(value);
   }, [onInputChange]);
@@ -464249,7 +464584,7 @@ function getInitialPasteId(messages) {
   }
   return maxId + 1;
 }
-var React125, import_react238, jsx_dev_runtime406, PROMPT_FOOTER_LINES = 5, MIN_INPUT_VIEWPORT_LINES = 3, PromptInput_default;
+var React126, import_react238, jsx_dev_runtime406, PROMPT_FOOTER_LINES = 5, MIN_INPUT_VIEWPORT_LINES = 3, PromptInput_default;
 var init_PromptInput = __esm(() => {
   init_shared();
   init_notifications();
@@ -464336,10 +464671,10 @@ var init_PromptInput = __esm(() => {
   init_usePromptInputPlaceholder();
   init_useSwarmBanner();
   init_utils11();
-  React125 = __toESM(require_react(), 1);
+  React126 = __toESM(require_react(), 1);
   import_react238 = __toESM(require_react(), 1);
   jsx_dev_runtime406 = __toESM(require_jsx_dev_runtime(), 1);
-  PromptInput_default = React125.memo(PromptInput);
+  PromptInput_default = React126.memo(PromptInput);
 });
 
 // src/tui/utils/hooks/apiQueryHookHelper.ts
@@ -472574,7 +472909,7 @@ function useLspInitializationNotification() {
     addNotification
   } = useNotifications();
   const setAppState = useSetAppState();
-  const [shouldPoll, setShouldPoll] = React126.useState(_temp183);
+  const [shouldPoll, setShouldPoll] = React127.useState(_temp183);
   let t0;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     t0 = new Set;
@@ -472582,7 +472917,7 @@ function useLspInitializationNotification() {
   } else {
     t0 = $[0];
   }
-  const notifiedErrorsRef = React126.useRef(t0);
+  const notifiedErrorsRef = React127.useRef(t0);
   let t1;
   if ($[1] !== addNotification || $[2] !== setAppState) {
     t1 = (source, errorMessage) => {
@@ -472693,7 +473028,7 @@ function useLspInitializationNotification() {
     t3 = $[8];
     t4 = $[9];
   }
-  React126.useEffect(t3, t4);
+  React127.useEffect(t3, t4);
 }
 function _temp280(e) {
   if (e.type === "generic-error") {
@@ -472704,7 +473039,7 @@ function _temp280(e) {
 function _temp183() {
   return isEnvTruthy2("true");
 }
-var import_compiler_runtime308, React126, jsx_dev_runtime418, LSP_POLL_INTERVAL_MS = 5000;
+var import_compiler_runtime308, React127, jsx_dev_runtime418, LSP_POLL_INTERVAL_MS = 5000;
 var init_useLspInitializationNotification = __esm(() => {
   init_dist3();
   init_bootstrapState();
@@ -472715,7 +473050,7 @@ var init_useLspInitializationNotification = __esm(() => {
   init_debug();
   init_envUtils2();
   import_compiler_runtime308 = __toESM(require_compiler_runtime(), 1);
-  React126 = __toESM(require_react(), 1);
+  React127 = __toESM(require_react(), 1);
   jsx_dev_runtime418 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
@@ -472928,8 +473263,8 @@ var init_lspRecommendation = __esm(() => {
 // src/tui/hooks/usePluginRecommendationBase.tsx
 function usePluginRecommendationBase() {
   const $ = import_compiler_runtime309.c(6);
-  const [recommendation, setRecommendation] = React127.useState(null);
-  const isCheckingRef = React127.useRef(false);
+  const [recommendation, setRecommendation] = React128.useState(null);
+  const isCheckingRef = React128.useRef(false);
   let t0;
   if ($[0] !== recommendation) {
     t0 = (resolve) => {
@@ -473017,7 +473352,7 @@ async function installPluginAndNotify(pluginId, pluginName, keyPrefix, addNotifi
     });
   }
 }
-var import_compiler_runtime309, React127, jsx_dev_runtime419;
+var import_compiler_runtime309, React128, jsx_dev_runtime419;
 var init_usePluginRecommendationBase = __esm(() => {
   init_figures();
   init_bootstrapState();
@@ -473025,7 +473360,7 @@ var init_usePluginRecommendationBase = __esm(() => {
   init_log5();
   init_marketplaceManager();
   import_compiler_runtime309 = __toESM(require_compiler_runtime(), 1);
-  React127 = __toESM(require_react(), 1);
+  React128 = __toESM(require_react(), 1);
   jsx_dev_runtime419 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
@@ -473044,7 +473379,7 @@ function useLspPluginRecommendation() {
   } else {
     t0 = $[0];
   }
-  const checkedFilesRef = React128.useRef(t0);
+  const checkedFilesRef = React129.useRef(t0);
   const {
     recommendation,
     clearRecommendation,
@@ -473097,7 +473432,7 @@ function useLspPluginRecommendation() {
     t1 = $[3];
     t2 = $[4];
   }
-  React128.useEffect(t1, t2);
+  React129.useEffect(t1, t2);
   let t3;
   if ($[5] !== addNotification || $[6] !== clearRecommendation || $[7] !== recommendation) {
     t3 = (response) => {
@@ -473180,7 +473515,7 @@ function _temp281(current) {
 function _temp184(s) {
   return s.fileHistory.trackedFiles;
 }
-var import_compiler_runtime310, React128, TIMEOUT_THRESHOLD_MS = 28000;
+var import_compiler_runtime310, React129, TIMEOUT_THRESHOLD_MS = 28000;
 var init_useLspPluginRecommendation = __esm(() => {
   init_bootstrapState();
   init_notifications();
@@ -473193,7 +473528,7 @@ var init_useLspPluginRecommendation = __esm(() => {
   init_settings3();
   init_usePluginRecommendationBase();
   import_compiler_runtime310 = __toESM(require_compiler_runtime(), 1);
-  React128 = __toESM(require_react(), 1);
+  React129 = __toESM(require_react(), 1);
 });
 
 // src/tui/components/LspRecommendation/LspRecommendationMenu.tsx
@@ -473203,9 +473538,9 @@ function LspRecommendationMenu({
   fileExtension,
   onResponse
 }) {
-  const onResponseRef = React129.useRef(onResponse);
+  const onResponseRef = React130.useRef(onResponse);
   onResponseRef.current = onResponse;
-  React129.useEffect(() => {
+  React130.useEffect(() => {
     const timeoutId = setTimeout((ref) => ref.current("no"), AUTO_DISMISS_MS, onResponseRef);
     return () => clearTimeout(timeoutId);
   }, []);
@@ -473320,19 +473655,19 @@ function LspRecommendationMenu({
     }, undefined, true, undefined, this)
   }, undefined, false, undefined, this);
 }
-var React129, jsx_dev_runtime420, AUTO_DISMISS_MS = 30000;
+var React130, jsx_dev_runtime420, AUTO_DISMISS_MS = 30000;
 var init_LspRecommendationMenu = __esm(() => {
   init_ink2();
   init_select();
   init_PermissionDialog();
-  React129 = __toESM(require_react(), 1);
+  React130 = __toESM(require_react(), 1);
   jsx_dev_runtime420 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
 // src/tui/hooks/useAtlasCodeHintRecommendation.tsx
 function useAtlasCodeHintRecommendation() {
   const $ = import_compiler_runtime311.c(11);
-  const pendingHint = React130.useSyncExternalStore(subscribeToPendingHint, getPendingHintSnapshot);
+  const pendingHint = React131.useSyncExternalStore(subscribeToPendingHint, getPendingHintSnapshot);
   const {
     addNotification
   } = useNotifications();
@@ -473369,7 +473704,7 @@ function useAtlasCodeHintRecommendation() {
     t0 = $[2];
     t1 = $[3];
   }
-  React130.useEffect(t0, t1);
+  React131.useEffect(t0, t1);
   let t2;
   if ($[4] !== addNotification || $[5] !== clearRecommendation || $[6] !== recommendation) {
     t2 = (response) => {
@@ -473429,7 +473764,7 @@ function useAtlasCodeHintRecommendation() {
   }
   return t3;
 }
-var import_compiler_runtime311, React130;
+var import_compiler_runtime311, React131;
 var init_useAtlasCodeHintRecommendation = __esm(() => {
   init_notifications();
   init_atlasCodeHints();
@@ -473438,7 +473773,7 @@ var init_useAtlasCodeHintRecommendation = __esm(() => {
   init_pluginInstallationHelpers();
   init_usePluginRecommendationBase();
   import_compiler_runtime311 = __toESM(require_compiler_runtime(), 1);
-  React130 = __toESM(require_react(), 1);
+  React131 = __toESM(require_react(), 1);
 });
 
 // src/tui/components/PluginHint/PluginHintMenu.tsx
@@ -473449,9 +473784,9 @@ function PluginHintMenu({
   sourceCommand,
   onResponse
 }) {
-  const onResponseRef = React131.useRef(onResponse);
+  const onResponseRef = React132.useRef(onResponse);
   onResponseRef.current = onResponse;
-  React131.useEffect(() => {
+  React132.useEffect(() => {
     const timeoutId = setTimeout((ref) => ref.current("no"), AUTO_DISMISS_MS2, onResponseRef);
     return () => clearTimeout(timeoutId);
   }, []);
@@ -473557,12 +473892,12 @@ function PluginHintMenu({
     }, undefined, true, undefined, this)
   }, undefined, false, undefined, this);
 }
-var React131, jsx_dev_runtime421, AUTO_DISMISS_MS2 = 30000;
+var React132, jsx_dev_runtime421, AUTO_DISMISS_MS2 = 30000;
 var init_PluginHintMenu = __esm(() => {
   init_ink2();
   init_select();
   init_PermissionDialog();
-  React131 = __toESM(require_react(), 1);
+  React132 = __toESM(require_react(), 1);
   jsx_dev_runtime421 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
@@ -475157,31 +475492,31 @@ function SessionTreeScreen({
   onResume,
   onAgenticSearch
 }) {
-  const [logs, setLogs] = React134.useState([]);
-  const [loading, setLoading] = React134.useState(true);
-  const [focusedIdx, setFocusedIdx] = React134.useState(0);
-  const [selectedIdx, setSelectedIdx] = React134.useState(null);
-  const [rowStates, setRowStates] = React134.useState(new Map);
-  const [scrollOffset, setScrollOffset] = React134.useState(0);
-  const [expanded, setExpanded] = React134.useState(false);
+  const [logs, setLogs] = React135.useState([]);
+  const [loading, setLoading] = React135.useState(true);
+  const [focusedIdx, setFocusedIdx] = React135.useState(0);
+  const [selectedIdx, setSelectedIdx] = React135.useState(null);
+  const [rowStates, setRowStates] = React135.useState(new Map);
+  const [scrollOffset, setScrollOffset] = React135.useState(0);
+  const [expanded, setExpanded] = React135.useState(false);
   const expandedIdx = expanded ? focusedIdx : null;
-  const [searchMode, setSearchMode] = React134.useState(false);
-  const [query, setQuery] = React134.useState("");
-  const [sortKey, setSortKey] = React134.useState("modified");
-  const [agenticResults, setAgenticResults] = React134.useState(null);
-  const exactCountCacheRef = React134.useRef(makeLru(64));
-  const [, bumpExactCounts] = React134.useReducer((x) => x + 1, 0);
-  const confirmTimerRef = React134.useRef(null);
-  const forkInFlightRef = React134.useRef(false);
-  const fileMetaCacheRef = React134.useRef(new Map);
-  const setRowState = React134.useCallback((sid, s) => {
+  const [searchMode, setSearchMode] = React135.useState(false);
+  const [query, setQuery] = React135.useState("");
+  const [sortKey, setSortKey] = React135.useState("modified");
+  const [agenticResults, setAgenticResults] = React135.useState(null);
+  const exactCountCacheRef = React135.useRef(makeLru(64));
+  const [, bumpExactCounts] = React135.useReducer((x) => x + 1, 0);
+  const confirmTimerRef = React135.useRef(null);
+  const forkInFlightRef = React135.useRef(false);
+  const fileMetaCacheRef = React135.useRef(new Map);
+  const setRowState = React135.useCallback((sid, s) => {
     setRowStates((prev) => {
       const next = new Map(prev);
       next.set(sid, s);
       return next;
     });
   }, []);
-  const loadLogs = React134.useCallback(async () => {
+  const loadLogs = React135.useCallback(async () => {
     const wt = getCurrentWorktreeSession2();
     const paths = wt ? [wt.worktreePath] : [getOriginalCwd()];
     const l = await loadSameRepoAllMessageLogs(paths);
@@ -475200,14 +475535,14 @@ function SessionTreeScreen({
     setLogs(l);
     setLoading(false);
   }, []);
-  React134.useEffect(() => {
+  React135.useEffect(() => {
     loadLogs();
     return () => {
       if (confirmTimerRef.current)
         clearTimeout(confirmTimerRef.current);
     };
   }, [loadLogs]);
-  const doFork = React134.useCallback(async (target) => {
+  const doFork = React135.useCallback(async (target) => {
     if (!target.sessionId || !target.fullPath)
       return;
     if (forkInFlightRef.current)
@@ -475240,12 +475575,12 @@ function SessionTreeScreen({
     setFocusedIdx(idx);
     setSelectedIdx(null);
   }
-  const computeViewLogs = React134.useCallback((base, q, sk, agentic) => {
+  const computeViewLogs = React135.useCallback((base, q, sk, agentic) => {
     const local = q ? filterLogs(base, q) : base;
     const chosen = agentic && local.length === 0 ? agentic : local;
     return sortLogsBy(chosen, sk);
   }, []);
-  const ensureExactCount = React134.useCallback(async (log) => {
+  const ensureExactCount = React135.useCallback(async (log) => {
     const sid = log.sessionId ?? "";
     if (!sid)
       return;
@@ -475520,7 +475855,7 @@ function SessionTreeScreen({
             }
             line += " " + flags;
             const summaryLine = "    └ " + truncateToVisibleWidth(getSummaryLine(log), termCols - 4 - 6);
-            return /* @__PURE__ */ jsx_dev_runtime428.jsxDEV(React134.Fragment, {
+            return /* @__PURE__ */ jsx_dev_runtime428.jsxDEV(React135.Fragment, {
               children: [
                 /* @__PURE__ */ jsx_dev_runtime428.jsxDEV(ThemedBox_default, {
                   noSelect: true,
@@ -475577,7 +475912,7 @@ function SessionTreeScreen({
     ]
   }, undefined, true, undefined, this);
 }
-var React134, jsx_dev_runtime428, AGENT_COLOR_THEME_FIELD, SESSION_ROW_HINT = "\uD83D\uDDB1 点击移动光标 · 滚轮/↑↓ 滚动 · enter 选中/进入 · f fork · x 摘要 · q 返回", SESSION_SORT_KEYS, SESSION_SORT_LABELS, HEADER_ROWS = 4, FOOTER_ROWS = 2;
+var React135, jsx_dev_runtime428, AGENT_COLOR_THEME_FIELD, SESSION_ROW_HINT = "\uD83D\uDDB1 点击移动光标 · 滚轮/↑↓ 滚动 · enter 选中/进入 · f fork · x 摘要 · q 返回", SESSION_SORT_KEYS, SESSION_SORT_LABELS, HEADER_ROWS = 4, FOOTER_ROWS = 2;
 var init_SessionTreeScreen = __esm(() => {
   init_ink2();
   init_config6();
@@ -475590,7 +475925,7 @@ var init_SessionTreeScreen = __esm(() => {
   init_displayTags();
   init_sessionStorage();
   init_branch();
-  React134 = __toESM(require_react(), 1);
+  React135 = __toESM(require_react(), 1);
   jsx_dev_runtime428 = __toESM(require_jsx_dev_runtime(), 1);
   AGENT_COLOR_THEME_FIELD = {
     red: "red_FOR_SUBAGENTS_ONLY",
@@ -477495,8 +477830,8 @@ function TranscriptSearchBar({
     onExit: () => onClose(query),
     onCancel
   });
-  const [indexStatus, setIndexStatus] = React137.useState("building");
-  React137.useEffect(() => {
+  const [indexStatus, setIndexStatus] = React138.useState("building");
+  React138.useEffect(() => {
     let alive = true;
     const warm = jumpRef.current?.warmSearchIndex;
     if (!warm) {
@@ -477681,8 +478016,8 @@ function REPL({
   const viewingAgentTaskId = useAppState((s) => s.viewingAgentTaskId);
   const setAppState = useSetAppState();
   const pendingScreen = useAppState((s) => s.pendingScreen);
-  const statuslineMouseWriteRef = React137.useContext(TerminalWriteContext);
-  React137.useEffect(() => {
+  const statuslineMouseWriteRef = React138.useContext(TerminalWriteContext);
+  React138.useEffect(() => {
     if (!statuslineMouseWriteRef)
       return;
     if (!isMouseTrackingEnabled())
@@ -477692,7 +478027,7 @@ function REPL({
       statuslineMouseWriteRef(DISABLE_MOUSE_TRACKING);
     };
   }, [statuslineMouseWriteRef]);
-  React137.useEffect(() => {
+  React138.useEffect(() => {
     if (pendingScreen === "session-tree") {
       setAppState((prev) => ({ ...prev, pendingScreen: undefined }));
       setScreen("session-tree");
@@ -477848,36 +478183,36 @@ function REPL({
   const scrollRef = import_react281.useRef(null);
   const modalScrollRef = import_react281.useRef(null);
   const lastUserScrollTsRef = import_react281.useRef(0);
-  const queryGuard = React137.useRef(new QueryGuard).current;
-  const isQueryActive = React137.useSyncExternalStore(queryGuard.subscribe, queryGuard.getSnapshot);
-  const [isExternalLoading, setIsExternalLoadingRaw] = React137.useState(remoteSessionConfig?.hasInitialPrompt ?? false);
+  const queryGuard = React138.useRef(new QueryGuard).current;
+  const isQueryActive = React138.useSyncExternalStore(queryGuard.subscribe, queryGuard.getSnapshot);
+  const [isExternalLoading, setIsExternalLoadingRaw] = React138.useState(remoteSessionConfig?.hasInitialPrompt ?? false);
   const isLoading = isQueryActive || isExternalLoading;
-  const [userInputOnProcessing, setUserInputOnProcessingRaw] = React137.useState(undefined);
-  const userInputBaselineRef = React137.useRef(0);
-  const userMessagePendingRef = React137.useRef(false);
-  const loadingStartTimeRef = React137.useRef(0);
-  const totalPausedMsRef = React137.useRef(0);
-  const pauseStartTimeRef = React137.useRef(null);
-  const resetTimingRefs = React137.useCallback(() => {
+  const [userInputOnProcessing, setUserInputOnProcessingRaw] = React138.useState(undefined);
+  const userInputBaselineRef = React138.useRef(0);
+  const userMessagePendingRef = React138.useRef(false);
+  const loadingStartTimeRef = React138.useRef(0);
+  const totalPausedMsRef = React138.useRef(0);
+  const pauseStartTimeRef = React138.useRef(null);
+  const resetTimingRefs = React138.useCallback(() => {
     loadingStartTimeRef.current = Date.now();
     totalPausedMsRef.current = 0;
     pauseStartTimeRef.current = null;
   }, []);
-  const wasQueryActiveRef = React137.useRef(false);
+  const wasQueryActiveRef = React138.useRef(false);
   if (isQueryActive && !wasQueryActiveRef.current) {
     resetTimingRefs();
   }
   wasQueryActiveRef.current = isQueryActive;
-  const setIsExternalLoading = React137.useCallback((value) => {
+  const setIsExternalLoading = React138.useCallback((value) => {
     setIsExternalLoadingRaw(value);
     if (value)
       resetTimingRefs();
   }, [resetTimingRefs]);
-  const swarmStartTimeRef = React137.useRef(null);
-  const swarmBudgetInfoRef = React137.useRef(undefined);
-  const focusedInputDialogRef = React137.useRef(undefined);
+  const swarmStartTimeRef = React138.useRef(null);
+  const swarmBudgetInfoRef = React138.useRef(undefined);
+  const focusedInputDialogRef = React138.useRef(undefined);
   const PROMPT_SUPPRESSION_MS = 1500;
-  const [isPromptInputActive, setIsPromptInputActive] = React137.useState(false);
+  const [isPromptInputActive, setIsPromptInputActive] = React138.useState(false);
   const [autoUpdaterResult, setAutoUpdaterResult] = import_react281.useState(null);
   import_react281.useEffect(() => {
     if (autoUpdaterResult?.notifications) {
@@ -479006,7 +479341,8 @@ Error: sandbox required but unavailable: ${reason}
     } catch (error) {
       logError3(error);
       const llmTimeoutHint = llmTimeoutRemediationHint(error, getCurrentLlmTimeoutMs());
-      const gwHint = gatewayUnreachableRemediationHint(error);
+      const endpointLabel = getCurrentEndpointLabel(mainLoopModelParam);
+      const gwHint = gatewayUnreachableRemediationHint(error, endpointLabel);
       setMessages((prev) => [...prev, createSystemMessage(`本轮执行出错：${errorMessage2(error)}。${llmTimeoutHint ? `${llmTimeoutHint} ` : ""}${gwHint ? `${gwHint} ` : ""}请重试。`, "error")]);
     } finally {
       if (queryGuard.end(thisGeneration)) {
@@ -479894,8 +480230,8 @@ Note: ctrl + z now suspends AtlasCode, ctrl + _ undoes input.
     setPositions
   } = useSearchHighlight();
   const transcriptCols = useTerminalSize().columns;
-  const prevColsRef = React137.useRef(transcriptCols);
-  React137.useEffect(() => {
+  const prevColsRef = React138.useRef(transcriptCols);
+  React138.useEffect(() => {
     if (prevColsRef.current !== transcriptCols) {
       prevColsRef.current = transcriptCols;
       if (searchQuery || searchOpen) {
@@ -480691,7 +481027,7 @@ Note: ctrl + z now suspends AtlasCode, ctrl + _ undoes input.
   }
   return mainReturn;
 }
-var import_compiler_runtime320, React137, import_react281, jsx_dev_runtime431, UltraplanChoiceDialog = () => null, UltraplanLaunchDialog = () => null, launchUltraplan2 = null, useVoiceIntegration2, VoiceKeybindingHandler2, useAntOrgWarningNotification = () => {}, getCoordinatorUserContext3, SUGGEST_BG_PR_NOOP = (_p, _n) => false, useScheduledTasks2, EMPTY_MCP_CLIENTS2, RECENT_SCROLL_REPIN_WINDOW_MS = 3000, TITLE_ANIMATION_FRAMES, TITLE_STATIC_PREFIX = "✳", TITLE_ANIMATION_INTERVAL_MS = 960;
+var import_compiler_runtime320, React138, import_react281, jsx_dev_runtime431, UltraplanChoiceDialog = () => null, UltraplanLaunchDialog = () => null, launchUltraplan2 = null, useVoiceIntegration2, VoiceKeybindingHandler2, useAntOrgWarningNotification = () => {}, getCoordinatorUserContext3, SUGGEST_BG_PR_NOOP = (_p, _n) => false, useScheduledTasks2, EMPTY_MCP_CLIENTS2, RECENT_SCROLL_REPIN_WINDOW_MS = 3000, TITLE_ANIMATION_FRAMES, TITLE_STATIC_PREFIX = "✳", TITLE_ANIMATION_INTERVAL_MS = 960;
 var init_REPL = __esm(() => {
   init_shared();
   init_modelprovider2();
@@ -480879,7 +481215,7 @@ var init_REPL = __esm(() => {
   init_osc();
   init_attachments();
   import_compiler_runtime320 = __toESM(require_compiler_runtime(), 1);
-  React137 = __toESM(require_react(), 1);
+  React138 = __toESM(require_react(), 1);
   import_react281 = __toESM(require_react(), 1);
   jsx_dev_runtime431 = __toESM(require_jsx_dev_runtime(), 1);
   useVoiceIntegration2 = feature("VOICE_MODE") ? (init_useVoiceIntegration(), __toCommonJS(exports_useVoiceIntegration)).useVoiceIntegration : () => ({