@nathapp/nax 0.65.5 → 0.66.0

package/dist/nax.js

@@ -3545,119 +3545,6 @@ var init_env = __esm(() => {
   ];
 });
 
-// src/agents/acp/parser.ts
-function createParseState() {
-  return {
-    text: "",
-    tokenUsage: undefined,
-    exactCostUsd: undefined,
-    stopReason: undefined,
-    error: undefined,
-    retryable: false
-  };
-}
-function parseAcpxJsonLine(line, state) {
-  try {
-    const event = JSON.parse(line);
-    if (event.jsonrpc === "2.0") {
-      if (event.method === "session/update" && event.params?.update) {
-        const update = event.params.update;
-        if (update.sessionUpdate === "agent_message_chunk" && update.content?.type === "text" && typeof update.content.text === "string") {
-          const text = update.content.text;
-          state.text += text;
-          return {
-            kind: "message_update",
-            deltaBytes: text.length
-          };
-        }
-        if (update.sessionUpdate === "agent_thought_chunk" && update.content?.type === "text" && typeof update.content.text === "string") {
-          return {
-            kind: "thinking_update",
-            deltaBytes: update.content.text.length
-          };
-        }
-        if (update.sessionUpdate === "usage_update") {
-          const activity = { kind: "usage_update" };
-          if (typeof update.used === "number") {
-            activity.outputTokens = update.used;
-          }
-          if (typeof update.cost?.amount === "number") {
-            activity.costUsd = update.cost.amount;
-            state.exactCostUsd = update.cost.amount;
-          }
-          return activity;
-        }
-      }
-      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;
-          state.tokenUsage = {
-            input_tokens: u.inputTokens ?? u.input_tokens ?? 0,
-            output_tokens: u.outputTokens ?? u.output_tokens ?? 0,
-            cache_read_input_tokens: u.cachedReadTokens ?? u.cache_read_input_tokens ?? 0,
-            cache_creation_input_tokens: u.cachedWriteTokens ?? u.cache_creation_input_tokens ?? 0
-          };
-        }
-      }
-      if (event.error && typeof event.error === "object") {
-        const err = event.error;
-        let errorMsg = typeof err.message === "string" ? err.message : JSON.stringify(event.error);
-        if (err.data && typeof err.data === "object") {
-          const data = err.data;
-          const suffix = [data.acpxCode, data.detailCode].filter(Boolean).join("/");
-          if (suffix)
-            errorMsg = `${errorMsg} [${suffix}]`;
-          if (!state.error && data.retryable === true)
-            state.retryable = true;
-        }
-        if (!state.error)
-          state.error = errorMsg;
-      }
-      return;
-    }
-    if (event.content && typeof event.content === "string")
-      state.text += event.content;
-    if (event.text && typeof event.text === "string")
-      state.text += event.text;
-    if (event.result && typeof event.result === "string")
-      state.text = event.result;
-    if (event.cumulative_token_usage)
-      state.tokenUsage = event.cumulative_token_usage;
-    if (event.usage) {
-      state.tokenUsage = {
-        input_tokens: event.usage.input_tokens ?? event.usage.prompt_tokens ?? 0,
-        output_tokens: event.usage.output_tokens ?? event.usage.completion_tokens ?? 0
-      };
-    }
-    if (event.stopReason)
-      state.stopReason = event.stopReason;
-    if (event.stop_reason)
-      state.stopReason = event.stop_reason;
-    if (event.error) {
-      state.error = typeof event.error === "string" ? event.error : event.error.message ?? JSON.stringify(event.error);
-    }
-  } catch {
-    if (!state.text)
-      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
-  };
-}
-
 // src/agents/acp/spawn-client.ts
 import { randomUUID } from "crypto";
 async function readAndParseLines(stream, state, onActivity) {
@@ -3837,6 +3724,13 @@ class SpawnAcpSession {
             costUsd: activity.costUsd,
             timestamp: now()
           });
+        } else if (activity.kind === "tool_call_update") {
+          emit({
+            ...baseEvent,
+            kind: "agent.tool_call_update",
+            toolName: activity.toolName,
+            timestamp: now()
+          });
         }
       } : undefined;
       const parsePromise = readAndParseLines(proc.stdout, parseState, onActivity).catch(() => {});
