@atlasharness/atlascode 0.1.16 → 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")
@@ -27094,12 +26857,14 @@ function startLlmWaitHeartbeat(modelId, attempt, totalRetries) {
 class OpenAIProvider {
   maxRetriesPerModel;
   timeoutMs;
-  constructor(maxRetriesPerModel = 3, timeoutMs = LLM_TIMEOUT_DEFAULT_MS) {
+  timeoutResolver;
+  constructor(maxRetriesPerModel = 3, timeoutMs = LLM_TIMEOUT_DEFAULT_MS, timeoutResolver) {
     this.maxRetriesPerModel = maxRetriesPerModel;
     this.timeoutMs = timeoutMs;
+    this.timeoutResolver = timeoutResolver;
   }
   getTimeoutMs() {
-    return this.timeoutMs;
+    return this.timeoutResolver ? this.timeoutResolver() : this.timeoutMs;
   }
   async chat(args) {
     const refs = getRoleModels(args.role, args.sessionModel, args.fallbackModel);
@@ -27139,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();
           }
@@ -27256,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();
     }
@@ -27444,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) {
@@ -27458,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);
   }
@@ -27779,7 +27544,7 @@ var init_queryWithRoleFallback = __esm(() => {
 
 // src/modelprovider/index.ts
 function getModelProvider() {
-  return _provider ??= new OpenAIProvider(3, resolveLlmTimeoutMs(process.env.ATLAS_LLM_TIMEOUT, llmTimeoutSettingsSource?.()));
+  return _provider ??= new OpenAIProvider(3, LLM_TIMEOUT_DEFAULT_MS, () => resolveLlmTimeoutMs(process.env.ATLAS_LLM_TIMEOUT, llmTimeoutSettingsSource?.()));
 }
 function setLlmTimeoutSettingsSource(next) {
   llmTimeoutSettingsSource = next;
@@ -27829,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();
@@ -80612,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))
@@ -80627,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;
@@ -80759,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();
 });
@@ -80779,6 +80888,7 @@ var init_QueryEngine = __esm(() => {
 // src/engine/query/index.ts
 var init_query2 = __esm(() => {
   init_loop();
+  init_turnRecovery();
   init_QueryEngine();
 });
 
@@ -203103,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)) {
@@ -203111,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();
@@ -272332,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();
@@ -490890,6 +491000,14 @@ function createCoreDependencies() {
       return;
     }
   });
+  setLlmTimeoutSettingsSource(() => {
+    try {
+      const v = getInitialSettings().llmTimeoutMs;
+      return typeof v === "number" ? v : undefined;
+    } catch {
+      return;
+    }
+  });
   return {
     sandboxManager,
     modelProvider: getModelProvider(),
@@ -493978,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.16",
+  "version": "0.1.17",
   "description": "AtlasCode \u2014 Coding Agent for the domestic computing ecosystem (Ascend NPU + domestic LLM backends)",
   "bin": {
     "atlas": "dist/cli.js",