@atlasharness/atlascode 0.1.15 → 0.1.17

package/dist/cli.js

@@ -129,6 +129,29 @@ function cliOk(msg) {
   return;
 }
 
+// src/cli/crashBackstop.ts
+function registerGlobalCrashBackstop() {
+  if (registered) {
+    return;
+  }
+  registered = true;
+  process.on("uncaughtException", (error) => {
+    writeCrashDiag("uncaughtException", error);
+  });
+  process.on("unhandledRejection", (reason) => {
+    writeCrashDiag("unhandledRejection", reason);
+  });
+}
+function writeCrashDiag(kind, value) {
+  const formatted = value instanceof Error ? `${value.name}: ${value.message}
+${value.stack ?? ""}`.trim() : String(value);
+  try {
+    process.stderr.write(`[atlas][${kind}] ${formatted}
+`);
+  } catch {}
+}
+var registered = false;
+
 // src/shared/feature.ts
 function feature(name) {
   const key = "FEATURE_" + name;
@@ -668,266 +691,6 @@ var init_shared = __esm(() => {
   init_types();
 });
 
-// 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) {
-  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);
-  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);
-  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
-      });
-    }
-  }
-  return outcomes;
-}
-var init_toolOrchestration = __esm(() => {
-  init_toolExecution();
-});
-
-// src/engine/pipeline/index.ts
-var init_pipeline = __esm(() => {
-  init_toolExecution();
-  init_toolOrchestration();
-});
-
 // node_modules/openai/internal/tslib.mjs
 function __classPrivateFieldSet(receiver, state, value, kind, f) {
   if (kind === "m")
@@ -20052,6 +19815,17 @@ var init_openai = __esm(() => {
   init_bedrock2();
 });
 
+// src/modelprovider/constants.ts
+var API_IMAGE_MAX_BASE64_SIZE, IMAGE_TARGET_RAW_SIZE, PDF_TARGET_RAW_SIZE, API_PDF_MAX_PAGES = 100, LLM_TIMEOUT_DEFAULT_MS = 600000, LLM_TIMEOUT_CAP_MS = 1800000, SUMMARIZE_CONNECTOR_TEXT_BETA_HEADER, AFK_MODE_BETA_HEADER;
+var init_constants2 = __esm(() => {
+  init_shared();
+  API_IMAGE_MAX_BASE64_SIZE = 5 * 1024 * 1024;
+  IMAGE_TARGET_RAW_SIZE = API_IMAGE_MAX_BASE64_SIZE * 3 / 4;
+  PDF_TARGET_RAW_SIZE = 20 * 1024 * 1024;
+  SUMMARIZE_CONNECTOR_TEXT_BETA_HEADER = feature("CONNECTOR_TEXT") ? "summarize-connector-text-2026-03-13" : "";
+  AFK_MODE_BETA_HEADER = feature("TRANSCRIPT_CLASSIFIER") ? "afk-mode-2026-01-31" : "";
+});
+
 // src/modelprovider/clients.ts
 function clientCacheKey(provider, baseURL, apiKey) {
   return provider + "|" + (baseURL || "") + "|" + (apiKey || "");
@@ -20066,7 +19840,7 @@ function getClientForEntry(entry) {
     baseURL: entry.baseURL,
     apiKey: entry.apiKey,
     maxRetries: 0,
-    timeout: 120000
+    timeout: LLM_TIMEOUT_DEFAULT_MS
   });
   clientCache.set(key, client);
   return client;
@@ -20074,6 +19848,7 @@ function getClientForEntry(entry) {
 var clientCache;
 var init_clients = __esm(() => {
   init_openai();
+  init_constants2();
   clientCache = new Map;
 });
 
@@ -27007,6 +26782,27 @@ var init_params = __esm(() => {
   init_effort();
 });
 
+// src/modelprovider/types.ts
+var APIError2, APIConnectionError2, APIConnectionTimeoutError2;
+var init_types2 = __esm(() => {
+  APIError2 = class APIError2 extends Error {
+    status;
+    error;
+    constructor(message, status, error) {
+      super(message);
+      this.name = "APIError";
+      if (status !== undefined)
+        this.status = status;
+      if (error !== undefined)
+        this.error = error;
+    }
+  };
+  APIConnectionError2 = class APIConnectionError2 extends APIError2 {
+  };
+  APIConnectionTimeoutError2 = class APIConnectionTimeoutError2 extends APIConnectionError2 {
+  };
+});
+
 // src/modelprovider/modelprovider.ts
 import { randomUUID } from "crypto";
 function mapOpenAIUsage(u) {
@@ -27025,6 +26821,29 @@ function isRetryableError(err) {
   const msg = String(err?.message || err?.code || "");
   return /timeout|ECONN|EPIPE|fetch failed|socket|aborted/i.test(msg);
 }
+function isClientRequestTimeout(err) {
+  if (!err || typeof err !== "object")
+    return false;
+  const e = err;
+  if (err instanceof APIConnectionTimeoutError2)
+    return true;
+  if (e.name === "APIConnectionTimeoutError" || e.name === "APITimeoutError")
+    return true;
+  return false;
+}
+function shouldRetryModelError(err, signal) {
+  if (signal?.aborted)
+    return false;
+  if (isClientRequestTimeout(err))
+    return false;
+  return isRetryableError(err);
+}
+function llmTimeoutRemediationHint(error, currentTimeoutMs) {
+  if (!isClientRequestTimeout(error))
+    return null;
+  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 startLlmWaitHeartbeat(modelId, attempt, totalRetries) {
   const startedAt = Date.now();
   const id = setInterval(() => {
@@ -27038,9 +26857,14 @@ function startLlmWaitHeartbeat(modelId, attempt, totalRetries) {
 class OpenAIProvider {
   maxRetriesPerModel;
   timeoutMs;
-  constructor(maxRetriesPerModel = 3, timeoutMs = 120000) {
+  timeoutResolver;
+  constructor(maxRetriesPerModel = 3, timeoutMs = LLM_TIMEOUT_DEFAULT_MS, timeoutResolver) {
     this.maxRetriesPerModel = maxRetriesPerModel;
     this.timeoutMs = timeoutMs;
+    this.timeoutResolver = timeoutResolver;
+  }
+  getTimeoutMs() {
+    return this.timeoutResolver ? this.timeoutResolver() : this.timeoutMs;
   }
   async chat(args) {
     const refs = getRoleModels(args.role, args.sessionModel, args.fallbackModel);
@@ -27080,7 +26904,7 @@ class OpenAIProvider {
           const stopWait = startLlmWaitHeartbeat(entry.modelId, attempt, this.maxRetriesPerModel);
           let res;
           try {
-            res = await client.chat.completions.create(params, { signal: args.signal, timeout: this.timeoutMs });
+            res = await client.chat.completions.create(params, { signal: args.signal, timeout: this.getTimeoutMs() });
           } finally {
             stopWait();
           }
@@ -27128,7 +26952,7 @@ class OpenAIProvider {
           };
         } catch (err) {
           lastErr = err;
-          if (!isRetryableError(err) || args.signal?.aborted)
+          if (!shouldRetryModelError(err, args.signal))
             break;
         }
       }
@@ -27178,7 +27002,7 @@ class OpenAIProvider {
           break;
         } catch (err) {
           lastErr = err;
-          if (!isRetryableError(err) || args.signal?.aborted)
+          if (!shouldRetryModelError(err, args.signal))
             break;
         }
       }
@@ -27188,7 +27012,7 @@ class OpenAIProvider {
     if (lastErr) {
       const message = lastErr instanceof Error ? lastErr.message || lastErr.name : String(lastErr);
       const code = lastErr?.name === "TimeoutError" ? "TIMEOUT" : "API_ERROR";
-      yield { type: "error", code, message, retryable: isRetryableError(lastErr) };
+      yield { type: "error", code, message, retryable: shouldRetryModelError(lastErr, args.signal) };
       return;
     }
     throw new Error(`No models configured for role '${args.role}'.`);
@@ -27197,7 +27021,7 @@ class OpenAIProvider {
     const stopWait = startLlmWaitHeartbeat(entry.modelId, attempt, totalRetries);
     let stream;
     try {
-      stream = await client.chat.completions.create({ ...params, stream: true, stream_options: { include_usage: true } }, { signal, timeout: this.timeoutMs });
+      stream = await client.chat.completions.create({ ...params, stream: true, stream_options: { include_usage: true } }, { signal, timeout: this.getTimeoutMs() });
     } finally {
       stopWait();
     }
@@ -27385,7 +27209,7 @@ class OpenAIProvider {
     const wav = Buffer.concat([header, pcm]);
     const file = new File([wav], "audio.wav", { type: "audio/wav" });
     const client = getClientForEntry(entry);
-    const resp = await client.audio.transcriptions.create({ file, model, ...language ? { language } : {} }, { timeout: this.timeoutMs });
+    const resp = await client.audio.transcriptions.create({ file, model, ...language ? { language } : {} }, { timeout: this.getTimeoutMs() });
     return resp?.text ?? "";
   }
   async synthesizeSpeech(text, model, voice) {
@@ -27399,7 +27223,7 @@ class OpenAIProvider {
       voice: voice || "alloy",
       input: text,
       response_format: "mp3"
-    }, { timeout: this.timeoutMs });
+    }, { timeout: this.getTimeoutMs() });
     const buf = await resp.arrayBuffer();
     return Buffer.from(buf);
   }
@@ -27434,15 +27258,15 @@ class OpenAIProvider {
 var init_modelprovider = __esm(() => {
   init_openai();
   init_clients();
+  init_constants2();
   init_roles7();
   init_shared();
   init_shared();
   init_params();
+  init_types2();
+  init_constants2();
 });
 
-// src/modelprovider/types.ts
-var init_types2 = () => {};
-
 // src/modelprovider/errorUtils.ts
 function extractConnectionErrorDetails(error) {
   if (!error || typeof error !== "object") {
@@ -27581,17 +27405,6 @@ var init_errorUtils = __esm(() => {
   ]);
 });
 
-// src/modelprovider/constants.ts
-var API_IMAGE_MAX_BASE64_SIZE, IMAGE_TARGET_RAW_SIZE, PDF_TARGET_RAW_SIZE, API_PDF_MAX_PAGES = 100, SUMMARIZE_CONNECTOR_TEXT_BETA_HEADER, AFK_MODE_BETA_HEADER;
-var init_constants2 = __esm(() => {
-  init_shared();
-  API_IMAGE_MAX_BASE64_SIZE = 5 * 1024 * 1024;
-  IMAGE_TARGET_RAW_SIZE = API_IMAGE_MAX_BASE64_SIZE * 3 / 4;
-  PDF_TARGET_RAW_SIZE = 20 * 1024 * 1024;
-  SUMMARIZE_CONNECTOR_TEXT_BETA_HEADER = feature("CONNECTOR_TEXT") ? "summarize-connector-text-2026-03-13" : "";
-  AFK_MODE_BETA_HEADER = feature("TRANSCRIPT_CLASSIFIER") ? "afk-mode-2026-01-31" : "";
-});
-
 // src/modelprovider/errorMessaging.ts
 function registerErrorMessagingPorts(p) {
   ports = p;
@@ -27731,10 +27544,22 @@ var init_queryWithRoleFallback = __esm(() => {
 
 // src/modelprovider/index.ts
 function getModelProvider() {
-  return _provider ??= new OpenAIProvider(3, resolveLlmTimeoutMs());
+  return _provider ??= new OpenAIProvider(3, LLM_TIMEOUT_DEFAULT_MS, () => resolveLlmTimeoutMs(process.env.ATLAS_LLM_TIMEOUT, llmTimeoutSettingsSource?.()));
+}
+function setLlmTimeoutSettingsSource(next) {
+  llmTimeoutSettingsSource = next;
+}
+function getCurrentLlmTimeoutMs() {
+  return resolveLlmTimeoutMs(process.env.ATLAS_LLM_TIMEOUT, llmTimeoutSettingsSource?.());
 }
-function resolveLlmTimeoutMs() {
-  return parseBoundedIntEnv("ATLAS_LLM_TIMEOUT", process.env.ATLAS_LLM_TIMEOUT, 120000, 1800000, 1).effective;
+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 === "")
+    return fromSettings();
+  const env = parseBoundedIntEnv("ATLAS_LLM_TIMEOUT", envRaw, LLM_TIMEOUT_DEFAULT_MS, LLM_TIMEOUT_CAP_MS, 1);
+  if (env.status !== "invalid")
+    return env.effective;
+  return fromSettings();
 }
 function lazyProxy(resolve) {
   return new Proxy({}, {
@@ -27745,13 +27570,16 @@ function lazyProxy(resolve) {
     }
   });
 }
-var _provider, modelProvider;
+var _provider, llmTimeoutSettingsSource = null, modelProvider;
 var init_modelprovider2 = __esm(() => {
   init_modelprovider();
+  init_constants2();
   init_shared();
+  init_constants2();
   init_modelprovider();
   init_types2();
   init_modelErrors();
+  init_modelprovider();
   init_params();
   init_roles7();
   init_errorUtils();
@@ -27766,6 +27594,345 @@ var init_modelprovider2 = __esm(() => {
   modelProvider = lazyProxy(getModelProvider);
 });
 
+// src/engine/query/turnRecovery.ts
+function parseNonNegativeInt(value, fallback) {
+  if (value === undefined || value === "")
+    return fallback;
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+function resolveTurnRecoveryConfig(env = process.env) {
+  return {
+    enabled: env.ATLAS_TURN_RECOVER_ENABLED !== "0",
+    maxRetries: parseNonNegativeInt(env.ATLAS_TURN_RECOVER_MAX, DEFAULT_MAX_RETRIES),
+    backoffBaseMs: parseNonNegativeInt(env.ATLAS_TURN_RECOVER_BACKOFF_MS, DEFAULT_BACKOFF_BASE_MS),
+    backoffCapMs: parseNonNegativeInt(env.ATLAS_TURN_RECOVER_BACKOFF_CAP_MS, DEFAULT_BACKOFF_CAP_MS)
+  };
+}
+function turnRecoveryBackoffMs(attempt, baseMs, capMs) {
+  const base = Math.max(0, baseMs);
+  const cap = Math.max(base, capMs);
+  if (attempt <= 0)
+    return Math.min(base, cap);
+  return Math.min(base * 2 ** attempt, cap);
+}
+function sleepSignalAware(ms, signal) {
+  if (ms <= 0)
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    let settled = false;
+    const timer = setTimeout(() => {
+      settled = true;
+      if (signal)
+        signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve();
+    }
+    if (signal)
+      signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function withTurnRecovery(attempt, options = {}) {
+  const cfg = options.config ?? resolveTurnRecoveryConfig();
+  if (!cfg.enabled) {
+    return attempt();
+  }
+  let lastErr;
+  for (let i = 0;i <= cfg.maxRetries; i++) {
+    if (i > 0 && options.signal?.aborted) {
+      throw options.signal.reason ?? new Error("aborted");
+    }
+    try {
+      return await attempt();
+    } catch (err) {
+      lastErr = err;
+      if (i < cfg.maxRetries && shouldRetryModelError(err, options.signal)) {
+        const backoff = turnRecoveryBackoffMs(i, cfg.backoffBaseMs, cfg.backoffCapMs);
+        if (backoff > 0) {
+          await sleepSignalAware(backoff, options.signal);
+        }
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastErr;
+}
+var DEFAULT_MAX_RETRIES = 13, DEFAULT_BACKOFF_BASE_MS = 100, DEFAULT_BACKOFF_CAP_MS = 1000;
+var init_turnRecovery = __esm(() => {
+  init_modelprovider2();
+});
+
+// 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) {
+  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);
+  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);
+  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
+      });
+    }
+  }
+  return outcomes;
+}
+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();
@@ -76317,7 +76484,7 @@ Important:
 // src/engine/tools/skill/skillTool.ts
 import { randomUUID as randomUUID14 } from "crypto";
 async function getAllCommands() {
-  return getCommands(getProjectRoot());
+  return getCommands(process.cwd());
 }
 function getToolUseIDFromParentMessage(parentMessage, toolName) {
   if (!parentMessage)
@@ -76388,7 +76555,6 @@ function skillHasOnlySafeProperties(command) {
 }
 var SKILL_TOOL_INPUT_SCHEMA, SAFE_SKILL_PROPERTIES, SkillTool;
 var init_skillTool = __esm(() => {
-  init_bootstrap();
   init_shared();
   init_permissions3();
   init_modelprovider2();
@@ -76455,7 +76621,7 @@ var init_skillTool = __esm(() => {
       return skill ?? "";
     },
     async description() {
-      return getSkillPrompt(getProjectRoot());
+      return getSkillPrompt(process.cwd());
     },
     async checkPermissions(input, context) {
       const { skill, args } = input;
@@ -80550,7 +80716,9 @@ async function queryOneRound(deps, tools, messages) {
     fallbackModel: deps.fallbackModel,
     options: deps.effortValue !== undefined ? { effortValue: deps.effortValue } : undefined
   };
-  let resp = await deps.modelProvider.chat(chatArgs);
+  let resp = await withTurnRecovery(() => deps.modelProvider.chat(chatArgs), {
+    signal: deps.signal
+  });
   let assistantContent = resp.message.content ?? [];
   const isEmptyContent = (content) => {
     if (!Array.isArray(content))
@@ -80565,7 +80733,9 @@ async function queryOneRound(deps, tools, messages) {
     });
   };
   if (isEmptyContent(assistantContent) && !deps.signal?.aborted) {
-    const retried = await deps.modelProvider.chat(chatArgs);
+    const retried = await withTurnRecovery(() => deps.modelProvider.chat(chatArgs), {
+      signal: deps.signal
+    });
     const retriedContent = retried.message.content ?? [];
     if (!isEmptyContent(retriedContent)) {
       resp = retried;
@@ -80697,6 +80867,7 @@ async function queryAgentLoop(deps, args) {
 var DEFAULT_AGENT_LOOP_MAX_TURNS = 20;
 var init_loop = __esm(() => {
   init_shared();
+  init_turnRecovery();
   init_pipeline();
   init_context();
 });
@@ -80717,6 +80888,7 @@ var init_QueryEngine = __esm(() => {
 // src/engine/query/index.ts
 var init_query2 = __esm(() => {
   init_loop();
+  init_turnRecovery();
   init_QueryEngine();
 });
 
@@ -121613,6 +121785,7 @@ var isMcpServerCommandEntry = () => ({}), isMcpServerNameEntry = () => ({}), isM
     object({ kind: literal("window"), tokens: number2().int().min(1000) }),
     object({ kind: literal("pct"), pct: number2().min(1).max(100) })
   ]).optional(),
+  llmTimeoutMs: number2().int().positive().optional(),
   prefersReducedMotion: boolean2().optional(),
   syntaxHighlightingDisabled: boolean2().optional(),
   spinnerTipsEnabled: boolean2().optional(),
@@ -148277,28 +148450,28 @@ function getEventPriority(eventType) {
     case "focus":
     case "blur":
     case "paste":
-      return import_constants48.DiscreteEventPriority;
+      return import_constants53.DiscreteEventPriority;
     case "resize":
     case "scroll":
     case "mousemove":
-      return import_constants48.ContinuousEventPriority;
+      return import_constants53.ContinuousEventPriority;
     default:
-      return import_constants48.DefaultEventPriority;
+      return import_constants53.DefaultEventPriority;
   }
 }
 
 class Dispatcher {
   currentEvent = null;
-  currentUpdatePriority = import_constants48.DefaultEventPriority;
+  currentUpdatePriority = import_constants53.DefaultEventPriority;
   discreteUpdates = null;
   resolveEventPriority() {
-    if (this.currentUpdatePriority !== import_constants48.NoEventPriority) {
+    if (this.currentUpdatePriority !== import_constants53.NoEventPriority) {
       return this.currentUpdatePriority;
     }
     if (this.currentEvent) {
       return getEventPriority(this.currentEvent.type);
     }
-    return import_constants48.DefaultEventPriority;
+    return import_constants53.DefaultEventPriority;
   }
   dispatch(target, event) {
     const previousEvent = this.currentEvent;
@@ -148323,18 +148496,18 @@ class Dispatcher {
   dispatchContinuous(target, event) {
     const previousPriority = this.currentUpdatePriority;
     try {
-      this.currentUpdatePriority = import_constants48.ContinuousEventPriority;
+      this.currentUpdatePriority = import_constants53.ContinuousEventPriority;
       return this.dispatch(target, event);
     } finally {
       this.currentUpdatePriority = previousPriority;
     }
   }
 }
-var import_constants48;
+var import_constants53;
 var init_dispatcher = __esm(() => {
   init_log5();
   init_event_handlers();
-  import_constants48 = __toESM(require_constants2(), 1);
+  import_constants53 = __toESM(require_constants2(), 1);
 });
 
 // src/tui/ink/events/terminal-event.ts
@@ -157141,7 +157314,7 @@ function applyPositionedHighlight(screen, stylePool, positions, rowOffset, curre
   }
   return true;
 }
-var import_constants50, timing;
+var import_constants55, timing;
 var init_render_to_screen = __esm(() => {
   init_debug();
   init_dom();
@@ -157150,7 +157323,7 @@ var init_render_to_screen = __esm(() => {
   init_reconciler();
   init_render_node_to_output();
   init_screen();
-  import_constants50 = __toESM(require_constants2(), 1);
+  import_constants55 = __toESM(require_constants2(), 1);
   timing = { reconcile: 0, yoga: 0, paint: 0, scan: 0, calls: 0 };
 });
 
@@ -157456,7 +157629,7 @@ class Ink {
         };
       }
     };
-    this.container = reconciler_default.createContainer(this.rootNode, import_constants51.ConcurrentRoot, null, false, null, "id", noop_default, noop_default, noop_default, noop_default);
+    this.container = reconciler_default.createContainer(this.rootNode, import_constants56.ConcurrentRoot, null, false, null, "id", noop_default, noop_default, noop_default, noop_default);
     if (false) {}
   }
   handleResume = () => {
@@ -158269,7 +158442,7 @@ function drainStdin(stdin = process.stdin) {
     }
   }
 }
-var import_constants51, jsx_dev_runtime8, ALT_SCREEN_ANCHOR_CURSOR, CURSOR_HOME_PATCH, ERASE_THEN_HOME_PATCH, CONSOLE_STDOUT_METHODS, CONSOLE_STDERR_METHODS;
+var import_constants56, jsx_dev_runtime8, ALT_SCREEN_ANCHOR_CURSOR, CURSOR_HOME_PATCH, ERASE_THEN_HOME_PATCH, CONSOLE_STDOUT_METHODS, CONSOLE_STDERR_METHODS;
 var init_ink = __esm(() => {
   init_noop();
   init_throttle2();
@@ -158302,7 +158475,7 @@ var init_ink = __esm(() => {
   init_dec();
   init_osc();
   init_useTerminalNotification();
-  import_constants51 = __toESM(require_constants2(), 1);
+  import_constants56 = __toESM(require_constants2(), 1);
   jsx_dev_runtime8 = __toESM(require_jsx_dev_runtime(), 1);
   ALT_SCREEN_ANCHOR_CURSOR = Object.freeze({
     x: 0,
@@ -203040,7 +203213,7 @@ var init_drainRunLoop = __esm(() => {
 
 // src/tui/utils/computerUse/escHotkey.ts
 function registerEscHotkey(onEscape) {
-  if (registered)
+  if (registered2)
     return true;
   const cu = requireComputerUseSwift();
   if (!cu.hotkey.registerEscape(onEscape)) {
@@ -203048,16 +203221,16 @@ function registerEscHotkey(onEscape) {
     return false;
   }
   retainPump();
-  registered = true;
+  registered2 = true;
   logForDebugging3("[cu-esc] registered");
   return true;
 }
 function notifyExpectedEscape() {
-  if (!registered)
+  if (!registered2)
     return;
   requireComputerUseSwift().hotkey.notifyExpectedEscape();
 }
-var registered = false;
+var registered2 = false;
 var init_escHotkey = __esm(() => {
   init_debug();
   init_drainRunLoop();
@@ -271660,7 +271833,7 @@ async function* runAgent2({
   }
   const skillsToPreload = agentDefinition.skills ?? [];
   if (skillsToPreload.length > 0) {
-    const allSkills = await getSkillToolCommands2(getProjectRoot());
+    const allSkills = await getSkillToolCommands2(process.cwd());
     const validSkills = [];
     for (const skillName of skillsToPreload) {
       const resolvedName = resolveSkillName(skillName, allSkills, agentDefinition);
@@ -272269,9 +272442,9 @@ function getDefaultMaxRetries() {
   if (process.env.ATLAS_MAX_RETRIES) {
     return parseInt(process.env.ATLAS_MAX_RETRIES || "", 10);
   }
-  return DEFAULT_MAX_RETRIES;
+  return DEFAULT_MAX_RETRIES2;
 }
-var DEFAULT_MAX_RETRIES = 10, BASE_DELAY_MS = 500, FOREGROUND_529_RETRY_SOURCES, PERSISTENT_MAX_BACKOFF_MS, PERSISTENT_RESET_CAP_MS;
+var DEFAULT_MAX_RETRIES2 = 10, BASE_DELAY_MS = 500, FOREGROUND_529_RETRY_SOURCES, PERSISTENT_MAX_BACKOFF_MS, PERSISTENT_RESET_CAP_MS;
 var init_withRetry = __esm(() => {
   init_shared();
   init_atlas();
@@ -274526,8 +274699,8 @@ var init_UI10 = __esm(() => {
 async function getAllCommands2(context) {
   const mcpSkills = context.getAppState().mcp.commands.filter((cmd) => cmd.type === "prompt" && cmd.loadedFrom === "mcp");
   if (mcpSkills.length === 0)
-    return getCommands2(getProjectRoot());
-  const localCommands = await getCommands2(getProjectRoot());
+    return getCommands2(process.cwd());
+  const localCommands = await getCommands2(process.cwd());
   return uniqBy_default([...localCommands, ...mcpSkills], "name");
 }
 async function executeForkedSkill2(command, commandName, args, context, canUseTool, parentMessage, onProgress) {
@@ -274623,7 +274796,6 @@ function isOfficialMarketplaceSkill(command) {
 var inputSchema14, outputSchema12, SkillTool2, SAFE_SKILL_PROPERTIES2;
 var init_SkillTool = __esm(() => {
   init_uniqBy();
-  init_bootstrap();
   init_commands5();
   init_Tool();
   init_debug();
@@ -274673,7 +274845,7 @@ var init_SkillTool = __esm(() => {
       return outputSchema12();
     },
     description: async ({ skill }) => `Execute skill: ${skill}`,
-    prompt: async () => getPrompt20(getProjectRoot()),
+    prompt: async () => getPrompt20(process.cwd()),
     toAutoClassifierInput: ({ skill }) => skill ?? "",
     async validateInput({ skill }, context) {
       const trimmed = skill.trim();
@@ -430263,6 +430435,7 @@ function wireContextHostPorts() {
   });
   setAutoCompactSettingsSource(() => getGlobalConfig().autoCompactEnabled);
   setAutoCompactWindowSettingsSource(() => getInitialSettings2().autoCompactWindow);
+  setLlmTimeoutSettingsSource(() => getInitialSettings2().llmTimeoutMs);
   setTimeBasedMCConfigSource(() => getFeatureValue_CACHED_MAY_BE_STALE("atlas_slate_heron", TIME_BASED_MC_CONFIG_DEFAULTS));
   clearPostCompactResetsForTesting();
   if (feature("CONTEXT_COLLAPSE")) {
@@ -430291,6 +430464,7 @@ function wireContextHostPorts() {
 }
 var init_contextHostWiring = __esm(() => {
   init_shared();
+  init_modelprovider2();
   init_engine();
   init_config6();
   init_settings3();
@@ -475922,7 +476096,8 @@ Error: sandbox required but unavailable: ${reason}
       await onQueryImpl(latestMessages, newMessages, abortController, shouldQuery, additionalAllowedTools, mainLoopModelParam, effort);
     } catch (error) {
       logError3(error);
-      setMessages((prev) => [...prev, createSystemMessage(`本轮执行出错：${errorMessage2(error)}。请重试。`, "error")]);
+      const llmTimeoutHint = llmTimeoutRemediationHint(error, getCurrentLlmTimeoutMs());
+      setMessages((prev) => [...prev, createSystemMessage(`本轮执行出错：${errorMessage2(error)}。${llmTimeoutHint ? `${llmTimeoutHint} ` : ""}请重试。`, "error")]);
     } finally {
       if (queryGuard.end(thisGeneration)) {
         setLastQueryCompletionTime(Date.now());
@@ -477601,6 +477776,7 @@ Note: ctrl + z now suspends AtlasHarness, ctrl + _ undoes input.
 var import_compiler_runtime323, React137, import_react280, jsx_dev_runtime427, 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();
   init_bootstrap();
   init_bootstrapState();
   init_tokenBudget();
@@ -490824,6 +491000,14 @@ function createCoreDependencies() {
       return;
     }
   });
+  setLlmTimeoutSettingsSource(() => {
+    try {
+      const v = getInitialSettings().llmTimeoutMs;
+      return typeof v === "number" ? v : undefined;
+    } catch {
+      return;
+    }
+  });
   return {
     sandboxManager,
     modelProvider: getModelProvider(),
@@ -493912,6 +494096,11 @@ async function binMain() {
     await main2();
     return;
   }
+  registerGlobalCrashBackstop();
+  if (process.env.ATLAS_TEST_CRASH_BACKSTOP === "1") {
+    process.emit("uncaughtException", new Error("atlas crash-backstop live probe"));
+    process.exit(0);
+  }
   getCoreDependencies();
   await main();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlasharness/atlascode",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "AtlasCode \u2014 Coding Agent for the domestic computing ecosystem (Ascend NPU + domestic LLM backends)",
   "bin": {
     "atlas": "dist/cli.js",