@nathapp/nax 0.83.5 → 0.83.6

package/dist/nax.js

@@ -29718,7 +29718,7 @@ function isBuiltInModelMap(agent, entry) {
   const tiers = Object.entries(entry);
   return tiers.length === Object.keys(builtIn).length && tiers.every(([tier, value]) => Object.hasOwn(builtIn, tier) && builtIn[tier] === value);
 }
-var DEFAULT_AGENT_PROTOCOL = "hybrid", DEFAULT_AGENT_NAME = "native", DEFAULT_ACP_TRANSPORT = "sdk", DEFAULT_MODEL_MAPS;
+var DEFAULT_AGENT_PROTOCOL = "hybrid", DEFAULT_AGENT_NAME = "native", DEFAULT_MODEL_MAPS;
 var init_agent_defaults = __esm(() => {
   init_internal();
   DEFAULT_MODEL_MAPS = {
@@ -31247,6 +31247,15 @@ function _applyRemovedWorktreeInheritShim(conf, warn = defaultConfigWarn) {
     execution: { ...execution, worktreeDependencies: { ...worktreeDependencies, mode: "off" } }
   };
 }
+function _applyRemovedAcpTransportShim(conf, warn = defaultConfigWarn) {
+  const agent = conf.agent;
+  const acp = agent?.acp;
+  if (acp === undefined || !Object.hasOwn(acp, "transport"))
+    return conf;
+  const { transport, ...rest } = acp;
+  warn(transport === "acpx" ? 'agent.acp.transport "acpx" was removed: the acpx CLI transport no longer exists, and ACP agents run through ' + "@nathapp/nax-agent-acp (each agent's ACP launcher must be installed). Remove the key from your config." : "agent.acp.transport was removed and has no effect: ACP agents always run through @nathapp/nax-agent-acp. " + "Remove the key from your config.");
+  return { ...conf, agent: { ...agent, acp: rest } };
+}
 function applyBatchModeCompat(conf, warn = defaultConfigWarn) {
   const routing = conf.routing;
   const llm = routing?.llm;
@@ -31373,6 +31382,7 @@ function applyConfigCompatShims(conf, logger, dedupe) {
   out = _applyRemovedRoutingKeysShim(out, warn);
   out = _applyLegacyReviewExecutionShim(out, warn);
   out = _applyRemovedWorktreeInheritShim(out, warn);
+  out = _applyRemovedAcpTransportShim(out, warn);
   out = _applyFinishAutoFlowShim(out, warn);
   out = _applyRemovedOptimizerKeysShim(out, warn);
   out = _applyRemovedCrossPackageDepthShim(out, warn);
@@ -33130,7 +33140,6 @@ var init_schemas_infra = __esm(() => {
     path: ["stopAfterRepeats"]
   });
   AgentAcpConfigSchema = exports_external.object({
-    transport: exports_external.enum(["acpx", "sdk"]).default(DEFAULT_ACP_TRANSPORT),
     promptRetries: exports_external.number().int().min(0).max(5).default(0),
     trackedSpawnDeadlineMs: exports_external.number().int().positive().default(1e4),
     trackedSpawnStartupDeadlineMs: exports_external.number().int().positive().default(30000)
@@ -33166,7 +33175,6 @@ var init_schemas_infra = __esm(() => {
       rebuildContext: true
     }),
     acp: AgentAcpConfigSchema.default({
-      transport: DEFAULT_ACP_TRANSPORT,
       promptRetries: 0,
       trackedSpawnDeadlineMs: 1e4,
       trackedSpawnStartupDeadlineMs: 30000
@@ -33254,7 +33262,7 @@ function validateProtocolGate(data, ctx) {
     ctx.addIssue({
       code: "custom",
       path: ["agent", "default"],
-      message: 'agent.protocol "acp" cannot reach agent.default "native", which is also the built-in default when agent.default is unset. Set agent.default to an acpx agent such as "claude", or use agent.protocol "hybrid".'
+      message: 'agent.protocol "acp" cannot reach agent.default "native", which is also the built-in default when agent.default is unset. Set agent.default to an ACP agent such as "claude", or use agent.protocol "hybrid".'
     });
   }
   if (protocol === "acp" && modelAgents.includes(NATIVE_AGENT_NAME)) {
@@ -33271,7 +33279,7 @@ function validateProtocolGate(data, ctx) {
       ctx.addIssue({
         code: "custom",
         path: ["models", agent],
-        message: `agent.protocol "native" permits only models.native; "${agent}" is an acpx agent. Use "hybrid" to run both.`
+        message: `agent.protocol "native" permits only models.native; "${agent}" is an ACP agent. Use "hybrid" to run both.`
       });
     }
     if ((data.agent?.default ?? DEFAULT_AGENT_NAME) !== NATIVE_AGENT_NAME) {
@@ -33759,7 +33767,6 @@ var init_schemas3 = __esm(() => {
       usageAudit: { enabled: false },
       fallback: { enabled: false, map: {}, maxHopsPerStory: 2, onQualityFailure: false, rebuildContext: true },
       acp: {
-        transport: DEFAULT_ACP_TRANSPORT,
         promptRetries: 0,
         trackedSpawnDeadlineMs: 1e4,
         trackedSpawnStartupDeadlineMs: 30000
@@ -34500,7 +34507,7 @@ function describeUnreferencedAgentModels(agents, config2) {
   const maps = agents.map((agent) => `models.${agent}`).join(", ");
   const head = `${maps} is declared but nothing dispatches to it: no agent.default, enabled fallback rung, pin, escalation rung, ` + `complexity route, routing profile or PRD story names ${agents.join(", ")}.`;
   if (config2.agent?.protocol === "native") {
-    return `${head} Under agent.protocol "native" acpx agents cannot run; remove the map or use protocol "hybrid".`;
+    return `${head} Under agent.protocol "native" ACP agents cannot run; remove the map or use protocol "hybrid".`;
   }
   const defaultAgent = config2.agent?.default ?? DEFAULT_AGENT_NAME;
   return `${head} Unassigned work runs on agent.default "${defaultAgent}". ` + `Set agent.default "${agents[0]}" to run it, or reference it from a pin or fallback rung.`;
@@ -34712,7 +34719,6 @@ __export(exports_config, {
   ContextConfigSchema: () => ContextConfigSchema,
   ContextV2ConfigSchema: () => ContextV2ConfigSchema,
   CuratorRetentionConfigSchema: () => CuratorRetentionConfigSchema,
-  DEFAULT_ACP_TRANSPORT: () => DEFAULT_ACP_TRANSPORT,
   DEFAULT_AGENT_IDLE_WATCHDOG_CONFIG: () => DEFAULT_AGENT_IDLE_WATCHDOG_CONFIG,
   DEFAULT_AGENT_NAME: () => DEFAULT_AGENT_NAME,
   DEFAULT_AGENT_PROTOCOL: () => DEFAULT_AGENT_PROTOCOL,
@@ -38137,41 +38143,341 @@ var init_accept = __esm(() => {
   init_prd();
 });
 
-// src/agents/turn/abort.ts
-function createAbortError(signal, fallback = "Run aborted") {
-  const reason = signal?.reason;
-  if (reason instanceof Error) {
-    return reason;
+// src/agents/errors/parse-agent-error.ts
+function parseAgentError(stderr) {
+  if (!stderr) {
+    return { type: "unknown" };
   }
-  if (typeof reason === "string" && reason.length > 0) {
-    return new Error(reason);
+  const parsedJson = parseJsonObject(stderr);
+  if (parsedJson) {
+    const classified = classifyJsonPayload(parsedJson);
+    if (classified)
+      return classified;
   }
-  return new Error(fallback);
+  if (!parsedJson) {
+    for (const embedded of extractEmbeddedJsonObjects(stderr)) {
+      const classified = classifyJsonPayload(embedded);
+      if (classified)
+        return classified;
+    }
+  }
+  const fromKeyValue = classifyFromCodeTokens(extractKeyValueCodes(stderr));
+  if (fromKeyValue)
+    return fromKeyValue;
+  const flatModel = classifyModelErrorMessage(stderr);
+  if (flatModel)
+    return flatModel;
+  return { type: "unknown" };
 }
-function throwIfAborted(signal, fallback) {
-  if (signal?.aborted) {
-    throw createAbortError(signal, fallback);
+function classifyJsonPayload(payload) {
+  const direct = classifyDirectType(payload);
+  if (direct)
+    return direct;
+  const nested = classifyNestedAnthropicError(payload);
+  if (nested)
+    return nested;
+  const jsonRpcModel = classifyJsonRpcModelError(payload);
+  if (jsonRpcModel)
+    return jsonRpcModel;
+  const structured = classifyFromCodeTokens(extractJsonCodeTokens(payload), payload);
+  if (structured)
+    return structured;
+  return null;
+}
+function classifyNestedAnthropicError(payload) {
+  if (payload.type !== "error")
+    return null;
+  const inner = payload.error;
+  if (!inner || typeof inner !== "object")
+    return null;
+  const innerType = inner.type;
+  if (typeof innerType !== "string")
+    return null;
+  switch (innerType) {
+    case "authentication_error":
+    case "permission_error":
+    case "invalid_api_key_error":
+      return { type: "auth" };
+    case "rate_limit_error":
+    case "overloaded_error": {
+      const retryAfterSeconds = toNumber(inner.retryAfterSeconds ?? inner.retry_after_seconds ?? payload.retryAfterSeconds ?? payload.retry_after_seconds);
+      return retryAfterSeconds !== undefined ? { type: "rate-limit", retryAfterSeconds } : { type: "rate-limit" };
+    }
+    default:
+      return null;
   }
 }
-async function raceWithAbort(promise2, signal, fallback) {
-  if (!signal) {
-    return promise2;
+function extractEmbeddedJsonObjects(text) {
+  const objects = [];
+  let i = 0;
+  while (i < text.length && objects.length < MAX_EMBEDDED_CANDIDATES) {
+    const open3 = text.indexOf("{", i);
+    if (open3 === -1)
+      break;
+    const close = findMatchingBrace(text, open3);
+    if (close === -1)
+      break;
+    const candidate = text.slice(open3, close + 1);
+    try {
+      const parsed = JSON.parse(candidate);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        objects.push(parsed);
+      }
+    } catch {}
+    i = close + 1;
   }
-  if (signal.aborted) {
-    throw createAbortError(signal, fallback);
+  return objects;
+}
+function findMatchingBrace(text, openIdx) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = openIdx;i < text.length; i++) {
+    const ch = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString)
+      continue;
+    if (ch === "{")
+      depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
   }
-  return await new Promise((resolve21, reject) => {
-    const onAbort = () => reject(createAbortError(signal, fallback));
-    signal.addEventListener("abort", onAbort, { once: true });
-    promise2.then((value) => {
-      signal.removeEventListener("abort", onAbort);
-      resolve21(value);
-    }, (error48) => {
-      signal.removeEventListener("abort", onAbort);
-      reject(error48);
-    });
-  });
+  return -1;
 }
+function parseJsonObject(stderr) {
+  try {
+    const value = JSON.parse(stderr);
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return value;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function classifyJsonRpcModelError(payload) {
+  const errObj = payload.error;
+  if (!errObj || typeof errObj !== "object")
+    return null;
+  const message = errObj.message;
+  if (typeof message !== "string")
+    return null;
+  return classifyModelErrorMessage(message);
+}
+function classifyModelErrorMessage(message) {
+  if (message.includes("There's an issue with the selected model") && message.includes("Run --model")) {
+    return { type: "model-not-available" };
+  }
+  return null;
+}
+function classifyDirectType(payload) {
+  const type = payload.type;
+  if (type !== "rate-limit" && type !== "auth" && type !== "timeout" && type !== "crash" && type !== "unknown") {
+    return null;
+  }
+  const result = { type };
+  if (type === "rate-limit") {
+    const retryAfterSeconds = toNumber(payload.retryAfterSeconds ?? payload.retry_after_seconds ?? payload.retryAfter);
+    if (retryAfterSeconds !== undefined) {
+      result.retryAfterSeconds = retryAfterSeconds;
+    }
+  }
+  return result;
+}
+function extractJsonCodeTokens(payload) {
+  const tokens = [];
+  const pushToken = (candidate) => {
+    if (typeof candidate === "number" && Number.isFinite(candidate)) {
+      tokens.push(String(candidate));
+    } else if (typeof candidate === "string" && candidate.trim()) {
+      tokens.push(candidate.trim());
+    }
+  };
+  const MAX_WALK_DEPTH = 8;
+  const walk = (obj, depth) => {
+    if (depth > MAX_WALK_DEPTH)
+      return;
+    const candidates = [obj.code, obj.status, obj.statusCode, obj.httpStatus, obj.errorCode, obj.detailCode];
+    for (const candidate of candidates)
+      pushToken(candidate);
+    for (const key of ["error", "data"]) {
+      const nested = obj[key];
+      if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+        walk(nested, depth + 1);
+      }
+    }
+  };
+  walk(payload, 0);
+  return tokens;
+}
+function extractKeyValueCodes(stderr) {
+  const tokens = [];
+  const patterns = [
+    /(?:status|statusCode|httpStatus|code)\s*[:=]\s*(\d{3})/g,
+    /(?:detailCode|errorCode)\s*[:=]\s*([A-Z0-9_]+)/g
+  ];
+  for (const pattern of patterns) {
+    while (true) {
+      const match = pattern.exec(stderr);
+      if (!match)
+        break;
+      const code = match[1];
+      if (code)
+        tokens.push(code);
+    }
+  }
+  return tokens;
+}
+function classifyFromCodeTokens(tokens, payload) {
+  for (const token of tokens.map((value) => value.toUpperCase())) {
+    if (token === "429" || token === "TOO_MANY_REQUESTS" || token === "RATE_LIMIT" || token === "RATE_LIMITED" || token === "QUOTA_EXCEEDED" || token === "RESOURCE_EXHAUSTED") {
+      const retryAfterSeconds = payload ? findRetryAfterSeconds(payload) : undefined;
+      return retryAfterSeconds !== undefined ? { type: "rate-limit", retryAfterSeconds } : { type: "rate-limit" };
+    }
+    if (token === "401" || token === "403" || token === "UNAUTHORIZED" || token === "FORBIDDEN" || token === "AUTH_FAILED" || token === "AUTHENTICATION_FAILED" || token === "PERMISSION_DENIED") {
+      return { type: "auth" };
+    }
+  }
+  return null;
+}
+function toNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return Math.trunc(value);
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return;
+}
+function findRetryAfterSeconds(payload) {
+  const topLevel = toNumber(payload.retryAfterSeconds ?? payload.retry_after_seconds ?? payload.retryAfter);
+  if (topLevel !== undefined)
+    return topLevel;
+  const error48 = payload.error;
+  if (error48 && typeof error48 === "object" && !Array.isArray(error48)) {
+    const errObj = error48;
+    const inError = toNumber(errObj.retryAfterSeconds ?? errObj.retry_after_seconds ?? errObj.retryAfter);
+    if (inError !== undefined)
+      return inError;
+    const data = errObj.data;
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const dataObj = data;
+      return toNumber(dataObj.retryAfterSeconds ?? dataObj.retry_after_seconds ?? dataObj.retryAfter);
+    }
+  }
+  return;
+}
+var MAX_EMBEDDED_CANDIDATES = 8;
+
+// src/agents/errors/index.ts
+var init_errors5 = () => {};
+
+// src/agents/transport-failure-message.ts
+function isTransportFailureMessage(message) {
+  if (!message)
+    return false;
+  const haystack = message.toLowerCase();
+  return TRANSPORT_FAULT_MARKERS.some((marker) => haystack.includes(marker));
+}
+var TRANSPORT_FAULT_MARKERS;
+var init_transport_failure_message = __esm(() => {
+  TRANSPORT_FAULT_MARKERS = [
+    "idle timeout exceeded",
+    "stream idle timeout",
+    "upstream timeout",
+    "bad gateway",
+    "service unavailable",
+    "gateway timeout",
+    "econnreset",
+    "econnrefused",
+    "econnaborted",
+    "etimedout",
+    "socket hang up",
+    "premature close",
+    "terminated: other side closed",
+    "network error"
+  ];
+});
+
+// src/agents/types.ts
+var CompleteError, SessionFailureError;
+var init_types4 = __esm(() => {
+  init_src();
+  CompleteError = class CompleteError extends Error {
+    exitCode;
+    retryable;
+    constructor(message, exitCode, retryable) {
+      super(message);
+      this.exitCode = exitCode;
+      this.retryable = retryable;
+      this.name = "CompleteError";
+    }
+  };
+  SessionFailureError = class SessionFailureError extends Error {
+    adapterFailure;
+    constructor(message, adapterFailure) {
+      super(message);
+      this.adapterFailure = adapterFailure;
+      this.name = "SessionFailureError";
+    }
+  };
+});
+
+// src/agents/complete-exception-classifier.ts
+function classifyCompleteException(err) {
+  if ((err instanceof SessionTurnError || err instanceof SessionFailureError) && err.adapterFailure !== undefined) {
+    return err.adapterFailure;
+  }
+  const fullMessage = errorMessage(err);
+  const message = fullMessage.slice(0, MAX_FAILURE_MESSAGE_CHARS);
+  if (err instanceof NaxError && err.code === "AGENT_TIMEOUT") {
+    return { category: "quality", outcome: "fail-timeout", retriable: true, message };
+  }
+  const parsed = parseAgentError(fullMessage);
+  switch (parsed.type) {
+    case "auth":
+      return { category: "availability", outcome: "fail-auth", retriable: false, message };
+    case "rate-limit":
+      return {
+        category: "availability",
+        outcome: "fail-rate-limit",
+        retriable: true,
+        message,
+        ...parsed.retryAfterSeconds !== undefined ? { retryAfterSeconds: parsed.retryAfterSeconds } : {}
+      };
+    case "model-not-available":
+      return { category: "quality", outcome: "fail-adapter-error", retriable: false, message };
+    case "timeout":
+      return { category: "quality", outcome: "fail-timeout", retriable: true, message };
+    case "crash":
+      return { category: "quality", outcome: "fail-adapter-error", retriable: false, message };
+    default:
+      return isTransportFailureMessage(fullMessage) ? { category: "availability", outcome: "fail-service-down", retriable: true, message } : { category: "quality", outcome: "fail-unknown", retriable: false, message };
+  }
+}
+var MAX_FAILURE_MESSAGE_CHARS = 500;
+var init_complete_exception_classifier = __esm(() => {
+  init_internal();
+  init_errors4();
+  init_errors5();
+  init_transport_failure_message();
+  init_types4();
+});
 
 // src/agents/cost/calculate.ts
 function resolvePricingSource(model) {
@@ -38188,7 +38494,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.83.5",
+    version: "0.83.6",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -38482,2404 +38788,33 @@ var init_cost = __esm(() => {
   init_rate_card();
 });
 
-// src/agents/turn/turn-deadline.ts
-function assembleTurnResult(input) {
-  const { totalTokenUsage, totalExactCostUsd, turnCount, interactions, timedOut, rateCard } = input;
-  const output = timedOut ? "" : input.output;
-  const hasUsage = totalTokenUsage.inputTokens > 0 || totalTokenUsage.outputTokens > 0;
-  const priced = hasUsage ? priceCall(totalTokenUsage, rateCard.rates) : undefined;
-  return {
-    output,
-    tokenUsage: totalTokenUsage,
-    estimatedCostUsd: priced?.costUsd ?? 0,
-    exactCostUsd: totalExactCostUsd,
-    internalRoundTrips: turnCount,
-    ...interactions.length > 0 ? { interactions } : {},
-    timedOut,
-    pricingSource: rateCard.source,
-    ...priced?.resolvedRates !== undefined ? { rates: priced.resolvedRates } : {}
-  };
-}
-function warnWallClockTimeout(sessionName, timeoutSeconds, stage) {
-  getSafeLogger2()?.warn(stage, "wall-clock timeout exceeded \u2014 session terminated", {
-    sessionName,
-    timeoutSeconds
-  });
-}
-var init_turn_deadline2 = __esm(() => {
-  init_logger2();
-  init_cost();
-});
-
-// src/agents/turn/index.ts
-var init_turn = __esm(() => {
-  init_turn_deadline2();
-});
-
-// src/utils/bun-deps.ts
-function typedSpawn(cmd, opts) {
-  return Bun.spawn(cmd, opts);
-}
-function which2(name) {
-  return Bun.which(name);
-}
-function sleep(ms) {
-  return Bun.sleep(ms);
-}
-function cancellableDelay(ms, signal) {
-  return new Promise((resolve21, reject) => {
-    if (signal?.aborted) {
-      reject(signal.reason ?? new Error("delay aborted"));
-      return;
-    }
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve21();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(signal?.reason ?? new Error("delay aborted"));
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-var spawn;
-var init_bun_deps = __esm(() => {
-  spawn = Bun.spawn;
-});
-
-// src/agents/errors/parse-agent-error.ts
-function classifyCompleteError(error48, pricingSource) {
-  if (error48.retryable === undefined)
-    return null;
-  return {
-    output: error48.message,
-    tokenUsage: { inputTokens: 0, outputTokens: 0 },
-    estimatedCostUsd: 0,
-    adapterFailure: {
-      category: "quality",
-      outcome: "fail-adapter-error",
-      retriable: error48.retryable,
-      message: error48.message.slice(0, 500)
-    },
-    ...pricingSource !== undefined ? { pricingSource } : {}
-  };
-}
-function classifyParsedAgentError(parsed, message, pricingSource) {
-  const base = {
-    output: message,
-    tokenUsage: { inputTokens: 0, outputTokens: 0 },
-    estimatedCostUsd: 0,
-    ...pricingSource !== undefined ? { pricingSource } : {}
-  };
-  const truncated = message.slice(0, 500);
-  switch (parsed.type) {
-    case "auth":
-      return {
-        ...base,
-        adapterFailure: { category: "availability", outcome: "fail-auth", retriable: false, message: truncated }
-      };
-    case "rate-limit":
-      return {
-        ...base,
-        adapterFailure: {
-          category: "availability",
-          outcome: "fail-rate-limit",
-          retriable: true,
-          message: truncated,
-          ...parsed.retryAfterSeconds !== undefined && { retryAfterSeconds: parsed.retryAfterSeconds }
-        }
-      };
-    case "model-not-available":
-      return {
-        ...base,
-        adapterFailure: { category: "quality", outcome: "fail-adapter-error", retriable: false, message: truncated }
-      };
-    default:
-      return null;
-  }
-}
-function parseAgentError(stderr) {
-  if (!stderr) {
-    return { type: "unknown" };
-  }
-  const parsedJson = parseJsonObject(stderr);
-  if (parsedJson) {
-    const classified = classifyJsonPayload(parsedJson);
-    if (classified)
-      return classified;
-  }
-  if (!parsedJson) {
-    for (const embedded of extractEmbeddedJsonObjects(stderr)) {
-      const classified = classifyJsonPayload(embedded);
-      if (classified)
-        return classified;
-    }
-  }
-  const bracketed = extractBracketedCodes(stderr);
-  const fromBracketed = classifyFromCodeTokens(bracketed);
-  if (fromBracketed)
-    return fromBracketed;
-  const fromKeyValue = classifyFromCodeTokens(extractKeyValueCodes(stderr));
-  if (fromKeyValue)
-    return fromKeyValue;
-  const flatModel = classifyModelErrorMessage(stderr);
-  if (flatModel)
-    return flatModel;
-  return { type: "unknown" };
-}
-function classifyJsonPayload(payload) {
-  const direct = classifyDirectType(payload);
-  if (direct)
-    return direct;
-  const nested = classifyNestedAnthropicError(payload);
-  if (nested)
-    return nested;
-  const jsonRpcModel = classifyJsonRpcModelError(payload);
-  if (jsonRpcModel)
-    return jsonRpcModel;
-  const structured = classifyFromCodeTokens(extractJsonCodeTokens(payload), payload);
-  if (structured)
-    return structured;
-  return null;
-}
-function classifyNestedAnthropicError(payload) {
-  if (payload.type !== "error")
-    return null;
-  const inner = payload.error;
-  if (!inner || typeof inner !== "object")
-    return null;
-  const innerType = inner.type;
-  if (typeof innerType !== "string")
-    return null;
-  switch (innerType) {
-    case "authentication_error":
-    case "permission_error":
-    case "invalid_api_key_error":
-      return { type: "auth" };
-    case "rate_limit_error":
-    case "overloaded_error": {
-      const retryAfterSeconds = toNumber(inner.retryAfterSeconds ?? inner.retry_after_seconds ?? payload.retryAfterSeconds ?? payload.retry_after_seconds);
-      return retryAfterSeconds !== undefined ? { type: "rate-limit", retryAfterSeconds } : { type: "rate-limit" };
-    }
-    default:
-      return null;
-  }
-}
-function extractEmbeddedJsonObjects(text) {
-  const objects = [];
-  let i = 0;
-  while (i < text.length && objects.length < MAX_EMBEDDED_CANDIDATES) {
-    const open3 = text.indexOf("{", i);
-    if (open3 === -1)
-      break;
-    const close = findMatchingBrace(text, open3);
-    if (close === -1)
-      break;
-    const candidate = text.slice(open3, close + 1);
-    try {
-      const parsed = JSON.parse(candidate);
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        objects.push(parsed);
-      }
-    } catch {}
-    i = close + 1;
-  }
-  return objects;
-}
-function findMatchingBrace(text, openIdx) {
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let i = openIdx;i < text.length; i++) {
-    const ch = text[i];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (ch === "\\" && inString) {
-      escaped = true;
-      continue;
-    }
-    if (ch === '"') {
-      inString = !inString;
-      continue;
-    }
-    if (inString)
-      continue;
-    if (ch === "{")
-      depth++;
-    else if (ch === "}") {
-      depth--;
-      if (depth === 0)
-        return i;
-    }
-  }
-  return -1;
-}
-function parseJsonObject(stderr) {
-  try {
-    const value = JSON.parse(stderr);
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      return value;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function classifyJsonRpcModelError(payload) {
-  const errObj = payload.error;
-  if (!errObj || typeof errObj !== "object")
-    return null;
-  const message = errObj.message;
-  if (typeof message !== "string")
-    return null;
-  return classifyModelErrorMessage(message);
-}
-function classifyModelErrorMessage(message) {
-  if (message.startsWith("Cannot apply --model") || message.startsWith("Cannot replay saved model")) {
-    return { type: "model-not-available" };
-  }
-  if (message.includes("There's an issue with the selected model") && message.includes("Run --model")) {
-    return { type: "model-not-available" };
-  }
-  return null;
-}
-function classifyDirectType(payload) {
-  const type = payload.type;
-  if (type !== "rate-limit" && type !== "auth" && type !== "timeout" && type !== "crash" && type !== "unknown") {
-    return null;
-  }
-  const result = { type };
-  if (type === "rate-limit") {
-    const retryAfterSeconds = toNumber(payload.retryAfterSeconds ?? payload.retry_after_seconds ?? payload.retryAfter);
-    if (retryAfterSeconds !== undefined) {
-      result.retryAfterSeconds = retryAfterSeconds;
-    }
-  }
-  return result;
-}
-function extractJsonCodeTokens(payload) {
-  const tokens = [];
-  const pushToken = (candidate) => {
-    if (typeof candidate === "number" && Number.isFinite(candidate)) {
-      tokens.push(String(candidate));
-    } else if (typeof candidate === "string" && candidate.trim()) {
-      tokens.push(candidate.trim());
-    }
-  };
-  const MAX_WALK_DEPTH = 8;
-  const walk = (obj, depth) => {
-    if (depth > MAX_WALK_DEPTH)
-      return;
-    const candidates = [
-      obj.code,
-      obj.status,
-      obj.statusCode,
-      obj.httpStatus,
-      obj.errorCode,
-      obj.acpxCode,
-      obj.detailCode
-    ];
-    for (const candidate of candidates)
-      pushToken(candidate);
-    for (const key of ["error", "data"]) {
-      const nested = obj[key];
-      if (nested && typeof nested === "object" && !Array.isArray(nested)) {
-        walk(nested, depth + 1);
-      }
-    }
-  };
-  walk(payload, 0);
-  return tokens;
-}
-function extractBracketedCodes(stderr) {
-  const tokens = [];
-  const matches = stderr.match(/\[([A-Z0-9_/-]+)\]/g) ?? [];
-  for (const entry of matches) {
-    const inner = entry.slice(1, -1);
-    for (const token of inner.split("/")) {
-      const trimmed = token.trim();
-      if (trimmed)
-        tokens.push(trimmed);
-    }
-  }
-  return tokens;
-}
-function extractKeyValueCodes(stderr) {
-  const tokens = [];
-  const patterns = [
-    /(?:status|statusCode|httpStatus|code)\s*[:=]\s*(\d{3})/g,
-    /(?:acpxCode|detailCode|errorCode)\s*[:=]\s*([A-Z0-9_]+)/g
-  ];
-  for (const pattern of patterns) {
-    while (true) {
-      const match = pattern.exec(stderr);
-      if (!match)
-        break;
-      const code = match[1];
-      if (code)
-        tokens.push(code);
-    }
-  }
-  return tokens;
-}
-function classifyFromCodeTokens(tokens, payload) {
-  for (const token of tokens.map((value) => value.toUpperCase())) {
-    if (token === "429" || token === "TOO_MANY_REQUESTS" || token === "RATE_LIMIT" || token === "RATE_LIMITED" || token === "QUOTA_EXCEEDED" || token === "RESOURCE_EXHAUSTED") {
-      const retryAfterSeconds = payload ? findRetryAfterSeconds(payload) : undefined;
-      return retryAfterSeconds !== undefined ? { type: "rate-limit", retryAfterSeconds } : { type: "rate-limit" };
-    }
-    if (token === "401" || token === "403" || token === "UNAUTHORIZED" || token === "FORBIDDEN" || token === "AUTH_FAILED" || token === "AUTHENTICATION_FAILED" || token === "PERMISSION_DENIED") {
-      return { type: "auth" };
-    }
-  }
-  return null;
-}
-function toNumber(value) {
-  if (typeof value === "number" && Number.isFinite(value))
-    return Math.trunc(value);
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number.parseInt(value, 10);
-    if (Number.isFinite(parsed))
-      return parsed;
-  }
-  return;
-}
-function findRetryAfterSeconds(payload) {
-  const topLevel = toNumber(payload.retryAfterSeconds ?? payload.retry_after_seconds ?? payload.retryAfter);
-  if (topLevel !== undefined)
-    return topLevel;
-  const error48 = payload.error;
-  if (error48 && typeof error48 === "object" && !Array.isArray(error48)) {
-    const errObj = error48;
-    const inError = toNumber(errObj.retryAfterSeconds ?? errObj.retry_after_seconds ?? errObj.retryAfter);
-    if (inError !== undefined)
-      return inError;
-    const data = errObj.data;
-    if (data && typeof data === "object" && !Array.isArray(data)) {
-      const dataObj = data;
-      return toNumber(dataObj.retryAfterSeconds ?? dataObj.retry_after_seconds ?? dataObj.retryAfter);
-    }
-  }
-  return;
-}
-var MAX_EMBEDDED_CANDIDATES = 8;
-
-// src/agents/errors/index.ts
-var init_errors5 = () => {};
-
-// src/agents/shared/env.ts
-import { homedir as homedir5 } from "os";
-import { isAbsolute as isAbsolute10 } from "path";
-function buildAllowedEnv(options) {
-  const allowed = {};
-  for (const varName of ESSENTIAL_VARS) {
-    if (process.env[varName])
-      allowed[varName] = process.env[varName];
-  }
-  const rawHome = process.env.HOME ?? "";
-  const safeHome = rawHome && isAbsolute10(rawHome) ? rawHome : homedir5();
-  if (rawHome !== safeHome) {
-    getSafeLogger2()?.warn("env", `HOME env is not absolute ("${rawHome}"), falling back to os.homedir(): ${safeHome}`);
-  }
-  allowed.HOME = safeHome;
-  for (const varName of API_KEY_VARS) {
-    if (process.env[varName])
-      allowed[varName] = process.env[varName];
-  }
-  for (const [key, value] of Object.entries(process.env)) {
-    if (ALLOWED_PREFIXES.some((prefix) => key.startsWith(prefix))) {
-      allowed[key] = value;
-    }
-  }
-  if (options?.modelEnv)
-    Object.assign(allowed, options.modelEnv);
-  if (options?.env)
-    Object.assign(allowed, options.env);
-  return allowed;
-}
-var ESSENTIAL_VARS, API_KEY_VARS, ALLOWED_PREFIXES;
-var init_env = __esm(() => {
-  init_logger2();
-  ESSENTIAL_VARS = ["PATH", "TMPDIR", "NODE_ENV", "USER", "LOGNAME"];
-  API_KEY_VARS = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GEMINI_API_KEY", "GOOGLE_API_KEY", "CLAUDE_API_KEY"];
-  ALLOWED_PREFIXES = [
-    "CLAUDE_",
-    "NAX_",
-    "CLAW_",
-    "TURBO_",
-    "ACPX_",
-    "CODEX_",
-    "GEMINI_",
-    "ANTHROPIC_",
-    "OPENCODE_",
-    "MINIMAX_"
-  ];
-});
-
-// src/agents/acp/reasoning-effort.ts
-async function discoverEffortOptionId(params) {
-  const { agentName, sessionName, cwd, storyId, spawn: spawn2 } = params;
-  const cmd = ["acpx", "--cwd", cwd, "--format", "json", agentName, "sessions", "show", sessionName];
-  try {
-    const { exitCode, stdout, stderr } = await spawn2(cmd);
-    if (exitCode !== 0) {
-      getSafeLogger2()?.debug("acp-adapter", "Could not list session config options; falling back to static map", {
-        storyId,
-        agentName,
-        cause: stdout || stderr
-      });
-      return;
-    }
-    const parsed = JSON.parse(stdout);
-    const options = parsed.acpx?.config_options;
-    const match = Array.isArray(options) ? options.find((o) => o?.category === THOUGHT_LEVEL_CATEGORY) : undefined;
-    return typeof match?.id === "string" ? match.id : undefined;
-  } catch (err) {
-    getSafeLogger2()?.debug("acp-adapter", "Effort option discovery failed; falling back to static map", {
-      storyId,
-      agentName,
-      cause: err instanceof Error ? err.message : String(err)
-    });
-    return;
-  }
-}
-async function applyReasoningEffort(params) {
-  const { effort, agentName, sessionName, cwd, storyId, spawn: spawn2 } = params;
-  if (!effort)
-    return;
-  const optionName = await discoverEffortOptionId({ agentName, sessionName, cwd, storyId, spawn: spawn2 }) ?? EFFORT_OPTION_BY_AGENT[agentName];
-  if (!optionName) {
-    getSafeLogger2()?.debug("acp-adapter", "Agent has no known effort option; skipping", {
-      storyId,
-      agentName,
-      effort
-    });
-    return;
-  }
-  const cmd = ["acpx", "--cwd", cwd, agentName, "set", optionName, effort, "-s", sessionName];
-  const { exitCode, stdout, stderr } = await spawn2(cmd);
-  if (exitCode !== 0) {
-    getSafeLogger2()?.warn("acp-adapter", `Failed to set ${optionName}; continuing at adapter default`, {
-      storyId,
-      effort,
-      session: sessionName,
-      cause: stdout || stderr
-    });
-  }
-}
-var THOUGHT_LEVEL_CATEGORY = "thought_level", EFFORT_OPTION_BY_AGENT;
-var init_reasoning_effort = __esm(() => {
-  init_logger2();
-  EFFORT_OPTION_BY_AGENT = {
-    codex: "reasoning_effort",
-    claude: "effort",
-    opencode: "effort",
-    pi: "thought_level"
-  };
-});
-
-// src/agents/acp/session-ids.ts
-function parseSessionIds(stdout) {
-  for (const line of stdout.split(`
-`).reverse()) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("{"))
-      continue;
-    try {
-      const parsed = JSON.parse(trimmed);
-      const sessionId = parsed.acpxSessionId;
-      const recordId = parsed.acpxRecordId;
-      if (typeof sessionId === "string" && sessionId.length > 0) {
-        return {
-          sessionId,
-          recordId: typeof recordId === "string" && recordId.length > 0 ? recordId : undefined
-        };
-      }
-    } catch {}
-  }
-  return { sessionId: undefined, recordId: undefined };
-}
-
-// src/agents/acp/spawn-client-deps.ts
-var ACPX_STREAM_DRAIN_TIMEOUT_MS = 5000, KILL_TREE_GRACE_MS = 250, TRACKED_SPAWN_DEADLINE_MS = 1e4, TRACKED_SPAWN_STARTUP_DEADLINE_MS = 30000, _spawnClientDeps;
-var init_spawn_client_deps = __esm(() => {
-  init_bun_deps();
-  _spawnClientDeps = {
-    spawn: typedSpawn,
-    streamDrainTimeoutMs: ACPX_STREAM_DRAIN_TIMEOUT_MS,
-    killTreeGraceMs: KILL_TREE_GRACE_MS,
-    trackedSpawnDeadlineMs: TRACKED_SPAWN_DEADLINE_MS,
-    trackedSpawnStartupDeadlineMs: TRACKED_SPAWN_STARTUP_DEADLINE_MS
-  };
-});
-
-// src/agents/acp/spawn-client-process.ts
-function makeStreamDrain(ms) {
-  let id;
-  const promise2 = new Promise((resolve21) => {
-    id = setTimeout(() => resolve21(""), ms);
-  });
-  return { promise: promise2, cancel: () => clearTimeout(id) };
-}
-function killProcessTree(pid, graceMs, exited) {
-  activeKillTimers.get(pid)?.cancel();
-  activeKillTimers.delete(pid);
-  try {
-    killProcessGroup(pid, "SIGTERM");
-    getSafeLogger2()?.debug("acp-adapter", `Sent SIGTERM to process group ${pid}`);
-  } catch {}
-  let settled2 = false;
-  const timer = { id: undefined };
-  const gracePromise = new Promise((resolve21) => {
-    timer.id = setTimeout(() => resolve21("grace"), graceMs);
-    if (timer.id.unref)
-      timer.id.unref();
-  });
-  const exitedPromise = exited?.then(() => "exited", () => "exited");
-  const raced = exitedPromise !== undefined ? Promise.race([gracePromise, exitedPromise]) : gracePromise;
-  raced.then((outcome) => {
-    clearTimeout(timer.id);
-    if (settled2)
-      return;
-    settled2 = true;
-    activeKillTimers.delete(pid);
-    if (outcome === "exited")
-      return;
-    if (!isProcessAlive(pid))
-      return;
-    try {
-      killProcessGroup(pid, "SIGKILL");
-    } catch {}
-  });
-  const handle = {
-    cancel: () => {
-      settled2 = true;
-      clearTimeout(timer.id);
-      activeKillTimers.delete(pid);
-    }
-  };
-  activeKillTimers.set(pid, handle);
-  return handle;
-}
-async function runTrackedSpawn(deps, cmd, opts, onPidSpawned, onPidExited, signal) {
-  const proc = deps.spawn(cmd, { stdout: "pipe", stderr: "pipe", ...opts });
-  const pid = proc.pid;
-  onPidSpawned?.(pid);
-  const exitedNotified = proc.exited.catch(() => -1).finally(() => {
-    try {
-      onPidExited?.(pid);
-    } catch {}
-  });
-  const deadlineController = new AbortController;
-  const forwardAbort = () => deadlineController.abort(signal?.reason);
-  if (signal?.aborted) {
-    deadlineController.abort(signal.reason);
-  } else {
-    signal?.addEventListener("abort", forwardAbort, { once: true });
-  }
-  const deadline = cancellableDelay(deps.trackedSpawnDeadlineMs, deadlineController.signal).catch(() => {});
-  try {
-    const raced = await Promise.race([
-      exitedNotified.then((code) => ({ timedOut: false, code })),
-      deadline.then(() => ({ timedOut: true, code: -1 }))
-    ]);
-    if (raced.timedOut) {
-      const reason = signal?.aborted ? "aborted" : "deadline exceeded";
-      getSafeLogger2()?.warn("acp-adapter", `trackedSpawn ${reason} \u2014 killing process tree for PID ${pid}`, {
-        pid,
-        deadlineMs: deps.trackedSpawnDeadlineMs,
-        reason
-      });
-      killProcessTree(pid, deps.killTreeGraceMs, proc.exited);
-      try {
-        proc.stdout?.cancel?.();
-      } catch {}
-      try {
-        proc.stderr?.cancel?.();
-      } catch {}
-      return { exitCode: -1, stdout: "", stderr: "" };
-    }
-    const [stdout, stderr] = await Promise.all([
-      drainStream(proc.stdout, deps.streamDrainTimeoutMs),
-      drainStream(proc.stderr, deps.streamDrainTimeoutMs)
-    ]);
-    return { exitCode: raced.code, stdout, stderr };
-  } finally {
-    deadlineController.abort();
-    signal?.removeEventListener("abort", forwardAbort);
-  }
-}
-async function drainStream(stream, timeoutMs) {
-  if (!stream)
-    return "";
-  const reader = stream.getReader();
-  const decoder = new TextDecoder;
-  const readAll = async () => {
-    let text = "";
-    for (;; ) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      text += decoder.decode(value, { stream: true });
-    }
-    text += decoder.decode();
-    return text;
-  };
-  const drain = makeStreamDrain(timeoutMs);
-  const winner = await Promise.race([
-    readAll().catch(() => "").then((text) => ({ fromStream: true, text })),
-    drain.promise.then(() => ({ fromStream: false, text: "" }))
-  ]).finally(() => drain.cancel());
-  if (!winner.fromStream) {
-    reader.cancel().catch(() => {});
-  }
-  return winner.text;
-}
-var activeKillTimers;
-var init_spawn_client_process = __esm(() => {
-  init_internal();
-  init_logger2();
-  init_bun_deps();
-  activeKillTimers = new Map;
-});
-
-// src/agents/acp/parser-line-handlers.ts
-function asFiniteNumber(...values) {
-  for (const v of values) {
-    if (typeof v === "number" && Number.isFinite(v))
-      return v;
-  }
-  return;
-}
-function isProtocolDrift(event) {
-  const looksLikeJsonRpcShape = typeof event.method === "string" && event.params !== undefined || event.id !== undefined && event.result && typeof event.result === "object";
-  return event.jsonrpc !== "2.0" && looksLikeJsonRpcShape;
-}
-function reportProtocolDrift(event, state) {
-  getSafeLogger2()?.error("acp-adapter", "Unsupported or missing JSON-RPC protocol version in acpx output", {
-    jsonrpc: event.jsonrpc,
-    method: typeof event.method === "string" ? event.method : undefined
-  });
-  state.error ??= "Unsupported acpx JSON-RPC protocol version";
-}
-function decorateAcpxError(err, errorMsg, state) {
-  let msg = errorMsg;
-  const data = err.data;
-  if (data && typeof data === "object") {
-    const suffix = [data.acpxCode, data.detailCode].filter(Boolean).join("/");
-    if (suffix)
-      msg = `${msg} [${suffix}]`;
-    if (!state.error && data.retryable === true)
-      state.retryable = true;
-  }
-  return msg;
-}
-function handleAgentMessageChunk(update, state) {
-  if (update.content?.type === "text" && typeof update.content.text === "string") {
-    const text = update.content.text;
-    state.text += text;
-    return {
-      kind: "message_update",
-      deltaBytes: text.length
-    };
-  }
-  return;
-}
-function handleAgentThoughtChunk(update) {
-  if (update.content?.type === "text" && typeof update.content.text === "string") {
-    return {
-      kind: "thinking_update",
-      deltaBytes: update.content.text.length
-    };
-  }
-  return;
-}
-function handleUsageUpdate(update, state) {
-  const activity = { kind: "usage_update" };
-  const metaUsage = update._meta != null && typeof update._meta === "object" ? update._meta.usage : undefined;
-  if (metaUsage != null && typeof metaUsage === "object") {
-    const inp = asFiniteNumber(metaUsage.inputTokens, metaUsage.input_tokens);
-    if (inp !== undefined)
-      activity.inputTokens = inp;
-    const out = asFiniteNumber(metaUsage.outputTokens, metaUsage.output_tokens);
-    if (out !== undefined)
-      activity.outputTokens = out;
-    const cacheRead = asFiniteNumber(metaUsage.cachedReadTokens, metaUsage.cache_read_input_tokens);
-    if (cacheRead !== undefined)
-      activity.cacheRead = cacheRead;
-    const cacheWrite = asFiniteNumber(metaUsage.cachedWriteTokens, metaUsage.cache_creation_input_tokens);
-    if (cacheWrite !== undefined)
-      activity.cacheWrite = cacheWrite;
-  }
-  if (activity.outputTokens == null) {
-    const used = asFiniteNumber(update.used);
-    if (used !== undefined)
-      activity.outputTokens = used;
-  }
-  const costAmount = asFiniteNumber(update.cost?.amount);
-  if (costAmount !== undefined) {
-    activity.costUsd = costAmount;
-    state.exactCostUsd = costAmount;
-  }
-  return activity;
-}
-function handleToolCallActivity(update) {
-  return {
-    kind: "tool_call_update",
-    toolName: extractToolName(update)
-  };
-}
-function extractToolName(update) {
-  const directName = update.toolName;
-  if (typeof directName === "string" && directName.trim())
-    return directName;
-  const nestedTool = update.tool;
-  if (nestedTool && typeof nestedTool === "object") {
-    const name = nestedTool.name;
-    if (typeof name === "string" && name.trim())
-      return name;
-  }
-  return;
-}
-function handleSessionUpdate(update, state) {
-  const key = update.sessionUpdate;
-  if (typeof key !== "string")
-    return;
-  if (!Object.hasOwn(SESSION_UPDATE_HANDLERS, key))
-    return;
-  return SESSION_UPDATE_HANDLERS[key](update, state);
-}
-function applyJsonRpcResult(event, state) {
-  if (event.id !== undefined && event.result && typeof event.result === "object") {
-    const result = event.result;
-    if (result.stopReason)
-      state.stopReason = result.stopReason;
-    if (result.stop_reason)
-      state.stopReason = result.stop_reason;
-    if (result.usage && typeof result.usage === "object") {
-      const u = result.usage;
-      const inputTokens = asFiniteNumber(u.inputTokens, u.input_tokens);
-      const outputTokens = asFiniteNumber(u.outputTokens, u.output_tokens);
-      if (inputTokens !== undefined && outputTokens !== undefined) {
-        state.tokenUsage = {
-          input_tokens: inputTokens,
-          output_tokens: outputTokens,
-          cache_read_input_tokens: asFiniteNumber(u.cachedReadTokens, u.cache_read_input_tokens) ?? 0,
-          cache_creation_input_tokens: asFiniteNumber(u.cachedWriteTokens, u.cache_creation_input_tokens) ?? 0
-        };
-      }
-    }
-  }
-}
-function applyJsonRpcError(event, state) {
-  if (event.error && typeof event.error === "object") {
-    const err = event.error;
-    let errorMsg = typeof err.message === "string" ? err.message : JSON.stringify(event.error);
-    errorMsg = decorateAcpxError(err, errorMsg, state);
-    if (!state.error)
-      state.error = errorMsg;
-  }
-}
-function handleJsonRpcEvent(event, state) {
-  if (event.method === "session/update" && event.params?.update) {
-    const activity = handleSessionUpdate(event.params.update, state);
-    if (activity !== undefined)
-      return activity;
-  }
-  applyJsonRpcResult(event, state);
-  applyJsonRpcError(event, state);
-  return;
-}
-function applyLegacyCumulativeUsage(event, state) {
-  if (event.cumulative_token_usage && typeof event.cumulative_token_usage === "object") {
-    const c = event.cumulative_token_usage;
-    const inputTokens = asFiniteNumber(c.input_tokens);
-    const outputTokens = asFiniteNumber(c.output_tokens);
-    if (inputTokens !== undefined && outputTokens !== undefined) {
-      state.tokenUsage = {
-        input_tokens: inputTokens,
-        output_tokens: outputTokens,
-        cache_read_input_tokens: asFiniteNumber(c.cache_read_input_tokens) ?? 0,
-        cache_creation_input_tokens: asFiniteNumber(c.cache_creation_input_tokens) ?? 0
-      };
-    }
-  }
-}
-function applyLegacyUsage(event, state) {
-  if (!event.usage)
-    return;
-  const legacyInputTokens = asFiniteNumber(event.usage.input_tokens, event.usage.prompt_tokens);
-  const legacyOutputTokens = asFiniteNumber(event.usage.output_tokens, event.usage.completion_tokens);
-  if (legacyInputTokens !== undefined && legacyOutputTokens !== undefined) {
-    state.tokenUsage = {
-      input_tokens: legacyInputTokens,
-      output_tokens: legacyOutputTokens
-    };
-  }
-}
-function applyLegacyStopReason(event, state) {
-  if (event.stopReason)
-    state.stopReason = event.stopReason;
-  if (event.stop_reason)
-    state.stopReason = event.stop_reason;
-}
-function applyLegacyError(event, state) {
-  if (!event.error)
-    return;
-  if (typeof event.error === "string") {
-    state.error ??= event.error;
-    return;
-  }
-  let errorMsg = typeof event.error.message === "string" ? event.error.message : JSON.stringify(event.error);
-  errorMsg = decorateAcpxError(event.error, errorMsg, state);
-  state.error ??= errorMsg;
-}
-function handleLegacyLine(event, state) {
-  if (event.result && typeof event.result === "string") {
-    state.text = event.result;
-  } else if (event.content && typeof event.content === "string") {
-    state.text += event.content;
-  } else if (event.text && typeof event.text === "string") {
-    state.text += event.text;
-  }
-  applyLegacyCumulativeUsage(event, state);
-  applyLegacyUsage(event, state);
-  applyLegacyStopReason(event, state);
-  applyLegacyError(event, state);
-}
-var SESSION_UPDATE_HANDLERS;
-var init_parser_line_handlers = __esm(() => {
-  init_logger2();
-  SESSION_UPDATE_HANDLERS = {
-    agent_message_chunk: handleAgentMessageChunk,
-    agent_thought_chunk: handleAgentThoughtChunk,
-    usage_update: handleUsageUpdate,
-    tool_call: handleToolCallActivity,
-    tool_call_update: handleToolCallActivity
-  };
-});
-
-// src/agents/acp/parser.ts
-function createParseState() {
-  return {
-    text: "",
-    tokenUsage: undefined,
-    exactCostUsd: undefined,
-    stopReason: undefined,
-    error: undefined,
-    retryable: false,
-    sawJsonLine: false
-  };
-}
-function parseAcpxJsonLine(line, state) {
-  try {
-    const event = JSON.parse(line);
-    if (!state.sawJsonLine) {
-      state.text = "";
-      state.sawJsonLine = true;
-    }
-    if (isProtocolDrift(event)) {
-      reportProtocolDrift(event, state);
-      return;
-    }
-    if (event.jsonrpc === "2.0") {
-      return handleJsonRpcEvent(event, state);
-    }
-    handleLegacyLine(event, state);
-  } catch {
-    if (!state.text && !state.sawJsonLine)
-      state.text = line;
-  }
-  return;
-}
-function finalizeParseState(state) {
-  return {
-    text: state.text.trim(),
-    tokenUsage: state.tokenUsage,
-    exactCostUsd: state.exactCostUsd,
-    stopReason: state.stopReason,
-    error: state.error,
-    retryable: state.retryable
-  };
-}
-var init_parser = __esm(() => {
-  init_parser_line_handlers();
-});
-
-// src/agents/acp/stdout-line-reader.ts
-function readStreamTail(stream, maxBytes = MAX_BUFFERED_STDERR_BYTES) {
-  const decoder = new TextDecoder;
-  const reader = stream.getReader();
-  let tail = "";
-  const append = (chunk) => {
-    tail += chunk;
-    const bytes = Buffer.byteLength(tail, "utf8");
-    if (bytes <= maxBytes)
-      return;
-    let cutoff = bytes - maxBytes;
-    let index = 0;
-    while (index < tail.length && cutoff > 0) {
-      const cp = tail.codePointAt(index) ?? 0;
-      const units = cp > 65535 ? 2 : 1;
-      index += units;
-      cutoff -= Buffer.byteLength(String.fromCodePoint(cp), "utf8");
-    }
-    tail = tail.slice(index);
-  };
-  const promise2 = (async () => {
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        append(decoder.decode(value, { stream: true }));
-      }
-      append(decoder.decode());
-      return tail;
-    } finally {
-      reader.releaseLock();
-    }
-  })();
-  return {
-    promise: promise2,
-    cancel: () => {
-      reader.cancel().catch(() => {});
-    }
-  };
-}
-function readAndParseLines(stream, state, onActivity) {
-  const decoder = new TextDecoder;
-  let remainder = "";
-  const reader = stream.getReader();
-  const promise2 = (async () => {
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        remainder += decoder.decode(value, { stream: true });
-        for (;; ) {
-          const nl = remainder.indexOf(`
-`);
-          if (nl < 0)
-            break;
-          const line = remainder.slice(0, nl);
-          remainder = remainder.slice(nl + 1);
-          if (line.trim()) {
-            const activity = parseAcpxJsonLine(line, state);
-            if (activity && onActivity)
-              onActivity(activity);
-          }
-        }
-        if (Buffer.byteLength(remainder, "utf8") > MAX_BUFFERED_LINE_BYTES) {
-          getSafeLogger2()?.error("acp-adapter", "Dropping oversized buffered stdout line (exceeds cap)", {
-            bufferedBytes: Buffer.byteLength(remainder, "utf8"),
-            maxBufferedLineBytes: MAX_BUFFERED_LINE_BYTES
-          });
-          remainder = "";
-        }
-      }
-      remainder += decoder.decode();
-      if (remainder.trim()) {
-        const activity = parseAcpxJsonLine(remainder.trim(), state);
-        if (activity && onActivity)
-          onActivity(activity);
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  })();
-  return {
-    promise: promise2,
-    cancel: () => {
-      reader.cancel().catch(() => {});
-    }
-  };
-}
-var MAX_BUFFERED_LINE_BYTES, MAX_BUFFERED_STDERR_BYTES;
-var init_stdout_line_reader = __esm(() => {
-  init_logger2();
-  init_parser();
-  MAX_BUFFERED_LINE_BYTES = 10 * 1024 * 1024;
-  MAX_BUFFERED_STDERR_BYTES = 64 * 1024;
-});
-
-// src/agents/acp/spawn-client-session.ts
-var exports_spawn_client_session = {};
-__export(exports_spawn_client_session, {
-  SpawnAcpSession: () => SpawnAcpSession
-});
-import { randomUUID as randomUUID8 } from "crypto";
-
-class SpawnAcpSession {
-  agentName;
-  sessionName;
-  cwd;
-  model;
-  modelLabel;
-  timeoutSeconds;
-  promptRetries;
-  permissionMode;
-  env;
-  onPidSpawned;
-  onPidExited;
-  onStreamActivity;
-  onActiveCall;
-  runId;
-  storyId;
-  stage;
-  trackedSpawnDeadlineMs;
-  activeProc = null;
-  _externallyCancelled = false;
-  id;
-  recordId;
-  constructor(opts) {
-    this.agentName = opts.agentName;
-    this.sessionName = opts.sessionName;
-    this.cwd = opts.cwd;
-    this.model = opts.model;
-    this.modelLabel = opts.modelLabel ?? opts.model;
-    this.timeoutSeconds = opts.timeoutSeconds;
-    this.promptRetries = opts.promptRetries;
-    this.permissionMode = opts.permissionMode;
-    this.env = opts.env;
-    this.onPidSpawned = opts.onPidSpawned;
-    this.onPidExited = opts.onPidExited;
-    this.onStreamActivity = opts.onStreamActivity;
-    this.onActiveCall = opts.onActiveCall;
-    this.runId = opts.runId ?? "";
-    this.storyId = opts.storyId;
-    this.stage = opts.stage;
-    this.id = opts.id;
-    this.recordId = opts.recordId;
-    this.trackedSpawnDeadlineMs = opts.trackedSpawnDeadlineMs ?? _spawnClientDeps.trackedSpawnDeadlineMs;
-  }
-  async prompt(text) {
-    const callId = randomUUID8();
-    const emit = this.onStreamActivity;
-    const now = () => Date.now();
-    this._externallyCancelled = false;
-    const baseEvent = {
-      callId,
-      runId: this.runId,
-      agentName: this.agentName,
-      sessionName: this.sessionName,
-      storyId: this.storyId,
-      stage: this.stage
-    };
-    const cmd = [
-      "acpx",
-      "--cwd",
-      this.cwd,
-      "--format",
-      "json",
-      ...this.permissionMode === "approve-all" ? ["--approve-all"] : [],
-      "--model",
-      this.model,
-      "--timeout",
-      String(this.timeoutSeconds),
-      ...this.promptRetries > 0 ? ["--prompt-retries", String(this.promptRetries)] : [],
-      this.agentName,
-      "prompt",
-      "-s",
-      this.sessionName,
-      "--file",
-      "-"
-    ];
-    getSafeLogger2()?.info("acp-adapter", "Sending prompt", {
-      session: this.sessionName,
-      permission: this.permissionMode,
-      cmd: cmd.join(" ")
-    });
-    getSafeLogger2()?.debug("acp-adapter", `Sending prompt to session: ${this.sessionName}`);
-    let proc;
-    try {
-      proc = _spawnClientDeps.spawn(cmd, {
-        cwd: this.cwd,
-        stdin: "pipe",
-        stdout: "pipe",
-        stderr: "pipe",
-        env: this.env,
-        detached: true
-      });
-    } catch (spawnErr) {
-      emit?.({ ...baseEvent, kind: "agent.call_ended", status: "error", timestamp: now() });
-      throw spawnErr;
-    }
-    this.activeProc = proc;
-    const processPid = proc.pid;
-    this.onPidSpawned?.(processPid);
-    this.onActiveCall?.(callId, () => this.cancelActivePrompt());
-    emit?.({
-      ...baseEvent,
-      kind: "agent.call_started",
-      model: this.modelLabel,
-      timeoutSeconds: this.timeoutSeconds,
-      timestamp: now()
-    });
-    emit?.({
-      ...baseEvent,
-      kind: "agent.process_update",
-      status: "spawned",
-      pid: processPid,
-      timestamp: now()
-    });
-    let exitNotified = false;
-    const notifyExit = () => {
-      if (exitNotified)
-        return;
-      exitNotified = true;
-      try {
-        this.onPidExited?.(processPid);
-      } catch {}
-    };
-    let callEndedEmitted = false;
-    try {
-      try {
-        proc.stdin?.write(text);
-        proc.stdin?.end();
-      } catch {
-        getSafeLogger2()?.warn("acp-adapter", "Failed to write prompt to acpx stdin (subprocess exited early)", {
-          session: this.sessionName
-        });
-      }
-      const parseState = createParseState();
-      const onActivity = emit ? (activity) => {
-        if (activity.kind === "message_update") {
-          emit({ ...baseEvent, kind: "agent.message_update", deltaBytes: activity.deltaBytes, timestamp: now() });
-        } else if (activity.kind === "thinking_update") {
-          emit({ ...baseEvent, kind: "agent.thinking_update", deltaBytes: activity.deltaBytes, timestamp: now() });
-        } else if (activity.kind === "usage_update") {
-          emit({
-            ...baseEvent,
-            kind: "agent.usage_update",
-            inputTokens: activity.inputTokens,
-            outputTokens: activity.outputTokens,
-            costUsd: activity.costUsd,
-            ...activity.cacheRead !== undefined ? { cacheRead: activity.cacheRead } : {},
-            ...activity.cacheWrite !== undefined ? { cacheWrite: activity.cacheWrite } : {},
-            cadence: "agent",
-            timestamp: now()
-          });
-        } else if (activity.kind === "tool_call_update") {
-          emit({
-            ...baseEvent,
-            kind: "agent.tool_call_update",
-            toolName: activity.toolName,
-            timestamp: now()
-          });
-        }
-      } : undefined;
-      const parseHandle = readAndParseLines(proc.stdout, parseState, onActivity);
-      const parsePromise = parseHandle.promise.catch(() => {});
-      const stderrHandle = readStreamTail(proc.stderr);
-      const stderrPromise = stderrHandle.promise.catch(() => "");
-      const exitCode = await proc.exited;
-      const drainA = makeStreamDrain(_spawnClientDeps.streamDrainTimeoutMs);
-      const drainB = makeStreamDrain(_spawnClientDeps.streamDrainTimeoutMs);
-      const stdoutRaceResult = Promise.race([
-        parsePromise.then(() => "parsed"),
-        drainA.promise.then(() => "drain")
-      ]).finally(() => drainA.cancel());
-      const [stdoutWinner, stderr] = await Promise.all([
-        stdoutRaceResult,
-        Promise.race([stderrPromise, drainB.promise]).finally(() => drainB.cancel())
-      ]);
-      if (stdoutWinner === "drain")
-        parseHandle.cancel();
-      if (stderr === "")
-        stderrHandle.cancel();
-      emit?.({ ...baseEvent, kind: "agent.process_update", status: "exited", exitCode, timestamp: now() });
-      if (exitCode !== 0) {
-        const parsedOnError = finalizeParseState(parseState);
-        const errorContent = parsedOnError.error || stderr || `Exit code ${exitCode}`;
-        getSafeLogger2()?.warn("acp-adapter", `Session prompt exited with code ${exitCode}`, {
-          exitCode,
-          error: errorContent.slice(0, 500),
-          ...stderr && stderr !== errorContent ? { banner: stderr.trim().slice(0, 200) } : {}
-        });
-        callEndedEmitted = true;
-        emit?.({ ...baseEvent, kind: "agent.call_ended", status: "error", exitCode, timestamp: now() });
-        const errResponse = {
-          messages: [{ role: "assistant", content: errorContent }],
-          stopReason: "error",
-          retryable: parsedOnError.retryable,
-          exitCode
-        };
-        if (this._externallyCancelled)
-          errResponse.cancelled = true;
-        return errResponse;
-      }
-      try {
-        const parsed = finalizeParseState(parseState);
-        callEndedEmitted = true;
-        const cancelled = this._externallyCancelled;
-        emit?.({ ...baseEvent, kind: "agent.call_ended", status: cancelled ? "error" : "success", timestamp: now() });
-        const successResponse = {
-          messages: [{ role: "assistant", content: parsed.text || "" }],
-          stopReason: cancelled ? "error" : parsed.stopReason ?? "end_turn",
-          cumulative_token_usage: parsed.tokenUsage,
-          exactCostUsd: parsed.exactCostUsd,
-          error: parsed.error,
-          retryable: parsed.retryable
-        };
-        if (cancelled)
-          successResponse.cancelled = true;
-        return successResponse;
-      } catch (err) {
-        getSafeLogger2()?.warn("acp-adapter", "Failed to parse session prompt response", {
-          stderr: stderr.slice(0, 200)
-        });
-        throw err;
-      }
-    } catch (err) {
-      if (!callEndedEmitted) {
-        callEndedEmitted = true;
-        emit?.({ ...baseEvent, kind: "agent.call_ended", status: "error", timestamp: now() });
-      }
-      throw err;
-    } finally {
-      this.activeProc = null;
-      notifyExit();
-    }
-  }
-  async trackedSpawn(cmd, opts, signal) {
-    return runTrackedSpawn({ ..._spawnClientDeps, trackedSpawnDeadlineMs: this.trackedSpawnDeadlineMs }, cmd, opts, this.onPidSpawned, this.onPidExited, signal);
-  }
-  killActiveProcTree() {
-    if (!this.activeProc)
-      return;
-    killProcessTree(this.activeProc.pid, _spawnClientDeps.killTreeGraceMs, this.activeProc.exited);
-  }
-  async close(options) {
-    if (this.activeProc) {
-      this.killActiveProcTree();
-      this.activeProc = null;
-    }
-    const cmd = ["acpx", "--cwd", this.cwd, this.agentName, "sessions", "close", this.sessionName];
-    getSafeLogger2()?.debug("acp-adapter", `Closing session: ${this.sessionName}`);
-    const { exitCode, stderr } = await this.trackedSpawn(cmd, undefined, options?.signal);
-    if (exitCode !== 0) {
-      getSafeLogger2()?.warn("acp-adapter", "Failed to close session", {
-        sessionName: this.sessionName,
-        stderr: stderr.slice(0, 200)
-      });
-    }
-    if (options?.forceTerminate) {
-      try {
-        await this.trackedSpawn(["acpx", "--cwd", this.cwd, this.agentName, "stop"], undefined, options?.signal);
-      } catch (err) {
-        getSafeLogger2()?.debug("acp-adapter", "acpx stop failed (swallowed)", { cause: String(err) });
-      }
-    }
-  }
-  async cancelActivePrompt() {
-    this._externallyCancelled = true;
-    if (this.activeProc) {
-      this.killActiveProcTree();
-      this.activeProc = null;
-    }
-    const cmd = ["acpx", "--cwd", this.cwd, this.agentName, "cancel"];
-    getSafeLogger2()?.debug("acp-adapter", `Cancelling active prompt: ${this.sessionName}`);
-    await this.trackedSpawn(cmd);
-  }
-}
-var init_spawn_client_session = __esm(() => {
-  init_agents();
-  init_logger2();
-  init_spawn_client_deps();
-  init_spawn_client_process();
-  init_stdout_line_reader();
-});
-
-// src/agents/acp/spawn-client.ts
-class SpawnAcpClient {
-  model;
-  rawModel;
-  reasoningEffort;
-  cwd;
-  timeoutSeconds;
-  promptRetries;
-  env;
-  onPidSpawned;
-  onPidExited;
-  onStreamActivity;
-  onActiveCall;
-  runId;
-  storyId;
-  stage;
-  trackedSpawnDeadlineMs;
-  trackedSpawnStartupDeadlineMs;
-  constructor(cmdStr, cwd, timeoutSeconds, onPidSpawned, promptRetries, onPidExited, opts) {
-    const parts = cmdStr.split(/\s+/);
-    const modelIdx = parts.indexOf("--model");
-    const rawModel = modelIdx >= 0 && parts[modelIdx + 1] ? parts[modelIdx + 1] : "default";
-    const spec = parseModelSpec(rawModel);
-    this.rawModel = rawModel;
-    this.model = spec.model;
-    this.reasoningEffort = spec.effort;
-    const lastToken = parts[parts.length - 1];
-    if (!lastToken || lastToken.startsWith("-")) {
-      throw new NaxError(`[acp-adapter] Could not parse agentName from cmdStr: "${cmdStr}"`, "ACP_AGENT_NAME_PARSE_FAILED", {
-        stage: "session",
-        cmdStr
-      });
-    }
-    if (!cwd) {
-      throw new NaxError("[acp-adapter] SpawnAcpClient requires cwd", "ACP_CWD_REQUIRED", { stage: "session" });
-    }
-    this.cwd = cwd;
-    this.timeoutSeconds = timeoutSeconds ?? DEFAULT_ACP_TIMEOUT_SECONDS;
-    this.promptRetries = promptRetries ?? 0;
-    this.env = buildAllowedEnv({ modelEnv: opts?.env });
-    this.onPidSpawned = onPidSpawned;
-    this.onPidExited = onPidExited;
-    this.onStreamActivity = opts?.onStreamActivity;
-    this.onActiveCall = opts?.onActiveCall;
-    this.runId = opts?.runId;
-    this.storyId = opts?.storyId;
-    this.stage = opts?.stage;
-    this.trackedSpawnDeadlineMs = opts?.trackedSpawnDeadlineMs ?? _spawnClientDeps.trackedSpawnDeadlineMs;
-    this.trackedSpawnStartupDeadlineMs = opts?.trackedSpawnStartupDeadlineMs ?? _spawnClientDeps.trackedSpawnStartupDeadlineMs;
-  }
-  async start() {}
-  async trackedSpawn(cmd, signal, deadlineMsOverride) {
-    return runTrackedSpawn({ ..._spawnClientDeps, trackedSpawnDeadlineMs: deadlineMsOverride ?? this.trackedSpawnStartupDeadlineMs }, cmd, undefined, this.onPidSpawned, this.onPidExited, signal);
-  }
-  async createSession(opts) {
-    const sessionName = opts.sessionName || `nax-${Date.now()}`;
-    const cmd = [
-      "acpx",
-      "--cwd",
-      this.cwd,
-      "--format",
-      "json",
-      opts.agentName,
-      "sessions",
-      "ensure",
-      "--name",
-      sessionName
-    ];
-    getSafeLogger2()?.debug("acp-adapter", `Ensuring session: ${sessionName}`);
-    const { exitCode, stdout, stderr } = await this.trackedSpawn(cmd);
-    if (exitCode !== 0) {
-      throw new NaxError(`[acp-adapter] Failed to create session: ${stdout || stderr || `exit code ${exitCode}`}`, "ACP_SESSION_CREATE_FAILED", { stage: "session", agentName: opts.agentName, exitCode });
-    }
-    const { sessionId, recordId } = parseSessionIds(stdout);
-    await applyReasoningEffort({
-      effort: this.reasoningEffort,
-      agentName: opts.agentName,
-      sessionName,
-      cwd: this.cwd,
-      storyId: this.storyId,
-      spawn: (c) => this.trackedSpawn(c)
-    });
-    const { SpawnAcpSession: SpawnAcpSession2 } = await Promise.resolve().then(() => (init_spawn_client_session(), exports_spawn_client_session));
-    return new SpawnAcpSession2({
-      agentName: opts.agentName,
-      sessionName,
-      cwd: this.cwd,
-      model: this.model,
-      modelLabel: this.rawModel,
-      timeoutSeconds: this.timeoutSeconds,
-      promptRetries: this.promptRetries,
-      permissionMode: opts.permissionMode,
-      env: this.env,
-      onPidSpawned: this.onPidSpawned,
-      onPidExited: this.onPidExited,
-      onStreamActivity: this.onStreamActivity,
-      onActiveCall: this.onActiveCall,
-      runId: this.runId,
-      storyId: this.storyId,
-      stage: this.stage,
-      id: sessionId,
-      recordId,
-      trackedSpawnDeadlineMs: this.trackedSpawnDeadlineMs
-    });
-  }
-  async loadSession(sessionName, agentName, permissionMode) {
-    const cmd = ["acpx", "--cwd", this.cwd, "--format", "json", agentName, "sessions", "ensure", "--name", sessionName];
-    const { exitCode, stdout } = await this.trackedSpawn(cmd);
-    if (exitCode !== 0) {
-      if (exitCode === -1) {
-        getSafeLogger2()?.warn("acp-adapter", "sessions ensure hit its trackedSpawn deadline \u2014 falling back to a context-less session", { sessionName, agentName });
-      }
-      return null;
-    }
-    const { sessionId, recordId } = parseSessionIds(stdout);
-    await applyReasoningEffort({
-      effort: this.reasoningEffort,
-      agentName,
-      sessionName,
-      cwd: this.cwd,
-      storyId: this.storyId,
-      spawn: (c) => this.trackedSpawn(c)
-    });
-    const { SpawnAcpSession: SpawnAcpSession2 } = await Promise.resolve().then(() => (init_spawn_client_session(), exports_spawn_client_session));
-    return new SpawnAcpSession2({
-      agentName,
-      sessionName,
-      cwd: this.cwd,
-      model: this.model,
-      modelLabel: this.rawModel,
-      timeoutSeconds: this.timeoutSeconds,
-      promptRetries: this.promptRetries,
-      permissionMode,
-      env: this.env,
-      onPidSpawned: this.onPidSpawned,
-      onPidExited: this.onPidExited,
-      onStreamActivity: this.onStreamActivity,
-      onActiveCall: this.onActiveCall,
-      runId: this.runId,
-      storyId: this.storyId,
-      stage: this.stage,
-      id: sessionId,
-      recordId,
-      trackedSpawnDeadlineMs: this.trackedSpawnDeadlineMs
-    });
-  }
-  async closeSession(sessionName, agentName, signal) {
-    const cmd = ["acpx", "--cwd", this.cwd, agentName, "sessions", "close", sessionName];
-    const { exitCode, stderr } = await this.trackedSpawn(cmd, signal, this.trackedSpawnDeadlineMs);
-    if (exitCode !== 0) {
-      getSafeLogger2()?.debug("acp-adapter", "Session close failed (ignored)", {
-        sessionName,
-        agentName,
-        exitCode,
-        stderr: stderr.slice(0, 200)
-      });
-    }
-  }
-  async forceStop(agentName, signal) {
-    const cmd = ["acpx", "--cwd", this.cwd, agentName, "stop"];
-    const { exitCode, stderr } = await this.trackedSpawn(cmd, signal, this.trackedSpawnDeadlineMs);
-    if (exitCode !== 0) {
-      getSafeLogger2()?.debug("acp-adapter", "forceStop failed (ignored)", {
-        agentName,
-        exitCode,
-        stderr: stderr.slice(0, 200)
-      });
-    }
-  }
-  async close() {}
-}
-function createSpawnAcpClient(cmdStr, cwd, timeoutSeconds, onPidSpawned, promptRetries, onPidExited, opts) {
-  return new SpawnAcpClient(cmdStr, cwd, timeoutSeconds, onPidSpawned, promptRetries, onPidExited, opts);
-}
-var DEFAULT_ACP_TIMEOUT_SECONDS = 1800;
-var init_spawn_client = __esm(() => {
-  init_src();
-  init_errors4();
-  init_logger2();
-  init_env();
-  init_reasoning_effort();
-  init_spawn_client_deps();
-  init_spawn_client_process();
-  init_spawn_client_deps();
-});
-
-// src/agents/acp/adapter-lifecycle.ts
-async function ensureAcpSession(client2, sessionName, agentName, permissionMode) {
-  if (!agentName) {
-    throw new NaxError("[acp-adapter] agentName is required for ensureAcpSession", "ACP_AGENT_NAME_REQUIRED", {
-      stage: "open-session",
-      sessionName
-    });
-  }
-  if (client2.cwd && !await _acpAdapterDeps.cwdExists(client2.cwd)) {
-    throw new NaxError(`[acp-adapter] Session cwd does not exist: ${client2.cwd} \u2014 cannot start agent "${agentName}". If this is a new package for the feature, ensure its directory is created before the run.`, "SESSION_CWD_MISSING", { stage: "open-session", agentName, cwd: client2.cwd, sessionName });
-  }
-  if (client2.loadSession) {
-    try {
-      const existing2 = await client2.loadSession(sessionName, agentName, permissionMode);
-      if (existing2) {
-        getSafeLogger2()?.debug("acp-adapter", `Resumed existing session: ${sessionName}`);
-        return { session: existing2, resumed: true };
-      }
-    } catch {}
-  }
-  getSafeLogger2()?.debug("acp-adapter", `Creating new session: ${sessionName}`);
-  return { session: await client2.createSession({ agentName, permissionMode, sessionName }), resumed: false };
-}
-async function runSessionPrompt(session2, prompt, timeoutMs, signal) {
-  throwIfAborted(signal, "Run aborted \u2014 shutdown in progress");
-  const promptPromise = session2.prompt(prompt);
-  let timeoutId;
-  const timeoutPromise = new Promise((resolve21) => {
-    timeoutId = setTimeout(() => resolve21("timeout"), timeoutMs);
-  });
-  let abortHandler;
-  const abortPromise = signal ? new Promise((resolve21) => {
-    abortHandler = () => resolve21("aborted");
-    signal.addEventListener("abort", abortHandler, { once: true });
-  }) : null;
-  let winner;
-  try {
-    winner = await Promise.race([promptPromise, timeoutPromise, ...abortPromise !== null ? [abortPromise] : []]);
-  } finally {
-    clearTimeout(timeoutId);
-    if (signal && abortHandler) {
-      signal.removeEventListener("abort", abortHandler);
-    }
-  }
-  if (winner === "timeout" || winner === "aborted") {
-    promptPromise.catch(() => {});
-    try {
-      await session2.cancelActivePrompt();
-    } catch {
-      await session2.close().catch(() => {});
-    }
-    return { response: null, timedOut: winner === "timeout", aborted: winner === "aborted" };
-  }
-  return { response: winner, timedOut: false, aborted: false };
-}
-async function closeAcpSession(session2) {
-  try {
-    await session2.close();
-  } catch (err) {
-    getSafeLogger2()?.warn("acp-adapter", "Failed to close session", { error: String(err) });
-  }
-}
-
-class AcpSessionHandleImpl {
-  id;
-  agentName;
-  protocolIds;
-  modelDef;
-  modelTier;
-  _client;
-  _session;
-  _sessionName;
-  _resumed;
-  _timeoutSeconds;
-  _modelDef;
-  _rateCard;
-  _permissionMode;
-  constructor(opts) {
-    this.id = opts.id;
-    this.agentName = opts.agentName;
-    this.protocolIds = opts.protocolIds;
-    this._client = opts.client;
-    this._session = opts.session;
-    this._sessionName = opts.sessionName;
-    this._resumed = opts.resumed;
-    this._timeoutSeconds = opts.timeoutSeconds;
-    this._modelDef = opts.modelDef;
-    this.modelDef = opts.modelDef;
-    this.modelTier = opts.modelTier;
-    this._rateCard = opts.rateCard;
-    this._permissionMode = opts.permissionMode;
-  }
-}
-var _acpAdapterDeps, _fallbackDeps;
-var init_adapter_lifecycle = __esm(() => {
-  init_cost();
-  init_errors4();
-  init_logger2();
-  init_bun_deps();
-  init_errors5();
-  init_turn();
-  init_spawn_client();
-  _acpAdapterDeps = {
-    which: which2,
-    sleep,
-    async cwdExists(dir) {
-      const { stat: stat7 } = await import("fs/promises");
-      try {
-        return (await stat7(dir)).isDirectory();
-      } catch {
-        return false;
-      }
-    },
-    createClient(cmdStr, cwd, timeoutSeconds, onPidSpawned, promptRetries, onPidExited, opts) {
-      return createSpawnAcpClient(cmdStr, cwd, timeoutSeconds, onPidSpawned, promptRetries, onPidExited, opts);
-    },
-    resolveRateCard(modelId) {
-      return resolveRateCard(modelId);
-    }
-  };
-  _fallbackDeps = {
-    parseAgentError,
-    sleep
-  };
-});
-
-// src/agents/acp/adapter-close-physical.ts
-async function closePhysicalSession(agentName, handle, workdir, options) {
-  const cmdStr = `acpx ${agentName}`;
-  const client2 = _acpAdapterDeps.createClient(cmdStr, workdir, undefined, undefined);
-  try {
-    await client2.start();
-    try {
-      if (client2.closeSession) {
-        await client2.closeSession(handle, agentName, options?.signal);
-        if (options?.force) {
-          await client2.forceStop?.(agentName, options?.signal).catch(() => {});
-        }
-      } else if (client2.loadSession) {
-        const session2 = await client2.loadSession(handle, agentName, SESSION_CLOSE_PERMISSION_MODE);
-        if (session2)
-          await session2.close({ forceTerminate: options?.force, signal: options?.signal }).catch(() => {});
-      }
-    } catch (err) {
-      getSafeLogger2()?.warn("acp-adapter", `[close] Failed to close session ${handle}`, { error: String(err) });
-    }
-  } finally {
-    await client2.close().catch(() => {});
-  }
-}
-var init_adapter_close_physical = __esm(() => {
-  init_config();
-  init_logger2();
-  init_adapter_lifecycle();
-});
-
-// src/agents/session-naming.ts
-import { createHash as createHash6 } from "crypto";
-function computeAcpHandle(workdir, featureName, storyId, sessionRole) {
-  const hash2 = createHash6("sha256").update(workdir).digest("hex").slice(0, 8);
-  const sanitize = (s) => s.replace(/[^a-z0-9]+/gi, "-").toLowerCase().replace(/^-+|-+$/g, "");
-  const parts = ["nax", hash2];
-  if (featureName)
-    parts.push(sanitize(featureName));
-  if (storyId)
-    parts.push(sanitize(storyId));
-  if (sessionRole)
-    parts.push(sanitize(sessionRole));
-  return parts.join("-");
-}
-var init_session_naming = () => {};
-
-// src/agents/types.ts
-var CompleteError, SessionFailureError;
-var init_types4 = __esm(() => {
-  init_src();
-  CompleteError = class CompleteError extends Error {
-    exitCode;
-    retryable;
-    constructor(message, exitCode, retryable) {
-      super(message);
-      this.exitCode = exitCode;
-      this.retryable = retryable;
-      this.name = "CompleteError";
-    }
-  };
-  SessionFailureError = class SessionFailureError extends Error {
-    adapterFailure;
-    constructor(message, adapterFailure) {
-      super(message);
-      this.adapterFailure = adapterFailure;
-      this.name = "SessionFailureError";
-    }
-  };
-});
-
-// src/agents/acp/adapter-output.ts
-function extractOutput(response) {
-  if (!response)
-    return "";
-  return response.messages.filter((m) => m.role === "assistant").map((m) => m.content).join(`
-`).trim();
-}
-function deriveTokenUsage(wire, rateCard, mapper) {
-  const tokenUsage = wire ? mapper.toInternal(wire) : { inputTokens: 0, outputTokens: 0 };
-  const nonzeroUsage = tokenUsage.inputTokens > 0 || tokenUsage.outputTokens > 0;
-  const priced = nonzeroUsage ? priceCall(tokenUsage, rateCard.rates) : undefined;
-  return {
-    tokenUsage,
-    estimatedCostUsd: priced?.costUsd ?? 0,
-    rates: priced?.resolvedRates
-  };
+// src/utils/bun-deps.ts
+function typedSpawn(cmd, opts) {
+  return Bun.spawn(cmd, opts);
 }
-function buildTurnResult2(input) {
-  const { lastResponse, ...rest } = input;
-  return assembleTurnResult({ ...rest, output: extractOutput(lastResponse) });
+function sleep(ms) {
+  return Bun.sleep(ms);
 }
-var init_adapter_output = __esm(() => {
-  init_cost();
-  init_turn();
-});
-
-// src/agents/acp/adapter-complete-flow.ts
-async function runCompleteFlow(input) {
-  const { adapter, prompt, options, mapper, rateCard, createClient: createClient2 } = input;
-  const tryOneAgent = async (agentName) => {
-    const cmdStr = `acpx --model ${options.modelDef.model} ${agentName}`;
-    const timeoutMs = options.timeoutMs ?? 120000;
-    const timeoutSeconds = Math.ceil(timeoutMs / 1000);
-    const client2 = createClient2(cmdStr, options.workdir, timeoutSeconds, options.onPidSpawned, options.promptRetries, options.onPidExited, {
-      onStreamActivity: options.onStreamActivity,
-      onActiveCall: options.onActiveCall,
-      trackedSpawnDeadlineMs: options.trackedSpawnDeadlineMs,
-      trackedSpawnStartupDeadlineMs: options.trackedSpawnStartupDeadlineMs,
-      env: options.modelDef.env
-    });
-    await client2.start();
-    let session2 = null;
-    try {
-      const completeSessionName = options.sessionName ?? computeAcpHandle(options.workdir, options.featureName, options.storyId, options.sessionRole);
-      session2 = await client2.createSession({
-        agentName,
-        permissionMode: options.resolvedPermissions.mode,
-        sessionName: completeSessionName
-      });
-      let timeoutId;
-      const timeoutPromise = new Promise((_, reject) => {
-        timeoutId = setTimeout(() => reject(new NaxError("complete() timed out", "AGENT_TIMEOUT", { stage: "acp", timeoutMs })), timeoutMs);
-      });
-      timeoutPromise.catch(() => {});
-      let response;
-      try {
-        const promptPromise = session2.prompt(prompt);
-        promptPromise.catch(() => {});
-        response = await Promise.race([promptPromise, timeoutPromise]);
-      } finally {
-        clearTimeout(timeoutId);
-      }
-      if (response.stopReason === "error") {
-        if (response.cancelled) {
-          const { tokenUsage: tokenUsage2, estimatedCostUsd: estimatedCostUsd2, rates: rates2 } = deriveTokenUsage(response.cumulative_token_usage, rateCard, mapper);
-          return {
-            output: "",
-            tokenUsage: tokenUsage2,
-            estimatedCostUsd: estimatedCostUsd2,
-            exactCostUsd: response.exactCostUsd,
-            cancelled: true,
-            pricingSource: rateCard.source,
-            ...rates2 !== undefined ? { rates: rates2 } : {}
-          };
-        }
-        const errSuffix = response.error ? `: ${response.error.slice(0, 500)}` : "";
-        throw new CompleteError(`complete() failed: stop reason is error${errSuffix}`, undefined, response.retryable);
-      }
-      const text = response.messages.filter((m) => m.role === "assistant").map((m) => m.content).join(`
-`).trim();
-      let unwrapped = text;
-      try {
-        const envelope = JSON.parse(text);
-        if (envelope?.type === "result" && typeof envelope?.result === "string") {
-          unwrapped = envelope.result;
-        }
-      } catch {}
-      if (!unwrapped) {
-        throw new CompleteError("complete() returned empty output");
-      }
-      const { tokenUsage, estimatedCostUsd, rates } = deriveTokenUsage(response.cumulative_token_usage, rateCard, mapper);
-      const exactCostUsd = response.exactCostUsd;
-      if (exactCostUsd !== undefined) {
-        getSafeLogger2()?.info("acp-adapter", "complete() cost", {
-          costUsd: exactCostUsd,
-          model: options.modelDef.model
-        });
-      }
-      return {
-        output: unwrapped,
-        tokenUsage,
-        estimatedCostUsd,
-        exactCostUsd,
-        pricingSource: rateCard.source,
-        ...rates !== undefined ? { rates } : {}
-      };
-    } finally {
-      if (session2) {
-        await session2.close({ forceTerminate: true }).catch(() => {});
-      }
-      await client2.close().catch(() => {});
-    }
-  };
-  try {
-    return await tryOneAgent(adapter.name);
-  } catch (err) {
-    const error48 = err instanceof Error ? err : new Error(String(err));
-    if (error48 instanceof CompleteError) {
-      const classified = classifyCompleteError(error48, rateCard.source);
-      if (classified)
-        return classified;
+function cancellableDelay(ms, signal) {
+  return new Promise((resolve21, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new Error("delay aborted"));
+      return;
     }
-    const degraded = classifyParsedAgentError(_fallbackDeps.parseAgentError(error48.message), error48.message, rateCard.source);
-    if (degraded)
-      return degraded;
-    throw err;
-  }
-}
-var init_adapter_complete_flow = __esm(() => {
-  init_errors4();
-  init_logger2();
-  init_errors5();
-  init_session_naming();
-  init_types4();
-  init_adapter_lifecycle();
-  init_adapter_output();
-});
-
-// src/agents/interaction/output-parsing.ts
-function extractQuestion(output) {
-  const text = output.trim();
-  if (!text)
-    return null;
-  const lines = text.split(`
-`).filter((l) => l.trim().length > 0);
-  const lastLine = lines.at(-1)?.trim() ?? "";
-  const lower = lastLine.toLowerCase();
-  const markers = [
-    "please confirm",
-    "please specify",
-    "please provide",
-    "which would you",
-    "should i ",
-    "do you want",
-    "can you clarify"
-  ];
-  const isQuestion = lastLine.endsWith("?") && lastLine.length > 10 || markers.some((m) => lower.includes(m));
-  if (!isQuestion)
-    return null;
-  const paragraphs = text.split(/\n\n+/);
-  const questionPara = paragraphs.at(-1)?.trim() ?? lastLine;
-  const contextPara = paragraphs.at(-2)?.trim();
-  return contextPara ? `${contextPara}
-
-${questionPara}` : questionPara;
-}
-function extractContextToolCall(output) {
-  const match = output.match(CONTEXT_TOOL_CALL_PATTERN);
-  if (!match)
-    return null;
-  const [, name, rawInput] = match;
-  const trimmedInput = rawInput.trim();
-  if (!trimmedInput) {
-    return { name, input: {} };
-  }
-  try {
-    return { name, input: JSON.parse(trimmedInput) };
-  } catch (error48) {
-    return {
-      name,
-      error: `Invalid JSON tool input: ${error48 instanceof Error ? error48.message : String(error48)}`
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve21();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason ?? new Error("delay aborted"));
     };
-  }
-}
-var CONTEXT_TOOL_CALL_PATTERN;
-var init_output_parsing = __esm(() => {
-  CONTEXT_TOOL_CALL_PATTERN = /<nax_tool_call\s+name="([^"]+)">\s*([\s\S]*?)\s*<\/nax_tool_call>/i;
-});
-
-// src/agents/interaction/turn-interactions.ts
-async function awaitInteractionReply(ctx, interaction, warnSuffix) {
-  let timeoutId;
-  try {
-    const response = await Promise.race([
-      raceWithAbort(ctx.interactionHandler.onInteraction(interaction), ctx.signal, INTERACTION_ABORT_MESSAGE),
-      new Promise((resolve21) => {
-        timeoutId = setTimeout(() => resolve21(null), ctx.timeoutMs ?? INTERACTION_TIMEOUT_MS);
-      })
-    ]);
-    if (response) {
-      return { kind: "answered", answer: response.answer };
-    }
-  } catch (err) {
-    if (ctx.signal?.aborted) {
-      return { kind: "aborted" };
-    }
-    getSafeLogger2()?.warn(ctx.stage, `InteractionHandler.onInteraction failed${warnSuffix}${err instanceof Error ? err.message : String(err)}`);
-  } finally {
-    clearTimeout(timeoutId);
-  }
-  return { kind: "no-reply" };
-}
-function toContextToolInteraction(toolCall) {
-  return toolCall.error ? { kind: "context-tool", name: toolCall.name, error: toolCall.error } : { kind: "context-tool", name: toolCall.name, input: toolCall.input };
-}
-var INTERACTION_TIMEOUT_MS, INTERACTION_ABORT_MESSAGE = "Run aborted \u2014 shutdown in progress";
-var init_turn_interactions = __esm(() => {
-  init_logger2();
-  init_turn();
-  INTERACTION_TIMEOUT_MS = 5 * 60 * 1000;
-});
-
-// src/agents/interaction/index.ts
-var init_interaction = __esm(() => {
-  init_output_parsing();
-  init_turn_interactions();
-});
-
-// src/agents/acp/adapter-send-turn.ts
-function buildSendTurnFrame(input) {
-  const { impl, mapper, opts } = input;
-  const { _sessionName: sessionName, _timeoutSeconds: timeoutSeconds, _rateCard: rateCard } = impl;
-  return {
-    impl,
-    mapper,
-    opts,
-    sessionName,
-    timeoutSeconds,
-    rateCard,
-    maxInteractions: opts.maxInteractions ?? DEFAULT_MAX_INTERACTIONS,
-    turnDeadline: createTurnDeadline(timeoutSeconds)
-  };
-}
-function initialSendTurnState(prompt) {
-  return {
-    sessionRecreated: false,
-    totalTokenUsage: { inputTokens: 0, outputTokens: 0 },
-    totalExactCostUsd: undefined,
-    interactions: [],
-    turnCount: 0,
-    lastResponse: null,
-    timedOut: false,
-    aborted: false,
-    currentPrompt: prompt
-  };
-}
-function zeroCostAbortedResult(frame) {
-  return {
-    output: "",
-    tokenUsage: { inputTokens: 0, outputTokens: 0 },
-    estimatedCostUsd: 0,
-    internalRoundTrips: 0,
-    pricingSource: frame.rateCard.source
-  };
-}
-async function beginTurnIteration(frame, state) {
-  if (frame.turnDeadline.expired()) {
-    state.timedOut = true;
-    warnWallClockTimeout(frame.sessionName, frame.timeoutSeconds, "acp-adapter");
-    return { kind: "break" };
-  }
-  state.turnCount++;
-  getSafeLogger2()?.debug("acp-adapter", `Session turn ${state.turnCount}/${frame.maxInteractions}`, {
-    sessionName: frame.sessionName
-  });
-  const turnResult = await runSessionPrompt(frame.impl._session, state.currentPrompt, frame.turnDeadline.remainingMs() ?? 0, frame.opts.signal);
-  if (turnResult.timedOut) {
-    state.timedOut = true;
-    warnWallClockTimeout(frame.sessionName, frame.timeoutSeconds, "acp-adapter");
-    return { kind: "break" };
-  }
-  if (turnResult.aborted) {
-    state.aborted = true;
-    return { kind: "break" };
-  }
-  state.lastResponse = turnResult.response;
-  if (!state.lastResponse)
-    return { kind: "break" };
-  return { kind: "response", response: state.lastResponse };
-}
-async function recoverNoSession(frame, state) {
-  if (state.lastResponse?.exitCode !== 4 || state.sessionRecreated) {
-    return false;
-  }
-  state.sessionRecreated = true;
-  getSafeLogger2()?.info("acp-adapter", "NO_SESSION detected \u2014 re-establishing session", {
-    sessionName: frame.sessionName
-  });
-  try {
-    const ensured = await ensureAcpSession(frame.impl._client, frame.impl._sessionName, frame.impl.agentName, frame.impl._permissionMode);
-    frame.impl._session = ensured.session;
-    state.turnCount--;
-    return true;
-  } catch (err) {
-    getSafeLogger2()?.warn("acp-adapter", "Session re-establishment failed after NO_SESSION", {
-      sessionName: frame.sessionName,
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return false;
-  }
-}
-function accumulateUsage(frame, state, response) {
-  if (response.cumulative_token_usage) {
-    state.totalTokenUsage = addTokenUsage(state.totalTokenUsage, frame.mapper.toInternal(response.cumulative_token_usage));
-  }
-  if (response.exactCostUsd !== undefined) {
-    state.totalExactCostUsd = (state.totalExactCostUsd ?? 0) + response.exactCostUsd;
-  }
-}
-function replyContext(frame) {
-  return { interactionHandler: frame.opts.interactionHandler, signal: frame.opts.signal, stage: "acp-adapter" };
-}
-async function handleContextToolCall(frame, state, toolCall) {
-  const interaction = toContextToolInteraction(toolCall);
-  const reply = await awaitInteractionReply(replyContext(frame), interaction, " for context-tool: ");
-  if (reply.kind === "answered") {
-    state.currentPrompt = reply.answer;
-    return true;
-  }
-  if (reply.kind === "aborted") {
-    state.aborted = true;
-  }
-  return false;
-}
-async function handleQuestion(frame, state, question) {
-  const reply = await awaitInteractionReply(replyContext(frame), { kind: "question", text: question }, ": ");
-  if (reply.kind === "answered") {
-    state.interactions.push({ turnIndex: state.turnCount, question, reply: reply.answer });
-    state.currentPrompt = reply.answer;
-    return true;
-  }
-  if (reply.kind === "aborted") {
-    state.aborted = true;
-  }
-  return false;
-}
-async function processResponseInteractions(frame, state, response) {
-  const outputText = extractOutput(response);
-  const isEndTurn = response.stopReason === "end_turn";
-  if (isEndTurn) {
-    const toolCall = extractContextToolCall(outputText);
-    if (toolCall) {
-      return await handleContextToolCall(frame, state, toolCall) ? "continue" : "break";
-    }
-    const question = extractQuestion(outputText);
-    if (question) {
-      return await handleQuestion(frame, state, question) ? "continue" : "break";
-    }
-  }
-  return "break";
-}
-function maybeWarnBudgetSpent(frame, state) {
-  if (state.turnCount >= frame.maxInteractions && !state.timedOut && !state.aborted && frame.maxInteractions > 1) {
-    getSafeLogger2()?.warn("acp-adapter", "Interaction budget spent", {
-      sessionName: frame.sessionName,
-      maxInteractions: frame.maxInteractions
-    });
-  }
-}
-function throwIfTurnFailed(frame, state) {
-  const lastResponse = state.lastResponse;
-  if (lastResponse?.stopReason !== "error") {
-    return;
-  }
-  const hasUsage = state.totalTokenUsage.inputTokens > 0 || state.totalTokenUsage.outputTokens > 0;
-  throw new SessionTurnError(lastResponse.cancelled ? "Agent session ended with stop reason: error (externally cancelled)" : "Agent session ended with stop reason: error", lastResponse.cancelled === true, lastResponse.retryable === true, state.totalTokenUsage, hasUsage ? estimateCostUsd(state.totalTokenUsage, frame.rateCard.rates) : 0, state.totalExactCostUsd, frame.rateCard.source);
-}
-async function runTurnLoop(frame, state) {
-  while (state.turnCount < frame.maxInteractions) {
-    const began = await beginTurnIteration(frame, state);
-    if (began.kind === "break")
-      break;
-    if (await recoverNoSession(frame, state))
-      continue;
-    accumulateUsage(frame, state, began.response);
-    if (await processResponseInteractions(frame, state, began.response) === "break")
-      break;
-  }
-  maybeWarnBudgetSpent(frame, state);
-  throwIfTurnFailed(frame, state);
-  return buildTurnResult2({
-    lastResponse: state.lastResponse,
-    totalTokenUsage: state.totalTokenUsage,
-    totalExactCostUsd: state.totalExactCostUsd,
-    turnCount: state.turnCount,
-    interactions: state.interactions,
-    timedOut: state.timedOut,
-    rateCard: frame.rateCard
+    signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
-var DEFAULT_MAX_INTERACTIONS = 10;
-var init_adapter_send_turn = __esm(() => {
-  init_src();
-  init_logger2();
-  init_cost();
-  init_interaction();
-  init_turn();
-  init_types4();
-  init_adapter_lifecycle();
-  init_adapter_output();
-});
-
-// src/agents/acp/agent-entries.ts
-function resolveRegistryEntry(agentName) {
-  return AGENT_REGISTRY[agentName] ?? DEFAULT_ENTRY;
-}
-var AGENT_REGISTRY, DEFAULT_ENTRY, ACP_ADAPTER_NAMES;
-var init_agent_entries = __esm(() => {
-  AGENT_REGISTRY = {
-    claude: {
-      binary: "claude",
-      displayName: "Claude Code (ACP)",
-      supportedTiers: ["fast", "balanced", "powerful"],
-      maxContextTokens: 200000
-    },
-    codex: {
-      binary: "codex",
-      displayName: "OpenAI Codex (ACP)",
-      supportedTiers: ["fast", "balanced"],
-      maxContextTokens: 128000
-    },
-    gemini: {
-      binary: "gemini",
-      displayName: "Gemini CLI (ACP)",
-      supportedTiers: ["fast", "balanced", "powerful"],
-      maxContextTokens: 1e6
-    },
-    opencode: {
-      binary: "opencode",
-      displayName: "opencode (ACP)",
-      supportedTiers: ["fast", "balanced", "powerful"],
-      maxContextTokens: 128000
-    },
-    pi: {
-      binary: "pi",
-      displayName: "Pi Coding Agent (ACP)",
-      supportedTiers: ["fast", "balanced", "powerful"],
-      maxContextTokens: 128000
-    }
-  };
-  DEFAULT_ENTRY = {
-    binary: "claude",
-    displayName: "ACP Agent",
-    supportedTiers: ["balanced"],
-    maxContextTokens: 128000
-  };
-  ACP_ADAPTER_NAMES = new Set(Object.keys(AGENT_REGISTRY));
-});
-
-// src/agents/acp/token-mapper.ts
-function toFiniteTokenCount2(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-function toFiniteOrUndefined(value) {
-  if (value === undefined)
-    return;
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-
-class AcpTokenUsageMapper {
-  toInternal(wire) {
-    return {
-      inputTokens: toFiniteTokenCount2(wire.input_tokens),
-      outputTokens: toFiniteTokenCount2(wire.output_tokens),
-      cacheReadTokens: toFiniteOrUndefined(wire.cache_read_input_tokens),
-      cacheWriteTokens: toFiniteOrUndefined(wire.cache_creation_input_tokens)
-    };
-  }
-}
-var defaultAcpTokenUsageMapper;
-var init_token_mapper = __esm(() => {
-  defaultAcpTokenUsageMapper = new AcpTokenUsageMapper;
-});
-
-// src/agents/acp/adapter.ts
-class AcpAgentAdapter {
-  name;
-  displayName;
-  binary;
-  capabilities;
-  _mapper;
-  constructor(agentName, mapper = defaultAcpTokenUsageMapper) {
-    const entry = resolveRegistryEntry(agentName);
-    this.name = agentName;
-    this.displayName = entry.displayName;
-    this.binary = entry.binary;
-    this._mapper = mapper;
-    this.capabilities = {
-      supportedTiers: entry.supportedTiers,
-      maxContextTokens: entry.maxContextTokens,
-      features: new Set(["tdd", "review", "refactor"])
-    };
-  }
-  async isInstalled() {
-    const path3 = _acpAdapterDeps.which(this.binary);
-    return path3 !== null;
-  }
-  buildCommand(_options) {
-    return ["acpx", this.name, "session"];
-  }
-  buildAllowedEnv(_options) {
-    return {};
-  }
-  async complete(prompt, options) {
-    const rateCard = await _acpAdapterDeps.resolveRateCard(options.modelDef.model);
-    return runCompleteFlow({
-      adapter: this,
-      prompt,
-      options,
-      mapper: this._mapper,
-      rateCard,
-      createClient: _acpAdapterDeps.createClient
-    });
-  }
-  async closePhysicalSession(handle, workdir, options) {
-    return closePhysicalSession(this.name, handle, workdir, options);
-  }
-  async openSession(name, opts) {
-    const {
-      agentName,
-      workdir,
-      resolvedPermissions,
-      modelDef,
-      timeoutSeconds,
-      promptRetries,
-      onSessionEstablished,
-      onPidSpawned,
-      onPidExited
-    } = opts;
-    const { signal } = opts;
-    throwIfAborted(signal, "Run aborted \u2014 shutdown in progress");
-    const rateCard = await _acpAdapterDeps.resolveRateCard(modelDef.model);
-    const cmdStr = `acpx --model ${modelDef.model} ${agentName}`;
-    const client2 = _acpAdapterDeps.createClient(cmdStr, workdir, timeoutSeconds, onPidSpawned, promptRetries, onPidExited, {
-      onStreamActivity: opts.onStreamActivity,
-      onActiveCall: opts.onActiveCall,
-      trackedSpawnDeadlineMs: opts.trackedSpawnDeadlineMs,
-      trackedSpawnStartupDeadlineMs: opts.trackedSpawnStartupDeadlineMs,
-      env: modelDef.env
-    });
-    let session2;
-    try {
-      await raceWithAbort(client2.start(), signal, "Run aborted \u2014 shutdown in progress");
-      const permissionMode = resolvedPermissions.mode;
-      getSafeLogger2()?.info("acp-adapter", "Permission mode resolved", {
-        permission: permissionMode,
-        stage: "open-session"
-      });
-      const ensured = await raceWithAbort(ensureAcpSession(client2, name, agentName, permissionMode), signal, "Run aborted \u2014 shutdown in progress");
-      session2 = ensured.session;
-      const protocolIds = {
-        recordId: session2.recordId ?? null,
-        sessionId: session2.id ?? null
-      };
-      if (onSessionEstablished) {
-        try {
-          onSessionEstablished(protocolIds, name);
-        } catch (err) {
-          getSafeLogger2()?.warn("acp-adapter", "onSessionEstablished callback threw \u2014 continuing", {
-            sessionName: name,
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
-      }
-      throwIfAborted(signal, "Run aborted \u2014 shutdown in progress");
-      return new AcpSessionHandleImpl({
-        id: name,
-        agentName,
-        protocolIds,
-        client: client2,
-        session: session2,
-        sessionName: name,
-        resumed: ensured.resumed,
-        timeoutSeconds,
-        modelDef,
-        modelTier: opts.modelTier,
-        rateCard,
-        permissionMode: resolvedPermissions.mode
-      });
-    } catch (error48) {
-      if (session2) {
-        await closeAcpSession(session2).catch(() => {});
-      }
-      await client2.close().catch(() => {});
-      throw error48;
-    }
-  }
-  async sendTurn(handle, prompt, opts) {
-    const impl = handle;
-    const frame = buildSendTurnFrame({ impl, mapper: this._mapper, opts });
-    if (frame.opts.signal?.aborted) {
-      return zeroCostAbortedResult(frame);
-    }
-    return runTurnLoop(frame, initialSendTurnState(prompt));
-  }
-  async closeSession(handle) {
-    const impl = handle;
-    try {
-      await closeAcpSession(impl._session);
-    } finally {
-      await impl._client.close().catch(() => {});
-    }
-  }
-}
-var init_adapter = __esm(() => {
-  init_logger2();
-  init_turn();
-  init_adapter_close_physical();
-  init_adapter_complete_flow();
-  init_adapter_lifecycle();
-  init_adapter_send_turn();
-  init_agent_entries();
-  init_token_mapper();
-  init_adapter_lifecycle();
-  init_adapter_output();
-  init_agent_entries();
-});
-
-// src/agents/acp/index.ts
-var init_acp = __esm(() => {
-  init_adapter();
-  init_parser();
-  init_spawn_client();
-  init_stdout_line_reader();
-  init_token_mapper();
-});
-
-// src/agents/transport-failure-message.ts
-function isTransportFailureMessage(message) {
-  if (!message)
-    return false;
-  const haystack = message.toLowerCase();
-  return TRANSPORT_FAULT_MARKERS.some((marker) => haystack.includes(marker));
-}
-var TRANSPORT_FAULT_MARKERS;
-var init_transport_failure_message = __esm(() => {
-  TRANSPORT_FAULT_MARKERS = [
-    "idle timeout exceeded",
-    "stream idle timeout",
-    "upstream timeout",
-    "bad gateway",
-    "service unavailable",
-    "gateway timeout",
-    "econnreset",
-    "econnrefused",
-    "econnaborted",
-    "etimedout",
-    "socket hang up",
-    "premature close",
-    "terminated: other side closed",
-    "network error"
-  ];
-});
-
-// src/agents/complete-exception-classifier.ts
-function classifyCompleteException(err) {
-  if ((err instanceof SessionTurnError || err instanceof SessionFailureError) && err.adapterFailure !== undefined) {
-    return err.adapterFailure;
-  }
-  const fullMessage = errorMessage(err);
-  const message = fullMessage.slice(0, MAX_FAILURE_MESSAGE_CHARS);
-  if (err instanceof NaxError && err.code === "AGENT_TIMEOUT") {
-    return { category: "quality", outcome: "fail-timeout", retriable: true, message };
-  }
-  const parsed = parseAgentError(fullMessage);
-  switch (parsed.type) {
-    case "auth":
-      return { category: "availability", outcome: "fail-auth", retriable: false, message };
-    case "rate-limit":
-      return {
-        category: "availability",
-        outcome: "fail-rate-limit",
-        retriable: true,
-        message,
-        ...parsed.retryAfterSeconds !== undefined ? { retryAfterSeconds: parsed.retryAfterSeconds } : {}
-      };
-    case "model-not-available":
-      return { category: "quality", outcome: "fail-adapter-error", retriable: false, message };
-    case "timeout":
-      return { category: "quality", outcome: "fail-timeout", retriable: true, message };
-    case "crash":
-      return { category: "quality", outcome: "fail-adapter-error", retriable: false, message };
-    default:
-      return isTransportFailureMessage(fullMessage) ? { category: "availability", outcome: "fail-service-down", retriable: true, message } : { category: "quality", outcome: "fail-unknown", retriable: false, message };
-  }
-}
-var MAX_FAILURE_MESSAGE_CHARS = 500;
-var init_complete_exception_classifier = __esm(() => {
-  init_internal();
-  init_errors4();
-  init_errors5();
-  init_transport_failure_message();
-  init_types4();
+var spawn;
+var init_bun_deps = __esm(() => {
+  spawn = Bun.spawn;
 });
 
 // src/agents/retry/failure-policy.ts
@@ -43734,14 +41669,14 @@ function analyzeTestExitCode(output, exitCode) {
   }
   return result;
 }
-var init_parser2 = __esm(() => {
+var init_parser = __esm(() => {
   init_detector2();
   init_parse_bun();
   init_parse_rust();
 });
 
 // src/test-runners/resolver.ts
-import { dirname as dirname12, isAbsolute as isAbsolute11, join as join31, relative as relative12, resolve as resolve21 } from "path";
+import { dirname as dirname12, isAbsolute as isAbsolute10, join as join31, relative as relative12, resolve as resolve21 } from "path";
 function buildResolved(globs, resolution) {
   return {
     globs,
@@ -43762,7 +41697,7 @@ function validateGlobs(patterns, stage) {
   }
 }
 async function resolveTestFilePatterns(config2, workdir, packageDir, options) {
-  if (packageDir !== undefined && isAbsolute11(packageDir)) {
+  if (packageDir !== undefined && isAbsolute10(packageDir)) {
     throw new NaxError(`resolveTestFilePatterns: packageDir must be relative to workdir, got absolute path "${packageDir}"`, "INVALID_PACKAGE_DIR", { stage: "resolver", workdir, packageDir });
   }
   if (packageDir) {
@@ -44464,7 +42399,7 @@ var init_test_runners = __esm(() => {
   init_detector2();
   init_parse_bun();
   init_parse_rust();
-  init_parser2();
+  init_parser();
   init_resolver();
   init_scoped_selection();
 });
@@ -44650,7 +42585,7 @@ var init_diff_utils = __esm(() => {
 
 // src/utils/path-security.ts
 import { realpathSync as realpathSync4 } from "fs";
-import { dirname as dirname13, isAbsolute as isAbsolute12, join as join34, normalize as normalize3, resolve as resolve22 } from "path";
+import { dirname as dirname13, isAbsolute as isAbsolute11, join as join34, normalize as normalize3, resolve as resolve22 } from "path";
 function safeRealpathForComparison(p) {
   try {
     return realpathSync4(p);
@@ -44668,7 +42603,7 @@ function isRelativeAndSafe(filePath2) {
   if (!isSafeRelativePath(filePath2))
     return false;
   const normalized = normalize3(filePath2);
-  if (isAbsolute12(normalized))
+  if (isAbsolute11(normalized))
     return false;
   return true;
 }
@@ -44677,7 +42612,7 @@ function validateModulePath(modulePath, allowedRoots) {
     return { valid: false, error: "Module path is empty" };
   }
   const resolvedRoots = allowedRoots.map((r) => safeRealpathForComparison(resolve22(r)));
-  if (isAbsolute12(modulePath)) {
+  if (isAbsolute11(modulePath)) {
     const normalized = normalize3(modulePath);
     const resolved = safeRealpathForComparison(normalized);
     const isWithin3 = resolvedRoots.some((root) => resolved.startsWith(`${root}/`) || resolved === root);
@@ -46713,7 +44648,7 @@ var init_hermetic = __esm(() => {
 });
 
 // src/prompts/sections/protocol-region.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 function call(tool, input) {
   return `${tool} ${JSON.stringify(input)}`;
 }
@@ -46830,7 +44765,7 @@ var KIND_PATTERN, NONCE, PROTOCOL_REGION_MARKER_PREFIX = "<!--nax:", REGION, OWN
 var init_protocol_region = __esm(() => {
   init_errors4();
   KIND_PATTERN = /^[a-z][a-z-]*$/;
-  NONCE = randomUUID9().slice(0, 8);
+  NONCE = randomUUID8().slice(0, 8);
   REGION = new RegExp(`<!--nax:([a-z][a-z-]*):([a-f0-9]+) (\\{.*?\\})-->\\n` + `((?:(?!<!--nax:[a-z][a-z-]*:[a-f0-9]+ )[\\s\\S])*?)` + `<!--\\/nax:\\1-->\\n?`, "g");
   OWN_OPEN = new RegExp(`<!--nax:[a-z][a-z-]*:${NONCE} `, "g");
   REGISTRY = {
@@ -51790,6 +49725,14 @@ function lintForNeutrality(content, fileName) {
 function estimateTokens3(text) {
   return Math.ceil(text.length / 4);
 }
+function handleFrontmatterFailure(err, filePath2, onInvalidFrontmatter, issues, logger) {
+  if (!(err instanceof RulesFrontmatterError))
+    throw err;
+  logger.warn("canonical-loader", onInvalidFrontmatter === "throw" ? "Invalid rule frontmatter \u2014 load will fail" : "Invalid rule frontmatter \u2014 skipping file", { file: filePath2, error: err.message });
+  if (onInvalidFrontmatter === "throw") {
+    issues.push({ file: filePath2, message: err.message });
+  }
+}
 function applyCanonicalRulesBudget(rules, budgetTokens, options = {}) {
   const enforce = options.enforce === true;
   const totalTokens = rules.reduce((sum, r) => sum + (r.tokens ?? estimateTokens3(r.content)), 0);
@@ -51848,6 +49791,7 @@ async function loadCanonicalRules(workdir, options = {}) {
   }
   const rules = [];
   const allViolations = [];
+  const frontmatterIssues = [];
   for (const filePath2 of filePaths) {
     const normalizedPath = filePath2.replaceAll("\\", "/");
     const normalizedRulesDir = rulesDir.replaceAll("\\", "/");
@@ -51868,14 +49812,8 @@ async function loadCanonicalRules(workdir, options = {}) {
     try {
       parsed = parseFrontmatter(content, filePath2);
     } catch (err) {
-      if (err instanceof RulesFrontmatterError) {
-        logger.warn("canonical-loader", "Invalid rule frontmatter \u2014 skipping file", {
-          file: filePath2,
-          error: err.message
-        });
-        continue;
-      }
-      throw err;
+      handleFrontmatterFailure(err, filePath2, options.onInvalidFrontmatter, frontmatterIssues, logger);
+      continue;
     }
     if (!parsed.content)
       continue;
@@ -51901,6 +49839,9 @@ async function loadCanonicalRules(workdir, options = {}) {
       ...parsed.warnings.length > 0 && { warnings: parsed.warnings }
     });
   }
+  if (frontmatterIssues.length > 0) {
+    throw new RulesFrontmatterLintError(frontmatterIssues);
+  }
   if (allViolations.length > 0) {
     throw new NeutralityLintError(allViolations);
   }
@@ -51936,7 +49877,7 @@ async function loadCanonicalRules(workdir, options = {}) {
   }
   return budgetResult.rules;
 }
-var CANONICAL_RULES_DIR = ".nax/rules", _canonicalLoaderDeps, NEUTRALITY_RULES, DEFAULT_CANONICAL_RULES_BUDGET_TOKENS = 8192, RULES_BUDGET_WARNING_RATIO = 0.75, RULE_ALLOW_MARKER, NeutralityLintError;
+var CANONICAL_RULES_DIR = ".nax/rules", _canonicalLoaderDeps, NEUTRALITY_RULES, DEFAULT_CANONICAL_RULES_BUDGET_TOKENS = 8192, RULES_BUDGET_WARNING_RATIO = 0.75, RULE_ALLOW_MARKER, NeutralityLintError, RulesFrontmatterLintError;
 var init_canonical_loader = __esm(() => {
   init_errors4();
   init_logger2();
@@ -52040,6 +49981,19 @@ ${summary}`, "NEUTRALITY_LINT_FAILED", {
       this.violations = violations;
     }
   };
+  RulesFrontmatterLintError = class RulesFrontmatterLintError extends NaxError {
+    issues;
+    constructor(issues) {
+      const summary = issues.map((i) => `  ${i.file}: ${i.message}`).join(`
+`);
+      super(`Canonical rules frontmatter lint failed:
+${summary}`, "RULES_FRONTMATTER_LINT_FAILED", {
+        stage: "canonical-loader",
+        issueCount: issues.length
+      });
+      this.issues = issues;
+    }
+  };
 });
 
 // src/context/engine/agent-profiles.ts
@@ -52433,7 +50387,7 @@ var init_digest = __esm(() => {
 
 // src/context/engine/manifest-store.ts
 import { mkdir as mkdir13 } from "fs/promises";
-import { dirname as dirname14, isAbsolute as isAbsolute13, join as join37, relative as relative17, resolve as resolve24 } from "path";
+import { dirname as dirname14, isAbsolute as isAbsolute12, join as join37, relative as relative17, resolve as resolve24 } from "path";
 function contextStoryDir(projectDir, featureId, storyId) {
   return join37(featureDir(projectDir, featureId), "stories", storyId);
 }
@@ -52444,11 +50398,11 @@ function rebuildManifestPath(projectDir, featureId, storyId) {
   return join37(contextStoryDir(projectDir, featureId, storyId), "rebuild-manifest.json");
 }
 function toStoredPath(projectDir, pathValue) {
-  const relativePath = isAbsolute13(pathValue) ? relative17(projectDir, pathValue) : pathValue;
+  const relativePath = isAbsolute12(pathValue) ? relative17(projectDir, pathValue) : pathValue;
   return relativePath === "" ? "." : relativePath;
 }
 function toAbsolutePath(projectDir, pathValue) {
-  return isAbsolute13(pathValue) ? pathValue : resolve24(projectDir, pathValue);
+  return isAbsolute12(pathValue) ? pathValue : resolve24(projectDir, pathValue);
 }
 function toStoredManifest(projectDir, manifest) {
   return {
@@ -52993,10 +50947,10 @@ var init_static_rules_scoping = __esm(() => {
 });
 
 // src/context/engine/providers/static-rules.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { join as join38 } from "path";
 function contentHash8(content) {
-  return createHash7("sha256").update(content).digest("hex").slice(0, 8);
+  return createHash6("sha256").update(content).digest("hex").slice(0, 8);
 }
 function canonicalRuleId(rule) {
   return rule.id ?? rule.fileName.replace(/\.md$/i, "");
@@ -53733,9 +51687,9 @@ var init_loop_handler_forwarding = __esm(() => {
 });
 
 // src/session/manager-deps.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import { mkdir as mkdir14 } from "fs/promises";
-import { isAbsolute as isAbsolute14, join as join39, relative as relative18, sep as sep13 } from "path";
+import { isAbsolute as isAbsolute13, join as join39, relative as relative18, sep as sep13 } from "path";
 function resolveProjectDirFromScratchDir(scratchDir) {
   const marker = `${sep13}.nax${sep13}features${sep13}`;
   const markerIdx = scratchDir.lastIndexOf(marker);
@@ -53747,7 +51701,7 @@ function resolveProjectDirFromScratchDir(scratchDir) {
   return;
 }
 function toProjectRelativePath(projectDir, pathValue) {
-  const relativePath = isAbsolute14(pathValue) ? relative18(projectDir, pathValue) : pathValue;
+  const relativePath = isAbsolute13(pathValue) ? relative18(projectDir, pathValue) : pathValue;
   return relativePath === "" ? "." : relativePath;
 }
 function deriveNativeTranscriptDir(opts) {
@@ -53775,7 +51729,7 @@ var init_manager_deps = __esm(() => {
   _sessionManagerDeps = {
     now: () => new Date().toISOString(),
     nowMs: () => Date.now(),
-    uuid: () => randomUUID10(),
+    uuid: () => randomUUID9(),
     sessionScratchDir: (projectDir, featureName, sessionId) => join39(featureDir(projectDir, featureName), "sessions", sessionId),
     writeDescriptor: async (scratchDir, descriptor, projectDir) => {
       await mkdir14(scratchDir, { recursive: true });
@@ -53838,9 +51792,9 @@ var init_model_selection = __esm(() => {
 });
 
 // src/runtime/session-name.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 function formatSessionName(req) {
-  const hash2 = createHash8("sha256").update(req.workdir).digest("hex").slice(0, 8);
+  const hash2 = createHash7("sha256").update(req.workdir).digest("hex").slice(0, 8);
   const sanitize = (s) => s.replace(/[^a-z0-9]+/gi, "-").toLowerCase().replace(/^-+|-+$/g, "");
   const parts = ["nax", hash2];
   if (req.featureName)
@@ -55042,9 +52996,9 @@ var init_staleness = __esm(() => {
 });
 
 // src/context/engine/providers/feature-context.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 function contentHash82(content) {
-  return createHash9("sha256").update(content).digest("hex").slice(0, 8);
+  return createHash8("sha256").update(content).digest("hex").slice(0, 8);
 }
 function estimateTokens4(text) {
   return Math.ceil(text.length / 4);
@@ -55449,9 +53403,9 @@ var init_code_neighbor_cache = __esm(() => {
 });
 
 // src/context/engine/providers/code-neighbor-chunk.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 function contentHash83(content) {
-  return createHash10("sha256").update(content).digest("hex").slice(0, 8);
+  return createHash9("sha256").update(content).digest("hex").slice(0, 8);
 }
 function assembleCodeNeighborChunk(input) {
   const { sections: sections2, truncated, maxGlobFiles } = input;
@@ -55529,7 +53483,7 @@ var MAX_CHUNK_TOKENS = 500;
 var init_code_neighbor_chunk = () => {};
 
 // src/context/engine/providers/code-neighbor-phases.ts
-import { isAbsolute as isAbsolute15, join as join44, relative as relative19, resolve as resolve25 } from "path";
+import { isAbsolute as isAbsolute14, join as join44, relative as relative19, resolve as resolve25 } from "path";
 function parseImportSpecifiers(content) {
   const specifiers = new Set;
   for (const match of content.matchAll(FROM_PATTERN)) {
@@ -55559,7 +53513,7 @@ function resolveImport(specifier, fromFile, workdir) {
 function packageScopeRelative(execRoot, packageDir) {
   if (!packageDir)
     return "";
-  const rel = isAbsolute15(packageDir) ? relative19(execRoot, packageDir) : packageDir;
+  const rel = isAbsolute14(packageDir) ? relative19(execRoot, packageDir) : packageDir;
   const normalized = rel.replace(/\\/g, "/").replace(/\/+$/, "");
   if (normalized === "" || normalized === "." || normalized.startsWith(".."))
     return "";
@@ -56584,7 +54538,7 @@ var init_render = __esm(() => {
 });
 
 // src/context/engine/rebuild.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 function toPackedChunks(prior, newAgentId, targetAgentId) {
   const priorAgentForNeutralize = prior.agentId ?? "";
   return prior.chunks.map((c) => {
@@ -56711,7 +54665,7 @@ var init_rebuild = __esm(() => {
   init_render();
   init_scratch_neutralizer();
   DEFAULT_REBUILD_DEPS = {
-    uuid: () => randomUUID11(),
+    uuid: () => randomUUID10(),
     getLogger: () => getLogger2()
   };
 });
@@ -56757,7 +54711,7 @@ var init_scoring = __esm(() => {
 });
 
 // src/context/engine/orchestrator.ts
-import { createHash as createHash11, randomUUID as randomUUID12 } from "crypto";
+import { createHash as createHash10, randomUUID as randomUUID11 } from "crypto";
 function buildPullToolDescriptors(stageToolNames, pullConfig) {
   if (!pullConfig?.enabled || stageToolNames.length === 0)
     return [];
@@ -56924,7 +54878,7 @@ class ContextOrchestrator {
     const providerResults = fetchResults.map(({ providerStatus }) => providerStatus);
     if (request.priorStageDigest && (request.planDigestBoost ?? 1) > 1) {
       const boost = request.planDigestBoost ?? 1;
-      const hash2 = createHash11("sha256").update(request.priorStageDigest).digest("hex").slice(0, 8);
+      const hash2 = createHash10("sha256").update(request.priorStageDigest).digest("hex").slice(0, 8);
       const tokens = Math.ceil(request.priorStageDigest.length / 4);
       allRaw.push({
         id: `plan-digest:${hash2}`,
@@ -57060,7 +55014,7 @@ var init_orchestrator = __esm(() => {
   init_stage_config();
   _orchestratorDeps = {
     now: () => Date.now(),
-    uuid: () => randomUUID12(),
+    uuid: () => randomUUID11(),
     getLogger: getLogger2,
     rebuild
   };
@@ -57068,10 +55022,10 @@ var init_orchestrator = __esm(() => {
 });
 
 // src/context/engine/providers/git-history.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { join as join46 } from "path";
 function contentHash84(content) {
-  return createHash12("sha256").update(content).digest("hex").slice(0, 8);
+  return createHash11("sha256").update(content).digest("hex").slice(0, 8);
 }
 async function hasHistoryAt(path5, repoRoot) {
   const { stdout, exitCode } = await _gitHistoryDeps.gitWithTimeout(["log", "--oneline", "-1", "--", path5], repoRoot);
@@ -57215,10 +55169,10 @@ var init_git_history = __esm(() => {
 });
 
 // src/context/engine/providers/lint-config.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { join as join47 } from "path";
 function contentHash85(content) {
-  return createHash13("sha256").update(content).digest("hex").slice(0, 8);
+  return createHash12("sha256").update(content).digest("hex").slice(0, 8);
 }
 function distillLintConfig(tool, raw) {
   if (tool !== "biome")
@@ -57956,9 +55910,9 @@ var init_metrics = __esm(() => {
 });
 
 // src/context/engine/providers/prior-run-failure.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 function contentHash86(content) {
-  return createHash14("sha256").update(content).digest("hex").slice(0, 8);
+  return createHash13("sha256").update(content).digest("hex").slice(0, 8);
 }
 function aggregatePriorFailures(runs, storyId) {
   let totalAttempts = 0;
@@ -58068,9 +56022,9 @@ async function readJsonlTail(path6, maxBytes = DEFAULT_JSONL_TAIL_BYTES) {
 var DEFAULT_JSONL_TAIL_BYTES = 65536;
 
 // src/context/engine/providers/session-scratch.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 function contentHash87(content) {
-  return createHash15("sha256").update(content).digest("hex").slice(0, 8);
+  return createHash14("sha256").update(content).digest("hex").slice(0, 8);
 }
 function parseJsonl(raw) {
   const entries = [];
@@ -58177,9 +56131,9 @@ var init_session_scratch = __esm(() => {
 });
 
 // src/context/engine/providers/test-coverage.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 function contentHash88(content) {
-  return createHash16("sha256").update(content).digest("hex").slice(0, 8);
+  return createHash15("sha256").update(content).digest("hex").slice(0, 8);
 }
 
 class TestCoverageProvider {
@@ -58259,9 +56213,9 @@ var init_test_coverage = __esm(() => {
 });
 
 // src/context/engine/providers/tool-diagnostics.ts
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 function contentHash89(content) {
-  return createHash17("sha256").update(content).digest("hex").slice(0, 8);
+  return createHash16("sha256").update(content).digest("hex").slice(0, 8);
 }
 function parseToolDiagnosticsJsonl(raw) {
   const entries = [];
@@ -58643,9 +56597,9 @@ var init_registry4 = __esm(() => {
 });
 
 // src/trust/store.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 import { mkdir as mkdir18, rename as rename5, stat as stat8, unlink as unlink4, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname20, isAbsolute as isAbsolute16, join as join48 } from "path";
+import { dirname as dirname20, isAbsolute as isAbsolute15, join as join48 } from "path";
 function trustStorePath() {
   return join48(globalConfigDir(), "trust.json");
 }
@@ -58716,7 +56670,7 @@ async function readFoldersForWrite(storePath) {
   return read.state === "ok" ? read.file.folders : [];
 }
 async function writeTrustStore(storePath, file2) {
-  const tempPath = `${storePath}.${process.pid}.${randomUUID13()}.tmp`;
+  const tempPath = `${storePath}.${process.pid}.${randomUUID12()}.tmp`;
   try {
     await writeFile10(tempPath, `${JSON.stringify(file2, null, 2)}
 `, { mode: 384 });
@@ -58745,7 +56699,7 @@ var init_store2 = __esm(() => {
   TrustStoreFileSchema = exports_external.object({
     version: exports_external.literal(1),
     folders: exports_external.array(exports_external.object({
-      path: exports_external.string().refine((path6) => isAbsolute16(path6), { message: "path must be absolute" }),
+      path: exports_external.string().refine((path6) => isAbsolute15(path6), { message: "path must be absolute" }),
       addedAt: exports_external.string(),
       via: exports_external.enum(["prompt", "cli"])
     }))
@@ -58811,7 +56765,7 @@ var init_trust = __esm(() => {
 });
 
 // src/context/engine/providers/plugin-loader.ts
-import { isAbsolute as isAbsolute17, join as join49, resolve as resolve28 } from "path";
+import { isAbsolute as isAbsolute16, join as join49, resolve as resolve28 } from "path";
 function isInitialisable(p) {
   return typeof p.init === "function";
 }
@@ -58834,7 +56788,7 @@ function extractProvider(mod) {
   return null;
 }
 function resolveModuleSpecifier(specifier, workdir) {
-  if (isAbsolute17(specifier)) {
+  if (isAbsolute16(specifier)) {
     throw new NaxError(`Plugin module path must be a bare package name or a project-relative path (./... or ../...): got absolute "${specifier}"`, "PLUGIN_MODULE_ABSOLUTE_PATH", { stage: "context", workdir, specifier });
   }
   if (specifier.startsWith("./") || specifier.startsWith("../")) {
@@ -59016,8 +56970,8 @@ var init_version = __esm(() => {
   NAX_AI_VERSION = CATALOG_VERSION;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("d79057cfa"))
-        return "d79057cfa";
+      if (/^[0-9a-f]{6,10}$/.test("eab634ebe"))
+        return "eab634ebe";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -60028,18 +57982,18 @@ var init_in_flight_usage = __esm(() => {
 });
 
 // src/runtime/packages.ts
-import { isAbsolute as isAbsolute18, join as join53, relative as relative21 } from "path";
+import { isAbsolute as isAbsolute17, join as join53, relative as relative21 } from "path";
 function packageWorkdir(view) {
   const { packageDir, repoRoot } = view;
   if (!packageDir)
     return repoRoot;
-  if (!repoRoot || isAbsolute18(packageDir))
+  if (!repoRoot || isAbsolute17(packageDir))
     return packageDir;
   return join53(repoRoot, packageDir);
 }
 function createPackageView(config2, packageDir, repoRoot, hasOverride, overlay) {
   const memo2 = new Map;
-  const relativeFromRoot = packageDir ? isAbsolute18(packageDir) && isAbsolute18(repoRoot) ? stripLeadingSlash(relative21(repoRoot, packageDir)) : packageDir : "";
+  const relativeFromRoot = packageDir ? isAbsolute17(packageDir) && isAbsolute17(repoRoot) ? stripLeadingSlash(relative21(repoRoot, packageDir)) : packageDir : "";
   return {
     packageDir,
     relativeFromRoot,
@@ -60075,7 +58029,7 @@ function createPackageRegistry(loader, repoRoot) {
   function toRelativeKey(packageDir) {
     if (!packageDir)
       return "";
-    if (isAbsolute18(packageDir) && isAbsolute18(repoRoot)) {
+    if (isAbsolute17(packageDir) && isAbsolute17(repoRoot)) {
       if (packageDir === repoRoot)
         return "";
       return stripLeadingSlash(relative21(repoRoot, packageDir));
@@ -60143,7 +58097,7 @@ function storyExecRoot(view) {
   const { repoRoot, packageDir } = view;
   if (!packageDir)
     return repoRoot;
-  if (!repoRoot || isAbsolute18(packageDir))
+  if (!repoRoot || isAbsolute17(packageDir))
     return packageDir;
   const segments = packageDir.split("/");
   if (segments[0] !== ".nax-wt" || segments.length < 2)
@@ -70504,7 +68458,7 @@ var require_which = __commonJS(function(exports, module) {
       pathExtExe
     };
   };
-  var which3 = (cmd, opt, cb) => {
+  var which2 = (cmd, opt, cb) => {
     if (typeof opt === "function") {
       cb = opt;
       opt = {};
@@ -70566,8 +68520,8 @@ var require_which = __commonJS(function(exports, module) {
       return null;
     throw getNotFoundError(cmd);
   };
-  module.exports = which3;
-  which3.sync = whichSync;
+  module.exports = which2;
+  which2.sync = whichSync;
 });
 
 // ../../node_modules/.bun/path-key@3.1.1/node_modules/path-key/index.js
@@ -70587,7 +68541,7 @@ var require_path_key = __commonJS(function(exports, module) {
 // ../../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
 var require_resolveCommand = __commonJS(function(exports, module) {
   var path7 = __require("path");
-  var which3 = require_which();
+  var which2 = require_which();
   var getPathKey = require_path_key();
   function resolveCommandAttempt(parsed, withoutPathExt) {
     const env2 = parsed.options.env || process.env;
@@ -70601,7 +68555,7 @@ var require_resolveCommand = __commonJS(function(exports, module) {
     }
     let resolved;
     try {
-      resolved = which3.sync(parsed.command, {
+      resolved = which2.sync(parsed.command, {
         path: env2[getPathKey({ env: env2 })],
         pathExt: withoutPathExt ? path7.delimiter : undefined
       });
@@ -71106,7 +69060,7 @@ var init_client4 = __esm(() => {
 });
 
 // src/mcp/lock.ts
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 import { mkdir as mkdir22, readFile as readFile9, writeFile as writeFile11 } from "fs/promises";
 import { join as join55 } from "path";
 function mcpLockPath(projectRoot) {
@@ -71121,7 +69075,7 @@ function canonical3(value) {
   return Object.fromEntries(entries.map(([k, v]) => [k, canonical3(v)]));
 }
 function schemaHash(schema) {
-  return createHash18("sha256").update(JSON.stringify(canonical3(schema) ?? null)).digest("hex").slice(0, 16);
+  return createHash17("sha256").update(JSON.stringify(canonical3(schema) ?? null)).digest("hex").slice(0, 16);
 }
 async function readMcpLock(projectRoot) {
   try {
@@ -71642,7 +69596,7 @@ var init_flake_probe = __esm(() => {
   init_internal();
   init_errors4();
   init_logger2();
-  init_parser2();
+  init_parser();
   init_executor();
   NO_TESTS_EXECUTED_MARKERS = [/no tests? to run/i, /^ran 0 tests?/im];
   _flakeProbeDeps = {
@@ -72981,10 +70935,10 @@ async function resolvePackageName(root) {
 var init_exec_package_name = () => {};
 
 // src/agents/nax-owned-writes.ts
-import { isAbsolute as isAbsolute19, relative as relative22, resolve as resolve31, sep as sep15 } from "path";
+import { isAbsolute as isAbsolute18, relative as relative22, resolve as resolve31, sep as sep15 } from "path";
 function naxWriteOptIns(root, allowWrite) {
   const naxDir = resolve31(root, ".nax");
-  const names = allowWrite.map((p) => relative22(naxDir, isAbsolute19(p) ? resolve31(p) : resolve31(root, p))).filter((rel) => rel !== "" && !rel.startsWith("..") && !rel.includes(sep15) && !isAbsolute19(rel)).filter((name) => name !== NAX_SCRATCHPAD_ENTRY && !NAX_NEVER_OPT_IN.has(name));
+  const names = allowWrite.map((p) => relative22(naxDir, isAbsolute18(p) ? resolve31(p) : resolve31(root, p))).filter((rel) => rel !== "" && !rel.startsWith("..") && !rel.includes(sep15) && !isAbsolute18(rel)).filter((name) => name !== NAX_SCRATCHPAD_ENTRY && !NAX_NEVER_OPT_IN.has(name));
   return new Set(names);
 }
 function isNaxConfigSegments(segments) {
@@ -73562,12 +71516,12 @@ var init_tool_preamble = __esm(() => {
 });
 
 // src/session/instruction-options.ts
-import { isAbsolute as isAbsolute20, relative as relative23 } from "path";
+import { isAbsolute as isAbsolute19, relative as relative23 } from "path";
 function instructionOptionsForSession(agentName, options) {
   if (agentName !== "native")
     return {};
   const packageDir = options.codingToolPackageDir;
-  const packageScope = packageDir ? isAbsolute20(packageDir) ? relative23(options.workdir, packageDir) : packageOverrideKey(packageDir) : ".";
+  const packageScope = packageDir ? isAbsolute19(packageDir) ? relative23(options.workdir, packageDir) : packageOverrideKey(packageDir) : ".";
   return {
     instructionFileName: options.config.agent?.native?.instructionFileName ?? DEFAULT_INSTRUCTION_FILE_NAME,
     instructionDirectories: options.instructionDirectories ?? [options.codingToolWorkdirLabel ?? (packageScope || ".")],
@@ -73774,7 +71728,7 @@ __export(exports_runtime, {
   totalSpendUsd: () => totalSpendUsd,
   writeProjectIdentity: () => writeProjectIdentity
 });
-import { basename as basename9, isAbsolute as isAbsolute21, join as join60, resolve as resolve32 } from "path";
+import { basename as basename9, isAbsolute as isAbsolute20, join as join60, resolve as resolve32 } from "path";
 function createRuntime(config2, workdir, opts) {
   const runId = crypto.randomUUID();
   const controller = new AbortController;
@@ -73805,7 +71759,7 @@ function createRuntime(config2, workdir, opts) {
   const reviewAuditor = opts?.reviewAuditor ?? (config2.review?.audit?.enabled ? new ReviewAuditor(runId, outputDir) : createNoOpReviewAuditor());
   const usageEnabled = config2.agent?.usageAudit?.enabled ?? false;
   const configuredUsageDir = config2.agent?.usageAudit?.dir;
-  const usageDir = configuredUsageDir === undefined ? join60(outputDir, "usage") : isAbsolute21(configuredUsageDir) ? configuredUsageDir : resolve32(workdir, configuredUsageDir);
+  const usageDir = configuredUsageDir === undefined ? join60(outputDir, "usage") : isAbsolute20(configuredUsageDir) ? configuredUsageDir : resolve32(workdir, configuredUsageDir);
   let usageAuditor;
   if (opts?.usageAuditor) {
     usageAuditor = opts.usageAuditor;
@@ -74001,12 +71955,12 @@ var init_runtime3 = __esm(() => {
 
 // src/context/engine/stage-assembler.ts
 import { readdir as readdir4 } from "fs/promises";
-import { isAbsolute as isAbsolute22, join as join61, resolve as resolve33 } from "path";
+import { isAbsolute as isAbsolute21, join as join61, resolve as resolve33 } from "path";
 function dedupeScratchDirs(dirs) {
   return [...new Set(dirs.filter((dir) => Boolean(dir)))];
 }
 function toAbsolutePath2(projectDir, pathValue) {
-  return isAbsolute22(pathValue) ? pathValue : resolve33(projectDir, pathValue);
+  return isAbsolute21(pathValue) ? pathValue : resolve33(projectDir, pathValue);
 }
 async function discoverSessionScratchDirsOnDisk(projectDir, featureName, storyId, ttlMs) {
   const logger = getLogger2();
@@ -80131,6 +78085,54 @@ var init_fix_review2 = __esm(() => {
   };
 });
 
+// src/agents/shared/env.ts
+import { homedir as homedir5 } from "os";
+import { isAbsolute as isAbsolute22 } from "path";
+function buildAllowedEnv(options) {
+  const allowed = {};
+  for (const varName of ESSENTIAL_VARS) {
+    if (process.env[varName])
+      allowed[varName] = process.env[varName];
+  }
+  const rawHome = process.env.HOME ?? "";
+  const safeHome = rawHome && isAbsolute22(rawHome) ? rawHome : homedir5();
+  if (rawHome !== safeHome) {
+    getSafeLogger2()?.warn("env", `HOME env is not absolute ("${rawHome}"), falling back to os.homedir(): ${safeHome}`);
+  }
+  allowed.HOME = safeHome;
+  for (const varName of API_KEY_VARS) {
+    if (process.env[varName])
+      allowed[varName] = process.env[varName];
+  }
+  for (const [key, value] of Object.entries(process.env)) {
+    if (ALLOWED_PREFIXES.some((prefix) => key.startsWith(prefix))) {
+      allowed[key] = value;
+    }
+  }
+  if (options?.modelEnv)
+    Object.assign(allowed, options.modelEnv);
+  if (options?.env)
+    Object.assign(allowed, options.env);
+  return allowed;
+}
+var ESSENTIAL_VARS, API_KEY_VARS, ALLOWED_PREFIXES;
+var init_env = __esm(() => {
+  init_logger2();
+  ESSENTIAL_VARS = ["PATH", "TMPDIR", "NODE_ENV", "USER", "LOGNAME"];
+  API_KEY_VARS = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GEMINI_API_KEY", "GOOGLE_API_KEY", "CLAUDE_API_KEY"];
+  ALLOWED_PREFIXES = [
+    "CLAUDE_",
+    "NAX_",
+    "CLAW_",
+    "TURBO_",
+    "CODEX_",
+    "GEMINI_",
+    "ANTHROPIC_",
+    "OPENCODE_",
+    "MINIMAX_"
+  ];
+});
+
 // src/utils/command-argv.ts
 function parseCommandToArgv(command) {
   const safeEnv = buildAllowedEnv();
@@ -84759,7 +82761,93 @@ var init_manager_run_fallback = __esm(() => {
   init_swap_decision();
 });
 
-// src/agents/acp-sdk/pricing.ts
+// src/agents/turn/abort.ts
+function createAbortError(signal, fallback = "Run aborted") {
+  const reason = signal?.reason;
+  if (reason instanceof Error) {
+    return reason;
+  }
+  if (typeof reason === "string" && reason.length > 0) {
+    return new Error(reason);
+  }
+  return new Error(fallback);
+}
+function throwIfAborted(signal, fallback) {
+  if (signal?.aborted) {
+    throw createAbortError(signal, fallback);
+  }
+}
+async function raceWithAbort(promise3, signal, fallback) {
+  if (!signal) {
+    return promise3;
+  }
+  if (signal.aborted) {
+    throw createAbortError(signal, fallback);
+  }
+  return await new Promise((resolve35, reject) => {
+    const onAbort = () => reject(createAbortError(signal, fallback));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise3.then((value) => {
+      signal.removeEventListener("abort", onAbort);
+      resolve35(value);
+    }, (error48) => {
+      signal.removeEventListener("abort", onAbort);
+      reject(error48);
+    });
+  });
+}
+
+// src/agents/turn/turn-deadline.ts
+function assembleTurnResult(input) {
+  const { totalTokenUsage, totalExactCostUsd, turnCount, interactions, timedOut, rateCard } = input;
+  const output = timedOut ? "" : input.output;
+  const hasUsage = totalTokenUsage.inputTokens > 0 || totalTokenUsage.outputTokens > 0;
+  const priced = hasUsage ? priceCall(totalTokenUsage, rateCard.rates) : undefined;
+  return {
+    output,
+    tokenUsage: totalTokenUsage,
+    estimatedCostUsd: priced?.costUsd ?? 0,
+    exactCostUsd: totalExactCostUsd,
+    internalRoundTrips: turnCount,
+    ...interactions.length > 0 ? { interactions } : {},
+    timedOut,
+    pricingSource: rateCard.source,
+    ...priced?.resolvedRates !== undefined ? { rates: priced.resolvedRates } : {}
+  };
+}
+function warnWallClockTimeout(sessionName, timeoutSeconds, stage) {
+  getSafeLogger2()?.warn(stage, "wall-clock timeout exceeded \u2014 session terminated", {
+    sessionName,
+    timeoutSeconds
+  });
+}
+var init_turn_deadline2 = __esm(() => {
+  init_logger2();
+  init_cost();
+});
+
+// src/agents/turn/index.ts
+var init_turn = __esm(() => {
+  init_turn_deadline2();
+});
+
+// src/agents/session-naming.ts
+import { createHash as createHash18 } from "crypto";
+function computeAcpHandle(workdir, featureName, storyId, sessionRole) {
+  const hash2 = createHash18("sha256").update(workdir).digest("hex").slice(0, 8);
+  const sanitize = (s) => s.replace(/[^a-z0-9]+/gi, "-").toLowerCase().replace(/^-+|-+$/g, "");
+  const parts = ["nax", hash2];
+  if (featureName)
+    parts.push(sanitize(featureName));
+  if (storyId)
+    parts.push(sanitize(storyId));
+  if (sessionRole)
+    parts.push(sanitize(sessionRole));
+  return parts.join("-");
+}
+var init_session_naming = () => {};
+
+// src/agents/acp/pricing.ts
 function spendOfResult(result) {
   return {
     tokenUsage: result.tokenUsage,
@@ -84795,7 +82883,7 @@ var init_pricing = __esm(() => {
   });
 });
 
-// src/agents/acp-sdk/failure-map.ts
+// src/agents/acp/failure-map.ts
 function capped(text) {
   return text.slice(0, MAX_MESSAGE_CHARS);
 }
@@ -88959,7 +87047,7 @@ function client3(options) {
   return new ClientApp(options);
 }
 var methods, startActiveSession, AgentContext, ClientContext, AgentConnectionHandle, ClientConnectionHandle, ActiveSession, agentRequestSpecs, agentNotificationSpecs, clientRequestSpecs, clientNotificationSpecs, agentRequestSpecsByMethod, agentNotificationSpecsByMethod, clientRequestSpecsByMethod, clientNotificationSpecsByMethod, sessionUpdateRouters, appBuilder, runAgentConnectHandlers, runClientConnectHandlers, stableConnectionOptions, AgentApp, ClientApp, legacyAgentRequestMethods, legacyAgentNotificationMethods, legacyClientRequestMethods, legacyClientNotificationMethods, TerminalHandle;
-var init_acp2 = __esm(() => {
+var init_acp = __esm(() => {
   init_schema3();
   init_zod_gen();
   init_stream();
@@ -89593,7 +87681,7 @@ function stopReasonError(stopReason) {
 }
 var EXCERPT_BYTES = 4096, AUTH_REQUIRED_CODE = -32000, RESOURCE_NOT_FOUND_CODE = -32002, RESTORE_STEPS, SESSION_NOT_FOUND_TEXT2, ACP_STOP_CODES;
 var init_errors6 = __esm(() => {
-  init_acp2();
+  init_acp();
   init_src();
   init_text();
   RESTORE_STEPS = new Set(["session/resume", "session/load"]);
@@ -90420,7 +88508,7 @@ async function agentGoneError(during, launched, secrets) {
 }
 var GONE_WAIT_MS = 1000, STDERR_DRAIN_MS = 200;
 var init_launch = __esm(() => {
-  init_acp2();
+  init_acp();
   init_src();
   init_errors6();
 });
@@ -90522,7 +88610,7 @@ function openConnection(target, handlers) {
   };
 }
 var init_connection = __esm(() => {
-  init_acp2();
+  init_acp();
 });
 
 // ../nax-agent-acp/src/client/pre-approval.ts
@@ -90794,7 +88882,7 @@ function initialDoc(o, record4, agentSessionId) {
 }
 var MAX_OFFERED_MODELS = 50, MAX_MODEL_ID_CHARS = 100;
 var init_open = __esm(() => {
-  init_acp2();
+  init_acp();
   init_src();
   init_capabilities();
   init_connection();
@@ -94120,7 +92208,97 @@ var init_client5 = __esm(() => {
   init_launchable();
 });
 
-// src/agents/acp-sdk/ask-port.ts
+// src/agents/interaction/output-parsing.ts
+function extractQuestion(output) {
+  const text = output.trim();
+  if (!text)
+    return null;
+  const lines2 = text.split(`
+`).filter((l) => l.trim().length > 0);
+  const lastLine = lines2.at(-1)?.trim() ?? "";
+  const lower = lastLine.toLowerCase();
+  const markers = [
+    "please confirm",
+    "please specify",
+    "please provide",
+    "which would you",
+    "should i ",
+    "do you want",
+    "can you clarify"
+  ];
+  const isQuestion = lastLine.endsWith("?") && lastLine.length > 10 || markers.some((m) => lower.includes(m));
+  if (!isQuestion)
+    return null;
+  const paragraphs = text.split(/\n\n+/);
+  const questionPara = paragraphs.at(-1)?.trim() ?? lastLine;
+  const contextPara = paragraphs.at(-2)?.trim();
+  return contextPara ? `${contextPara}
+
+${questionPara}` : questionPara;
+}
+function extractContextToolCall(output) {
+  const match = output.match(CONTEXT_TOOL_CALL_PATTERN);
+  if (!match)
+    return null;
+  const [, name, rawInput] = match;
+  const trimmedInput = rawInput.trim();
+  if (!trimmedInput) {
+    return { name, input: {} };
+  }
+  try {
+    return { name, input: JSON.parse(trimmedInput) };
+  } catch (error48) {
+    return {
+      name,
+      error: `Invalid JSON tool input: ${error48 instanceof Error ? error48.message : String(error48)}`
+    };
+  }
+}
+var CONTEXT_TOOL_CALL_PATTERN;
+var init_output_parsing = __esm(() => {
+  CONTEXT_TOOL_CALL_PATTERN = /<nax_tool_call\s+name="([^"]+)">\s*([\s\S]*?)\s*<\/nax_tool_call>/i;
+});
+
+// src/agents/interaction/turn-interactions.ts
+async function awaitInteractionReply(ctx, interaction, warnSuffix) {
+  let timeoutId;
+  try {
+    const response = await Promise.race([
+      raceWithAbort(ctx.interactionHandler.onInteraction(interaction), ctx.signal, INTERACTION_ABORT_MESSAGE),
+      new Promise((resolve36) => {
+        timeoutId = setTimeout(() => resolve36(null), ctx.timeoutMs ?? INTERACTION_TIMEOUT_MS);
+      })
+    ]);
+    if (response) {
+      return { kind: "answered", answer: response.answer };
+    }
+  } catch (err) {
+    if (ctx.signal?.aborted) {
+      return { kind: "aborted" };
+    }
+    getSafeLogger2()?.warn(ctx.stage, `InteractionHandler.onInteraction failed${warnSuffix}${err instanceof Error ? err.message : String(err)}`);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+  return { kind: "no-reply" };
+}
+function toContextToolInteraction(toolCall) {
+  return toolCall.error ? { kind: "context-tool", name: toolCall.name, error: toolCall.error } : { kind: "context-tool", name: toolCall.name, input: toolCall.input };
+}
+var INTERACTION_TIMEOUT_MS, INTERACTION_ABORT_MESSAGE = "Run aborted \u2014 shutdown in progress";
+var init_turn_interactions = __esm(() => {
+  init_logger2();
+  init_turn();
+  INTERACTION_TIMEOUT_MS = 5 * 60 * 1000;
+});
+
+// src/agents/interaction/index.ts
+var init_interaction = __esm(() => {
+  init_output_parsing();
+  init_turn_interactions();
+});
+
+// src/agents/acp/ask-port.ts
 function beatWhileWaiting(turn, beatMs) {
   let timer;
   const beat = () => {
@@ -94169,13 +92347,13 @@ function createAskPort(slot, beatMs = AWAITING_HUMAN_BEAT_MS, audit) {
     }
   };
 }
-var STAGE = "acp-sdk", AWAITING_HUMAN_BEAT_MS = 30000;
+var STAGE = "acp", AWAITING_HUMAN_BEAT_MS = 30000;
 var init_ask_port = __esm(() => {
   init_logger2();
   init_interaction();
 });
 
-// src/agents/acp-sdk/profile-map.ts
+// src/agents/acp/profile-map.ts
 function acpProfileFor(mode) {
   return PROFILE_BY_MODE[mode];
 }
@@ -94188,7 +92366,7 @@ var init_profile_map = __esm(() => {
   });
 });
 
-// src/agents/acp-sdk/open-context.ts
+// src/agents/acp/open-context.ts
 function backendEnv(modelEnv) {
   const allowed2 = buildAllowedEnv(modelEnv === undefined ? undefined : { modelEnv: { ...modelEnv } });
   return Object.fromEntries(Object.entries(allowed2).filter((entry2) => typeof entry2[1] === "string" && ENV_NAME.test(entry2[0]) && !entry2[1].includes("\x00")));
@@ -94244,7 +92422,7 @@ var init_open_context = __esm(() => {
   ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
 });
 
-// src/agents/acp-sdk/tool-audit.ts
+// src/agents/acp/tool-audit.ts
 function inputOf2(input) {
   return typeof input === "object" && input !== null && !Array.isArray(input) ? input : { value: input };
 }
@@ -94300,7 +92478,7 @@ var init_tool_audit2 = __esm(() => {
   init_src();
 });
 
-// src/agents/acp-sdk/turn-slot.ts
+// src/agents/acp/turn-slot.ts
 function createTurnSlot() {
   let running;
   return {
@@ -94320,7 +92498,7 @@ var init_turn_slot = __esm(() => {
   IDLE_SIGNAL2 = new AbortController().signal;
 });
 
-// src/agents/acp-sdk/session.ts
+// src/agents/acp/session.ts
 import { stat as stat10 } from "fs/promises";
 function errorText(err) {
   return err instanceof Error ? err.message : String(err);
@@ -94336,6 +92514,18 @@ async function discard(store, name) {
     });
   });
 }
+async function discardAcpSessionLeftover(transcriptDir, name) {
+  if (transcriptDir === undefined)
+    return;
+  try {
+    await discard(transcriptStoreFor(transcriptDir), name);
+  } catch (err) {
+    getSafeLogger2()?.warn(STAGE2, "Could not discard a stale ACP session transcript", {
+      sessionName: name,
+      error: errorText(err)
+    });
+  }
+}
 function processHooks(base) {
   return {
     spawned: (pid) => {
@@ -94354,7 +92544,7 @@ function killAgent(process5) {
     killProcessGroup(process5.pid, "SIGKILL");
 }
 async function openBackend2(base, resume) {
-  const backend2 = _acpSdkDeps.acpBackend(backendOptions(base.agent, base.opts, processHooks(base)));
+  const backend2 = _acpDeps.acpBackend(backendOptions(base.agent, base.opts, processHooks(base)));
   return backend2.open(openContext({
     name: base.name,
     opts: base.opts,
@@ -94441,7 +92631,7 @@ async function createSession(name, agent, opts) {
     process: { pid: undefined }
   };
   try {
-    const rateCard = await _acpSdkDeps.resolveRateCard(opts.modelDef.model);
+    const rateCard = await _acpDeps.resolveRateCard(opts.modelDef.model);
     const opened = await openWithLeftover(base);
     const protocolIds = await protocolIdsOf(base.store, name);
     const handle2 = Object.freeze({
@@ -94517,7 +92707,7 @@ async function reopenFresh(session2) {
   await discard(session2.store, session2.name);
   session2.opened = await openBackend2(session2, undefined);
 }
-var STAGE2 = "acp-sdk", DISCARD_CODES, _acpSdkDeps;
+var STAGE2 = "acp", DISCARD_CODES, _acpDeps;
 var init_session3 = __esm(() => {
   init_src();
   init_client5();
@@ -94535,7 +92725,7 @@ var init_session3 = __esm(() => {
     "AGENT_SESSION_NOT_FOUND",
     "TRANSCRIPT_CORRUPT"
   ]);
-  _acpSdkDeps = {
+  _acpDeps = {
     acpBackend: (options) => acpBackend(options),
     launchCandidateKind: (agent) => launchCandidateKind(agent),
     resolveRateCard: (modelId) => resolveRateCard(modelId),
@@ -94550,7 +92740,7 @@ var init_session3 = __esm(() => {
   };
 });
 
-// src/agents/acp-sdk/prompt-retry.ts
+// src/agents/acp/prompt-retry.ts
 function isRetryablePromptError(err) {
   if (isSessionGone(err))
     return false;
@@ -94571,8 +92761,8 @@ var init_prompt_retry = __esm(() => {
   RETRYABLE_RPC_CODES = new Set([-32603, -32700]);
 });
 
-// src/agents/acp-sdk/stream-bridge.ts
-import { randomUUID as randomUUID14 } from "crypto";
+// src/agents/acp/stream-bridge.ts
+import { randomUUID as randomUUID13 } from "crypto";
 function toolUpdate(toolName) {
   return toolName === undefined ? { kind: "agent.tool_call_update" } : { kind: "agent.tool_call_update", toolName };
 }
@@ -94617,7 +92807,7 @@ function sender(ctx) {
     try {
       ctx.emit(event);
     } catch (err) {
-      getSafeLogger2()?.debug("acp-sdk", "A stream listener threw; the turn continues", {
+      getSafeLogger2()?.debug("acp", "A stream listener threw; the turn continues", {
         sessionName: ctx.sessionName,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -94625,7 +92815,7 @@ function sender(ctx) {
   };
 }
 function startCall(ctx, now = Date.now) {
-  const callId = randomUUID14();
+  const callId = randomUUID13();
   const send = sender(ctx);
   const base = {
     callId,
@@ -94673,8 +92863,8 @@ var init_stream_bridge = __esm(() => {
   init_logger2();
 });
 
-// src/agents/acp-sdk/turn-loop.ts
-import { randomUUID as randomUUID15 } from "crypto";
+// src/agents/acp/turn-loop.ts
+import { randomUUID as randomUUID14 } from "crypto";
 function used(state) {
   return state.turnCount + state.asked;
 }
@@ -94750,7 +92940,7 @@ async function sendWithRetries(loop, attempt) {
         retry: retryIndex + 1,
         of: retries
       });
-      await _acpSdkDeps.delay(promptRetryDelayMs(retryIndex), attempt.controller.signal);
+      await _acpDeps.delay(promptRetryDelayMs(retryIndex), attempt.controller.signal);
     }
   }
   return sendOnce(loop.session, loop.state.currentPrompt, attempt);
@@ -94765,7 +92955,7 @@ async function runIteration(loop) {
   }
   const timer = armDeadline(controller, loop.deadline.remainingMs());
   const call2 = startCall(session2.stream);
-  const turnId = opts.turnId ?? randomUUID15();
+  const turnId = opts.turnId ?? randomUUID14();
   try {
     session2.opts.onActiveCall?.(call2.callId, async () => controller.abort(new WatchdogCancel));
     session2.slot.set({
@@ -94792,7 +92982,7 @@ async function runIteration(loop) {
     session2.slot.clear();
   }
 }
-function replyContext2(loop) {
+function replyContext(loop) {
   return { interactionHandler: loop.opts.interactionHandler, signal: loop.opts.signal, stage: STAGE3 };
 }
 function answerOf(loop, reply2) {
@@ -94805,13 +92995,13 @@ function answerOf(loop, reply2) {
 async function nextPrompt(loop, output) {
   const toolCall = extractContextToolCall(output);
   if (toolCall !== null) {
-    const reply2 = await awaitInteractionReply(replyContext2(loop), toContextToolInteraction(toolCall), " for context-tool: ");
+    const reply2 = await awaitInteractionReply(replyContext(loop), toContextToolInteraction(toolCall), " for context-tool: ");
     return answerOf(loop, reply2);
   }
   const question = extractQuestion(output);
   if (question === null)
     return;
-  const answer = answerOf(loop, await awaitInteractionReply(replyContext2(loop), { kind: "question", text: question }, ": "));
+  const answer = answerOf(loop, await awaitInteractionReply(replyContext(loop), { kind: "question", text: question }, ": "));
   if (answer !== undefined)
     loop.state.interactions.push({ turnIndex: loop.state.turnCount, question, reply: answer });
   return answer;
@@ -94859,7 +93049,7 @@ async function runLoop(loop) {
     rateCard: loop.session.rateCard
   });
 }
-async function runTurnLoop2(session2, prompt, opts) {
+async function runTurnLoop(session2, prompt, opts) {
   if (session2.running !== undefined) {
     throw new NaxError(`ACP session "${session2.name}" already has a turn in flight`, "ACP_SDK_TURN_IN_FLIGHT", {
       stage: STAGE3,
@@ -94869,7 +93059,7 @@ async function runTurnLoop2(session2, prompt, opts) {
   const run = runLoop({
     session: session2,
     opts,
-    max: opts.maxInteractions ?? DEFAULT_MAX_INTERACTIONS2,
+    max: opts.maxInteractions ?? DEFAULT_MAX_INTERACTIONS,
     deadline: createTurnDeadline(session2.opts.timeoutSeconds),
     state: {
       turnCount: 0,
@@ -94893,7 +93083,7 @@ async function runTurnLoop2(session2, prompt, opts) {
     session2.running = undefined;
   }
 }
-var STAGE3 = "acp-sdk", DEFAULT_MAX_INTERACTIONS2 = 10;
+var STAGE3 = "acp", DEFAULT_MAX_INTERACTIONS = 10;
 var init_turn_loop2 = __esm(() => {
   init_src();
   init_errors4();
@@ -94907,7 +93097,7 @@ var init_turn_loop2 = __esm(() => {
   init_stream_bridge();
 });
 
-// src/agents/acp-sdk/complete.ts
+// src/agents/acp/complete.ts
 function sessionOptsFor(adapterName, options, timeoutMs) {
   return {
     agentName: adapterName,
@@ -94962,7 +93152,7 @@ async function runComplete(adapterName, agent, prompt, options) {
   }
   const session2 = await openClassified(name, agent, sessionOptsFor(adapterName, options, timeoutMs));
   try {
-    const result = await runTurnLoop2(session2, prompt, {
+    const result = await runTurnLoop(session2, prompt, {
       interactionHandler: NO_OP_INTERACTION_HANDLER2,
       maxInteractions: 1,
       ...options.signal === undefined ? {} : { signal: options.signal }
@@ -94989,7 +93179,7 @@ async function openClassified(name, agent, opts) {
     throw new SessionFailureError(failure3.message, failure3.adapterFailure);
   }
 }
-var STAGE4 = "acp-sdk", DEFAULT_COMPLETE_TIMEOUT_MS = 120000, MS_PER_SECOND = 1000;
+var STAGE4 = "acp", DEFAULT_COMPLETE_TIMEOUT_MS = 120000, MS_PER_SECOND = 1000;
 var init_complete2 = __esm(() => {
   init_src();
   init_errors4();
@@ -95003,11 +93193,11 @@ var init_complete2 = __esm(() => {
   init_turn_loop2();
 });
 
-// src/agents/acp-sdk/entries.ts
-function acpSdkEntry(agentName) {
+// src/agents/acp/entries.ts
+function acpEntry(agentName) {
   return Object.hasOwn(ENTRIES, agentName) ? ENTRIES[agentName] : undefined;
 }
-var ENTRIES, ACP_SDK_AGENT_NAMES, UNSUPPORTED_ENTRY;
+var ENTRIES, ACP_AGENT_NAMES2, UNSUPPORTED_ENTRY;
 var init_entries = __esm(() => {
   ENTRIES = Object.freeze({
     claude: {
@@ -95046,7 +93236,7 @@ var init_entries = __esm(() => {
       maxContextTokens: 128000
     }
   });
-  ACP_SDK_AGENT_NAMES = new Set(Object.keys(ENTRIES));
+  ACP_AGENT_NAMES2 = new Set(Object.keys(ENTRIES));
   UNSUPPORTED_ENTRY = Object.freeze({
     binary: "",
     displayName: "ACP Agent",
@@ -95055,7 +93245,7 @@ var init_entries = __esm(() => {
   });
 });
 
-// src/agents/acp-sdk/adapter.ts
+// src/agents/acp/adapter.ts
 function notifyEstablished(opts, protocolIds, name) {
   if (opts.onSessionEstablished === undefined || protocolIds === undefined)
     return;
@@ -95069,7 +93259,7 @@ function notifyEstablished(opts, protocolIds, name) {
   }
 }
 
-class AcpSdkAgentAdapter {
+class AcpAgentAdapter {
   name;
   displayName;
   binary;
@@ -95077,7 +93267,7 @@ class AcpSdkAgentAdapter {
   entry;
   live = new Map;
   constructor(agentName) {
-    this.entry = acpSdkEntry(agentName);
+    this.entry = acpEntry(agentName);
     const shown2 = this.entry ?? UNSUPPORTED_ENTRY;
     this.name = agentName;
     this.displayName = shown2.displayName;
@@ -95089,10 +93279,10 @@ class AcpSdkAgentAdapter {
     };
   }
   async isInstalled() {
-    return this.entry !== undefined && _acpSdkDeps.launchCandidateKind(this.entry.agent) !== undefined;
+    return this.entry !== undefined && _acpDeps.launchCandidateKind(this.entry.agent) !== undefined;
   }
   launchNote() {
-    if (this.entry === undefined || _acpSdkDeps.launchCandidateKind(this.entry.agent) !== "npx")
+    if (this.entry === undefined || _acpDeps.launchCandidateKind(this.entry.agent) !== "npx")
       return;
     return `Only the npx fallback can launch ACP agent "${this.name}"; the first run downloads it inside the startup deadline`;
   }
@@ -95130,7 +93320,7 @@ class AcpSdkAgentAdapter {
     return session2.handle;
   }
   async sendTurn(handle2, prompt, opts) {
-    return runTurnLoop2(this.sessionFor(handle2.id), prompt, opts);
+    return runTurnLoop(this.sessionFor(handle2.id), prompt, opts);
   }
   async closeSession(handle2) {
     const session2 = this.live.get(handle2.id);
@@ -95155,12 +93345,12 @@ class AcpSdkAgentAdapter {
   requireEntry(sessionName) {
     if (this.entry !== undefined)
       return this.entry;
-    throw new NaxError(`Agent "${this.name}" has no ACP launcher; it cannot run on agent.acp.transport "sdk"`, "ACP_AGENT_UNSUPPORTED", { stage: STAGE5, agentName: this.name, sessionName });
+    throw new NaxError(`Agent "${this.name}" has no ACP launcher, so it cannot run as an ACP agent`, "ACP_AGENT_UNSUPPORTED", { stage: STAGE5, agentName: this.name, sessionName });
   }
   async requireWorkdir(sessionName, workdir) {
-    if (await _acpSdkDeps.cwdExists(workdir))
+    if (await _acpDeps.cwdExists(workdir))
       return;
-    throw new NaxError(`[acp-sdk] Session cwd does not exist: ${workdir} \u2014 cannot start agent "${this.name}". If this is a new package for the feature, ensure its directory is created before the run.`, "SESSION_CWD_MISSING", { stage: "open-session", agentName: this.name, cwd: workdir, sessionName });
+    throw new NaxError(`[acp] Session cwd does not exist: ${workdir} \u2014 cannot start agent "${this.name}". If this is a new package for the feature, ensure its directory is created before the run.`, "SESSION_CWD_MISSING", { stage: "open-session", agentName: this.name, cwd: workdir, sessionName });
   }
   sessionFor(id) {
     const session2 = this.live.get(id);
@@ -95172,8 +93362,8 @@ class AcpSdkAgentAdapter {
     });
   }
 }
-var STAGE5 = "acp-sdk";
-var init_adapter2 = __esm(() => {
+var STAGE5 = "acp";
+var init_adapter = __esm(() => {
   init_errors4();
   init_logger2();
   init_env();
@@ -95184,9 +93374,17 @@ var init_adapter2 = __esm(() => {
   init_turn_loop2();
 });
 
-// src/agents/acp-sdk/index.ts
-var init_acp_sdk = __esm(() => {
-  init_adapter2();
+// src/agents/acp/index.ts
+var exports_acp = {};
+__export(exports_acp, {
+  ACP_AGENT_NAMES: () => ACP_AGENT_NAMES2,
+  AcpAgentAdapter: () => AcpAgentAdapter,
+  _acpDeps: () => _acpDeps,
+  acpEntry: () => acpEntry,
+  discardAcpSessionLeftover: () => discardAcpSessionLeftover
+});
+var init_acp2 = __esm(() => {
+  init_adapter();
   init_entries();
   init_session3();
 });
@@ -95246,11 +93444,11 @@ var init_native_agent = __esm(() => {
 });
 
 // src/agents/registry.ts
-function acpAdapterFor(name, transport) {
-  return transport === "sdk" ? new AcpSdkAgentAdapter(name) : new AcpAgentAdapter(name);
+function acpAdapterFor(name) {
+  return new AcpAgentAdapter(name);
 }
 function adapterFor(name) {
-  return name === NATIVE_AGENT_NAME ? new NativeAgentAdapter : acpAdapterFor(name, DEFAULT_ACP_TRANSPORT);
+  return name === NATIVE_AGENT_NAME ? new NativeAgentAdapter : acpAdapterFor(name);
 }
 function buildAdapterList() {
   return [...Array.from(_registryTestAdapters.values()), ...KNOWN_AGENT_NAMES.map(adapterFor)];
@@ -95268,14 +93466,10 @@ function createAgentRegistry(config2) {
   const adapterCache = new Map;
   const protocol = config2.agent?.protocol ?? DEFAULT_AGENT_PROTOCOL;
   logger?.info("agents", `Agent protocol: ${protocol}`, { protocol, hasConfig: !!config2.agent });
-  const transport = config2.agent?.acp?.transport ?? DEFAULT_ACP_TRANSPORT;
-  if (transport !== DEFAULT_ACP_TRANSPORT) {
-    logger?.info("agents", `ACP transport: ${transport} (S4b development key)`, { transport });
-  }
   function cachedAdapter(name) {
     let adapter = adapterCache.get(name);
     if (adapter === undefined) {
-      adapter = name === NATIVE_AGENT_NAME ? new NativeAgentAdapter(undefined, config2.agent?.native?.catalogOverrides ?? []) : acpAdapterFor(name, transport);
+      adapter = name === NATIVE_AGENT_NAME ? new NativeAgentAdapter(undefined, config2.agent?.native?.catalogOverrides ?? []) : acpAdapterFor(name);
       adapterCache.set(name, adapter);
       logger?.debug("agents", `Created ${adapter.constructor.name} for ${name}`, { name });
     }
@@ -95312,8 +93506,7 @@ var init_registry6 = __esm(() => {
   init_src();
   init_config();
   init_logger2();
-  init_adapter();
-  init_acp_sdk();
+  init_acp2();
   init_native_agent();
   KNOWN_AGENT_NAMES = ["claude", "codex", "opencode", "gemini", "aider", "pi", NATIVE_AGENT_NAME];
   _registryTestAdapters = new Map;
@@ -95938,7 +94131,6 @@ var init_utils = __esm(() => {
 // src/agents/index.ts
 var init_agents = __esm(() => {
   init_src();
-  init_acp();
   init_complete_exception_classifier();
   init_cost();
   init_manager2();
@@ -95954,8 +94146,7 @@ var init_agents = __esm(() => {
 // src/cli/agents.ts
 async function agentsListCommand(config2, _workdir) {
   const acpReachable = (config2.agent?.protocol ?? DEFAULT_AGENT_PROTOCOL) !== "native";
-  const transport = config2.agent?.acp?.transport ?? DEFAULT_ACP_TRANSPORT;
-  const adapters = acpReachable ? Array.from(ACP_SDK_AGENT_NAMES).map((name) => acpAdapterFor(name, transport)) : [];
+  const adapters = acpReachable ? Array.from(ACP_AGENT_NAMES2).map((name) => acpAdapterFor(name)) : [];
   const defaultAgent = resolveDefaultAgent(config2);
   const acpVersions = await Promise.all(adapters.map(async (agent) => ({
     name: agent.name,
@@ -96023,7 +94214,7 @@ var _cliAgentsDeps;
 var init_agents2 = __esm(() => {
   init_src();
   init_agents();
-  init_acp_sdk();
+  init_acp2();
   init_native_agent();
   init_version_detection();
   init_config();
@@ -97065,7 +95256,6 @@ var init_config_descriptions = __esm(() => {
     agent: "Agent protocol configuration (ACP-003)",
     "agent.protocol": "Protocol for agent communication: 'acp' (default) | 'native' | 'hybrid'",
     "agent.acp": "ACP agent transport settings (claude, codex, opencode, gemini, pi)",
-    "agent.acp.transport": "How ACP agents are driven: 'sdk' (default) uses @nathapp/nax-agent-acp in-process; 'acpx' shells out to the acpx CLI (S4b development key; S4b-5 removes acpx and this key)",
     "agent.native.instructionFileName": "Repository instruction filename (default: AGENTS.md). Custom Markdown basenames load without AGENTS/CLAUDE fallbacks.",
     "agent.native.catalogOverrides": "Native only. Explicit catalog entries for model ids newer than the bundled pi-ai snapshot, plus optional provider-wide baseUrl/headers.",
     "agent.native.catalogOverrides.baseUrl": "Provider-wide endpoint redirect. WARNING: applies to EVERY model of that provider, bundled ones included, and the provider's stored credential is sent to this host. https only (http allowed for localhost/127.0.0.1); credentials in the URL are rejected.",
@@ -97087,7 +95277,7 @@ var init_config_descriptions = __esm(() => {
     "agent.spinBreaker.stopAfterNoProgressSeconds": "Seconds with no new call key after which a repeat run ends the turn so a slow spin stops as fail-spin before the tool-call-only idle watchdog cancels it as fail-stale (default: half agent.idleWatchdog.toolCallOnlyIdleTimeoutSeconds, 900 when that watchdog is off; 0 disables) (nax#2017)",
     "quality.testing": "Hermetic test enforcement \u2014 per-package overridable (ENH-010)",
     "quality.testing.hermetic": "Inject hermetic test requirement into prompts \u2014 never call real external services in tests (default: true)",
-    "quality.testing.externalBoundaries": "Project-specific CLI tools/clients to mock (e.g. ['claude', 'acpx', 'redis'])",
+    "quality.testing.externalBoundaries": "Project-specific CLI tools/clients to mock (e.g. ['claude', 'gh', 'redis'])",
     "quality.testing.mockGuidance": "Project-specific mocking guidance injected verbatim into the prompt",
     mcp: "External MCP servers the native agent may call tools on (client only; nax is not an MCP server)",
     "mcp.servers": "Map of server id to server block. The id is the tool-name namespace: a tool named search_graph on server codebase-memory is advertised as codebase-memory__search_graph",
@@ -107976,7 +106166,7 @@ var init_escalation = __esm(() => {
 });
 
 // src/execution/lock.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 import { rename as rename6, unlink as unlink6 } from "fs/promises";
 import { hostname as hostname3 } from "os";
 import path14 from "path";
@@ -108020,7 +106210,7 @@ function parseHolder(raw) {
   }
 }
 async function publishFileAtomically(targetPath, content) {
-  const tempPath = `${targetPath}.${randomUUID16()}.tmp`;
+  const tempPath = `${targetPath}.${randomUUID15()}.tmp`;
   try {
     await Bun.write(tempPath, content);
     const fs = await import("fs");
@@ -110783,7 +108973,7 @@ var init_scope_files = __esm(() => {
 });
 
 // src/pipeline/stages/context.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 import { join as join99 } from "path";
 async function runV2Path(ctx) {
   const logger = getLogger2();
@@ -111024,7 +109214,7 @@ var init_context3 = __esm(() => {
     createOrchestrator: createDefaultOrchestrator,
     loadPlugins: loadPluginProviders,
     v1FeatureProvider: () => new FeatureContextProvider,
-    uuid: () => randomUUID17(),
+    uuid: () => randomUUID16(),
     readDigest: readDigestFile,
     writeDigest: writeDigestFile,
     loadFeatureManifests,
@@ -111847,52 +110037,9 @@ var exports_merge_conflict_rectify = {};
 __export(exports_merge_conflict_rectify, {
   _mergeRectifyDeps: () => _mergeRectifyDeps,
   buildRectificationPipelineContext: () => buildRectificationPipelineContext,
-  closeStaleAcpSession: () => closeStaleAcpSession,
-  evictStaleSessions: () => evictStaleSessions,
   rectifyConflictedStory: () => rectifyConflictedStory,
   rectifyMergeFailure: () => rectifyMergeFailure
 });
-async function closeStaleAcpSession(worktreePath, sessionName) {
-  const logger = getSafeLogger2();
-  try {
-    const cmd = ["acpx", "--cwd", worktreePath, "claude", "sessions", "close", sessionName];
-    logger?.debug("parallel", "Closing stale ACP session before rectification", { sessionName });
-    const proc = _mergeRectifyDeps.typedSpawn(cmd, {
-      stdout: "pipe",
-      stderr: "pipe",
-      detached: true
-    });
-    let timedOut = false;
-    await new Promise((resolve39) => {
-      let settled2 = false;
-      const finish = () => {
-        if (settled2)
-          return;
-        settled2 = true;
-        clearTimeout(timer);
-        resolve39();
-      };
-      const timer = setTimeout(() => {
-        timedOut = true;
-        try {
-          _mergeRectifyDeps.killProcessGroup(proc.pid, "SIGKILL");
-        } catch {}
-        finish();
-      }, _mergeRectifyDeps.timeoutMs);
-      proc.exited.then(finish, finish);
-    });
-    if (timedOut) {
-      logger?.debug("parallel", "Stale ACP session eviction timed out \u2014 swallowed (best-effort)", {
-        sessionName,
-        timeoutMs: _mergeRectifyDeps.timeoutMs
-      });
-    }
-  } catch {}
-}
-async function evictStaleSessions(worktreePath) {
-  const cwd = worktreePath ?? ".";
-  await closeStaleAcpSession(cwd, "nax-evict-stale-sentinel");
-}
 function rectifyMergeFailure(storyId, cost, mergeResult) {
   return {
     success: false,
@@ -111945,7 +110092,11 @@ async function rectifyConflictedStory(options) {
       storyId,
       role: "main"
     });
-    await closeStaleAcpSession(worktreePath, staleSessionName);
+    const transcriptDir = deriveNativeTranscriptDir({
+      featureName: prd.feature,
+      transcriptRoot: pipelineContextBase.runtime.outputDir
+    });
+    await _mergeRectifyDeps.discardStaleSession(transcriptDir, staleSessionName).catch(() => {});
     const story = prd.userStories.find((s) => s.id === storyId);
     if (!story) {
       return { success: false, storyId, cost: 0, finalConflict: false, pipelineFailure: true };
@@ -111992,18 +110143,18 @@ async function rectifyConflictedStory(options) {
     return { success: false, storyId, cost: 0, finalConflict: false, pipelineFailure: true };
   }
 }
-var STALE_SESSION_CLOSE_TIMEOUT_MS = 3000, _mergeRectifyDeps;
+var _mergeRectifyDeps;
 var init_merge_conflict_rectify = __esm(() => {
   init_internal();
-  init_bun_deps();
   init_logger2();
+  init_manager_deps();
   init_worktree();
   init_parallel_worker();
   _mergeRectifyDeps = {
-    typedSpawn,
-    spawn: typedSpawn,
-    killProcessGroup,
-    timeoutMs: STALE_SESSION_CLOSE_TIMEOUT_MS
+    discardStaleSession: async (transcriptDir, name) => {
+      const { discardAcpSessionLeftover: discardAcpSessionLeftover2 } = await Promise.resolve().then(() => (init_acp2(), exports_acp));
+      await discardAcpSessionLeftover2(transcriptDir, name);
+    }
   };
 });
 
@@ -113937,7 +112088,7 @@ var init_run_cleanup = __esm(() => {
 });
 
 // src/execution/session-manager-runtime.ts
-async function closePhysicalSession2(descriptor, agentGetFn, force, signal) {
+async function closePhysicalSession(descriptor, agentGetFn, force, signal) {
   if (!descriptor.handle)
     return;
   const adapter = agentGetFn?.(descriptor.agent);
@@ -113956,7 +112107,7 @@ async function closeStorylessSession(sessionManager, descriptor, agentGetFn, opt
     } catch {}
   }
   const force = opts?.force === true || descriptor.state === "FAILED";
-  await closePhysicalSession2(descriptor, agentGetFn, force, opts?.signal);
+  await closePhysicalSession(descriptor, agentGetFn, force, opts?.signal);
   return 1;
 }
 function getStorylessCloseChain(state) {
@@ -113979,7 +112130,7 @@ async function closeStorySessions(sessionManager, storyId, agentGetFn, opts) {
   const closedSessions = sessionManager.closeStory(storyId);
   for (const descriptor of closedSessions) {
     const force = opts?.force === true || descriptor.state === "FAILED";
-    await closePhysicalSession2(descriptor, agentGetFn, force, opts?.signal);
+    await closePhysicalSession(descriptor, agentGetFn, force, opts?.signal);
   }
   return closedSessions.length;
 }
@@ -113996,7 +112147,7 @@ async function failAndClose(sessionManager, sessionId, agentGetFn) {
   }
   const failed3 = sessionManager.get(sessionId);
   if (failed3) {
-    await closePhysicalSession2(failed3, agentGetFn, true);
+    await closePhysicalSession(failed3, agentGetFn, true);
   }
 }
 async function closeAllRunSessions(sessionManager, agentGetFn, opts) {
@@ -118999,14 +117150,14 @@ var init_gitignore_reconcile = __esm(() => {
 });
 
 // src/review/language-commands.ts
-function resolveLanguageCommand(language, check2, which3) {
+function resolveLanguageCommand(language, check2, which2) {
   const languageTable = LANGUAGE_COMMANDS[language];
   if (!languageTable)
     return null;
   const entry2 = languageTable[check2];
   if (!entry2)
     return null;
-  const binaryPath = which3(entry2.binary);
+  const binaryPath = which2(entry2.binary);
   if (!binaryPath)
     return null;
   return entry2.command;
@@ -129141,7 +127292,7 @@ async function checkCanonicalRulesLint(workdir) {
   let ruleCount = 0;
   try {
     for (const root of roots) {
-      const rules = await _checkCanonicalRulesDeps.loadCanonicalRules(root);
+      const rules = await _checkCanonicalRulesDeps.loadCanonicalRules(root, { onInvalidFrontmatter: "throw" });
       ruleCount += rules.length;
     }
   } catch (err) {
@@ -129155,6 +127306,16 @@ async function checkCanonicalRulesLint(workdir) {
         message: `Canonical rules lint failed (${err.violations.length} violation(s)): ${detail}`
       };
     }
+    if (err instanceof RulesFrontmatterLintError) {
+      const first = err.issues[0];
+      const detail = first ? `${first.file}: ${first.message}` : "unknown location";
+      return {
+        name: "canonical-rules-lint",
+        tier: "blocker",
+        passed: false,
+        message: `Canonical rules lint failed (${err.issues.length} file(s) with invalid frontmatter): ${detail}`
+      };
+    }
     return {
       name: "canonical-rules-lint",
       tier: "blocker",
@@ -129503,10 +127664,10 @@ async function findMissingNativeCredentials(config2) {
 function describeMissingNativeCredentials(missing) {
   const uses = missing.map(({ provider: provider2, tiers }) => `${provider2} (${tiers.map((tier) => `models.native.${tier}`).join(", ")})`).join("; ");
   const logins = missing.map(({ provider: provider2 }) => `nax auth login ${provider2}`).join(" / ");
-  return `The default native agent needs a credential for ${uses}, but none is stored or in the environment. ` + `Run ${logins}, set the provider's API key environment variable, point models.native at a provider you have ` + `credentials for, or set agent.default "claude" to use an acpx agent.`;
+  return `The default native agent needs a credential for ${uses}, but none is stored or in the environment. ` + `Run ${logins}, set the provider's API key environment variable, point models.native at a provider you have ` + `credentials for, or set agent.default "claude" to use an ACP agent.`;
 }
 function describeCredentialFault(error48) {
-  return `The default native agent's credentials could not be read (${error48.code}): ${error48.message} ` + `Fix the credential source, or set agent.default "claude" to use an acpx agent.`;
+  return `The default native agent's credentials could not be read (${error48.code}): ${error48.message} ` + `Fix the credential source, or set agent.default "claude" to use an ACP agent.`;
 }
 async function checkNativeCredentials(config2) {
   try {
@@ -131767,6 +129928,69 @@ function collectCanonicalRuleRoots(workdir, globCanonicalRuleFiles = _rulesLintD
   }
   return [...roots].sort();
 }
+async function loadRootForLint(root, deps) {
+  try {
+    const rules = await deps.loadCanonicalRules(root, { onInvalidFrontmatter: "throw" });
+    return { kind: "loaded", rules };
+  } catch (err) {
+    if (err instanceof RulesFrontmatterLintError)
+      return { kind: "frontmatter-errors", issues: err.issues };
+    return { kind: "failed", cause: err };
+  }
+}
+function reportFrontmatterIssues(issues, root, logger) {
+  for (const issue2 of issues) {
+    logger.error("rules-lint", "Canonical rule frontmatter is invalid \u2014 nax will ignore this file at run time", {
+      file: issue2.file,
+      error: issue2.message,
+      root,
+      code: "INVALID_FRONTMATTER"
+    });
+  }
+}
+function lintRulesForRoot(rules, root, isSinglePackageRepo, deps, logger) {
+  let warningCount = 0;
+  for (const rule of rules) {
+    for (const warning of rule.warnings ?? []) {
+      warningCount++;
+      logger.warn("rules-lint", `Rule frontmatter warning: ${warning}`, {
+        file: rule.path ?? rule.fileName,
+        root
+      });
+    }
+    for (const pattern of rule.appliesTo ?? []) {
+      const globResult = deps.globHasMatch(pattern, root);
+      if (globResult === "match")
+        continue;
+      warningCount++;
+      if (globResult === "unknown") {
+        logger.warn("rules-lint", "Canonical rule appliesTo glob could not be verified within the dead-glob scan cap", {
+          file: rule.path ?? rule.fileName,
+          pattern,
+          root,
+          code: "GLOB_SCAN_UNKNOWN"
+        });
+        continue;
+      }
+      logger.warn("rules-lint", "Canonical rule appliesTo glob matches no files in the linted repository", {
+        file: rule.path ?? rule.fileName,
+        pattern,
+        root
+      });
+    }
+    if (isSinglePackageRepo && rule.paths && rule.paths.length > 0) {
+      warningCount++;
+      logger.warn("rules-lint", "Canonical rule declares paths: but the repository has no workspace packages \u2014 paths: is inert in single-package repos. Use appliesTo: for file globs.", {
+        file: join135(root, CANONICAL_RULES_DIR, rule.path ?? rule.fileName),
+        code: "INERT_PATHS",
+        paths: rule.paths,
+        root,
+        warningCount
+      });
+    }
+  }
+  return warningCount;
+}
 async function rulesLintCommand(options, deps = _rulesLintDeps) {
   const workdir = options.dir ?? process.cwd();
   const roots = collectCanonicalRuleRoots(workdir, deps.globCanonicalRuleFiles);
@@ -131779,52 +130003,24 @@ async function rulesLintCommand(options, deps = _rulesLintDeps) {
   }
   let totalRuleFiles = 0;
   let warningCount = 0;
+  const frontmatterIssues = [];
   const failedRoots = [];
   for (const root of roots) {
-    let rules;
-    try {
-      rules = await deps.loadCanonicalRules(root);
-    } catch (err) {
-      failedRoots.push({ root, cause: err });
+    const load = await loadRootForLint(root, deps);
+    if (load.kind === "failed") {
+      failedRoots.push({ root, cause: load.cause });
       continue;
     }
-    totalRuleFiles += rules.length;
-    for (const rule of rules) {
-      for (const warning of rule.warnings ?? []) {
-        warningCount++;
-        logger.warn("rules-lint", `Rule frontmatter warning: ${warning}`, {
-          file: rule.path ?? rule.fileName,
-          root
-        });
-      }
-      for (const pattern of rule.appliesTo ?? []) {
-        const globResult = deps.globHasMatch(pattern, root);
-        if (globResult === "match")
-          continue;
-        warningCount++;
-        if (globResult === "unknown") {
-          logger.warn("rules-lint", "Canonical rule appliesTo glob could not be verified within the dead-glob scan cap", { file: rule.path ?? rule.fileName, pattern, root, code: "GLOB_SCAN_UNKNOWN" });
-          continue;
-        }
-        logger.warn("rules-lint", "Canonical rule appliesTo glob matches no files in the linted repository", {
-          file: rule.path ?? rule.fileName,
-          pattern,
-          root
-        });
-      }
-      if (isSinglePackageRepo && rule.paths && rule.paths.length > 0) {
-        warningCount++;
-        logger.warn("rules-lint", "Canonical rule declares paths: but the repository has no workspace packages \u2014 paths: is inert in single-package repos. Use appliesTo: for file globs.", {
-          file: join135(root, CANONICAL_RULES_DIR, rule.path ?? rule.fileName),
-          code: "INERT_PATHS",
-          paths: rule.paths,
-          root,
-          warningCount
-        });
-      }
+    if (load.kind === "frontmatter-errors") {
+      reportFrontmatterIssues(load.issues, root, logger);
+      frontmatterIssues.push(...load.issues);
+      continue;
     }
+    const rules = load.rules;
+    totalRuleFiles += rules.length;
+    warningCount += lintRulesForRoot(rules, root, isSinglePackageRepo, deps, logger);
   }
-  if (totalRuleFiles === 0 && failedRoots.length === 0) {
+  if (totalRuleFiles === 0 && failedRoots.length === 0 && frontmatterIssues.length === 0) {
     warningCount++;
     logger.warn("rules-lint", "Canonical rules store is empty \u2014 no rule files found across any rule root. Run `nax rules migrate` to seed the store.", { code: "EMPTY_STORE", roots: roots.length });
   }
@@ -131836,6 +130032,9 @@ async function rulesLintCommand(options, deps = _rulesLintDeps) {
       causes: failedRoots.map((f) => f.cause)
     });
   }
+  if (frontmatterIssues.length > 0) {
+    throw new NaxError(`Canonical rules lint failed: ${frontmatterIssues.length} rule file(s) have invalid frontmatter. nax ignores these at run time; fix them so the rules actually load.`, "RULES_LINT_FAILED", { stage: "rules-lint", errorCount: frontmatterIssues.length, issues: frontmatterIssues });
+  }
   const scopeLabel = roots.length === 1 ? "repo root" : `${roots.length} rule roots`;
   if (warningCount > 0) {
     console.log(`[WARN] Canonical rules lint completed with ${warningCount} warning(s) (${totalRuleFiles} file(s) across ${scopeLabel}).`);
@@ -146207,12 +144406,7 @@ __export(exports_preflight, {
 function parseCompareList(input) {
   return input.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
 }
-function contestantTransport(profileData, base2) {
-  const agent = profileData.agent;
-  const transport = agent?.acp?.transport;
-  return transport === "acpx" || transport === "sdk" ? transport : base2;
-}
-async function validateContestants(names, projectRoot, deps = _preflightDeps, baseTransport = DEFAULT_ACP_TRANSPORT) {
+async function validateContestants(names, projectRoot, deps = _preflightDeps) {
   const hasAcpAdapterEntry = deps.hasAcpAdapterEntry ?? _preflightDeps.hasAcpAdapterEntry;
   const loadProfileFn = deps.loadProfile ?? _preflightDeps.loadProfile;
   if (!hasAcpAdapterEntry || !loadProfileFn) {
@@ -146248,7 +144442,7 @@ async function validateContestants(names, projectRoot, deps = _preflightDeps, ba
       });
       continue;
     }
-    if (!await deps.isInstalled(resolvedAgent, contestantTransport(resolvedProfileData, baseTransport))) {
+    if (!await deps.isInstalled(resolvedAgent)) {
       errors5.push({
         agent: name,
         reason: "dnf-not-installed",
@@ -146334,15 +144528,15 @@ var BAKEOFF_BRANCH_PREFIX = "nax/bakeoff-", _preflightDeps;
 var init_preflight = __esm(() => {
   init_internal();
   init_agents();
-  init_acp_sdk();
+  init_acp2();
   init_config();
   init_profile();
   init_errors4();
   init_logger2();
   init_git2();
   _preflightDeps = {
-    isInstalled: (agentName, transport) => acpAdapterFor(agentName, transport).isInstalled(),
-    hasAcpAdapterEntry: (name) => ACP_SDK_AGENT_NAMES.has(name),
+    isInstalled: (agentName) => acpAdapterFor(agentName).isInstalled(),
+    hasAcpAdapterEntry: (name) => ACP_AGENT_NAMES2.has(name),
     loadProfile: (profileName, projectRoot) => loadProfile(profileName, projectRoot)
   };
 });
@@ -146523,7 +144717,7 @@ async function persistBakeoffResult(result2, outputDir) {
 async function runBakeoff(options, deps = {}) {
   const merged2 = { ..._coordinatorDeps, ...deps };
   await reclaimStaleBakeoffBranches(options.projectRoot);
-  const { validAgents, errors: errors5, profileData } = await merged2.validateContestants(options.agents, options.projectRoot, undefined, options.config.agent?.acp?.transport ?? DEFAULT_ACP_TRANSPORT);
+  const { validAgents, errors: errors5, profileData } = await merged2.validateContestants(options.agents, options.projectRoot);
   const results = [];
   for (const agent of validAgents) {
     const contestantOptions = {