@@ -4115,6 +4009,7 @@ function createSpawnAcpClient(cmdStr, cwd, timeoutSeconds, onPidSpawned, promptR
 }
 var ACPX_STREAM_DRAIN_TIMEOUT_MS = 5000, _spawnClientDeps;
 var init_spawn_client = __esm(() => {
+  init_agents();
   init_logger2();
   init_bun_deps();
   init_env();
@@ -4793,6 +4688,144 @@ var init_adapter = __esm(() => {
   };
 });
 
+// src/agents/acp/parser.ts
+function createParseState() {
+  return {
+    text: "",
+    tokenUsage: undefined,
+    exactCostUsd: undefined,
+    stopReason: undefined,
+    error: undefined,
+    retryable: false
+  };
+}
+function parseAcpxJsonLine(line, state) {
+  try {
+    const event = JSON.parse(line);
+    if (event.jsonrpc === "2.0") {
+      if (event.method === "session/update" && event.params?.update) {
+        const update = event.params.update;
+        if (update.sessionUpdate === "agent_message_chunk" && update.content?.type === "text" && typeof update.content.text === "string") {
+          const text = update.content.text;
+          state.text += text;
+          return {
+            kind: "message_update",
+            deltaBytes: text.length
+          };
+        }
+        if (update.sessionUpdate === "agent_thought_chunk" && update.content?.type === "text" && typeof update.content.text === "string") {
+          return {
+            kind: "thinking_update",
+            deltaBytes: update.content.text.length
+          };
+        }
+        if (update.sessionUpdate === "usage_update") {
+          const activity = { kind: "usage_update" };
+          if (typeof update.used === "number") {
+            activity.outputTokens = update.used;
+          }
+          if (typeof update.cost?.amount === "number") {
+            activity.costUsd = update.cost.amount;
+            state.exactCostUsd = update.cost.amount;
+          }
+          return activity;
+        }
+        if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") {
+          return {
+            kind: "tool_call_update",
+            toolName: extractToolName(update)
+          };
+        }
+      }
+      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;
+          state.tokenUsage = {
+            input_tokens: u.inputTokens ?? u.input_tokens ?? 0,
+            output_tokens: u.outputTokens ?? u.output_tokens ?? 0,
+            cache_read_input_tokens: u.cachedReadTokens ?? u.cache_read_input_tokens ?? 0,
+            cache_creation_input_tokens: u.cachedWriteTokens ?? u.cache_creation_input_tokens ?? 0
+          };
+        }
+      }
+      if (event.error && typeof event.error === "object") {
+        const err = event.error;
+        let errorMsg = typeof err.message === "string" ? err.message : JSON.stringify(event.error);
+        if (err.data && typeof err.data === "object") {
+          const data = err.data;
+          const suffix = [data.acpxCode, data.detailCode].filter(Boolean).join("/");
+          if (suffix)
+            errorMsg = `${errorMsg} [${suffix}]`;
+          if (!state.error && data.retryable === true)
+            state.retryable = true;
+        }
+        if (!state.error)
+          state.error = errorMsg;
+      }
+      return;
+    }
+    if (event.content && typeof event.content === "string")
+      state.text += event.content;
+    if (event.text && typeof event.text === "string")
+      state.text += event.text;
+    if (event.result && typeof event.result === "string")
+      state.text = event.result;
+    if (event.cumulative_token_usage)
+      state.tokenUsage = event.cumulative_token_usage;
+    if (event.usage) {
+      state.tokenUsage = {
+        input_tokens: event.usage.input_tokens ?? event.usage.prompt_tokens ?? 0,
+        output_tokens: event.usage.output_tokens ?? event.usage.completion_tokens ?? 0
+      };
+    }
+    if (event.stopReason)
+      state.stopReason = event.stopReason;
+    if (event.stop_reason)
+      state.stopReason = event.stop_reason;
+    if (event.error) {
+      state.error = typeof event.error === "string" ? event.error : event.error.message ?? JSON.stringify(event.error);
+    }
+  } catch {
+    if (!state.text)
+      state.text = line;
+  }
+  return;
+}
+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 finalizeParseState(state) {
+  return {
+    text: state.text.trim(),
+    tokenUsage: state.tokenUsage,
+    exactCostUsd: state.exactCostUsd,
+    stopReason: state.stopReason,
+    error: state.error,
+    retryable: state.retryable
+  };
+}
+
+// src/agents/acp/index.ts
+var init_acp = __esm(() => {
+  init_adapter();
+  init_spawn_client();
+  init_token_mapper();
+});
+
 // src/agents/registry.ts
 async function getInstalledAgents() {
   return [];
@@ -5235,7 +5268,7 @@ class AgentManager {
     let rateLimitRetry = 0;
     let staleRetryAttempts = 0;
     let currentBundle = request.bundle;
-    let currentFailure;
+    let currentHopKind = { kind: "primary" };
     let finalPrompt;
     const _opStartMs = Date.now();
     const _agentChain = [primaryAgent];
@@ -5246,7 +5279,7 @@ class AgentManager {
         let result;
         let updatedBundle = currentBundle;
         if (request.executeHop) {
-          const hopOut = await request.executeHop(currentAgent, currentBundle, currentFailure, request.runOptions);
+          const hopOut = await request.executeHop(currentAgent, currentBundle, currentHopKind, request.runOptions);
           result = hopOut.result;
           updatedBundle = hopOut.bundle ?? currentBundle;
           finalPrompt = hopOut.prompt ?? finalPrompt;
@@ -5299,6 +5332,7 @@ class AgentManager {
             attempt: staleRetryAttempts,
             agent: currentAgent
           });
+          currentHopKind = { kind: "stale-retry", attempt: staleRetryAttempts };
           continue;
         }
         const hasBundleForSwap = !!bundleForSwapCheck || isFailStale;
@@ -5364,7 +5398,7 @@ class AgentManager {
         hopsSoFar += 1;
         rateLimitRetry = 0;
         currentBundle = updatedBundle;
-        currentFailure = adapterFailure;
+        currentHopKind = { kind: "swap", failure: adapterFailure };
         const hop = {
           storyId: request.runOptions.storyId,
           priorAgent: currentAgent,
@@ -5673,49 +5707,6 @@ function resolveDefaultAgent(config) {
 }
 var FALLBACK_DEFAULT_AGENT = "claude";
 
-// src/agents/index.ts
-var init_agents = __esm(() => {
-  init_interaction_handler();
-  init_types();
-  init_registry();
-  init_cost();
-  init_version_detection();
-  init_manager();
-});
-
-// src/interaction/bridge-builder.ts
-function buildInteractionBridge(chain, context, timeoutMs = DEFAULT_INTERACTION_TIMEOUT_MS) {
-  const plugin = chain?.getPrimary();
-  if (!plugin)
-    return;
-  return {
-    detectQuestion: async (text) => QUESTION_PATTERNS.some((p) => p.test(text)),
-    onQuestionDetected: async (text) => {
-      const requestId = `ix-${context.stage}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-      await plugin.send({
-        id: requestId,
-        type: "input",
-        featureName: context.featureName ?? "unknown",
-        storyId: context.storyId,
-        stage: context.stage,
-        summary: text,
-        fallback: "continue",
-        createdAt: Date.now()
-      });
-      try {
-        const response = await plugin.receive(requestId, timeoutMs);
-        return response.value ?? "continue";
-      } catch {
-        return "continue";
-      }
-    }
-  };
-}
-var QUESTION_PATTERNS, DEFAULT_INTERACTION_TIMEOUT_MS = 120000;
-var init_bridge_builder = __esm(() => {
-  QUESTION_PATTERNS = [/\?\s*$/, /\bwhich\b/i, /\bshould i\b/i, /\bunclear\b/i, /\bplease clarify\b/i];
-});
-
 // src/agents/retry/types.ts
 var ParseValidationError;
 var init_types3 = __esm(() => {
@@ -5898,6 +5889,51 @@ var init_retry = __esm(() => {
   init_parse_retry();
 });
 
+// src/agents/index.ts
+var init_agents = __esm(() => {
+  init_interaction_handler();
+  init_types();
+  init_acp();
+  init_registry();
+  init_cost();
+  init_version_detection();
+  init_manager();
+  init_retry();
+});
+
+// src/interaction/bridge-builder.ts
+function buildInteractionBridge(chain, context, timeoutMs = DEFAULT_INTERACTION_TIMEOUT_MS) {
+  const plugin = chain?.getPrimary();
+  if (!plugin)
+    return;
+  return {
+    detectQuestion: async (text) => QUESTION_PATTERNS.some((p) => p.test(text)),
+    onQuestionDetected: async (text) => {
+      const requestId = `ix-${context.stage}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+      await plugin.send({
+        id: requestId,
+        type: "input",
+        featureName: context.featureName ?? "unknown",
+        storyId: context.storyId,
+        stage: context.stage,
+        summary: text,
+        fallback: "continue",
+        createdAt: Date.now()
+      });
+      try {
+        const response = await plugin.receive(requestId, timeoutMs);
+        return response.value ?? "continue";
+      } catch {
+        return "continue";
+      }
+    }
+  };
+}
+var QUESTION_PATTERNS, DEFAULT_INTERACTION_TIMEOUT_MS = 120000;
+var init_bridge_builder = __esm(() => {
+  QUESTION_PATTERNS = [/\?\s*$/, /\bwhich\b/i, /\bshould i\b/i, /\bunclear\b/i, /\bplease clarify\b/i];
+});
+
 // src/config/schema-types.ts
 function isBuiltinModelTier(value) {
   return value === "fast" || value === "balanced" || value === "powerful";
@@ -20219,8 +20255,8 @@ var init_schemas_execution = __esm(() => {
 // src/config/schemas-infra.ts
 var PlanConfigSchema, AcceptanceFixConfigSchema, AcceptanceConfigSchema, LlmRoutingConfigSchema, RoutingConfigSchema, OptimizerConfigSchema, PluginConfigEntrySchema, HooksConfigSchema, InteractionConfigSchema, StorySizeGateConfigSchema, PromptAuditConfigSchema, AgentFallbackConfigSchema, DEFAULT_AGENT_IDLE_WATCHDOG_CONFIG, AgentIdleWatchdogConfigSchema, AgentAcpConfigSchema, AgentConfigSchema, PrecheckConfigSchema, PromptsConfigSchema, ProjectProfileSchema, VALID_AGENT_TYPES, GenerateConfigSchema, CuratorThresholdsSchema, CuratorConfigSchema;
 var init_schemas_infra = __esm(() => {
+  init_config();
   init_zod();
-  init_schemas_model();
   PlanConfigSchema = exports_external.object({
     model: ConfiguredModelSchema,
     outputPath: exports_external.string().min(1, "plan.outputPath must be non-empty"),
@@ -20323,7 +20359,8 @@ var init_schemas_infra = __esm(() => {
     enabled: true,
     mode: "warn-then-cancel",
     idleTimeoutSeconds: 900,
-    activityKinds: ["message_update", "thinking_update", "usage_update"],
+    toolCallOnlyIdleTimeoutSeconds: 1800,
+    activityKinds: ["message_update", "thinking_update", "usage_update", "tool_call_update"],
     cancelGraceSeconds: 10,
     maxRetryAttempts: 3
   };
@@ -20331,7 +20368,8 @@ var init_schemas_infra = __esm(() => {
     enabled: exports_external.boolean().default(true),
     mode: exports_external.enum(["off", "observe", "warn-then-cancel", "cancel"]).default("warn-then-cancel"),
     idleTimeoutSeconds: exports_external.number().nonnegative().default(900),
-    activityKinds: exports_external.array(exports_external.enum(["message_update", "thinking_update", "usage_update"])).default(["message_update", "thinking_update", "usage_update"]),
+    toolCallOnlyIdleTimeoutSeconds: exports_external.number().nonnegative().default(1800),
+    activityKinds: exports_external.array(exports_external.enum(["message_update", "thinking_update", "usage_update", "tool_call_update"])).default(["message_update", "thinking_update", "usage_update", "tool_call_update"]),
     cancelGraceSeconds: exports_external.number().nonnegative().default(10),
     maxRetryAttempts: exports_external.number().int().nonnegative().default(3)
   }).refine((config2) => config2.mode === "off" || config2.idleTimeoutSeconds > 0, {
@@ -21610,6 +21648,7 @@ function createConfigLoader(config2) {
 // src/config/index.ts
 var init_config = __esm(() => {
   init_schema();
+  init_schemas_model();
   init_loader();
   init_path_security();
   init_paths();
@@ -24160,7 +24199,7 @@ async function hasCommitsForStory(workdir, storyId, maxCommits = 20) {
   }
 }
 function detectMergeConflict(output) {
-  return output.includes("CONFLICT") || output.includes("conflict");
+  return output.includes("<<<<<<<") || output.includes(">>>>>>>") || /\bCONFLICT\s*\(/.test(output) || output.includes("Merge conflict in");
 }
 async function autoCommitIfDirty(workdir, stage, role, storyId) {
   const logger = _gitDeps.getSafeLogger();
@@ -28249,6 +28288,7 @@ var init_context = __esm(() => {
   init_feature_context_filter();
   init_feature_context();
   init_builder();
+  init_engine();
   init_test_scanner();
   init_auto_detect();
 });
@@ -29873,7 +29913,10 @@ Worked example:
 
 **Convention / coding-standard violations almost always belong as \`"info"\`** unless an AC specifically names the convention or the symbol it concerns.
 
-If you cannot find an AC that names the **specific symbol** in your finding, downgrade to \`"info"\`. A finding dropped by the validator is worse than one correctly classified as advisory.`;
+**Scope constraints are not Acceptance Criteria:**
+The story description may contain a "Scope" section with "In:" and "Out:" bullets. These are implementation guidelines, not ACs. A finding about code changed outside the stated scope (e.g., a file listed under "Out:") cannot cite a scope constraint as its \`acQuote\`/\`acIndex\` because scope text is not in the numbered AC list. Emit scope-violation findings as \`"warning"\` \u2014 never \`"error"\`. Never use \`acIndex: 0\`; \`acIndex\` is 1-based (first AC bullet = 1).
+
+If you cannot find an AC that names the **specific symbol** in your finding, downgrade to \`"info"\` or \`"warning"\`. A finding dropped by the validator is worse than one correctly classified as advisory.`;
 var init_adversarial_review_builder = () => {};
 
 // src/prompts/builders/acceptance-builder-helpers.ts
@@ -31352,12 +31395,12 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
     hopBodyInput
   } = ctx;
   const stage = pipelineStage ?? "run";
-  return async (agentName, hopBundle, failure, resolvedRunOptions) => {
+  return async (agentName, hopBundle, hopKind, resolvedRunOptions) => {
     const logger = getLogger();
     let workingBundle = hopBundle;
     let prompt = resolvedRunOptions.prompt;
-    if (failure && hopBundle) {
-      workingBundle = _buildHopCallbackDeps.rebuildForAgent(hopBundle, agentName, failure, story.id);
+    if (hopKind.kind === "swap" && hopBundle) {
+      workingBundle = _buildHopCallbackDeps.rebuildForAgent(hopBundle, agentName, hopKind.failure, story.id);
       if (projectDir && featureName && workingBundle.manifest.rebuildInfo) {
         try {
           await _buildHopCallbackDeps.writeRebuildManifest(projectDir, featureName, story.id, {
@@ -31381,8 +31424,8 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
       }
       prompt = RectifierPromptBuilder.swapHandoff(resolvedRunOptions.prompt, workingBundle.pushMarkdown);
     }
-    if (failure && sessionId) {
-      sessionManager.handoff?.(sessionId, agentName, failure.outcome);
+    if (hopKind.kind === "swap" && sessionId) {
+      sessionManager.handoff?.(sessionId, agentName, hopKind.failure.outcome);
     }
     const contextToolRuntime = workingBundle ? _buildHopCallbackDeps.createContextToolRuntime({
       bundle: workingBundle,
@@ -31399,19 +31442,44 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
       role: resolvedRunOptions.sessionRole ?? "implementer",
       pipelineStage: stage
     });
-    const modelDef = failure === undefined ? resolvedRunOptions.modelDef ?? resolveModelForAgent(config2.models, agentName, effectiveTier, defaultAgent) : resolveModelForAgent(config2.models, agentName, effectiveTier, defaultAgent);
-    const timeoutSeconds = resolvedRunOptions.timeoutSeconds ?? config2.execution.sessionTimeoutSeconds;
-    const handle = await sessionManager.openSession(sessionName, {
-      agentName,
-      role: resolvedRunOptions.sessionRole ?? "implementer",
-      workdir,
-      pipelineStage: stage,
-      modelDef,
-      timeoutSeconds,
-      featureName,
-      storyId: story.id,
-      signal: resolvedRunOptions.abortSignal
-    });
+    let handle;
+    if (hopKind.kind === "stale-retry") {
+      const cached2 = sessionManager.getLiveHandle(sessionName);
+      if (cached2 && cached2.agentName === agentName) {
+        handle = cached2;
+      } else {
+        logger.warn("execution", "Stale-retry: live handle missing, re-opening session", {
+          storyId: story.id,
+          sessionName,
+          attempt: hopKind.attempt
+        });
+        const modelDef = resolvedRunOptions.modelDef ?? resolveModelForAgent(config2.models, agentName, effectiveTier, defaultAgent);
+        handle = await sessionManager.openSession(sessionName, {
+          agentName,
+          role: resolvedRunOptions.sessionRole ?? "implementer",
+          workdir,
+          pipelineStage: stage,
+          modelDef,
+          timeoutSeconds: resolvedRunOptions.timeoutSeconds ?? config2.execution.sessionTimeoutSeconds,
+          featureName,
+          storyId: story.id,
+          signal: resolvedRunOptions.abortSignal
+        });
+      }
+    } else {
+      const modelDef = hopKind.kind === "primary" ? resolvedRunOptions.modelDef ?? resolveModelForAgent(config2.models, agentName, effectiveTier, defaultAgent) : resolveModelForAgent(config2.models, agentName, effectiveTier, defaultAgent);
+      handle = await sessionManager.openSession(sessionName, {
+        agentName,
+        role: resolvedRunOptions.sessionRole ?? "implementer",
+        workdir,
+        pipelineStage: stage,
+        modelDef,
+        timeoutSeconds: resolvedRunOptions.timeoutSeconds ?? config2.execution.sessionTimeoutSeconds,
+        featureName,
+        storyId: story.id,
+        signal: resolvedRunOptions.abortSignal
+      });
+    }
     try {
       const send = (turnPrompt) => agentManager.runAsSession(agentName, handle, turnPrompt, {
         storyId: story.id,
@@ -31447,7 +31515,9 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
         prompt
       };
     } finally {
-      await sessionManager.closeSession(handle);
+      if (hopKind.kind !== "stale-retry") {
+        await sessionManager.closeSession(handle);
+      }
     }
   };
 }
@@ -39524,224 +39594,783 @@ var init_agent_stream_events = __esm(() => {
   init_logger2();
 });
 
-// src/agents/factory.ts
-function createAgentManager(config2, opts) {
-  return new AgentManager(config2, undefined, opts);
+// src/runtime/middleware/cancellation.ts
+function cancellationMiddleware() {
+  return {
+    name: "cancellation",
+    async before(ctx) {
+      if (ctx.signal?.aborted) {
+        throw new NaxError("Agent call cancelled before start", "AGENT_CANCELLED", {
+          stage: ctx.stage ?? "run",
+          agentName: ctx.agentName
+        });
+      }
+    }
+  };
 }
-var init_factory = __esm(() => {
-  init_manager();
+var init_cancellation = __esm(() => {
+  init_errors();
 });
 
-// src/execution/pid-registry.ts
-import { existsSync as existsSync9 } from "fs";
-import { appendFile as appendFile2 } from "fs/promises";
+// src/runtime/middleware/logging.ts
+function attachLoggingSubscriber(bus, runId) {
+  const offDispatch = bus.onDispatch((event) => {
+    getSafeLogger()?.info("middleware", "Agent call complete", {
+      storyId: event.storyId,
+      runId,
+      agentName: event.agentName,
+      kind: event.kind,
+      stage: event.stage,
+      durationMs: event.durationMs
+    });
+  });
+  const offError = bus.onDispatchError((event) => {
+    getSafeLogger()?.warn("middleware", "Agent call failed", {
+      storyId: event.storyId,
+      runId,
+      agentName: event.agentName,
+      stage: event.stage,
+      durationMs: event.durationMs,
+      error: event.errorMessage
+    });
+  });
+  return () => {
+    offDispatch();
+    offError();
+  };
+}
+var init_logging2 = __esm(() => {
+  init_logger2();
+});
 
-class PidRegistry {
-  workdir;
-  pidsFilePath;
-  pids = new Set;
-  frozen = false;
-  constructor(workdir, _platform) {
-    this.workdir = workdir;
-    this.pidsFilePath = `${workdir}/${PID_REGISTRY_FILE}`;
-  }
-  freeze() {
-    if (this.frozen)
-      return;
-    this.frozen = true;
-    getSafeLogger()?.debug("pid-registry", "Registry frozen \u2014 new registrations blocked");
-  }
-  isFrozen() {
-    return this.frozen;
-  }
-  async register(pid) {
-    const logger = getSafeLogger();
-    if (this.frozen) {
-      logger?.warn("pid-registry", `Registration blocked (registry frozen) PID ${pid}`, { pid });
-      return;
-    }
-    this.pids.add(pid);
-    const entry = {
-      pid,
-      spawnedAt: new Date().toISOString(),
-      workdir: this.workdir
-    };
-    try {
-      const line = `${JSON.stringify(entry)}
-`;
-      await appendFile2(this.pidsFilePath, line);
-      logger?.debug("pid-registry", `Registered PID ${pid}`, { pid });
-    } catch (err) {
-      logger?.warn("pid-registry", `Failed to write PID ${pid} to registry`, {
-        error: err.message
-      });
-    }
-  }
-  async unregister(pid) {
-    const logger = getSafeLogger();
-    this.pids.delete(pid);
-    try {
-      await this.writePidsFile();
-      logger?.debug("pid-registry", `Unregistered PID ${pid}`, { pid });
-    } catch (err) {
-      logger?.warn("pid-registry", `Failed to unregister PID ${pid}`, {
-        error: err.message
-      });
-    }
-  }
-  async killAll() {
-    const logger = getSafeLogger();
-    const pids = Array.from(this.pids);
-    if (pids.length === 0) {
-      logger?.debug("pid-registry", "No PIDs to kill");
-      return;
-    }
-    logger?.info("pid-registry", `Killing ${pids.length} registered processes`, { pids });
-    const killPromises = pids.map((pid) => this.killPid(pid));
-    await Promise.allSettled(killPromises);
-    try {
-      await Bun.write(this.pidsFilePath, "");
-      this.pids.clear();
-      logger?.info("pid-registry", "All registered PIDs killed and registry cleared");
-    } catch (err) {
-      logger?.warn("pid-registry", "Failed to clear registry file", {
-        error: err.message
-      });
-    }
-  }
-  async cleanupStale() {
-    const logger = getSafeLogger();
-    if (!existsSync9(this.pidsFilePath)) {
-      logger?.debug("pid-registry", "No stale PIDs file found");
-      return;
-    }
-    try {
-      const content = await Bun.file(this.pidsFilePath).text();
-      const lines = content.split(`
-`).filter((line) => line.trim()).map((line) => {
-        try {
-          return JSON.parse(line);
-        } catch {
-          return null;
+// src/runtime/middleware/agent-stream-logging.ts
+function attachAgentStreamLogging(bus, runId) {
+  const activeCalls = new Map;
+  return bus.onAgentStream((event) => {
+    switch (event.kind) {
+      case "agent.call_started": {
+        const now = event.timestamp;
+        activeCalls.set(event.callId, {
+          callId: event.callId,
+          agentName: event.agentName,
+          storyId: event.storyId,
+          stage: event.stage,
+          startedAt: now,
+          lastActivityAt: now,
+          messageUpdates: 0,
+          thinkingUpdates: 0,
+          usageUpdates: 0,
+          toolCallUpdates: 0
+        });
+        getSafeLogger()?.info("agent-stream", "Agent call started", {
+          storyId: event.storyId,
+          runId,
+          callId: event.callId,
+          agentName: event.agentName,
+          stage: event.stage,
+          model: event.model,
+          timeoutSeconds: event.timeoutSeconds
+        });
+        break;
+      }
+      case "agent.message_update": {
+        const state = activeCalls.get(event.callId);
+        if (state) {
+          state.messageUpdates++;
+          state.lastActivityAt = event.timestamp;
         }
-      }).filter((entry) => entry !== null);
-      if (lines.length === 0) {
-        logger?.debug("pid-registry", "No stale PIDs to cleanup");
-        await Bun.write(this.pidsFilePath, "");
-        return;
+        break;
       }
-      const stalePids = lines.map((entry) => entry.pid);
-      logger?.info("pid-registry", `Found ${stalePids.length} stale PID entries from previous run; clearing file without signaling (PIDs likely recycled)`, { pids: stalePids });
-      await Bun.write(this.pidsFilePath, "");
-      logger?.info("pid-registry", "Stale PIDs file cleared");
-    } catch (err) {
-      logger?.warn("pid-registry", "Failed to cleanup stale PIDs", {
-        error: err.message
-      });
-    }
-  }
-  async killPid(pid) {
-    const logger = getSafeLogger();
-    if (!Number.isInteger(pid) || pid <= 1) {
-      logger?.warn("pid-registry", `Refusing to signal non-positive or reserved PID ${pid}`, { pid });
-      return;
-    }
-    try {
-      const checkProc = Bun.spawn(["kill", "-0", String(pid)], {
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const checkCode = await checkProc.exited;
-      if (checkCode !== 0) {
-        logger?.debug("pid-registry", `PID ${pid} not found (already exited)`, { pid });
-        return;
+      case "agent.thinking_update": {
+        const state = activeCalls.get(event.callId);
+        if (state) {
+          state.thinkingUpdates++;
+          state.lastActivityAt = event.timestamp;
+        }
+        break;
       }
-      const killProc = Bun.spawn(["kill", "-TERM", String(pid)], {
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const killCode = await killProc.exited;
-      if (killCode === 0) {
-        logger?.debug("pid-registry", `Killed PID ${pid}`, { pid });
-      } else {
-        const stderr = await new Response(killProc.stderr).text();
-        logger?.warn("pid-registry", `Failed to kill PID ${pid}`, {
-          pid,
-          exitCode: killCode,
-          stderr: stderr.trim()
-        });
+      case "agent.usage_update": {
+        const state = activeCalls.get(event.callId);
+        if (state) {
+          state.usageUpdates++;
+          state.lastActivityAt = event.timestamp;
+        }
+        break;
+      }
+      case "agent.tool_call_update": {
+        const state = activeCalls.get(event.callId);
+        if (state) {
+          state.toolCallUpdates++;
+          state.lastActivityAt = event.timestamp;
+        }
+        break;
+      }
+      case "agent.process_update":
+        break;
+      case "agent.call_ended": {
+        const state = activeCalls.get(event.callId);
+        if (state) {
+          const idleMs = event.timestamp - state.lastActivityAt;
+          getSafeLogger()?.info("agent-stream", "Agent call ended", {
+            storyId: state.storyId,
+            runId,
+            callId: state.callId,
+            agentName: state.agentName,
+            stage: state.stage,
+            messageUpdates: state.messageUpdates,
+            thinkingUpdates: state.thinkingUpdates,
+            usageUpdates: state.usageUpdates,
+            toolCallUpdates: state.toolCallUpdates,
+            lastActivityAt: state.lastActivityAt,
+            idleMs,
+            status: event.status
+          });
+          activeCalls.delete(event.callId);
+        }
+        break;
       }
-    } catch (err) {
-      logger?.warn("pid-registry", `Error killing PID ${pid}`, {
-        pid,
-        error: err.message
-      });
     }
-  }
-  async writePidsFile() {
-    const entries = Array.from(this.pids).map((pid) => ({
-      pid,
-      spawnedAt: new Date().toISOString(),
-      workdir: this.workdir
-    }));
-    const content = entries.map((entry) => JSON.stringify(entry)).join(`
-`);
-    await Bun.write(this.pidsFilePath, content ? `${content}
-` : "");
-  }
-  getPids() {
-    return Array.from(this.pids);
-  }
+  });
 }
-var PID_REGISTRY_FILE = ".nax-pids";
-var init_pid_registry = __esm(() => {
+var init_agent_stream_logging = __esm(() => {
   init_logger2();
 });
 
-// src/session/manager-deps.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { mkdir as mkdir5 } from "fs/promises";
-import { isAbsolute as isAbsolute9, join as join27, relative as relative10, sep } from "path";
-function resolveProjectDirFromScratchDir(scratchDir) {
-  const marker = `${sep}.nax${sep}features${sep}`;
-  const markerIdx = scratchDir.lastIndexOf(marker);
-  if (markerIdx > 0)
-    return scratchDir.slice(0, markerIdx);
-  const posixIdx = scratchDir.lastIndexOf("/.nax/features/");
-  if (posixIdx > 0)
-    return scratchDir.slice(0, posixIdx);
-  return;
-}
-function toProjectRelativePath(projectDir, pathValue) {
-  const relativePath = isAbsolute9(pathValue) ? relative10(projectDir, pathValue) : pathValue;
-  return relativePath === "" ? "." : relativePath;
+// src/runtime/middleware/cost.ts
+function attachCostSubscriber(bus, aggregator, runId) {
+  const offDispatch = bus.onDispatch((event) => {
+    const tu = event.tokenUsage;
+    const exactCostUsd = event.exactCostUsd;
+    const estimatedCostUsd = event.estimatedCostUsd ?? exactCostUsd ?? 0;
+    if (!tu && exactCostUsd == null && estimatedCostUsd === 0)
+      return;
+    const costUsd = exactCostUsd ?? estimatedCostUsd;
+    const confidence = exactCostUsd != null ? "exact" : "estimated";
+    const costEvent = {
+      ts: event.timestamp,
+      runId,
+      agentName: event.agentName,
+      model: "unknown",
+      stage: event.stage,
+      storyId: event.storyId,
+      tokens: tu ? {
+        input: tu.inputTokens ?? 0,
+        output: tu.outputTokens ?? 0,
+        cacheRead: tu.cacheReadInputTokens,
+        cacheWrite: tu.cacheCreationInputTokens
+      } : { input: 0, output: 0 },
+      estimatedCostUsd,
+      exactCostUsd,
+      costUsd,
+      confidence,
+      durationMs: event.durationMs
+    };
+    aggregator.record(costEvent);
+  });
+  const offError = bus.onDispatchError((event) => {
+    const errorEvent = {
+      ts: event.timestamp,
+      runId,
+      agentName: event.agentName,
+      stage: event.stage,
+      storyId: event.storyId,
+      errorCode: event.errorCode,
+      durationMs: event.durationMs
+    };
+    aggregator.recordError(errorEvent);
+  });
+  const offCompleted = bus.onOperationCompleted((event) => {
+    const summary = {
+      runId,
+      operation: event.operation,
+      hopCount: event.hopCount,
+      fallbackTriggered: event.fallbackTriggered,
+      totalCostUsd: event.totalCostUsd,
+      totalElapsedMs: event.totalElapsedMs,
+      finalStatus: event.finalStatus
+    };
+    aggregator.recordOperationSummary(summary);
+  });
+  return () => {
+    offDispatch();
+    offError();
+    offCompleted();
+  };
 }
-var _sessionManagerDeps;
-var init_manager_deps = __esm(() => {
-  _sessionManagerDeps = {
-    now: () => new Date().toISOString(),
-    nowMs: () => Date.now(),
-    uuid: () => randomUUID3(),
-    sessionScratchDir: (projectDir, featureName, sessionId) => join27(projectDir, ".nax", "features", featureName, "sessions", sessionId),
-    writeDescriptor: async (scratchDir, descriptor, projectDir) => {
-      await mkdir5(scratchDir, { recursive: true });
-      const { handle: _handle, ...persistable } = descriptor;
-      const derivedProjectDir = projectDir ?? resolveProjectDirFromScratchDir(scratchDir);
-      if (derivedProjectDir) {
-        persistable.workdir = toProjectRelativePath(derivedProjectDir, persistable.workdir);
-        if (persistable.scratchDir) {
-          persistable.scratchDir = toProjectRelativePath(derivedProjectDir, persistable.scratchDir);
-        }
+
+// src/runtime/middleware/audit.ts
+function attachAuditSubscriber(bus, auditor, runId) {
+  const offDispatch = bus.onDispatch((event) => {
+    const entry = {
+      ts: event.timestamp,
+      runId,
+      agentName: event.agentName,
+      stage: event.stage,
+      storyId: event.storyId,
+      permissionProfile: event.resolvedPermissions.mode,
+      prompt: event.prompt,
+      response: event.response,
+      durationMs: event.durationMs,
+      callType: event.kind === "session-turn" ? "run" : "complete",
+      workdir: event.workdir,
+      projectDir: event.projectDir,
+      featureName: event.featureName,
+      sessionName: event.sessionName,
+      ...event.kind === "session-turn" && {
+        sessionId: event.protocolIds.sessionId ?? null,
+        recordId: event.protocolIds.recordId ?? null,
+        turn: event.turn
       }
-      await Bun.write(join27(scratchDir, "descriptor.json"), JSON.stringify(persistable, null, 2));
-    }
+    };
+    auditor.record(entry);
+  });
+  const offError = bus.onDispatchError((event) => {
+    const entry = {
+      ts: event.timestamp,
+      runId,
+      agentName: event.agentName,
+      stage: event.stage,
+      storyId: event.storyId,
+      errorCode: event.errorCode,
+      errorMessage: event.errorMessage,
+      durationMs: event.durationMs,
+      callType: event.origin === "completeAs" ? "complete" : "run",
+      permissionProfile: event.resolvedPermissions.mode,
+      prompt: event.prompt
+    };
+    auditor.recordError(entry);
+  });
+  return () => {
+    offDispatch();
+    offError();
   };
-});
+}
 
-// src/session/manager-run.ts
-async function runTrackedSession(state, id, runner, request) {
-  const startedAt = Date.now();
-  const pre = state.sessions.get(id);
+// src/runtime/middleware/review-audit.ts
+function reviewerFromRole(role) {
+  if (role === "reviewer-semantic")
+    return "semantic";
+  if (role === "reviewer-adversarial")
+    return "adversarial";
+  return null;
+}
+function attachReviewAuditSubscriber(bus, auditor, runId) {
+  const offDispatch = bus.onDispatch((event) => {
+    if (event.kind !== "session-turn")
+      return;
+    const reviewer = reviewerFromRole(event.sessionRole);
+    if (!reviewer)
+      return;
+    auditor.recordDispatch({
+      runId,
+      reviewer,
+      sessionName: event.sessionName,
+      sessionId: event.protocolIds.sessionId ?? null,
+      recordId: event.protocolIds.recordId ?? null,
+      workdir: event.workdir,
+      projectDir: event.projectDir,
+      agentName: event.agentName,
+      storyId: event.storyId,
+      featureName: event.featureName
+    });
+  });
+  const offDecision = bus.onReviewDecision((event) => {
+    auditor.recordDecision({
+      runId: event.runId,
+      reviewer: event.reviewer,
+      sessionName: event.sessionName,
+      sessionId: event.sessionId,
+      recordId: event.recordId,
+      workdir: event.workdir,
+      projectDir: event.projectDir,
+      outputDir: event.outputDir,
+      agentName: event.agentName,
+      storyId: event.storyId,
+      featureName: event.featureName,
+      parsed: event.parsed,
+      looksLikeFail: event.looksLikeFail,
+      failOpen: event.failOpen,
+      passed: event.passed,
+      blockingThreshold: event.blockingThreshold,
+      result: event.result,
+      advisoryFindings: event.advisoryFindings
+    });
+  });
+  return () => {
+    offDispatch();
+    offDecision();
+  };
+}
+
+// src/runtime/middleware/idle-watchdog.ts
+function scheduleTickIfNeeded(tickRef, tick, intervalMs) {
+  if (tickRef.handle !== null)
+    return;
+  tickRef.handle = setTimeout(tick, intervalMs);
+}
+function handleObserveTimeout(state, reason, idleDurationMs, nonToolCallIdleMs) {
+  if (state.warnedForCurrentIdlePeriod)
+    return;
+  state.warnedForCurrentIdlePeriod = true;
+  getSafeLogger()?.warn("idle-watchdog", reason === "tool_call_only_idle_timeout_exceeded" ? "Tool-call-only idle timeout exceeded" : "Idle timeout exceeded", {
+    storyId: state.storyId,
+    key: reason,
+    callId: state.callId,
+    mode: "observe",
+    idleDurationMs,
+    nonToolCallIdleMs,
+    toolCallUpdates: state.toolCallUpdates
+  });
+}
+async function handleCancelTimeout(state, reason, controllerRegistry, maxRetryAttempts, activeStates) {
+  if (state.cancelAttempts >= maxRetryAttempts) {
+    getSafeLogger()?.error("idle-watchdog", "Max retry attempts exceeded", {
+      storyId: state.storyId,
+      key: "max_retry_attempts_exceeded",
+      callId: state.callId,
+      cancelAttempts: state.cancelAttempts
+    });
+    activeStates.delete(state.callId);
+    return;
+  }
+  state.cancelAttempts++;
+  state.lastActivityAt = Date.now();
+  getSafeLogger()?.warn("idle-watchdog", reason === "tool_call_only_idle_timeout_exceeded" ? "Canceling tool-call-only idle call" : "Canceling idle call", {
+    storyId: state.storyId,
+    key: reason,
+    callId: state.callId,
+    mode: "cancel",
+    action: "cancel",
+    toolCallUpdates: state.toolCallUpdates
+  });
+  const cancel = controllerRegistry.get(state.callId);
+  if (cancel)
+    await cancel().catch(() => {});
+}
+function handleWarnThenCancelTimeout(state, reason, controllerRegistry, maxRetryAttempts, idleTimeoutMs, toolCallOnlyTimeoutMs, graceMs, activeStates) {
+  if (state.cancelAttempts >= maxRetryAttempts) {
+    getSafeLogger()?.error("idle-watchdog", "Max retry attempts exceeded", {
+      storyId: state.storyId,
+      key: "max_retry_attempts_exceeded",
+      callId: state.callId,
+      cancelAttempts: state.cancelAttempts
+    });
+    activeStates.delete(state.callId);
+    return;
+  }
+  getSafeLogger()?.warn("idle-watchdog", reason === "tool_call_only_idle_timeout_exceeded" ? "Tool-call-only idle timeout exceeded, entering grace period" : "Idle timeout exceeded, entering grace period", {
+    storyId: state.storyId,
+    key: reason,
+    callId: state.callId,
+    mode: "warn-then-cancel",
+    gracePeriodMs: graceMs,
+    toolCallUpdates: state.toolCallUpdates
+  });
+  state.inGracePeriod = true;
+  state.graceReason = reason;
+  state.graceTimer = setTimeout(async () => {
+    if (!activeStates.has(state.callId))
+      return;
+    state.inGracePeriod = false;
+    state.graceTimer = undefined;
+    state.graceReason = undefined;
+    const currentReason = getTimeoutReason(state, Date.now(), idleTimeoutMs, toolCallOnlyTimeoutMs);
+    if (currentReason !== reason)
+      return;
+    state.cancelAttempts++;
+    state.lastActivityAt = Date.now();
+    const cancel = controllerRegistry.get(state.callId);
+    if (cancel)
+      await cancel().catch(() => {});
+  }, graceMs);
+}
+function clearGrace(state) {
+  if (state.inGracePeriod && state.graceTimer !== undefined) {
+    clearTimeout(state.graceTimer);
+    state.graceTimer = undefined;
+    state.inGracePeriod = false;
+    state.graceReason = undefined;
+  }
+}
+function resetActivity(state, newTimestamp, options) {
+  state.lastActivityAt = newTimestamp;
+  state.warnedForCurrentIdlePeriod = false;
+  if (options.clearGrace)
+    clearGrace(state);
+}
+function getTimeoutReason(state, now, idleTimeoutMs, toolCallOnlyTimeoutMs) {
+  if (now - state.lastActivityAt >= idleTimeoutMs)
+    return "idle_timeout_exceeded";
+  if (toolCallOnlyTimeoutMs > idleTimeoutMs && now - state.lastNonToolCallActivityAt >= toolCallOnlyTimeoutMs) {
+    return "tool_call_only_idle_timeout_exceeded";
+  }
+  return;
+}
+function attachAgentIdleWatchdog(agentStreamEvents, controllerRegistry, config2) {
+  const watchdogConfig = config2.agent?.idleWatchdog;
+  if (!watchdogConfig?.enabled || watchdogConfig.mode === "off" || watchdogConfig.mode === undefined) {
+    return agentStreamEvents.onAgentStream(() => {});
+  }
+  const mode = watchdogConfig.mode;
+  const idleTimeoutMs = (watchdogConfig.idleTimeoutSeconds ?? 30) * 1000;
+  const toolCallOnlyTimeoutMs = (watchdogConfig.toolCallOnlyIdleTimeoutSeconds ?? 0) * 1000;
+  const graceMs = (watchdogConfig.cancelGraceSeconds ?? 5) * 1000;
+  const maxRetryAttempts = watchdogConfig.maxRetryAttempts ?? 3;
+  const activityKinds = new Set(watchdogConfig.activityKinds ?? ["message_update", "thinking_update", "usage_update", "tool_call_update"]);
+  const tickIntervalMs = Math.max(1, Math.ceil(idleTimeoutMs / 4));
+  const activeStates = new Map;
+  const tickRef = { handle: null };
+  function tick() {
+    tickRef.handle = null;
+    const now = Date.now();
+    for (const [, state] of activeStates) {
+      if (state.inGracePeriod)
+        continue;
+      const idleDurationMs = now - state.lastActivityAt;
+      const nonToolCallIdleMs = now - state.lastNonToolCallActivityAt;
+      const reason = getTimeoutReason(state, now, idleTimeoutMs, toolCallOnlyTimeoutMs);
+      if (!reason)
+        continue;
+      if (mode === "observe")
+        handleObserveTimeout(state, reason, idleDurationMs, nonToolCallIdleMs);
+      else if (mode === "cancel") {
+        handleCancelTimeout(state, reason, controllerRegistry, maxRetryAttempts, activeStates);
+      } else if (mode === "warn-then-cancel") {
+        handleWarnThenCancelTimeout(state, reason, controllerRegistry, maxRetryAttempts, idleTimeoutMs, toolCallOnlyTimeoutMs, graceMs, activeStates);
+      }
+    }
+    if (activeStates.size > 0)
+      scheduleTickIfNeeded(tickRef, tick, tickIntervalMs);
+  }
+  const unsubscribe = agentStreamEvents.onAgentStream((event) => {
+    switch (event.kind) {
+      case "agent.call_started": {
+        const now = Date.now();
+        activeStates.set(event.callId, {
+          callId: event.callId,
+          agentName: event.agentName,
+          sessionName: event.sessionName,
+          storyId: event.storyId,
+          stage: event.stage,
+          pid: event.pid,
+          startedAt: now,
+          lastActivityAt: now,
+          lastNonToolCallActivityAt: now,
+          messageUpdates: 0,
+          thinkingUpdates: 0,
+          usageUpdates: 0,
+          toolCallUpdates: 0,
+          cancelAttempts: 0,
+          inGracePeriod: false,
+          warnedForCurrentIdlePeriod: false
+        });
+        getSafeLogger()?.debug("idle-watchdog", "Watchdog tracking call", {
+          storyId: event.storyId,
+          callId: event.callId,
+          mode,
+          idleTimeoutMs,
+          toolCallOnlyTimeoutMs
+        });
+        scheduleTickIfNeeded(tickRef, tick, tickIntervalMs);
+        break;
+      }
+      case "agent.message_update": {
+        const state = activeStates.get(event.callId);
+        if (state && activityKinds.has("message_update")) {
+          state.messageUpdates++;
+          state.lastNonToolCallActivityAt = event.timestamp;
+          resetActivity(state, event.timestamp, { clearGrace: true });
+        }
+        break;
+      }
+      case "agent.thinking_update": {
+        const state = activeStates.get(event.callId);
+        if (state && activityKinds.has("thinking_update")) {
+          state.thinkingUpdates++;
+          state.lastNonToolCallActivityAt = event.timestamp;
+          resetActivity(state, event.timestamp, { clearGrace: true });
+        }
+        break;
+      }
+      case "agent.usage_update": {
+        const state = activeStates.get(event.callId);
+        if (state && activityKinds.has("usage_update")) {
+          state.usageUpdates++;
+          state.lastNonToolCallActivityAt = event.timestamp;
+          resetActivity(state, event.timestamp, { clearGrace: true });
+        }
+        break;
+      }
+      case "agent.tool_call_update": {
+        const state = activeStates.get(event.callId);
+        if (state && activityKinds.has("tool_call_update")) {
+          state.toolCallUpdates++;
+          resetActivity(state, event.timestamp, {
+            clearGrace: state.graceReason === "idle_timeout_exceeded"
+          });
+        }
+        break;
+      }
+      case "agent.process_update":
+        break;
+      case "agent.call_ended": {
+        const state = activeStates.get(event.callId);
+        if (state) {
+          if (state.graceTimer !== undefined)
+            clearTimeout(state.graceTimer);
+          activeStates.delete(event.callId);
+        }
+        if (activeStates.size === 0 && tickRef.handle !== null) {
+          clearTimeout(tickRef.handle);
+          tickRef.handle = null;
+        }
+        break;
+      }
+    }
+  });
+  return () => {
+    unsubscribe();
+    for (const state of activeStates.values()) {
+      if (state.graceTimer !== undefined)
+        clearTimeout(state.graceTimer);
+    }
+    activeStates.clear();
+    if (tickRef.handle !== null) {
+      clearTimeout(tickRef.handle);
+      tickRef.handle = null;
+    }
+  };
+}
+var init_idle_watchdog = __esm(() => {
+  init_logger2();
+});
+
+// src/runtime/middleware/index.ts
+var init_middleware = __esm(() => {
+  init_cancellation();
+  init_logging2();
+  init_agent_stream_logging();
+  init_idle_watchdog();
+});
+
+// src/agents/factory.ts
+function createAgentManager(config2, opts) {
+  return new AgentManager(config2, undefined, opts);
+}
+var init_factory = __esm(() => {
+  init_manager();
+});
+
+// src/execution/pid-registry.ts
+import { existsSync as existsSync9 } from "fs";
+import { appendFile as appendFile2 } from "fs/promises";
+
+class PidRegistry {
+  workdir;
+  pidsFilePath;
+  pids = new Set;
+  frozen = false;
+  constructor(workdir, _platform) {
+    this.workdir = workdir;
+    this.pidsFilePath = `${workdir}/${PID_REGISTRY_FILE}`;
+  }
+  freeze() {
+    if (this.frozen)
+      return;
+    this.frozen = true;
+    getSafeLogger()?.debug("pid-registry", "Registry frozen \u2014 new registrations blocked");
+  }
+  isFrozen() {
+    return this.frozen;
+  }
+  async register(pid) {
+    const logger = getSafeLogger();
+    if (this.frozen) {
+      logger?.warn("pid-registry", `Registration blocked (registry frozen) PID ${pid}`, { pid });
+      return;
+    }
+    this.pids.add(pid);
+    const entry = {
+      pid,
+      spawnedAt: new Date().toISOString(),
+      workdir: this.workdir
+    };
+    try {
+      const line = `${JSON.stringify(entry)}
+`;
+      await appendFile2(this.pidsFilePath, line);
+      logger?.debug("pid-registry", `Registered PID ${pid}`, { pid });
+    } catch (err) {
+      logger?.warn("pid-registry", `Failed to write PID ${pid} to registry`, {
+        error: err.message
+      });
+    }
+  }
+  async unregister(pid) {
+    const logger = getSafeLogger();
+    this.pids.delete(pid);
+    try {
+      await this.writePidsFile();
+      logger?.debug("pid-registry", `Unregistered PID ${pid}`, { pid });
+    } catch (err) {
+      logger?.warn("pid-registry", `Failed to unregister PID ${pid}`, {
+        error: err.message
+      });
+    }
+  }
+  async killAll() {
+    const logger = getSafeLogger();
+    const pids = Array.from(this.pids);
+    if (pids.length === 0) {
+      logger?.debug("pid-registry", "No PIDs to kill");
+      return;
+    }
+    logger?.info("pid-registry", `Killing ${pids.length} registered processes`, { pids });
+    const killPromises = pids.map((pid) => this.killPid(pid));
+    await Promise.allSettled(killPromises);
+    try {
+      await Bun.write(this.pidsFilePath, "");
+      this.pids.clear();
+      logger?.info("pid-registry", "All registered PIDs killed and registry cleared");
+    } catch (err) {
+      logger?.warn("pid-registry", "Failed to clear registry file", {
+        error: err.message
+      });
+    }
+  }
+  async cleanupStale() {
+    const logger = getSafeLogger();
+    if (!existsSync9(this.pidsFilePath)) {
+      logger?.debug("pid-registry", "No stale PIDs file found");
+      return;
+    }
+    try {
+      const content = await Bun.file(this.pidsFilePath).text();
+      const lines = content.split(`
+`).filter((line) => line.trim()).map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter((entry) => entry !== null);
+      if (lines.length === 0) {
+        logger?.debug("pid-registry", "No stale PIDs to cleanup");
+        await Bun.write(this.pidsFilePath, "");
+        return;
+      }
+      const stalePids = lines.map((entry) => entry.pid);
+      logger?.info("pid-registry", `Found ${stalePids.length} stale PID entries from previous run; clearing file without signaling (PIDs likely recycled)`, { pids: stalePids });
+      await Bun.write(this.pidsFilePath, "");
+      logger?.info("pid-registry", "Stale PIDs file cleared");
+    } catch (err) {
+      logger?.warn("pid-registry", "Failed to cleanup stale PIDs", {
+        error: err.message
+      });
+    }
+  }
+  async killPid(pid) {
+    const logger = getSafeLogger();
+    if (!Number.isInteger(pid) || pid <= 1) {
+      logger?.warn("pid-registry", `Refusing to signal non-positive or reserved PID ${pid}`, { pid });
+      return;
+    }
+    try {
+      const checkProc = Bun.spawn(["kill", "-0", String(pid)], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const checkCode = await checkProc.exited;
+      if (checkCode !== 0) {
+        logger?.debug("pid-registry", `PID ${pid} not found (already exited)`, { pid });
+        return;
+      }
+      const killProc = Bun.spawn(["kill", "-TERM", String(pid)], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const killCode = await killProc.exited;
+      if (killCode === 0) {
+        logger?.debug("pid-registry", `Killed PID ${pid}`, { pid });
+      } else {
+        const stderr = await new Response(killProc.stderr).text();
+        logger?.warn("pid-registry", `Failed to kill PID ${pid}`, {
+          pid,
+          exitCode: killCode,
+          stderr: stderr.trim()
+        });
+      }
+    } catch (err) {
+      logger?.warn("pid-registry", `Error killing PID ${pid}`, {
+        pid,
+        error: err.message
+      });
+    }
+  }
+  async writePidsFile() {
+    const entries = Array.from(this.pids).map((pid) => ({
+      pid,
+      spawnedAt: new Date().toISOString(),
+      workdir: this.workdir
+    }));
+    const content = entries.map((entry) => JSON.stringify(entry)).join(`
+`);
+    await Bun.write(this.pidsFilePath, content ? `${content}
+` : "");
+  }
+  getPids() {
+    return Array.from(this.pids);
+  }
+}
+var PID_REGISTRY_FILE = ".nax-pids";
+var init_pid_registry = __esm(() => {
+  init_logger2();
+});
+
+// src/session/manager-deps.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { mkdir as mkdir5 } from "fs/promises";
+import { isAbsolute as isAbsolute9, join as join27, relative as relative10, sep } from "path";
+function resolveProjectDirFromScratchDir(scratchDir) {
+  const marker = `${sep}.nax${sep}features${sep}`;
+  const markerIdx = scratchDir.lastIndexOf(marker);
+  if (markerIdx > 0)
+    return scratchDir.slice(0, markerIdx);
+  const posixIdx = scratchDir.lastIndexOf("/.nax/features/");
+  if (posixIdx > 0)
+    return scratchDir.slice(0, posixIdx);
+  return;
+}
+function toProjectRelativePath(projectDir, pathValue) {
+  const relativePath = isAbsolute9(pathValue) ? relative10(projectDir, pathValue) : pathValue;
+  return relativePath === "" ? "." : relativePath;
+}
+var _sessionManagerDeps;
+var init_manager_deps = __esm(() => {
+  _sessionManagerDeps = {
+    now: () => new Date().toISOString(),
+    nowMs: () => Date.now(),
+    uuid: () => randomUUID3(),
+    sessionScratchDir: (projectDir, featureName, sessionId) => join27(projectDir, ".nax", "features", featureName, "sessions", sessionId),
+    writeDescriptor: async (scratchDir, descriptor, projectDir) => {
+      await mkdir5(scratchDir, { recursive: true });
+      const { handle: _handle, ...persistable } = descriptor;
+      const derivedProjectDir = projectDir ?? resolveProjectDirFromScratchDir(scratchDir);
+      if (derivedProjectDir) {
+        persistable.workdir = toProjectRelativePath(derivedProjectDir, persistable.workdir);
+        if (persistable.scratchDir) {
+          persistable.scratchDir = toProjectRelativePath(derivedProjectDir, persistable.scratchDir);
+        }
+      }
+      await Bun.write(join27(scratchDir, "descriptor.json"), JSON.stringify(persistable, null, 2));
+    }
+  };
+});
+
+// src/session/manager-run.ts
+async function runTrackedSession(state, id, runner, request) {
+  const startedAt = Date.now();
+  const pre = state.sessions.get(id);
   if (!pre) {
     throw new NaxError(`Session "${id}" not found in registry`, "SESSION_NOT_FOUND", {
       stage: "session",
@@ -40053,838 +40682,331 @@ class SessionManager {
       });
     }
     const allowed = SESSION_TRANSITIONS[session.state];
-    if (!allowed.includes(to)) {
-      throw new NaxError(`Invalid session transition: ${session.state} \u2192 ${to} (session ${id})`, "SESSION_INVALID_TRANSITION", { stage: "session", sessionId: id, from: session.state, to, allowed });
-    }
-    const now = _sessionManagerDeps.now();
-    const updated = {
-      ...session,
-      state: to,
-      lastActivityAt: now
-    };
-    if (options?.protocolIds) {
-      updated.protocolIds = options.protocolIds;
-    }
-    if (options?.completedStage) {
-      updated.completedStages = [...session.completedStages, options.completedStage];
-    }
-    this._sessions.set(id, updated);
-    this._persistDescriptor(updated);
-    getLogger().debug("session", "Session transitioned", {
-      storyId: session.storyId,
-      sessionId: id,
-      from: session.state,
-      to
-    });
-    return { ...updated };
-  }
-  bindHandle(id, handle, protocolIds) {
-    const session = this._sessions.get(id);
-    if (!session) {
-      throw new NaxError(`Session "${id}" not found in registry`, "SESSION_NOT_FOUND", {
-        stage: "session",
-        sessionId: id
-      });
-    }
-    const updated = {
-      ...session,
-      handle,
-      protocolIds,
-      lastActivityAt: _sessionManagerDeps.now()
-    };
-    this._sessions.set(id, updated);
-    this._persistDescriptor(updated);
-    getLogger().debug("session", "Session handle bound", {
-      storyId: session.storyId,
-      sessionId: id,
-      handle
-    });
-    return { ...updated };
-  }
-  handoff(id, newAgent, reason) {
-    const session = this._sessions.get(id);
-    if (!session) {
-      throw new NaxError(`Session "${id}" not found in registry`, "SESSION_NOT_FOUND", {
-        stage: "session",
-        sessionId: id
-      });
-    }
-    const updated = {
-      ...session,
-      agent: newAgent,
-      lastActivityAt: _sessionManagerDeps.now()
-    };
-    this._sessions.set(id, updated);
-    this._persistDescriptor(updated);
-    getLogger().info("session", "Session handed off to fallback agent", {
-      storyId: session.storyId,
-      sessionId: id,
-      fromAgent: session.agent,
-      toAgent: newAgent,
-      ...reason && { reason }
-    });
-    return { ...updated };
-  }
-  resume(storyId, role) {
-    const terminal = ["COMPLETED", "FAILED"];
-    for (const session of this._sessions.values()) {
-      if (session.storyId === storyId && session.role === role && !terminal.includes(session.state)) {
-        getLogger().debug("session", "Session resumed", {
-          storyId,
-          sessionId: session.id,
-          role,
-          state: session.state
-        });
-        return { ...session };
-      }
-    }
-    return null;
-  }
-  closeStory(storyId) {
-    const terminal = ["COMPLETED", "FAILED"];
-    const closed = [];
-    const now = _sessionManagerDeps.now();
-    for (const [id, session] of this._sessions.entries()) {
-      if (session.storyId !== storyId)
-        continue;
-      if (terminal.includes(session.state))
-        continue;
-      const updated = { ...session, state: "COMPLETED", lastActivityAt: now };
-      this._sessions.set(id, updated);
-      this._persistDescriptor(updated);
-      closed.push({ ...updated });
-      getLogger().debug("session", "Session closed by closeStory", {
-        storyId,
-        sessionId: id,
-        priorState: session.state
-      });
-    }
-    return closed;
-  }
-  getForStory(storyId) {
-    return Array.from(this._sessions.values()).filter((s) => s.storyId === storyId).map((s) => ({ ...s }));
-  }
-  listActive() {
-    const terminal = ["COMPLETED", "FAILED"];
-    return Array.from(this._sessions.values()).filter((s) => !terminal.includes(s.state)).map((s) => ({ ...s }));
-  }
-  _findByName(name) {
-    for (const session of this._sessions.values()) {
-      if (session.handle === name)
-        return session;
-    }
-    return;
-  }
-  descriptor(name) {
-    const session = this._findByName(name);
-    return session ? { ...session } : null;
-  }
-  nameFor(req) {
-    return formatSessionName(req);
-  }
-  async openSession(name, opts) {
-    const liveHandle = this._liveHandles.get(name);
-    if (liveHandle && liveHandle.agentName === opts.agentName) {
-      const liveDesc = this._findByName(name);
-      if (!liveDesc || liveDesc.state !== "COMPLETED" && liveDesc.state !== "FAILED") {
-        return liveHandle;
-      }
-      this._liveHandles.delete(name);
-    }
-    const adapter = this._getAdapter(opts.agentName);
-    if (!adapter) {
-      throw new NaxError(`SessionManager.openSession: no adapter found for agent "${opts.agentName}"`, "ADAPTER_NOT_FOUND", { stage: "session", agentName: opts.agentName });
-    }
-    const resolvedPermissions = resolvePermissions(this._config, opts.pipelineStage);
-    const existingDescriptor = this._findByName(name);
-    const resume = existingDescriptor !== undefined;
-    const handle = await adapter.openSession(name, {
-      agentName: opts.agentName,
-      workdir: opts.workdir,
-      resolvedPermissions,
-      modelDef: opts.modelDef,
-      timeoutSeconds: opts.timeoutSeconds,
-      onPidSpawned: this._pidRegistry ? (pid) => this._pidRegistry?.register(pid) : undefined,
-      onPidExited: this._pidRegistry ? (pid) => this._pidRegistry?.unregister(pid) : undefined,
-      onSessionEstablished: opts.onSessionEstablished,
-      signal: opts.signal,
-      resume,
-      onActiveCall: this._buildOnActiveCall(name),
-      onStreamActivity: this._onStreamActivity
-    });
-    this._liveHandles.set(name, handle);
-    const protocolIds = handle.protocolIds ?? NULL_PROTOCOL_IDS;
-    if (!existingDescriptor) {
-      const created = this.create({
-        role: opts.role ?? "main",
-        agent: opts.agentName,
-        workdir: opts.workdir,
-        featureName: opts.featureName,
-        storyId: opts.storyId,
-        handle: name
-      });
-      this.transition(created.id, "RUNNING", { protocolIds });
-    } else if (existingDescriptor.state === "CREATED") {
-      this.transition(existingDescriptor.id, "RUNNING", { protocolIds });
-    } else if (existingDescriptor.state === "COMPLETED" || existingDescriptor.state === "FAILED") {
-      this._cancelledSessions.delete(name);
-      const updated = {
-        ...existingDescriptor,
-        state: "RUNNING",
-        protocolIds,
-        lastActivityAt: _sessionManagerDeps.now()
-      };
-      this._sessions.set(existingDescriptor.id, updated);
-      this._persistDescriptor(updated);
-    } else {
-      getLogger().warn("session", "openSession called on already-RUNNING session", {
-        storyId: opts.storyId,
-        sessionName: name
-      });
-    }
-    getLogger().debug("session", "Session opened via SessionManager", {
-      storyId: opts.storyId,
-      sessionName: name,
-      agentName: opts.agentName,
-      resume
-    });
-    return handle;
-  }
-  async closeSession(handle) {
-    const desc = this._findByName(handle.id);
-    const adapter = this._getAdapter(handle.agentName);
-    this._liveHandles.delete(handle.id);
-    if (adapter) {
-      try {
-        await adapter.closeSession(handle);
-      } catch (err) {
-        getLogger().warn("session", "adapter.closeSession failed (swallowed)", {
-          storyId: desc?.storyId,
-          sessionName: handle.id,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-    }
-    if (desc && desc.state === "RUNNING") {
-      this.transition(desc.id, "COMPLETED");
-    }
-    this._busySessions.delete(handle.id);
-    this._cancelledSessions.delete(handle.id);
-  }
-  async sendPrompt(handle, prompt, opts) {
-    if (this._cancelledSessions.has(handle.id)) {
-      throw new NaxError(`Session "${handle.id}" was cancelled \u2014 close it and open a new session to continue`, "SESSION_CANCELLED", { stage: "session", sessionName: handle.id });
-    }
-    if (this._busySessions.has(handle.id)) {
-      throw new NaxError(`Session "${handle.id}" is already processing a prompt (single-flight invariant)`, "SESSION_BUSY", { stage: "session", sessionName: handle.id });
-    }
-    const terminalDesc = this._findByName(handle.id);
-    if (terminalDesc && (terminalDesc.state === "COMPLETED" || terminalDesc.state === "FAILED")) {
-      throw new NaxError(`Session "${handle.id}" is in terminal state ${terminalDesc.state} \u2014 call openSession first to resume`, "SESSION_TERMINAL_STATE", { stage: "session", sessionName: handle.id, state: terminalDesc.state });
-    }
-    const adapter = this._getAdapter(handle.agentName);
-    if (!adapter) {
-      throw new NaxError(`SessionManager.sendPrompt: no adapter found for agent "${handle.agentName}"`, "ADAPTER_NOT_FOUND", { stage: "session", agentName: handle.agentName });
-    }
-    this._busySessions.add(handle.id);
-    try {
-      const result = await adapter.sendTurn(handle, prompt, {
-        interactionHandler: opts?.interactionHandler ?? NO_OP_INTERACTION_HANDLER,
-        signal: opts?.signal,
-        maxTurns: opts?.maxTurns
-      });
-      return { ...result, protocolIds: result.protocolIds ?? handle.protocolIds };
-    } catch (err) {
-      if (err instanceof SessionTurnError && err.cancelled) {
-        const wasWatchdog = (this._watchdogCancelledCallsBySession.get(handle.id)?.size ?? 0) > 0;
-        if (wasWatchdog) {
-          throw new SessionFailureError("idle watchdog cancelled session \u2014 no stream activity", {
-            category: "availability",
-            outcome: "fail-stale",
-            retriable: true,
-            message: "idle watchdog cancelled session \u2014 no stream activity"
-          });
-        }
-      }
-      if (opts?.signal?.aborted || err instanceof Error && err.name === "AbortError") {
-        this._cancelledSessions.add(handle.id);
-        const desc = this._findByName(handle.id);
-        if (desc && desc.state === "RUNNING") {
-          this.transition(desc.id, "FAILED");
-        }
-      }
-      throw err;
-    } finally {
-      this._clearWatchdogCancelledCalls(handle.id);
-      this._busySessions.delete(handle.id);
-    }
-  }
-  async runInSession(idOrName, promptOrFnOrRunner, optsOrRequest, _legacyOptions) {
-    if (typeof promptOrFnOrRunner === "object" && promptOrFnOrRunner !== null && "run" in promptOrFnOrRunner && typeof promptOrFnOrRunner.run === "function") {
-      return this._runTrackedSession(idOrName, promptOrFnOrRunner, optsOrRequest);
-    }
-    const opts = optsOrRequest;
-    const handle = await this.openSession(idOrName, opts);
-    try {
-      if (typeof promptOrFnOrRunner === "string") {
-        return await this.sendPrompt(handle, promptOrFnOrRunner, {
-          interactionHandler: opts.interactionHandler,
-          signal: opts.signal,
-          maxTurns: opts.maxTurns
-        });
-      }
-      return await promptOrFnOrRunner(handle);
-    } finally {
-      await this.closeSession(handle);
-    }
-  }
-  async _runTrackedSession(id, runner, request) {
-    return runTrackedSession({
-      sessions: this._sessions,
-      transition: (sid, to, opts) => this.transition(sid, to, opts),
-      bindHandle: (sid, handle, protocolIds) => this.bindHandle(sid, handle, protocolIds),
-      handoff: (sid, agent, reason) => this.handoff(sid, agent, reason),
-      persistDescriptor: (desc) => this._persistDescriptor(desc),
-      dispatchEvents: this._dispatchEvents,
-      defaultAgent: this._defaultAgent,
-      nameFor: (req) => this.nameFor(req)
-    }, id, runner, request);
-  }
-  sweepOrphans(ttlMs = DEFAULT_ORPHAN_TTL_MS) {
-    return sweepOrphansImpl(this._sessions, ttlMs);
-  }
-}
-var NULL_PROTOCOL_IDS;
-var init_manager2 = __esm(() => {
-  init_types();
-  init_errors();
-  init_logger2();
-  init_dispatch_events();
-  init_no_op_interaction_handler();
-  init_manager_deps();
-  init_manager_run();
-  init_manager_sweep();
-  init_naming();
-  init_types7();
-  init_manager_deps();
-  NULL_PROTOCOL_IDS = { recordId: null, sessionId: null };
-});
-
-// src/session/index.ts
-var init_session = __esm(() => {
-  init_manager2();
-  init_naming();
-  init_types7();
-});
-
-// src/runtime/middleware/cancellation.ts
-function cancellationMiddleware() {
-  return {
-    name: "cancellation",
-    async before(ctx) {
-      if (ctx.signal?.aborted) {
-        throw new NaxError("Agent call cancelled before start", "AGENT_CANCELLED", {
-          stage: ctx.stage ?? "run",
-          agentName: ctx.agentName
-        });
-      }
-    }
-  };
-}
-var init_cancellation = __esm(() => {
-  init_errors();
-});
-
-// src/runtime/middleware/logging.ts
-function attachLoggingSubscriber(bus, runId) {
-  const offDispatch = bus.onDispatch((event) => {
-    getSafeLogger()?.info("middleware", "Agent call complete", {
-      storyId: event.storyId,
-      runId,
-      agentName: event.agentName,
-      kind: event.kind,
-      stage: event.stage,
-      durationMs: event.durationMs
-    });
-  });
-  const offError = bus.onDispatchError((event) => {
-    getSafeLogger()?.warn("middleware", "Agent call failed", {
-      storyId: event.storyId,
-      runId,
-      agentName: event.agentName,
-      stage: event.stage,
-      durationMs: event.durationMs,
-      error: event.errorMessage
-    });
-  });
-  return () => {
-    offDispatch();
-    offError();
-  };
-}
-var init_logging2 = __esm(() => {
-  init_logger2();
-});
-
-// src/runtime/middleware/agent-stream-logging.ts
-function attachAgentStreamLogging(bus, runId) {
-  const activeCalls = new Map;
-  return bus.onAgentStream((event) => {
-    switch (event.kind) {
-      case "agent.call_started": {
-        const now = event.timestamp;
-        activeCalls.set(event.callId, {
-          callId: event.callId,
-          agentName: event.agentName,
-          storyId: event.storyId,
-          stage: event.stage,
-          startedAt: now,
-          lastActivityAt: now,
-          messageUpdates: 0,
-          thinkingUpdates: 0,
-          usageUpdates: 0
-        });
-        getSafeLogger()?.info("agent-stream", "Agent call started", {
-          storyId: event.storyId,
-          runId,
-          callId: event.callId,
-          agentName: event.agentName,
-          stage: event.stage,
-          model: event.model,
-          timeoutSeconds: event.timeoutSeconds
-        });
-        break;
-      }
-      case "agent.message_update": {
-        const state = activeCalls.get(event.callId);
-        if (state) {
-          state.messageUpdates++;
-          state.lastActivityAt = event.timestamp;
-        }
-        break;
-      }
-      case "agent.thinking_update": {
-        const state = activeCalls.get(event.callId);
-        if (state) {
-          state.thinkingUpdates++;
-          state.lastActivityAt = event.timestamp;
-        }
-        break;
-      }
-      case "agent.usage_update": {
-        const state = activeCalls.get(event.callId);
-        if (state) {
-          state.usageUpdates++;
-          state.lastActivityAt = event.timestamp;
-        }
-        break;
-      }
-      case "agent.process_update":
-        break;
-      case "agent.call_ended": {
-        const state = activeCalls.get(event.callId);
-        if (state) {
-          const idleMs = event.timestamp - state.lastActivityAt;
-          getSafeLogger()?.info("agent-stream", "Agent call ended", {
-            storyId: state.storyId,
-            runId,
-            callId: state.callId,
-            agentName: state.agentName,
-            stage: state.stage,
-            messageUpdates: state.messageUpdates,
-            thinkingUpdates: state.thinkingUpdates,
-            usageUpdates: state.usageUpdates,
-            lastActivityAt: state.lastActivityAt,
-            idleMs,
-            status: event.status
-          });
-          activeCalls.delete(event.callId);
-        }
-        break;
-      }
-    }
-  });
-}
-var init_agent_stream_logging = __esm(() => {
-  init_logger2();
-});
-
-// src/runtime/middleware/cost.ts
-function attachCostSubscriber(bus, aggregator, runId) {
-  const offDispatch = bus.onDispatch((event) => {
-    const tu = event.tokenUsage;
-    const exactCostUsd = event.exactCostUsd;
-    const estimatedCostUsd = event.estimatedCostUsd ?? exactCostUsd ?? 0;
-    if (!tu && exactCostUsd == null && estimatedCostUsd === 0)
-      return;
-    const costUsd = exactCostUsd ?? estimatedCostUsd;
-    const confidence = exactCostUsd != null ? "exact" : "estimated";
-    const costEvent = {
-      ts: event.timestamp,
-      runId,
-      agentName: event.agentName,
-      model: "unknown",
-      stage: event.stage,
-      storyId: event.storyId,
-      tokens: tu ? {
-        input: tu.inputTokens ?? 0,
-        output: tu.outputTokens ?? 0,
-        cacheRead: tu.cacheReadInputTokens,
-        cacheWrite: tu.cacheCreationInputTokens
-      } : { input: 0, output: 0 },
-      estimatedCostUsd,
-      exactCostUsd,
-      costUsd,
-      confidence,
-      durationMs: event.durationMs
-    };
-    aggregator.record(costEvent);
-  });
-  const offError = bus.onDispatchError((event) => {
-    const errorEvent = {
-      ts: event.timestamp,
-      runId,
-      agentName: event.agentName,
-      stage: event.stage,
-      storyId: event.storyId,
-      errorCode: event.errorCode,
-      durationMs: event.durationMs
-    };
-    aggregator.recordError(errorEvent);
-  });
-  const offCompleted = bus.onOperationCompleted((event) => {
-    const summary = {
-      runId,
-      operation: event.operation,
-      hopCount: event.hopCount,
-      fallbackTriggered: event.fallbackTriggered,
-      totalCostUsd: event.totalCostUsd,
-      totalElapsedMs: event.totalElapsedMs,
-      finalStatus: event.finalStatus
-    };
-    aggregator.recordOperationSummary(summary);
-  });
-  return () => {
-    offDispatch();
-    offError();
-    offCompleted();
-  };
-}
-
-// src/runtime/middleware/audit.ts
-function attachAuditSubscriber(bus, auditor, runId) {
-  const offDispatch = bus.onDispatch((event) => {
-    const entry = {
-      ts: event.timestamp,
-      runId,
-      agentName: event.agentName,
-      stage: event.stage,
-      storyId: event.storyId,
-      permissionProfile: event.resolvedPermissions.mode,
-      prompt: event.prompt,
-      response: event.response,
-      durationMs: event.durationMs,
-      callType: event.kind === "session-turn" ? "run" : "complete",
-      workdir: event.workdir,
-      projectDir: event.projectDir,
-      featureName: event.featureName,
-      sessionName: event.sessionName,
-      ...event.kind === "session-turn" && {
-        sessionId: event.protocolIds.sessionId ?? null,
-        recordId: event.protocolIds.recordId ?? null,
-        turn: event.turn
-      }
-    };
-    auditor.record(entry);
-  });
-  const offError = bus.onDispatchError((event) => {
-    const entry = {
-      ts: event.timestamp,
-      runId,
-      agentName: event.agentName,
-      stage: event.stage,
-      storyId: event.storyId,
-      errorCode: event.errorCode,
-      errorMessage: event.errorMessage,
-      durationMs: event.durationMs,
-      callType: event.origin === "completeAs" ? "complete" : "run",
-      permissionProfile: event.resolvedPermissions.mode,
-      prompt: event.prompt
-    };
-    auditor.recordError(entry);
-  });
-  return () => {
-    offDispatch();
-    offError();
-  };
-}
-
-// src/runtime/middleware/review-audit.ts
-function reviewerFromRole(role) {
-  if (role === "reviewer-semantic")
-    return "semantic";
-  if (role === "reviewer-adversarial")
-    return "adversarial";
-  return null;
-}
-function attachReviewAuditSubscriber(bus, auditor, runId) {
-  const offDispatch = bus.onDispatch((event) => {
-    if (event.kind !== "session-turn")
-      return;
-    const reviewer = reviewerFromRole(event.sessionRole);
-    if (!reviewer)
-      return;
-    auditor.recordDispatch({
-      runId,
-      reviewer,
-      sessionName: event.sessionName,
-      sessionId: event.protocolIds.sessionId ?? null,
-      recordId: event.protocolIds.recordId ?? null,
-      workdir: event.workdir,
-      projectDir: event.projectDir,
-      agentName: event.agentName,
-      storyId: event.storyId,
-      featureName: event.featureName
-    });
-  });
-  const offDecision = bus.onReviewDecision((event) => {
-    auditor.recordDecision({
-      runId: event.runId,
-      reviewer: event.reviewer,
-      sessionName: event.sessionName,
-      sessionId: event.sessionId,
-      recordId: event.recordId,
-      workdir: event.workdir,
-      projectDir: event.projectDir,
-      outputDir: event.outputDir,
-      agentName: event.agentName,
-      storyId: event.storyId,
-      featureName: event.featureName,
-      parsed: event.parsed,
-      looksLikeFail: event.looksLikeFail,
-      failOpen: event.failOpen,
-      passed: event.passed,
-      blockingThreshold: event.blockingThreshold,
-      result: event.result,
-      advisoryFindings: event.advisoryFindings
-    });
-  });
-  return () => {
-    offDispatch();
-    offDecision();
-  };
-}
-
-// src/runtime/middleware/idle-watchdog.ts
-function scheduleTickIfNeeded(tickRef, tick, intervalMs) {
-  if (tickRef.handle !== null)
-    return;
-  tickRef.handle = setTimeout(tick, intervalMs);
-}
-function handleObserveTimeout(state, idleDurationMs) {
-  if (state.warnedForCurrentIdlePeriod)
-    return;
-  state.warnedForCurrentIdlePeriod = true;
-  getSafeLogger()?.warn("idle-watchdog", "Idle timeout exceeded", {
-    storyId: state.storyId,
-    key: "idle_timeout_exceeded",
-    callId: state.callId,
-    mode: "observe",
-    idleDurationMs
-  });
-}
-async function handleCancelTimeout(state, controllerRegistry, maxRetryAttempts, activeStates) {
-  if (state.cancelAttempts >= maxRetryAttempts) {
-    getSafeLogger()?.error("idle-watchdog", "Max retry attempts exceeded", {
-      storyId: state.storyId,
-      key: "max_retry_attempts_exceeded",
-      callId: state.callId,
-      cancelAttempts: state.cancelAttempts
+    if (!allowed.includes(to)) {
+      throw new NaxError(`Invalid session transition: ${session.state} \u2192 ${to} (session ${id})`, "SESSION_INVALID_TRANSITION", { stage: "session", sessionId: id, from: session.state, to, allowed });
+    }
+    const now = _sessionManagerDeps.now();
+    const updated = {
+      ...session,
+      state: to,
+      lastActivityAt: now
+    };
+    if (options?.protocolIds) {
+      updated.protocolIds = options.protocolIds;
+    }
+    if (options?.completedStage) {
+      updated.completedStages = [...session.completedStages, options.completedStage];
+    }
+    this._sessions.set(id, updated);
+    this._persistDescriptor(updated);
+    getLogger().debug("session", "Session transitioned", {
+      storyId: session.storyId,
+      sessionId: id,
+      from: session.state,
+      to
     });
-    activeStates.delete(state.callId);
-    return;
+    return { ...updated };
   }
-  state.cancelAttempts++;
-  state.lastActivityAt = Date.now();
-  getSafeLogger()?.warn("idle-watchdog", "Canceling idle call", {
-    storyId: state.storyId,
-    key: "idle_timeout_exceeded",
-    callId: state.callId,
-    mode: "cancel",
-    action: "cancel"
-  });
-  const cancel = controllerRegistry.get(state.callId);
-  if (cancel)
-    await cancel().catch(() => {});
-}
-function handleWarnThenCancelTimeout(state, controllerRegistry, maxRetryAttempts, idleTimeoutMs, graceMs, activeStates) {
-  if (state.cancelAttempts >= maxRetryAttempts) {
-    getSafeLogger()?.error("idle-watchdog", "Max retry attempts exceeded", {
-      storyId: state.storyId,
-      key: "max_retry_attempts_exceeded",
-      callId: state.callId,
-      cancelAttempts: state.cancelAttempts
+  bindHandle(id, handle, protocolIds) {
+    const session = this._sessions.get(id);
+    if (!session) {
+      throw new NaxError(`Session "${id}" not found in registry`, "SESSION_NOT_FOUND", {
+        stage: "session",
+        sessionId: id
+      });
+    }
+    const updated = {
+      ...session,
+      handle,
+      protocolIds,
+      lastActivityAt: _sessionManagerDeps.now()
+    };
+    this._sessions.set(id, updated);
+    this._persistDescriptor(updated);
+    getLogger().debug("session", "Session handle bound", {
+      storyId: session.storyId,
+      sessionId: id,
+      handle
     });
-    activeStates.delete(state.callId);
-    return;
+    return { ...updated };
   }
-  getSafeLogger()?.warn("idle-watchdog", "Idle timeout exceeded, entering grace period", {
-    storyId: state.storyId,
-    key: "idle_timeout_exceeded",
-    callId: state.callId,
-    mode: "warn-then-cancel",
-    gracePeriodMs: graceMs
-  });
-  state.inGracePeriod = true;
-  state.graceTimer = setTimeout(async () => {
-    if (!activeStates.has(state.callId))
-      return;
-    state.inGracePeriod = false;
-    state.graceTimer = undefined;
-    if (Date.now() - state.lastActivityAt < idleTimeoutMs)
-      return;
-    state.cancelAttempts++;
-    state.lastActivityAt = Date.now();
-    const cancel = controllerRegistry.get(state.callId);
-    if (cancel)
-      await cancel().catch(() => {});
-  }, graceMs);
-}
-function resetActivity(state, newTimestamp) {
-  state.lastActivityAt = newTimestamp;
-  state.warnedForCurrentIdlePeriod = false;
-  if (state.inGracePeriod && state.graceTimer !== undefined) {
-    clearTimeout(state.graceTimer);
-    state.graceTimer = undefined;
-    state.inGracePeriod = false;
+  handoff(id, newAgent, reason) {
+    const session = this._sessions.get(id);
+    if (!session) {
+      throw new NaxError(`Session "${id}" not found in registry`, "SESSION_NOT_FOUND", {
+        stage: "session",
+        sessionId: id
+      });
+    }
+    const updated = {
+      ...session,
+      agent: newAgent,
+      lastActivityAt: _sessionManagerDeps.now()
+    };
+    this._sessions.set(id, updated);
+    this._persistDescriptor(updated);
+    getLogger().info("session", "Session handed off to fallback agent", {
+      storyId: session.storyId,
+      sessionId: id,
+      fromAgent: session.agent,
+      toAgent: newAgent,
+      ...reason && { reason }
+    });
+    return { ...updated };
   }
-}
-function attachAgentIdleWatchdog(agentStreamEvents, controllerRegistry, config2) {
-  const watchdogConfig = config2.agent?.idleWatchdog;
-  if (!watchdogConfig?.enabled || watchdogConfig.mode === "off" || watchdogConfig.mode === undefined) {
-    return agentStreamEvents.onAgentStream(() => {});
+  resume(storyId, role) {
+    const terminal = ["COMPLETED", "FAILED"];
+    for (const session of this._sessions.values()) {
+      if (session.storyId === storyId && session.role === role && !terminal.includes(session.state)) {
+        getLogger().debug("session", "Session resumed", {
+          storyId,
+          sessionId: session.id,
+          role,
+          state: session.state
+        });
+        return { ...session };
+      }
+    }
+    return null;
   }
-  const mode = watchdogConfig.mode;
-  const idleTimeoutMs = (watchdogConfig.idleTimeoutSeconds ?? 30) * 1000;
-  const graceMs = (watchdogConfig.cancelGraceSeconds ?? 5) * 1000;
-  const maxRetryAttempts = watchdogConfig.maxRetryAttempts ?? 3;
-  const activityKinds = new Set(watchdogConfig.activityKinds ?? ["message_update", "thinking_update", "usage_update"]);
-  const tickIntervalMs = Math.max(1, Math.ceil(idleTimeoutMs / 4));
-  const activeStates = new Map;
-  const tickRef = { handle: null };
-  function tick() {
-    tickRef.handle = null;
-    const now = Date.now();
-    for (const [, state] of activeStates) {
-      if (state.inGracePeriod)
+  closeStory(storyId) {
+    const terminal = ["COMPLETED", "FAILED"];
+    const closed = [];
+    const now = _sessionManagerDeps.now();
+    for (const [id, session] of this._sessions.entries()) {
+      if (session.storyId !== storyId)
         continue;
-      const idleDurationMs = now - state.lastActivityAt;
-      if (idleDurationMs < idleTimeoutMs)
+      if (terminal.includes(session.state))
         continue;
-      if (mode === "observe")
-        handleObserveTimeout(state, idleDurationMs);
-      else if (mode === "cancel")
-        handleCancelTimeout(state, controllerRegistry, maxRetryAttempts, activeStates);
-      else if (mode === "warn-then-cancel") {
-        handleWarnThenCancelTimeout(state, controllerRegistry, maxRetryAttempts, idleTimeoutMs, graceMs, activeStates);
+      const updated = { ...session, state: "COMPLETED", lastActivityAt: now };
+      this._sessions.set(id, updated);
+      this._persistDescriptor(updated);
+      closed.push({ ...updated });
+      getLogger().debug("session", "Session closed by closeStory", {
+        storyId,
+        sessionId: id,
+        priorState: session.state
+      });
+    }
+    return closed;
+  }
+  getForStory(storyId) {
+    return Array.from(this._sessions.values()).filter((s) => s.storyId === storyId).map((s) => ({ ...s }));
+  }
+  listActive() {
+    const terminal = ["COMPLETED", "FAILED"];
+    return Array.from(this._sessions.values()).filter((s) => !terminal.includes(s.state)).map((s) => ({ ...s }));
+  }
+  _findByName(name) {
+    for (const session of this._sessions.values()) {
+      if (session.handle === name)
+        return session;
+    }
+    return;
+  }
+  descriptor(name) {
+    const session = this._findByName(name);
+    return session ? { ...session } : null;
+  }
+  nameFor(req) {
+    return formatSessionName(req);
+  }
+  getLiveHandle(name) {
+    return this._liveHandles.get(name);
+  }
+  async openSession(name, opts) {
+    const liveHandle = this._liveHandles.get(name);
+    if (liveHandle && liveHandle.agentName === opts.agentName) {
+      const liveDesc = this._findByName(name);
+      if (!liveDesc || liveDesc.state !== "COMPLETED" && liveDesc.state !== "FAILED") {
+        return liveHandle;
       }
+      this._liveHandles.delete(name);
     }
-    if (activeStates.size > 0)
-      scheduleTickIfNeeded(tickRef, tick, tickIntervalMs);
+    const adapter = this._getAdapter(opts.agentName);
+    if (!adapter) {
+      throw new NaxError(`SessionManager.openSession: no adapter found for agent "${opts.agentName}"`, "ADAPTER_NOT_FOUND", { stage: "session", agentName: opts.agentName });
+    }
+    const resolvedPermissions = resolvePermissions(this._config, opts.pipelineStage);
+    const existingDescriptor = this._findByName(name);
+    const resume = existingDescriptor !== undefined;
+    const handle = await adapter.openSession(name, {
+      agentName: opts.agentName,
+      workdir: opts.workdir,
+      resolvedPermissions,
+      modelDef: opts.modelDef,
+      timeoutSeconds: opts.timeoutSeconds,
+      onPidSpawned: this._pidRegistry ? (pid) => this._pidRegistry?.register(pid) : undefined,
+      onPidExited: this._pidRegistry ? (pid) => this._pidRegistry?.unregister(pid) : undefined,
+      onSessionEstablished: opts.onSessionEstablished,
+      signal: opts.signal,
+      resume,
+      onActiveCall: this._buildOnActiveCall(name),
+      onStreamActivity: this._onStreamActivity
+    });
+    this._liveHandles.set(name, handle);
+    const protocolIds = handle.protocolIds ?? NULL_PROTOCOL_IDS;
+    if (!existingDescriptor) {
+      const created = this.create({
+        role: opts.role ?? "main",
+        agent: opts.agentName,
+        workdir: opts.workdir,
+        featureName: opts.featureName,
+        storyId: opts.storyId,
+        handle: name
+      });
+      this.transition(created.id, "RUNNING", { protocolIds });
+    } else if (existingDescriptor.state === "CREATED") {
+      this.transition(existingDescriptor.id, "RUNNING", { protocolIds });
+    } else if (existingDescriptor.state === "COMPLETED" || existingDescriptor.state === "FAILED") {
+      this._cancelledSessions.delete(name);
+      const updated = {
+        ...existingDescriptor,
+        state: "RUNNING",
+        protocolIds,
+        lastActivityAt: _sessionManagerDeps.now()
+      };
+      this._sessions.set(existingDescriptor.id, updated);
+      this._persistDescriptor(updated);
+    } else {
+      getLogger().warn("session", "openSession called on already-RUNNING session", {
+        storyId: opts.storyId,
+        sessionName: name
+      });
+    }
+    getLogger().debug("session", "Session opened via SessionManager", {
+      storyId: opts.storyId,
+      sessionName: name,
+      agentName: opts.agentName,
+      resume
+    });
+    return handle;
   }
-  const unsubscribe = agentStreamEvents.onAgentStream((event) => {
-    switch (event.kind) {
-      case "agent.call_started": {
-        const now = Date.now();
-        activeStates.set(event.callId, {
-          callId: event.callId,
-          agentName: event.agentName,
-          sessionName: event.sessionName,
-          storyId: event.storyId,
-          stage: event.stage,
-          pid: event.pid,
-          startedAt: now,
-          lastActivityAt: now,
-          messageUpdates: 0,
-          thinkingUpdates: 0,
-          usageUpdates: 0,
-          cancelAttempts: 0,
-          inGracePeriod: false,
-          warnedForCurrentIdlePeriod: false
-        });
-        getSafeLogger()?.debug("idle-watchdog", "Watchdog tracking call", {
-          storyId: event.storyId,
-          callId: event.callId,
-          mode,
-          idleTimeoutMs
+  async closeSession(handle) {
+    const desc = this._findByName(handle.id);
+    const adapter = this._getAdapter(handle.agentName);
+    this._liveHandles.delete(handle.id);
+    if (adapter) {
+      try {
+        await adapter.closeSession(handle);
+      } catch (err) {
+        getLogger().warn("session", "adapter.closeSession failed (swallowed)", {
+          storyId: desc?.storyId,
+          sessionName: handle.id,
+          error: err instanceof Error ? err.message : String(err)
         });
-        scheduleTickIfNeeded(tickRef, tick, tickIntervalMs);
-        break;
-      }
-      case "agent.message_update": {
-        const state = activeStates.get(event.callId);
-        if (state && activityKinds.has("message_update")) {
-          state.messageUpdates++;
-          resetActivity(state, event.timestamp);
-        }
-        break;
-      }
-      case "agent.thinking_update": {
-        const state = activeStates.get(event.callId);
-        if (state && activityKinds.has("thinking_update")) {
-          state.thinkingUpdates++;
-          resetActivity(state, event.timestamp);
-        }
-        break;
       }
-      case "agent.usage_update": {
-        const state = activeStates.get(event.callId);
-        if (state && activityKinds.has("usage_update")) {
-          state.usageUpdates++;
-          resetActivity(state, event.timestamp);
+    }
+    if (desc && desc.state === "RUNNING") {
+      this.transition(desc.id, "COMPLETED");
+    }
+    this._busySessions.delete(handle.id);
+    this._cancelledSessions.delete(handle.id);
+  }
+  async sendPrompt(handle, prompt, opts) {
+    if (this._cancelledSessions.has(handle.id)) {
+      throw new NaxError(`Session "${handle.id}" was cancelled \u2014 close it and open a new session to continue`, "SESSION_CANCELLED", { stage: "session", sessionName: handle.id });
+    }
+    if (this._busySessions.has(handle.id)) {
+      throw new NaxError(`Session "${handle.id}" is already processing a prompt (single-flight invariant)`, "SESSION_BUSY", { stage: "session", sessionName: handle.id });
+    }
+    const terminalDesc = this._findByName(handle.id);
+    if (terminalDesc && (terminalDesc.state === "COMPLETED" || terminalDesc.state === "FAILED")) {
+      throw new NaxError(`Session "${handle.id}" is in terminal state ${terminalDesc.state} \u2014 call openSession first to resume`, "SESSION_TERMINAL_STATE", { stage: "session", sessionName: handle.id, state: terminalDesc.state });
+    }
+    const adapter = this._getAdapter(handle.agentName);
+    if (!adapter) {
+      throw new NaxError(`SessionManager.sendPrompt: no adapter found for agent "${handle.agentName}"`, "ADAPTER_NOT_FOUND", { stage: "session", agentName: handle.agentName });
+    }
+    this._busySessions.add(handle.id);
+    try {
+      const result = await adapter.sendTurn(handle, prompt, {
+        interactionHandler: opts?.interactionHandler ?? NO_OP_INTERACTION_HANDLER,
+        signal: opts?.signal,
+        maxTurns: opts?.maxTurns
+      });
+      return { ...result, protocolIds: result.protocolIds ?? handle.protocolIds };
+    } catch (err) {
+      if (err instanceof SessionTurnError && err.cancelled) {
+        const wasWatchdog = (this._watchdogCancelledCallsBySession.get(handle.id)?.size ?? 0) > 0;
+        if (wasWatchdog) {
+          throw new SessionFailureError("idle watchdog cancelled session \u2014 no stream activity", {
+            category: "availability",
+            outcome: "fail-stale",
+            retriable: true,
+            message: "idle watchdog cancelled session \u2014 no stream activity"
+          });
         }
-        break;
       }
-      case "agent.process_update":
-        break;
-      case "agent.call_ended": {
-        const state = activeStates.get(event.callId);
-        if (state) {
-          if (state.graceTimer !== undefined)
-            clearTimeout(state.graceTimer);
-          activeStates.delete(event.callId);
-        }
-        if (activeStates.size === 0 && tickRef.handle !== null) {
-          clearTimeout(tickRef.handle);
-          tickRef.handle = null;
+      if (opts?.signal?.aborted || err instanceof Error && err.name === "AbortError") {
+        this._cancelledSessions.add(handle.id);
+        const desc = this._findByName(handle.id);
+        if (desc && desc.state === "RUNNING") {
+          this.transition(desc.id, "FAILED");
         }
-        break;
       }
+      throw err;
+    } finally {
+      this._clearWatchdogCancelledCalls(handle.id);
+      this._busySessions.delete(handle.id);
     }
-  });
-  return () => {
-    unsubscribe();
-    for (const state of activeStates.values()) {
-      if (state.graceTimer !== undefined)
-        clearTimeout(state.graceTimer);
+  }
+  async runInSession(idOrName, promptOrFnOrRunner, optsOrRequest, _legacyOptions) {
+    if (typeof promptOrFnOrRunner === "object" && promptOrFnOrRunner !== null && "run" in promptOrFnOrRunner && typeof promptOrFnOrRunner.run === "function") {
+      return this._runTrackedSession(idOrName, promptOrFnOrRunner, optsOrRequest);
     }
-    activeStates.clear();
-    if (tickRef.handle !== null) {
-      clearTimeout(tickRef.handle);
-      tickRef.handle = null;
+    const opts = optsOrRequest;
+    const handle = await this.openSession(idOrName, opts);
+    try {
+      if (typeof promptOrFnOrRunner === "string") {
+        return await this.sendPrompt(handle, promptOrFnOrRunner, {
+          interactionHandler: opts.interactionHandler,
+          signal: opts.signal,
+          maxTurns: opts.maxTurns
+        });
+      }
+      return await promptOrFnOrRunner(handle);
+    } finally {
+      await this.closeSession(handle);
     }
-  };
+  }
+  async _runTrackedSession(id, runner, request) {
+    return runTrackedSession({
+      sessions: this._sessions,
+      transition: (sid, to, opts) => this.transition(sid, to, opts),
+      bindHandle: (sid, handle, protocolIds) => this.bindHandle(sid, handle, protocolIds),
+      handoff: (sid, agent, reason) => this.handoff(sid, agent, reason),
+      persistDescriptor: (desc) => this._persistDescriptor(desc),
+      dispatchEvents: this._dispatchEvents,
+      defaultAgent: this._defaultAgent,
+      nameFor: (req) => this.nameFor(req)
+    }, id, runner, request);
+  }
+  sweepOrphans(ttlMs = DEFAULT_ORPHAN_TTL_MS) {
+    return sweepOrphansImpl(this._sessions, ttlMs);
+  }
 }
-var init_idle_watchdog = __esm(() => {
+var NULL_PROTOCOL_IDS;
+var init_manager2 = __esm(() => {
+  init_types();
+  init_errors();
   init_logger2();
+  init_dispatch_events();
+  init_no_op_interaction_handler();
+  init_manager_deps();
+  init_manager_run();
+  init_manager_sweep();
+  init_naming();
+  init_types7();
+  init_manager_deps();
+  NULL_PROTOCOL_IDS = { recordId: null, sessionId: null };
 });
 
-// src/runtime/middleware/index.ts
-var init_middleware = __esm(() => {
-  init_cancellation();
-  init_logging2();
-  init_agent_stream_logging();
-  init_idle_watchdog();
+// src/session/index.ts
+var init_session = __esm(() => {
+  init_manager2();
+  init_naming();
+  init_types7();
 });
 
 // src/runtime/session-run-hop.ts
@@ -40981,6 +41103,8 @@ __export(exports_runtime, {
   createNoOpPromptAuditor: () => createNoOpPromptAuditor,
   createNoOpCostAggregator: () => createNoOpCostAggregator,
   claimProjectIdentity: () => claimProjectIdentity,
+  attachAgentStreamLogging: () => attachAgentStreamLogging,
+  attachAgentIdleWatchdog: () => attachAgentIdleWatchdog,
   _reviewAuditDeps: () => _reviewAuditDeps,
   _promptAuditorDeps: () => _promptAuditorDeps,
   _costAggDeps: () => _costAggDeps,
@@ -41118,6 +41242,7 @@ var init_runtime = __esm(() => {
   init_paths2();
   init_dispatch_events();
   init_agent_stream_events();
+  init_middleware();
   init_factory();
   init_manager();
   init_config();
@@ -43304,12 +43429,6 @@ class PipelineEventEmitter {
 }
 var init_events = () => {};
 
-// src/pipeline/index.ts
-var init_pipeline = __esm(() => {
-  init_runner3();
-  init_events();
-});
-
 // src/utils/log-test-output.ts
 function logTestOutput(logger, stage, output, opts = {}) {
   if (!logger || !output)
@@ -43532,6 +43651,7 @@ var init_acceptance2 = __esm(() => {
       ];
       const allFailedACs = [];
       const allFindings = [];
+      const failedPackages = [];
       const allOutputParts = [];
       let anyError = false;
       let errorExitCode = 0;
@@ -43586,6 +43706,7 @@ ${stderr}`;
           errorExitCode = exitCode;
           allFailedACs.push("AC-ERROR");
           allFindings.push(acSentinelToFinding("AC-ERROR", output));
+          failedPackages.push({ testPath, packageDir, testFramework, commandOverride });
           continue;
         }
         for (const acId of actualFailures) {
@@ -43595,6 +43716,7 @@ ${stderr}`;
           }
         }
         if (actualFailures.length > 0) {
+          failedPackages.push({ testPath, packageDir, testFramework, commandOverride });
           logger.error("acceptance", "Acceptance tests failed", {
             storyId: ctx.story.id,
             failedACs: actualFailures,
@@ -43648,7 +43770,8 @@ ${stderr}`;
       ctx.acceptanceFailures = {
         failedACs: allFailedACs,
         findings: allFindings,
-        testOutput: combinedOutput
+        testOutput: combinedOutput,
+        failedPackages
       };
       logger.info("acceptance", "verdict", {
         storyId: ctx.story.id,
@@ -45306,6 +45429,9 @@ var init_dialogue = __esm(() => {
 function normalizeWs(s) {
   return s.replace(/\s+/g, " ").trim();
 }
+function stripMarkdownInline(s) {
+  return s.replace(/`/g, "").replace(/\*\*/g, "").replace(/\*/g, "");
+}
 function extractLocusKeywords(finding) {
   const keywords = [];
   if (finding.file) {
@@ -45335,8 +45461,8 @@ function validateAcQuote(finding, acceptanceCriteria) {
   if (typeof acIndex !== "number" || acIndex < 1 || acIndex > acceptanceCriteria.length) {
     return { valid: false, code: "ac_index_out_of_range" };
   }
-  const acText = normalizeWs(acceptanceCriteria[acIndex - 1]);
-  const normalizedQuote = normalizeWs(acQuote);
+  const acText = normalizeWs(stripMarkdownInline(acceptanceCriteria[acIndex - 1]));
+  const normalizedQuote = normalizeWs(stripMarkdownInline(acQuote));
   if (!acText.toLowerCase().includes(normalizedQuote.toLowerCase())) {
     return { valid: false, code: "ac_quote_not_substring" };
   }
@@ -50632,8 +50758,8 @@ Category: ${outcome.failureCategory ?? "unknown"}`,
         contextToolRunCounter: ctx.contextToolRunCounter,
         pipelineStage: "run"
       }, ctx.sessionId, baseRunOptions) : undefined;
-      const executeHop = hopCallback ? async (agentName, hopBundle, failure, resolvedRunOptions) => {
-        const hop = await hopCallback(agentName, hopBundle, failure, resolvedRunOptions);
+      const executeHop = hopCallback ? async (agentName, hopBundle, hopKind, resolvedRunOptions) => {
+        const hop = await hopCallback(agentName, hopBundle, hopKind, resolvedRunOptions);
         finalBundle = hop.bundle ?? finalBundle;
         finalPrompt = hop.prompt;
         return hop;
@@ -52322,7 +52448,8 @@ __export(exports_stages, {
   constitutionStage: () => constitutionStage,
   completionStage: () => completionStage,
   autofixStage: () => autofixStage,
-  acceptanceStage: () => acceptanceStage
+  acceptanceStage: () => acceptanceStage,
+  _executionDeps: () => _executionDeps
 });
 var defaultPipeline, postRunPipeline, preRunPipeline;
 var init_stages = __esm(() => {
@@ -52374,6 +52501,13 @@ var init_stages = __esm(() => {
   preRunPipeline = [acceptanceSetupStage];
 });
 
+// src/pipeline/index.ts
+var init_pipeline = __esm(() => {
+  init_runner3();
+  init_events();
+  init_stages();
+});
+
 // src/cli/prompts-shared.ts
 function buildFrontmatter(story, ctx, role) {
   const lines = [];
@@ -55183,7 +55317,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.65.5",
+    version: "0.66.0",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -55272,8 +55406,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("a329264b"))
-        return "a329264b";
+      if (/^[0-9a-f]{6,10}$/.test("fee8f22f"))
+        return "fee8f22f";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -55611,6 +55745,11 @@ var init_crash_recovery = __esm(() => {
   init_crash_heartbeat();
 });
 
+// src/acceptance/fix-generator.ts
+var init_fix_generator = __esm(() => {
+  init_test_path();
+});
+
 // src/acceptance/content-loader.ts
 async function loadAcceptanceTestContent(pathsOrFallback) {
   if (!pathsOrFallback)
@@ -55632,6 +55771,15 @@ async function loadAcceptanceTestContent(pathsOrFallback) {
   return [];
 }
 
+// src/acceptance/index.ts
+var init_acceptance4 = __esm(() => {
+  init_refinement();
+  init_generator();
+  init_fix_generator();
+  init_semantic_verdict();
+  init_test_path();
+});
+
 // src/acceptance/fix-diagnosis.ts
 function parseImportStatements(content) {
   const importRegex = /import\s+(?:{[^}]+}|[^;]+)\s+from\s+["']([^"']+)["']/g;
@@ -55876,6 +56024,7 @@ var exports_acceptance_loop = {};
 __export(exports_acceptance_loop, {
   runAcceptanceLoop: () => runAcceptanceLoop,
   runAcceptanceFixCycle: () => runAcceptanceFixCycle,
+  resolveAcceptanceFixTarget: () => resolveAcceptanceFixTarget,
   regenerateAcceptanceTest: () => regenerateAcceptanceTest,
   loadSpecContent: () => loadSpecContent,
   loadAcceptanceTestContent: () => loadAcceptanceTestContent2,
@@ -55886,6 +56035,15 @@ __export(exports_acceptance_loop, {
   _acceptanceLoopDeps: () => _acceptanceLoopDeps,
   _acceptanceFixCycleDeps: () => _acceptanceFixCycleDeps
 });
+function resolveAcceptanceFixTarget(acceptanceTestPaths, failedPackages, config2) {
+  const failedPackage = failedPackages?.[0];
+  const matchedEntry = failedPackage ? acceptanceTestPaths?.find((entry) => entry.testPath === failedPackage.testPath || entry.packageDir === failedPackage.packageDir) : undefined;
+  const selectedPathEntry = matchedEntry ?? acceptanceTestPaths?.[0];
+  return {
+    acceptanceTestPath: failedPackage?.testPath ?? selectedPathEntry?.testPath ?? "",
+    testCommand: failedPackage?.commandOverride ?? matchedEntry?.commandOverride ?? config2.acceptance.command ?? config2.quality?.commands?.test
+  };
+}
 function convertFailuresToFindings(failedACs, testOutput) {
   return failedACs.map((ac) => {
     if (ac === "AC-HOOK" || ac === "AC-ERROR") {
@@ -55956,7 +56114,12 @@ async function runAcceptanceTestsOnce(ctx, prd) {
   const failures = acceptanceContext.acceptanceFailures;
   if (!failures || failures.failedACs.length === 0)
     return { passed: true, failedACs: [], testOutput: "" };
-  return { passed: false, failedACs: failures.failedACs, testOutput: failures.testOutput };
+  return {
+    passed: false,
+    failedACs: failures.failedACs,
+    testOutput: failures.testOutput,
+    failedPackages: failures.failedPackages
+  };
 }
 async function runAcceptanceFixCycle(ctx, prd, initialFailures, diagnosis, acceptanceTestPath, testCommand) {
   const runtime = ctx.runtime;
@@ -56093,10 +56256,11 @@ async function runAcceptanceLoop(ctx) {
       logger?.error("acceptance", "Runtime not found for diagnosis", { storyId: firstStory?.id });
       return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty, failures.failedACs, acceptanceRetries);
     }
+    const { acceptanceTestPath, testCommand } = resolveAcceptanceFixTarget(ctx.acceptanceTestPaths, failures.failedPackages, ctx.config);
     const testEntries = ctx.acceptanceTestPaths ? await loadAcceptanceTestContent(ctx.acceptanceTestPaths.map((p) => p.testPath)) : [];
-    const testFileContent = testEntries[0]?.content ?? "";
-    const acceptanceTestPath = testEntries[0]?.testPath ?? ctx.acceptanceTestPaths?.[0]?.testPath ?? "";
-    const testCommand = ctx.config.quality?.commands?.test;
+    const effectiveAcceptanceTestPath = acceptanceTestPath || testEntries[0]?.testPath || "";
+    const selectedTestEntry = testEntries.find((entry) => entry.testPath === effectiveAcceptanceTestPath);
+    const testFileContent = selectedTestEntry?.content ?? testEntries[0]?.content ?? "";
     const strategy = ctx.config.acceptance.fix?.strategy ?? "diagnose-first";
     const diagnosis = await resolveAcceptanceDiagnosis({
       ctx,
@@ -56107,7 +56271,7 @@ async function runAcceptanceLoop(ctx) {
       diagnosisOpts: {
         testOutput: failures.testOutput,
         testFileContent,
-        acceptanceTestPath,
+        acceptanceTestPath: effectiveAcceptanceTestPath,
         workdir: ctx.workdir,
         storyId: firstStory?.id
       }
@@ -56118,7 +56282,7 @@ async function runAcceptanceLoop(ctx) {
       confidence: diagnosis.confidence,
       attempt: acceptanceRetries
     });
-    const cycleResult = await runAcceptanceFixCycle(ctx, prd, failures, diagnosis, acceptanceTestPath, testCommand);
+    const cycleResult = await runAcceptanceFixCycle(ctx, prd, failures, diagnosis, effectiveAcceptanceTestPath, testCommand);
     totalCost += cycleResult.costUsd ?? 0;
     const success2 = cycleResult.exitReason === "resolved" || cycleResult.finalFindings.length === 0;
     return buildResult(success2, prd, totalCost, iterations, storiesCompleted, prdDirty, success2 ? undefined : cycleResult.finalFindings.map((f) => f.message), acceptanceRetries + cycleResult.iterations.length);
@@ -56127,8 +56291,7 @@ async function runAcceptanceLoop(ctx) {
 }
 var _acceptanceLoopDeps, _acceptanceFixCycleDeps, MAX_STUB_REGENS = 2;
 var init_acceptance_loop = __esm(() => {
-  init_semantic_verdict();
-  init_test_path();
+  init_acceptance4();
   init_findings();
   init_hooks();
   init_logger2();
@@ -57932,9 +58095,9 @@ var _quoteIntegrityDeps, CONTEXT_LINES = 3;
 var init_quote_integrity = __esm(() => {
   init_logger2();
   _quoteIntegrityDeps = {
-    readFile: async (path20) => {
+    readFile: async (path21) => {
       try {
-        return await Bun.file(path20).text();
+        return await Bun.file(path21).text();
       } catch {
         return null;
       }
@@ -58199,7 +58362,7 @@ var exports_merge_conflict_rectify = {};
 __export(exports_merge_conflict_rectify, {
   rectifyConflictedStory: () => rectifyConflictedStory
 });
-import path20 from "path";
+import path21 from "path";
 async function closeStaleAcpSession(worktreePath, sessionName) {
   const logger = getSafeLogger();
   try {
@@ -58226,7 +58389,7 @@ async function rectifyConflictedStory(options) {
       await worktreeManager.remove(workdir, storyId);
     } catch {}
     await worktreeManager.create(workdir, storyId);
-    const worktreePath = path20.join(workdir, ".nax-wt", storyId);
+    const worktreePath = path21.join(workdir, ".nax-wt", storyId);
     const { formatSessionName: formatSessionName2 } = await Promise.resolve().then(() => (init_naming(), exports_naming));
     const staleSessionName = formatSessionName2({
       workdir: worktreePath,
@@ -58899,7 +59062,7 @@ __export(exports_parallel_batch, {
   runParallelBatch: () => runParallelBatch,
   _parallelBatchDeps: () => _parallelBatchDeps
 });
-import path21 from "path";
+import path22 from "path";
 async function runParallelBatch(options) {
   const { stories, ctx, prd } = options;
   const { workdir, config: config2, maxConcurrency, pipelineContext, eventEmitter, agentGetFn, hooks, pluginRegistry } = ctx;
@@ -58918,9 +59081,9 @@ async function runParallelBatch(options) {
       });
       throw error48;
     }
-    worktreePaths.set(story.id, path21.join(workdir, ".nax-wt", story.id));
+    worktreePaths.set(story.id, path22.join(workdir, ".nax-wt", story.id));
   }
-  const rootConfigPath = path21.join(workdir, ".nax", "config.json");
+  const rootConfigPath = path22.join(workdir, ".nax", "config.json");
   const profileOverride = config2.profile && config2.profile !== "default" ? { profile: config2.profile } : undefined;
   const storyEffectiveConfigs = new Map;
   await Promise.all(stories.filter((story) => story.workdir).map(async (story) => {
@@ -59779,7 +59942,7 @@ __export(exports_migrate, {
 });
 import { existsSync as existsSync35 } from "fs";
 import { mkdir as mkdir17, readdir as readdir6, rename as rename3 } from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 async function detectGeneratedContent(naxDir) {
   if (!existsSync35(naxDir))
     return [];
@@ -59792,17 +59955,17 @@ async function detectGeneratedContent(naxDir) {
   }
   for (const entry of entries) {
     if (GENERATED_NAMES.has(entry)) {
-      candidates.push({ name: entry, srcPath: path22.join(naxDir, entry) });
+      candidates.push({ name: entry, srcPath: path23.join(naxDir, entry) });
     }
   }
-  const featuresDir = path22.join(naxDir, "features");
+  const featuresDir = path23.join(naxDir, "features");
   if (existsSync35(featuresDir)) {
     let featureDirs = [];
     try {
       featureDirs = await readdir6(featuresDir);
     } catch {}
     for (const fid of featureDirs) {
-      const featureDir = path22.join(featuresDir, fid);
+      const featureDir = path23.join(featuresDir, fid);
       let subEntries = [];
       try {
         subEntries = await readdir6(featureDir);
@@ -59812,12 +59975,12 @@ async function detectGeneratedContent(naxDir) {
       for (const sub of subEntries) {
         if (GENERATED_FEATURE_SUBNAMES.has(sub)) {
           candidates.push({
-            name: path22.join("features", fid, sub),
-            srcPath: path22.join(featureDir, sub)
+            name: path23.join("features", fid, sub),
+            srcPath: path23.join(featureDir, sub)
           });
         }
         if (sub === "stories") {
-          const storiesDir = path22.join(featureDir, "stories");
+          const storiesDir = path23.join(featureDir, "stories");
           let storyDirs = [];
           try {
             storyDirs = await readdir6(storiesDir);
@@ -59825,7 +59988,7 @@ async function detectGeneratedContent(naxDir) {
             continue;
           }
           for (const sid of storyDirs) {
-            const storyDir = path22.join(storiesDir, sid);
+            const storyDir = path23.join(storiesDir, sid);
             let storyEntries = [];
             try {
               storyEntries = await readdir6(storyDir);
@@ -59835,8 +59998,8 @@ async function detectGeneratedContent(naxDir) {
             for (const se of storyEntries) {
               if (se.startsWith("context-manifest-") && se.endsWith(".json")) {
                 candidates.push({
-                  name: path22.join("features", fid, "stories", sid, se),
-                  srcPath: path22.join(storyDir, se)
+                  name: path23.join("features", fid, "stories", sid, se),
+                  srcPath: path23.join(storyDir, se)
                 });
               }
             }
@@ -59857,15 +60020,15 @@ async function migrateCommand(options) {
         name: options.reclaim
       });
     }
-    const src = path22.join(globalConfigDir(), options.reclaim);
+    const src = path23.join(globalConfigDir(), options.reclaim);
     if (!existsSync35(src)) {
       throw new NaxError(`Nothing to reclaim: ~/.nax/${options.reclaim} does not exist`, "MIGRATE_RECLAIM_NOT_FOUND", {
         stage: "migrate",
         name: options.reclaim
       });
     }
-    const archiveBase = path22.join(globalConfigDir(), "_archive");
-    const archiveDest = path22.join(archiveBase, `${options.reclaim}-${Date.now()}`);
+    const archiveBase = path23.join(globalConfigDir(), "_archive");
+    const archiveDest = path23.join(archiveBase, `${options.reclaim}-${Date.now()}`);
     await mkdir17(archiveBase, { recursive: true });
     await rename3(src, archiveDest);
     logger.info("migrate", `Reclaimed: archived to ${archiveDest}`, { storyId: "_migrate" });
@@ -59902,8 +60065,8 @@ async function migrateCommand(options) {
     logger.info("migrate", `Merged: identity for "${options.merge}" updated`, { storyId: "_migrate" });
     return;
   }
-  const naxDir = path22.join(options.workdir, ".nax");
-  const configPath = path22.join(naxDir, "config.json");
+  const naxDir = path23.join(options.workdir, ".nax");
+  const configPath = path23.join(naxDir, "config.json");
   if (!existsSync35(configPath)) {
     throw new NaxError("No .nax/config.json found \u2014 run nax init first", "MIGRATE_NO_CONFIG", {
       stage: "migrate",
@@ -59919,7 +60082,7 @@ async function migrateCommand(options) {
       cause: e
     });
   }
-  const projectKey = config2.name?.trim() || path22.basename(options.workdir);
+  const projectKey = config2.name?.trim() || path23.basename(options.workdir);
   const destBase = projectOutputDir(projectKey, config2.outputDir);
   const candidates = await detectGeneratedContent(naxDir);
   if (candidates.length === 0) {
@@ -59928,7 +60091,7 @@ async function migrateCommand(options) {
   }
   if (options.dryRun) {
     for (const c of candidates) {
-      logger.info("migrate", `[dry-run] Would move: ${c.srcPath} -> ${path22.join(destBase, c.name)}`, {
+      logger.info("migrate", `[dry-run] Would move: ${c.srcPath} -> ${path23.join(destBase, c.name)}`, {
         storyId: "_migrate"
       });
     }
@@ -59937,8 +60100,8 @@ async function migrateCommand(options) {
   await mkdir17(destBase, { recursive: true });
   let moved = 0;
   for (const candidate of candidates) {
-    const dest = path22.join(destBase, candidate.name);
-    await mkdir17(path22.dirname(dest), { recursive: true });
+    const dest = path23.join(destBase, candidate.name);
+    await mkdir17(path23.dirname(dest), { recursive: true });
     if (existsSync35(dest)) {
       throw new NaxError(`Migration conflict: destination already exists.
   Source:      ${candidate.srcPath}
@@ -59968,7 +60131,7 @@ async function migrateCommand(options) {
     moved++;
     logger.info("migrate", `Moved: ${candidate.name}`, { storyId: "_migrate" });
   }
-  await Bun.write(path22.join(destBase, ".migrated-from"), JSON.stringify({ from: options.workdir, migratedAt: new Date().toISOString() }, null, 2));
+  await Bun.write(path23.join(destBase, ".migrated-from"), JSON.stringify({ from: options.workdir, migratedAt: new Date().toISOString() }, null, 2));
   logger.info("migrate", `Migration complete: ${moved} entries moved`, {
     storyId: "_migrate",
     destBase
@@ -60085,7 +60248,7 @@ __export(exports_precheck_runner, {
   runPrecheckValidation: () => runPrecheckValidation
 });
 import { mkdirSync as mkdirSync6 } from "fs";
-import path23 from "path";
+import path24 from "path";
 async function runPrecheckValidation(ctx) {
   const logger = getSafeLogger();
   if (process.env.NAX_PRECHECK !== "1") {
@@ -60100,7 +60263,7 @@ async function runPrecheckValidation(ctx) {
     silent: true
   });
   if (ctx.logFilePath) {
-    mkdirSync6(path23.dirname(ctx.logFilePath), { recursive: true });
+    mkdirSync6(path24.dirname(ctx.logFilePath), { recursive: true });
     const precheckLog = {
       type: "precheck",
       timestamp: new Date().toISOString(),
@@ -60401,7 +60564,7 @@ __export(exports_run_setup, {
   setupRun: () => setupRun,
   _runSetupDeps: () => _runSetupDeps
 });
-import path24 from "path";
+import path25 from "path";
 function warnFallbackMisconfiguration(config2, agentGetFn, logger) {
   if (!agentGetFn)
     return;
@@ -60488,7 +60651,7 @@ async function setupRun(options) {
   statusWriter.setPrd(prd);
   {
     const { detectGeneratedContent: detectGeneratedContent2, migrateCommand: migrateCommand2 } = await Promise.resolve().then(() => (init_migrate(), exports_migrate));
-    const naxDir = path24.join(workdir, ".nax");
+    const naxDir = path25.join(workdir, ".nax");
     const candidates = await detectGeneratedContent2(naxDir).catch(() => []);
     if (candidates.length > 0) {
       logger?.info("setup", "Found generated content under .nax/ \u2014 migrating to output dir", {
@@ -60515,7 +60678,7 @@ async function setupRun(options) {
         remoteUrl = new TextDecoder().decode(gitResult.stdout).trim() || null;
       }
     } catch {}
-    const projectKey = config2.name?.trim() || path24.basename(workdir);
+    const projectKey = config2.name?.trim() || path25.basename(workdir);
     await claimProjectIdentity2(projectKey, workdir, remoteUrl).catch((err) => {
       if (err instanceof NaxError && err.code === "RUN_NAME_COLLISION") {
         throw err;
@@ -60570,8 +60733,8 @@ async function setupRun(options) {
       explicit: Object.fromEntries(explicitFields.map((f) => [f, existingProjectConfig[f]])),
       detected: Object.fromEntries(autodetectedFields.map((f) => [f, detectedProfile[f]]))
     });
-    const globalPluginsDir = path24.join(globalConfigDir(), "plugins");
-    const projectPluginsDir = path24.join(workdir, ".nax", "plugins");
+    const globalPluginsDir = path25.join(globalConfigDir(), "plugins");
+    const projectPluginsDir = path25.join(workdir, ".nax", "plugins");
     const configPlugins = config2.plugins || [];
     const resolvedPatterns = await resolveTestFilePatterns(config2, workdir);
     const isTestFileFn = (filename) => resolvedPatterns.regex.some((re) => re.test(filename));
@@ -62062,11 +62225,11 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
         fiber = fiber.next, id--;
       return fiber;
     }
-    function copyWithSetImpl(obj, path25, index, value) {
-      if (index >= path25.length)
+    function copyWithSetImpl(obj, path26, index, value) {
+      if (index >= path26.length)
         return value;
-      var key = path25[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-      updated[key] = copyWithSetImpl(obj[key], path25, index + 1, value);
+      var key = path26[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+      updated[key] = copyWithSetImpl(obj[key], path26, index + 1, value);
       return updated;
     }
     function copyWithRename(obj, oldPath, newPath) {
@@ -62086,11 +62249,11 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
       index + 1 === oldPath.length ? (updated[newPath[index]] = updated[oldKey], isArrayImpl(updated) ? updated.splice(oldKey, 1) : delete updated[oldKey]) : updated[oldKey] = copyWithRenameImpl(obj[oldKey], oldPath, newPath, index + 1);
       return updated;
     }
-    function copyWithDeleteImpl(obj, path25, index) {
-      var key = path25[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-      if (index + 1 === path25.length)
+    function copyWithDeleteImpl(obj, path26, index) {
+      var key = path26[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+      if (index + 1 === path26.length)
         return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
-      updated[key] = copyWithDeleteImpl(obj[key], path25, index + 1);
+      updated[key] = copyWithDeleteImpl(obj[key], path26, index + 1);
       return updated;
     }
     function shouldSuspendImpl() {
@@ -72113,29 +72276,29 @@ Check the top-level render call using <` + componentName2 + ">.");
     var didWarnAboutNestedUpdates = false;
     var didWarnAboutFindNodeInStrictMode = {};
     var overrideHookState = null, overrideHookStateDeletePath = null, overrideHookStateRenamePath = null, overrideProps = null, overridePropsDeletePath = null, overridePropsRenamePath = null, scheduleUpdate = null, scheduleRetry = null, setErrorHandler = null, setSuspenseHandler = null;
-    overrideHookState = function(fiber, id, path25, value) {
+    overrideHookState = function(fiber, id, path26, value) {
       id = findHook(fiber, id);
-      id !== null && (path25 = copyWithSetImpl(id.memoizedState, path25, 0, value), id.memoizedState = path25, id.baseState = path25, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path25 = enqueueConcurrentRenderForLane(fiber, 2), path25 !== null && scheduleUpdateOnFiber(path25, fiber, 2));
+      id !== null && (path26 = copyWithSetImpl(id.memoizedState, path26, 0, value), id.memoizedState = path26, id.baseState = path26, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path26 = enqueueConcurrentRenderForLane(fiber, 2), path26 !== null && scheduleUpdateOnFiber(path26, fiber, 2));
     };
-    overrideHookStateDeletePath = function(fiber, id, path25) {
+    overrideHookStateDeletePath = function(fiber, id, path26) {
       id = findHook(fiber, id);
-      id !== null && (path25 = copyWithDeleteImpl(id.memoizedState, path25, 0), id.memoizedState = path25, id.baseState = path25, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path25 = enqueueConcurrentRenderForLane(fiber, 2), path25 !== null && scheduleUpdateOnFiber(path25, fiber, 2));
+      id !== null && (path26 = copyWithDeleteImpl(id.memoizedState, path26, 0), id.memoizedState = path26, id.baseState = path26, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path26 = enqueueConcurrentRenderForLane(fiber, 2), path26 !== null && scheduleUpdateOnFiber(path26, fiber, 2));
     };
     overrideHookStateRenamePath = function(fiber, id, oldPath, newPath) {
       id = findHook(fiber, id);
       id !== null && (oldPath = copyWithRename(id.memoizedState, oldPath, newPath), id.memoizedState = oldPath, id.baseState = oldPath, fiber.memoizedProps = assign2({}, fiber.memoizedProps), oldPath = enqueueConcurrentRenderForLane(fiber, 2), oldPath !== null && scheduleUpdateOnFiber(oldPath, fiber, 2));
     };
-    overrideProps = function(fiber, path25, value) {
-      fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path25, 0, value);
+    overrideProps = function(fiber, path26, value) {
+      fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path26, 0, value);
       fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-      path25 = enqueueConcurrentRenderForLane(fiber, 2);
-      path25 !== null && scheduleUpdateOnFiber(path25, fiber, 2);
+      path26 = enqueueConcurrentRenderForLane(fiber, 2);
+      path26 !== null && scheduleUpdateOnFiber(path26, fiber, 2);
     };
-    overridePropsDeletePath = function(fiber, path25) {
-      fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path25, 0);
+    overridePropsDeletePath = function(fiber, path26) {
+      fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path26, 0);
       fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-      path25 = enqueueConcurrentRenderForLane(fiber, 2);
-      path25 !== null && scheduleUpdateOnFiber(path25, fiber, 2);
+      path26 = enqueueConcurrentRenderForLane(fiber, 2);
+      path26 !== null && scheduleUpdateOnFiber(path26, fiber, 2);
     };
     overridePropsRenamePath = function(fiber, oldPath, newPath) {
       fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
@@ -76190,8 +76353,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return false;
         }
-        function utils_getInObject(object2, path25) {
-          return path25.reduce(function(reduced, attr) {
+        function utils_getInObject(object2, path26) {
+          return path26.reduce(function(reduced, attr) {
             if (reduced) {
               if (utils_hasOwnProperty.call(reduced, attr)) {
                 return reduced[attr];
@@ -76203,11 +76366,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             return null;
           }, object2);
         }
-        function deletePathInObject(object2, path25) {
-          var length = path25.length;
-          var last2 = path25[length - 1];
+        function deletePathInObject(object2, path26) {
+          var length = path26.length;
+          var last2 = path26[length - 1];
           if (object2 != null) {
-            var parent = utils_getInObject(object2, path25.slice(0, length - 1));
+            var parent = utils_getInObject(object2, path26.slice(0, length - 1));
             if (parent) {
               if (src_isArray(parent)) {
                 parent.splice(last2, 1);
@@ -76233,11 +76396,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             }
           }
         }
-        function utils_setInObject(object2, path25, value) {
-          var length = path25.length;
-          var last2 = path25[length - 1];
+        function utils_setInObject(object2, path26, value) {
+          var length = path26.length;
+          var last2 = path26[length - 1];
           if (object2 != null) {
-            var parent = utils_getInObject(object2, path25.slice(0, length - 1));
+            var parent = utils_getInObject(object2, path26.slice(0, length - 1));
             if (parent) {
               parent[last2] = value;
             }
@@ -76768,8 +76931,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           unserializable: Symbol("unserializable")
         };
         var LEVEL_THRESHOLD = 2;
-        function createDehydrated(type, inspectable, data, cleaned, path25) {
-          cleaned.push(path25);
+        function createDehydrated(type, inspectable, data, cleaned, path26) {
+          cleaned.push(path26);
           var dehydrated = {
             inspectable,
             type,
@@ -76787,13 +76950,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return dehydrated;
         }
-        function dehydrate(data, cleaned, unserializable, path25, isPathAllowed) {
+        function dehydrate(data, cleaned, unserializable, path26, isPathAllowed) {
           var level = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
           var type = getDataType(data);
           var isPathAllowedCheck;
           switch (type) {
             case "html_element":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -76802,7 +76965,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "function":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -76811,14 +76974,14 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "string":
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (isPathAllowedCheck) {
                 return data;
               } else {
                 return data.length <= 500 ? data : data.slice(0, 500) + "...";
               }
             case "bigint":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -76827,7 +76990,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "symbol":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -76836,9 +76999,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "react_element": {
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                cleaned.push(path25);
+                cleaned.push(path26);
                 return {
                   inspectable: true,
                   preview_short: formatDataForPreview(data, false),
@@ -76855,19 +77018,19 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 preview_long: formatDataForPreview(data, true),
                 name: getDisplayNameForReactElement(data) || "Unknown"
               };
-              unserializableValue.key = dehydrate(data.key, cleaned, unserializable, path25.concat(["key"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              unserializableValue.key = dehydrate(data.key, cleaned, unserializable, path26.concat(["key"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               if (data.$$typeof === REACT_LEGACY_ELEMENT_TYPE) {
-                unserializableValue.ref = dehydrate(data.ref, cleaned, unserializable, path25.concat(["ref"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                unserializableValue.ref = dehydrate(data.ref, cleaned, unserializable, path26.concat(["ref"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               }
-              unserializableValue.props = dehydrate(data.props, cleaned, unserializable, path25.concat(["props"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-              unserializable.push(path25);
+              unserializableValue.props = dehydrate(data.props, cleaned, unserializable, path26.concat(["props"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              unserializable.push(path26);
               return unserializableValue;
             }
             case "react_lazy": {
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               var payload = data._payload;
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                cleaned.push(path25);
+                cleaned.push(path26);
                 var inspectable = payload !== null && hydration_typeof(payload) === "object" && (payload._status === 1 || payload._status === 2 || payload.status === "fulfilled" || payload.status === "rejected");
                 return {
                   inspectable,
@@ -76884,13 +77047,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 preview_long: formatDataForPreview(data, true),
                 name: "lazy()"
               };
-              _unserializableValue._payload = dehydrate(payload, cleaned, unserializable, path25.concat(["_payload"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-              unserializable.push(path25);
+              _unserializableValue._payload = dehydrate(payload, cleaned, unserializable, path26.concat(["_payload"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              unserializable.push(path26);
               return _unserializableValue;
             }
             case "array_buffer":
             case "data_view":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -76900,21 +77063,21 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "array":
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path25);
+                return createDehydrated(type, true, data, cleaned, path26);
               }
               var arr = [];
               for (var i = 0;i < data.length; i++) {
-                arr[i] = dehydrateKey(data, i, cleaned, unserializable, path25.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                arr[i] = dehydrateKey(data, i, cleaned, unserializable, path26.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               }
               return arr;
             case "html_all_collection":
             case "typed_array":
             case "iterator":
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path25);
+                return createDehydrated(type, true, data, cleaned, path26);
               } else {
                 var _unserializableValue2 = {
                   unserializable: true,
@@ -76926,13 +77089,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                   name: typeof data.constructor !== "function" || typeof data.constructor.name !== "string" || data.constructor.name === "Object" ? "" : data.constructor.name
                 };
                 Array.from(data).forEach(function(item, i2) {
-                  return _unserializableValue2[i2] = dehydrate(item, cleaned, unserializable, path25.concat([i2]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  return _unserializableValue2[i2] = dehydrate(item, cleaned, unserializable, path26.concat([i2]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
                 });
-                unserializable.push(path25);
+                unserializable.push(path26);
                 return _unserializableValue2;
               }
             case "opaque_iterator":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -76941,7 +77104,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "date":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -76950,7 +77113,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "regexp":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -76959,9 +77122,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "thenable":
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                cleaned.push(path25);
+                cleaned.push(path26);
                 return {
                   inspectable: data.status === "fulfilled" || data.status === "rejected",
                   preview_short: formatDataForPreview(data, false),
@@ -76982,8 +77145,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                     preview_long: formatDataForPreview(data, true),
                     name: "fulfilled Thenable"
                   };
-                  _unserializableValue3.value = dehydrate(data.value, cleaned, unserializable, path25.concat(["value"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-                  unserializable.push(path25);
+                  _unserializableValue3.value = dehydrate(data.value, cleaned, unserializable, path26.concat(["value"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  unserializable.push(path26);
                   return _unserializableValue3;
                 }
                 case "rejected": {
@@ -76994,12 +77157,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                     preview_long: formatDataForPreview(data, true),
                     name: "rejected Thenable"
                   };
-                  _unserializableValue4.reason = dehydrate(data.reason, cleaned, unserializable, path25.concat(["reason"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-                  unserializable.push(path25);
+                  _unserializableValue4.reason = dehydrate(data.reason, cleaned, unserializable, path26.concat(["reason"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  unserializable.push(path26);
                   return _unserializableValue4;
                 }
                 default:
-                  cleaned.push(path25);
+                  cleaned.push(path26);
                   return {
                     inspectable: false,
                     preview_short: formatDataForPreview(data, false),
@@ -77009,21 +77172,21 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                   };
               }
             case "object":
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path25);
+                return createDehydrated(type, true, data, cleaned, path26);
               } else {
                 var object2 = {};
                 getAllEnumerableKeys(data).forEach(function(key) {
                   var name = key.toString();
-                  object2[name] = dehydrateKey(data, key, cleaned, unserializable, path25.concat([name]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  object2[name] = dehydrateKey(data, key, cleaned, unserializable, path26.concat([name]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
                 });
                 return object2;
               }
             case "class_instance": {
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path25);
+                return createDehydrated(type, true, data, cleaned, path26);
               }
               var value = {
                 unserializable: true,
@@ -77035,15 +77198,15 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               };
               getAllEnumerableKeys(data).forEach(function(key) {
                 var keyAsString = key.toString();
-                value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path25.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path26.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               });
-              unserializable.push(path25);
+              unserializable.push(path26);
               return value;
             }
             case "error": {
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path25);
+                return createDehydrated(type, true, data, cleaned, path26);
               }
               var _value = {
                 unserializable: true,
@@ -77053,22 +77216,22 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 preview_long: formatDataForPreview(data, true),
                 name: data.name
               };
-              _value.message = dehydrate(data.message, cleaned, unserializable, path25.concat(["message"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-              _value.stack = dehydrate(data.stack, cleaned, unserializable, path25.concat(["stack"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              _value.message = dehydrate(data.message, cleaned, unserializable, path26.concat(["message"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              _value.stack = dehydrate(data.stack, cleaned, unserializable, path26.concat(["stack"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               if ("cause" in data) {
-                _value.cause = dehydrate(data.cause, cleaned, unserializable, path25.concat(["cause"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                _value.cause = dehydrate(data.cause, cleaned, unserializable, path26.concat(["cause"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               }
               getAllEnumerableKeys(data).forEach(function(key) {
                 var keyAsString = key.toString();
-                _value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path25.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                _value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path26.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               });
-              unserializable.push(path25);
+              unserializable.push(path26);
               return _value;
             }
             case "infinity":
             case "nan":
             case "undefined":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 type
               };
@@ -77076,10 +77239,10 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               return data;
           }
         }
-        function dehydrateKey(parent, key, cleaned, unserializable, path25, isPathAllowed) {
+        function dehydrateKey(parent, key, cleaned, unserializable, path26, isPathAllowed) {
           var level = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
           try {
-            return dehydrate(parent[key], cleaned, unserializable, path25, isPathAllowed, level);
+            return dehydrate(parent[key], cleaned, unserializable, path26, isPathAllowed, level);
           } catch (error48) {
             var preview = "";
             if (hydration_typeof(error48) === "object" && error48 !== null && typeof error48.stack === "string") {
@@ -77087,7 +77250,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             } else if (typeof error48 === "string") {
               preview = error48;
             }
-            cleaned.push(path25);
+            cleaned.push(path26);
             return {
               inspectable: false,
               preview_short: "[Exception]",
@@ -77097,8 +77260,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             };
           }
         }
-        function fillInPath(object2, data, path25, value) {
-          var target = getInObject(object2, path25);
+        function fillInPath(object2, data, path26, value) {
+          var target = getInObject(object2, path26);
           if (target != null) {
             if (!target[meta3.unserializable]) {
               delete target[meta3.inspectable];
@@ -77113,9 +77276,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           if (value !== null && data.unserializable.length > 0) {
             var unserializablePath = data.unserializable[0];
-            var isMatch2 = unserializablePath.length === path25.length;
-            for (var i = 0;i < path25.length; i++) {
-              if (path25[i] !== unserializablePath[i]) {
+            var isMatch2 = unserializablePath.length === path26.length;
+            for (var i = 0;i < path26.length; i++) {
+              if (path26[i] !== unserializablePath[i]) {
                 isMatch2 = false;
                 break;
               }
@@ -77124,13 +77287,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               upgradeUnserializable(value, value);
             }
           }
-          setInObject(object2, path25, value);
+          setInObject(object2, path26, value);
         }
         function hydrate(object2, cleaned, unserializable) {
-          cleaned.forEach(function(path25) {
-            var length = path25.length;
-            var last2 = path25[length - 1];
-            var parent = getInObject(object2, path25.slice(0, length - 1));
+          cleaned.forEach(function(path26) {
+            var length = path26.length;
+            var last2 = path26[length - 1];
+            var parent = getInObject(object2, path26.slice(0, length - 1));
             if (!parent || !parent.hasOwnProperty(last2)) {
               return;
             }
@@ -77156,10 +77319,10 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               parent[last2] = replaced;
             }
           });
-          unserializable.forEach(function(path25) {
-            var length = path25.length;
-            var last2 = path25[length - 1];
-            var parent = getInObject(object2, path25.slice(0, length - 1));
+          unserializable.forEach(function(path26) {
+            var length = path26.length;
+            var last2 = path26[length - 1];
+            var parent = getInObject(object2, path26.slice(0, length - 1));
             if (!parent || !parent.hasOwnProperty(last2)) {
               return;
             }
@@ -77280,11 +77443,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           return gte2(version2, FIRST_DEVTOOLS_BACKEND_LOCKSTEP_VER);
         }
         function cleanForBridge(data, isPathAllowed) {
-          var path25 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+          var path26 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
           if (data !== null) {
             var cleanedPaths = [];
             var unserializablePaths = [];
-            var cleanedData = dehydrate(data, cleanedPaths, unserializablePaths, path25, isPathAllowed);
+            var cleanedData = dehydrate(data, cleanedPaths, unserializablePaths, path26, isPathAllowed);
             return {
               data: cleanedData,
               cleaned: cleanedPaths,
@@ -77294,18 +77457,18 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             return null;
           }
         }
-        function copyWithDelete(obj, path25) {
+        function copyWithDelete(obj, path26) {
           var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-          var key = path25[index];
+          var key = path26[index];
           var updated = shared_isArray(obj) ? obj.slice() : utils_objectSpread({}, obj);
-          if (index + 1 === path25.length) {
+          if (index + 1 === path26.length) {
             if (shared_isArray(updated)) {
               updated.splice(key, 1);
             } else {
               delete updated[key];
             }
           } else {
-            updated[key] = copyWithDelete(obj[key], path25, index + 1);
+            updated[key] = copyWithDelete(obj[key], path26, index + 1);
           }
           return updated;
         }
@@ -77326,14 +77489,14 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return updated;
         }
-        function copyWithSet(obj, path25, value) {
+        function copyWithSet(obj, path26, value) {
           var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-          if (index >= path25.length) {
+          if (index >= path26.length) {
             return value;
           }
-          var key = path25[index];
+          var key = path26[index];
           var updated = shared_isArray(obj) ? obj.slice() : utils_objectSpread({}, obj);
-          updated[key] = copyWithSet(obj[key], path25, value, index + 1);
+          updated[key] = copyWithSet(obj[key], path26, value, index + 1);
           return updated;
         }
         function getEffectDurations(root) {
@@ -78661,12 +78824,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             bridge_defineProperty(_this, "overrideValueAtPath", function(_ref) {
-              var { id, path: path25, rendererID, type, value } = _ref;
+              var { id, path: path26, rendererID, type, value } = _ref;
               switch (type) {
                 case "context":
                   _this.send("overrideContext", {
                     id,
-                    path: path25,
+                    path: path26,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -78675,7 +78838,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 case "hooks":
                   _this.send("overrideHookState", {
                     id,
-                    path: path25,
+                    path: path26,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -78684,7 +78847,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 case "props":
                   _this.send("overrideProps", {
                     id,
-                    path: path25,
+                    path: path26,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -78693,7 +78856,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 case "state":
                   _this.send("overrideState", {
                     id,
-                    path: path25,
+                    path: path26,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -79027,12 +79190,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "copyElementPath", function(_ref5) {
-              var { id, path: path25, rendererID } = _ref5;
+              var { id, path: path26, rendererID } = _ref5;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                var value = renderer.getSerializedElementValueByPath(id, path25);
+                var value = renderer.getSerializedElementValueByPath(id, path26);
                 if (value != null) {
                   _this._bridge.send("saveToClipboard", value);
                 } else {
@@ -79041,12 +79204,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "deletePath", function(_ref6) {
-              var { hookID, id, path: path25, rendererID, type } = _ref6;
+              var { hookID, id, path: path26, rendererID, type } = _ref6;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                renderer.deletePath(type, id, hookID, path25);
+                renderer.deletePath(type, id, hookID, path26);
               }
             });
             agent_defineProperty(_this, "getBackendVersion", function() {
@@ -79083,12 +79246,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "inspectElement", function(_ref9) {
-              var { forceFullData, id, path: path25, rendererID, requestID } = _ref9;
+              var { forceFullData, id, path: path26, rendererID, requestID } = _ref9;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                _this._bridge.send("inspectedElement", renderer.inspectElement(requestID, id, path25, forceFullData));
+                _this._bridge.send("inspectedElement", renderer.inspectElement(requestID, id, path26, forceFullData));
                 if (_this._persistedSelectionMatch === null || _this._persistedSelectionMatch.id !== id) {
                   _this._persistedSelection = null;
                   _this._persistedSelectionMatch = null;
@@ -79122,15 +79285,15 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
               for (var rendererID in _this._rendererInterfaces) {
                 var renderer = _this._rendererInterfaces[rendererID];
-                var path25 = null;
+                var path26 = null;
                 if (suspendedByPathIndex !== null && rendererPath !== null) {
                   var suspendedByPathRendererIndex = suspendedByPathIndex - suspendedByOffset;
                   var rendererHasRequestedSuspendedByPath = renderer.getElementAttributeByPath(id, ["suspendedBy", suspendedByPathRendererIndex]) !== undefined;
                   if (rendererHasRequestedSuspendedByPath) {
-                    path25 = ["suspendedBy", suspendedByPathRendererIndex].concat(rendererPath);
+                    path26 = ["suspendedBy", suspendedByPathRendererIndex].concat(rendererPath);
                   }
                 }
-                var inspectedRootsPayload = renderer.inspectElement(requestID, id, path25, forceFullData);
+                var inspectedRootsPayload = renderer.inspectElement(requestID, id, path26, forceFullData);
                 switch (inspectedRootsPayload.type) {
                   case "hydrated-path":
                     inspectedRootsPayload.path[1] += suspendedByOffset;
@@ -79224,20 +79387,20 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideValueAtPath", function(_ref15) {
-              var { hookID, id, path: path25, rendererID, type, value } = _ref15;
+              var { hookID, id, path: path26, rendererID, type, value } = _ref15;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                renderer.overrideValueAtPath(type, id, hookID, path25, value);
+                renderer.overrideValueAtPath(type, id, hookID, path26, value);
               }
             });
             agent_defineProperty(_this, "overrideContext", function(_ref16) {
-              var { id, path: path25, rendererID, wasForwarded, value } = _ref16;
+              var { id, path: path26, rendererID, wasForwarded, value } = _ref16;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path25,
+                  path: path26,
                   rendererID,
                   type: "context",
                   value
@@ -79245,11 +79408,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideHookState", function(_ref17) {
-              var { id, hookID, path: path25, rendererID, wasForwarded, value } = _ref17;
+              var { id, hookID, path: path26, rendererID, wasForwarded, value } = _ref17;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path25,
+                  path: path26,
                   rendererID,
                   type: "hooks",
                   value
@@ -79257,11 +79420,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideProps", function(_ref18) {
-              var { id, path: path25, rendererID, wasForwarded, value } = _ref18;
+              var { id, path: path26, rendererID, wasForwarded, value } = _ref18;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path25,
+                  path: path26,
                   rendererID,
                   type: "props",
                   value
@@ -79269,11 +79432,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideState", function(_ref19) {
-              var { id, path: path25, rendererID, wasForwarded, value } = _ref19;
+              var { id, path: path26, rendererID, wasForwarded, value } = _ref19;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path25,
+                  path: path26,
                   rendererID,
                   type: "state",
                   value
@@ -79340,12 +79503,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               _this._bridge.send("stopInspectingHost", selected);
             });
             agent_defineProperty(_this, "storeAsGlobal", function(_ref23) {
-              var { count, id, path: path25, rendererID } = _ref23;
+              var { count, id, path: path26, rendererID } = _ref23;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                renderer.storeAsGlobal(id, path25, count);
+                renderer.storeAsGlobal(id, path26, count);
               }
             });
             agent_defineProperty(_this, "updateHookSettings", function(settings) {
@@ -79362,12 +79525,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 var rendererID = +rendererIDString;
                 var renderer = _this._rendererInterfaces[rendererID];
                 if (_this._lastSelectedRendererID === rendererID) {
-                  var path25 = renderer.getPathForElement(_this._lastSelectedElementID);
-                  if (path25 !== null) {
-                    renderer.setTrackedPath(path25);
+                  var path26 = renderer.getPathForElement(_this._lastSelectedElementID);
+                  if (path26 !== null) {
+                    renderer.setTrackedPath(path26);
                     _this._persistedSelection = {
                       rendererID,
-                      path: path25
+                      path: path26
                     };
                   }
                 }
@@ -79442,11 +79605,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               var rendererID = _this._lastSelectedRendererID;
               var id = _this._lastSelectedElementID;
               var renderer = _this._rendererInterfaces[rendererID];
-              var path25 = renderer != null ? renderer.getPathForElement(id) : null;
-              if (path25 !== null) {
+              var path26 = renderer != null ? renderer.getPathForElement(id) : null;
+              if (path26 !== null) {
                 storage_sessionStorageSetItem(SESSION_STORAGE_LAST_SELECTION_KEY, JSON.stringify({
                   rendererID,
-                  path: path25
+                  path: path26
                 }));
               } else {
                 storage_sessionStorageRemoveItem(SESSION_STORAGE_LAST_SELECTION_KEY);
@@ -80169,7 +80332,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             hasElementWithId: function hasElementWithId() {
               return false;
             },
-            inspectElement: function inspectElement(requestID, id, path25) {
+            inspectElement: function inspectElement(requestID, id, path26) {
               return {
                 id,
                 responseID: requestID,
@@ -85439,9 +85602,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             }
             return null;
           }
-          function getElementAttributeByPath(id, path25) {
+          function getElementAttributeByPath(id, path26) {
             if (isMostRecentlyInspectedElement(id)) {
-              return utils_getInObject(mostRecentlyInspectedElement, path25);
+              return utils_getInObject(mostRecentlyInspectedElement, path26);
             }
             return;
           }
@@ -86144,9 +86307,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           function isMostRecentlyInspectedElementCurrent(id) {
             return isMostRecentlyInspectedElement(id) && !hasElementUpdatedSinceLastInspected;
           }
-          function mergeInspectedPaths(path25) {
+          function mergeInspectedPaths(path26) {
             var current = currentlyInspectedPaths;
-            path25.forEach(function(key) {
+            path26.forEach(function(key) {
               if (!current[key]) {
                 current[key] = {};
               }
@@ -86154,21 +86317,21 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             });
           }
           function createIsPathAllowed(key, secondaryCategory) {
-            return function isPathAllowed(path25) {
+            return function isPathAllowed(path26) {
               switch (secondaryCategory) {
                 case "hooks":
-                  if (path25.length === 1) {
+                  if (path26.length === 1) {
                     return true;
                   }
-                  if (path25[path25.length - 2] === "hookSource" && path25[path25.length - 1] === "fileName") {
+                  if (path26[path26.length - 2] === "hookSource" && path26[path26.length - 1] === "fileName") {
                     return true;
                   }
-                  if (path25[path25.length - 1] === "subHooks" || path25[path25.length - 2] === "subHooks") {
+                  if (path26[path26.length - 1] === "subHooks" || path26[path26.length - 2] === "subHooks") {
                     return true;
                   }
                   break;
                 case "suspendedBy":
-                  if (path25.length < 5) {
+                  if (path26.length < 5) {
                     return true;
                   }
                   break;
@@ -86179,8 +86342,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               if (!current) {
                 return false;
               }
-              for (var i = 0;i < path25.length; i++) {
-                current = current[path25[i]];
+              for (var i = 0;i < path26.length; i++) {
+                current = current[path26[i]];
                 if (!current) {
                   return false;
                 }
@@ -86234,38 +86397,38 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 break;
             }
           }
-          function storeAsGlobal(id, path25, count) {
+          function storeAsGlobal(id, path26, count) {
             if (isMostRecentlyInspectedElement(id)) {
-              var value = utils_getInObject(mostRecentlyInspectedElement, path25);
+              var value = utils_getInObject(mostRecentlyInspectedElement, path26);
               var key = "$reactTemp".concat(count);
               window[key] = value;
               console.log(key);
               console.log(value);
             }
           }
-          function getSerializedElementValueByPath(id, path25) {
+          function getSerializedElementValueByPath(id, path26) {
             if (isMostRecentlyInspectedElement(id)) {
-              var valueToCopy = utils_getInObject(mostRecentlyInspectedElement, path25);
+              var valueToCopy = utils_getInObject(mostRecentlyInspectedElement, path26);
               return serializeToString(valueToCopy);
             }
           }
-          function inspectElement(requestID, id, path25, forceFullData) {
-            if (path25 !== null) {
-              mergeInspectedPaths(path25);
+          function inspectElement(requestID, id, path26, forceFullData) {
+            if (path26 !== null) {
+              mergeInspectedPaths(path26);
             }
             if (isMostRecentlyInspectedElement(id) && !forceFullData) {
               if (!hasElementUpdatedSinceLastInspected) {
-                if (path25 !== null) {
+                if (path26 !== null) {
                   var secondaryCategory = null;
-                  if (path25[0] === "hooks" || path25[0] === "suspendedBy") {
-                    secondaryCategory = path25[0];
+                  if (path26[0] === "hooks" || path26[0] === "suspendedBy") {
+                    secondaryCategory = path26[0];
                   }
                   return {
                     id,
                     responseID: requestID,
                     type: "hydrated-path",
-                    path: path25,
-                    value: cleanForBridge(utils_getInObject(mostRecentlyInspectedElement, path25), createIsPathAllowed(null, secondaryCategory), path25)
+                    path: path26,
+                    value: cleanForBridge(utils_getInObject(mostRecentlyInspectedElement, path26), createIsPathAllowed(null, secondaryCategory), path26)
                   };
                 } else {
                   return {
@@ -86461,7 +86624,7 @@ The error thrown in the component is:
               console.groupEnd();
             }
           }
-          function deletePath(type, id, hookID, path25) {
+          function deletePath(type, id, hookID, path26) {
             var devtoolsInstance = idToDevToolsInstanceMap.get(id);
             if (devtoolsInstance === undefined) {
               console.warn('Could not find DevToolsInstance with id "'.concat(id, '"'));
@@ -86475,11 +86638,11 @@ The error thrown in the component is:
               var instance2 = fiber.stateNode;
               switch (type) {
                 case "context":
-                  path25 = path25.slice(1);
+                  path26 = path26.slice(1);
                   switch (fiber.tag) {
                     case ClassComponent:
-                      if (path25.length === 0) {} else {
-                        deletePathInObject(instance2.context, path25);
+                      if (path26.length === 0) {} else {
+                        deletePathInObject(instance2.context, path26);
                       }
                       instance2.forceUpdate();
                       break;
@@ -86489,21 +86652,21 @@ The error thrown in the component is:
                   break;
                 case "hooks":
                   if (typeof overrideHookStateDeletePath === "function") {
-                    overrideHookStateDeletePath(fiber, hookID, path25);
+                    overrideHookStateDeletePath(fiber, hookID, path26);
                   }
                   break;
                 case "props":
                   if (instance2 === null) {
                     if (typeof overridePropsDeletePath === "function") {
-                      overridePropsDeletePath(fiber, path25);
+                      overridePropsDeletePath(fiber, path26);
                     }
                   } else {
-                    fiber.pendingProps = copyWithDelete(instance2.props, path25);
+                    fiber.pendingProps = copyWithDelete(instance2.props, path26);
                     instance2.forceUpdate();
                   }
                   break;
                 case "state":
-                  deletePathInObject(instance2.state, path25);
+                  deletePathInObject(instance2.state, path26);
                   instance2.forceUpdate();
                   break;
               }
@@ -86558,7 +86721,7 @@ The error thrown in the component is:
               }
             }
           }
-          function overrideValueAtPath(type, id, hookID, path25, value) {
+          function overrideValueAtPath(type, id, hookID, path26, value) {
             var devtoolsInstance = idToDevToolsInstanceMap.get(id);
             if (devtoolsInstance === undefined) {
               console.warn('Could not find DevToolsInstance with id "'.concat(id, '"'));
@@ -86572,13 +86735,13 @@ The error thrown in the component is:
               var instance2 = fiber.stateNode;
               switch (type) {
                 case "context":
-                  path25 = path25.slice(1);
+                  path26 = path26.slice(1);
                   switch (fiber.tag) {
                     case ClassComponent:
-                      if (path25.length === 0) {
+                      if (path26.length === 0) {
                         instance2.context = value;
                       } else {
-                        utils_setInObject(instance2.context, path25, value);
+                        utils_setInObject(instance2.context, path26, value);
                       }
                       instance2.forceUpdate();
                       break;
@@ -86588,18 +86751,18 @@ The error thrown in the component is:
                   break;
                 case "hooks":
                   if (typeof overrideHookState === "function") {
-                    overrideHookState(fiber, hookID, path25, value);
+                    overrideHookState(fiber, hookID, path26, value);
                   }
                   break;
                 case "props":
                   switch (fiber.tag) {
                     case ClassComponent:
-                      fiber.pendingProps = copyWithSet(instance2.props, path25, value);
+                      fiber.pendingProps = copyWithSet(instance2.props, path26, value);
                       instance2.forceUpdate();
                       break;
                     default:
                       if (typeof overrideProps === "function") {
-                        overrideProps(fiber, path25, value);
+                        overrideProps(fiber, path26, value);
                       }
                       break;
                   }
@@ -86607,7 +86770,7 @@ The error thrown in the component is:
                 case "state":
                   switch (fiber.tag) {
                     case ClassComponent:
-                      utils_setInObject(instance2.state, path25, value);
+                      utils_setInObject(instance2.state, path26, value);
                       instance2.forceUpdate();
                       break;
                   }
@@ -86893,14 +87056,14 @@ The error thrown in the component is:
           var trackedPathMatchInstance = null;
           var trackedPathMatchDepth = -1;
           var mightBeOnTrackedPath = false;
-          function setTrackedPath(path25) {
-            if (path25 === null) {
+          function setTrackedPath(path26) {
+            if (path26 === null) {
               trackedPathMatchFiber = null;
               trackedPathMatchInstance = null;
               trackedPathMatchDepth = -1;
               mightBeOnTrackedPath = false;
             }
-            trackedPath = path25;
+            trackedPath = path26;
           }
           function updateTrackedPathStateBeforeMount(fiber, fiberInstance) {
             if (trackedPath === null || !mightBeOnTrackedPath) {
@@ -87664,9 +87827,9 @@ The error thrown in the component is:
           }
           var currentlyInspectedElementID = null;
           var currentlyInspectedPaths = {};
-          function mergeInspectedPaths(path25) {
+          function mergeInspectedPaths(path26) {
             var current = currentlyInspectedPaths;
-            path25.forEach(function(key) {
+            path26.forEach(function(key) {
               if (!current[key]) {
                 current[key] = {};
               }
@@ -87674,13 +87837,13 @@ The error thrown in the component is:
             });
           }
           function createIsPathAllowed(key) {
-            return function isPathAllowed(path25) {
+            return function isPathAllowed(path26) {
               var current = currentlyInspectedPaths[key];
               if (!current) {
                 return false;
               }
-              for (var i = 0;i < path25.length; i++) {
-                current = current[path25[i]];
+              for (var i = 0;i < path26.length; i++) {
+                current = current[path26[i]];
                 if (!current) {
                   return false;
                 }
@@ -87730,24 +87893,24 @@ The error thrown in the component is:
                 break;
             }
           }
-          function storeAsGlobal(id, path25, count) {
+          function storeAsGlobal(id, path26, count) {
             var inspectedElement = inspectElementRaw(id);
             if (inspectedElement !== null) {
-              var value = utils_getInObject(inspectedElement, path25);
+              var value = utils_getInObject(inspectedElement, path26);
               var key = "$reactTemp".concat(count);
               window[key] = value;
               console.log(key);
               console.log(value);
             }
           }
-          function getSerializedElementValueByPath(id, path25) {
+          function getSerializedElementValueByPath(id, path26) {
             var inspectedElement = inspectElementRaw(id);
             if (inspectedElement !== null) {
-              var valueToCopy = utils_getInObject(inspectedElement, path25);
+              var valueToCopy = utils_getInObject(inspectedElement, path26);
               return serializeToString(valueToCopy);
             }
           }
-          function inspectElement(requestID, id, path25, forceFullData) {
+          function inspectElement(requestID, id, path26, forceFullData) {
             if (forceFullData || currentlyInspectedElementID !== id) {
               currentlyInspectedElementID = id;
               currentlyInspectedPaths = {};
@@ -87760,8 +87923,8 @@ The error thrown in the component is:
                 type: "not-found"
               };
             }
-            if (path25 !== null) {
-              mergeInspectedPaths(path25);
+            if (path26 !== null) {
+              mergeInspectedPaths(path26);
             }
             updateSelectedElement(id);
             inspectedElement.context = cleanForBridge(inspectedElement.context, createIsPathAllowed("context"));
@@ -87964,10 +88127,10 @@ The error thrown in the component is:
               console.groupEnd();
             }
           }
-          function getElementAttributeByPath(id, path25) {
+          function getElementAttributeByPath(id, path26) {
             var inspectedElement = inspectElementRaw(id);
             if (inspectedElement !== null) {
-              return utils_getInObject(inspectedElement, path25);
+              return utils_getInObject(inspectedElement, path26);
             }
             return;
           }
@@ -87984,14 +88147,14 @@ The error thrown in the component is:
             }
             return element.type;
           }
-          function deletePath(type, id, hookID, path25) {
+          function deletePath(type, id, hookID, path26) {
             var internalInstance = idToInternalInstanceMap.get(id);
             if (internalInstance != null) {
               var publicInstance = internalInstance._instance;
               if (publicInstance != null) {
                 switch (type) {
                   case "context":
-                    deletePathInObject(publicInstance.context, path25);
+                    deletePathInObject(publicInstance.context, path26);
                     forceUpdate(publicInstance);
                     break;
                   case "hooks":
@@ -87999,12 +88162,12 @@ The error thrown in the component is:
                   case "props":
                     var element = internalInstance._currentElement;
                     internalInstance._currentElement = legacy_renderer_objectSpread(legacy_renderer_objectSpread({}, element), {}, {
-                      props: copyWithDelete(element.props, path25)
+                      props: copyWithDelete(element.props, path26)
                     });
                     forceUpdate(publicInstance);
                     break;
                   case "state":
-                    deletePathInObject(publicInstance.state, path25);
+                    deletePathInObject(publicInstance.state, path26);
                     forceUpdate(publicInstance);
                     break;
                 }
@@ -88038,14 +88201,14 @@ The error thrown in the component is:
               }
             }
           }
-          function overrideValueAtPath(type, id, hookID, path25, value) {
+          function overrideValueAtPath(type, id, hookID, path26, value) {
             var internalInstance = idToInternalInstanceMap.get(id);
             if (internalInstance != null) {
               var publicInstance = internalInstance._instance;
               if (publicInstance != null) {
                 switch (type) {
                   case "context":
-                    utils_setInObject(publicInstance.context, path25, value);
+                    utils_setInObject(publicInstance.context, path26, value);
                     forceUpdate(publicInstance);
                     break;
                   case "hooks":
@@ -88053,12 +88216,12 @@ The error thrown in the component is:
                   case "props":
                     var element = internalInstance._currentElement;
                     internalInstance._currentElement = legacy_renderer_objectSpread(legacy_renderer_objectSpread({}, element), {}, {
-                      props: copyWithSet(element.props, path25, value)
+                      props: copyWithSet(element.props, path26, value)
                     });
                     forceUpdate(publicInstance);
                     break;
                   case "state":
-                    utils_setInObject(publicInstance.state, path25, value);
+                    utils_setInObject(publicInstance.state, path26, value);
                     forceUpdate(publicInstance);
                     break;
                 }
@@ -88099,7 +88262,7 @@ The error thrown in the component is:
             return [];
           }
           function setTraceUpdatesEnabled(enabled) {}
-          function setTrackedPath(path25) {}
+          function setTrackedPath(path26) {}
           function getOwnersList(id) {
             return null;
           }
@@ -94963,11 +95126,23 @@ init_version();
 init_crash_recovery();
 
 // src/execution/runner-completion.ts
-init_test_path();
+init_acceptance4();
+init_config();
 init_hooks();
 init_logger2();
 init_prd();
+import path20 from "path";
+
+// src/review/index.ts
+init_semantic_helpers();
+init_adversarial();
+init_categorization();
+init_diff_utils();
+init_finding_projection();
 init_orchestrator2();
+init_runner4();
+
+// src/execution/runner-completion.ts
 init_git();
 init_crash_recovery();
 init_story_context();
@@ -94979,7 +95154,8 @@ var _runnerCompletionDeps = {
   async handleRunCompletion(opts) {
     const { handleRunCompletion: handleRunCompletion2 } = await Promise.resolve().then(() => (init_run_completion(), exports_run_completion));
     return handleRunCompletion2(opts);
-  }
+  },
+  loadConfigForWorkdir
 };
 async function runCompletionPhase(options) {
   const logger = getSafeLogger();
@@ -94998,7 +95174,27 @@ async function runCompletionPhase(options) {
       logger?.info("execution", "Acceptance already passed \u2014 skipping acceptance phase");
     } else if (options.config.acceptance.enabled && isComplete(options.prd)) {
       options.statusWriter.setPostRunPhase("acceptance", { status: "running" });
-      const acceptanceTestPaths = options.featureDir ? groupStoriesByPackage(options.prd, options.workdir, options.feature, options.config.acceptance.testPath, options.config.project?.language).map((g) => ({ testPath: g.testPath, packageDir: g.packageDir })) : undefined;
+      const acceptanceTestPaths = options.featureDir ? await Promise.all(groupStoriesByPackage(options.prd, options.workdir, options.feature, options.config.acceptance.testPath, options.config.project?.language).map(async (g) => {
+        const relativeWorkdir = path20.relative(options.workdir, g.packageDir);
+        let groupConfig = options.config;
+        if (relativeWorkdir && relativeWorkdir !== ".") {
+          try {
+            groupConfig = await _runnerCompletionDeps.loadConfigForWorkdir(path20.join(options.workdir, ".nax", "config.json"), relativeWorkdir);
+          } catch (error48) {
+            logger?.warn("execution", "Falling back to root config for package acceptance settings", {
+              packageDir: g.packageDir,
+              relativeWorkdir,
+              error: errorMessage(error48)
+            });
+          }
+        }
+        return {
+          testPath: g.testPath,
+          packageDir: g.packageDir,
+          testFramework: groupConfig.project?.testFramework,
+          commandOverride: groupConfig.acceptance.command
+        };
+      })) : undefined;
       const acceptanceResult = await _runnerCompletionDeps.runAcceptanceLoop({
         config: options.config,
         prd: options.prd,
@@ -100201,8 +100397,8 @@ function Text({ color, backgroundColor, dimColor = false, bold = false, italic =
 }
 
 // node_modules/ink/build/components/ErrorOverview.js
-var cleanupPath = (path25) => {
-  return path25?.replace(`file://${cwd()}/`, "");
+var cleanupPath = (path26) => {
+  return path26?.replace(`file://${cwd()}/`, "");
 };
 var stackUtils = new import_stack_utils.default({
   cwd: cwd(),
@@ -102319,6 +102515,7 @@ function useAgentStreamEvents(bus) {
               messageUpdates: 0,
               thinkingUpdates: 0,
               usageUpdates: 0,
+              toolCallUpdates: 0,
               status: "active"
             });
             break;
@@ -102356,6 +102553,17 @@ function useAgentStreamEvents(bus) {
             }
             break;
           }
+          case "agent.tool_call_update": {
+            const state = next.get(event.callId);
+            if (state) {
+              next.set(event.callId, {
+                ...state,
+                toolCallUpdates: state.toolCallUpdates + 1,
+                lastActivityAt: event.timestamp
+              });
+            }
+            break;
+          }
           case "agent.call_ended": {
             const state = next.get(event.callId);
             if (state) {
@@ -103540,8 +103748,8 @@ configProfileCmd.command("current").description("Show the currently active profi
 });
 configProfileCmd.command("create <name>").description("Create a new empty profile").option("-d, --dir <path>", "Project directory", process.cwd()).action(async (name, options) => {
   try {
-    const path25 = await profileCreateCommand(name, options.dir);
-    console.log(`Created profile at: ${path25}`);
+    const path26 = await profileCreateCommand(name, options.dir);
+    console.log(`Created profile at: ${path26}`);
   } catch (err) {
     console.error(source_default.red(`Error: ${err.message}`));
     process.exit(1);