@tangle-network/agent-eval 0.119.0 → 0.120.0

package/dist/{chunk-7A4LIMMY.js → chunk-S5TT5R3L.js}

@@ -8,9 +8,9 @@ import {
   CostLedger
 } from "./chunk-JHOJHHU7.js";
 import {
-  TraceFileMissingError,
-  buildTraceAnalystTools
-} from "./chunk-6QIM2EAP.js";
+  buildTraceAnalystTools,
+  runTraceAnalysisLoop
+} from "./chunk-PXD6ZFNY.js";
 import {
   validateAgentProfileCell
 } from "./chunk-XJYR7XFV.js";
@@ -27,12 +27,14 @@ var configuredModels = /* @__PURE__ */ new WeakMap();
 function createAnalystAi(config) {
   const model = config.model.trim();
   if (!model) throw new TypeError("createAnalystAi: model must be a non-empty string");
-  const service = ai({
+  const args = {
     name: config.provider ?? "openai",
     apiKey: config.apiKey,
-    apiURL: config.baseUrl,
+    ...config.baseUrl ? { apiURL: config.baseUrl } : {},
+    ...config.headers ? { headers: config.headers } : {},
     config: { model }
-  });
+  };
+  const service = ai(args);
   configuredModels.set(service, model);
   return service;
 }
@@ -589,9 +591,6 @@ That produced no valid findings. The report DOES describe issues \u2014 re-extra
   return { findings: [], outcome: "extraction_failed" };
 }
 
-// src/analyst/kind-factory.ts
-import { AxJSRuntime, agent } from "@ax-llm/ax";
-
 // src/analyst/ax-cost-service.ts
 function meterAxChatService(ai2, options) {
   assertPositiveInteger(options.maxOutputTokens, "maxOutputTokens");
@@ -699,10 +698,17 @@ function costReceiptFromAxResponse(response, fallbackModel) {
     validUsage(tokens.reasoningTokens) ? tokens.reasoningTokens : 0,
     thoughtsTokens
   );
-  const outputTokens = tokens.completionTokens + thoughtsTokens;
+  const separateReasoningTokens = reasoningTokens > tokens.completionTokens ? reasoningTokens : 0;
+  const additionalOutputTokens = Math.max(thoughtsTokens, separateReasoningTokens);
+  const outputTokens = tokens.completionTokens + additionalOutputTokens;
   const directTotal = tokens.promptTokens + tokens.completionTokens;
-  const classifiedTotal = directTotal + thoughtsTokens + totalCacheTokens;
-  if (reasoningTokens > outputTokens || tokens.totalTokens !== directTotal && tokens.totalTokens !== classifiedTotal) {
+  const validTotals = /* @__PURE__ */ new Set([
+    directTotal,
+    directTotal + totalCacheTokens,
+    directTotal + additionalOutputTokens,
+    directTotal + totalCacheTokens + additionalOutputTokens
+  ]);
+  if (!validTotals.has(tokens.totalTokens)) {
     return {
       model,
       inputTokens: 0,
@@ -751,7 +757,8 @@ function containsUnboundedOrCacheableContent(request) {
   if (request.functions?.some((fn) => fn.cache === true)) return true;
   return request.chatPrompt.some((message) => {
     if (message.cache === true) return true;
-    return Array.isArray(message.content) && message.content.some((part) => part.cache === true || part.type !== "text");
+    if (!("content" in message) || !Array.isArray(message.content)) return false;
+    return message.content.some((part) => part.cache === true || part.type !== "text");
   });
 }
 function modelName(value) {
@@ -827,6 +834,7 @@ function validateUsageSettlementTimeout(timeoutMs) {
 
 // src/analyst/kind-factory.ts
 function createTraceAnalystKind(spec, opts) {
+  rejectRemovedKindOptions(spec);
   const version = opts.versionSuffix ? `${spec.version}+${opts.versionSuffix}` : spec.version;
   const model = resolveAnalystModel(opts.ai, opts.model);
   const minimumEvidenceCitations = spec.minimumEvidenceCitations ?? 1;
@@ -838,7 +846,7 @@ function createTraceAnalystKind(spec, opts) {
     id: spec.id,
     description: spec.description,
     inputKind: "trace-store",
-    cost: spec.cost,
+    cost: { ...spec.cost, settlement_timeout_ms: settlementTimeoutMs },
     version,
     async analyze(store, ctx) {
       const maxOutputTokens = spec.maxOutputTokens ?? 4096;
@@ -859,62 +867,37 @@ function createTraceAnalystKind(spec, opts) {
       });
       try {
         const tools = spec.buildTools(store);
-        const maxDepth = spec.recursion?.maxDepth ?? 0;
-        const maxParallel = spec.recursion?.maxParallelSubagents ?? 2;
+        const maxSubqueries = spec.subqueries?.maxCalls ?? 0;
+        const maxParallel = spec.subqueries?.maxParallel ?? 2;
         const priorContext = renderPriorFindings(ctx.priorFindings);
         const upstreamContext = renderUpstreamFindings(ctx.upstreamFindings);
-        const functions = tools;
         const actorDescription = spec.actorDescription.trim() + priorContext + upstreamContext + "\n\n" + RAW_FINDING_SCHEMA_PROMPT + (minimumEvidenceCitations > 1 ? `
 
-This kind requires at least ${minimumEvidenceCitations} evidence citations per finding; rows with fewer are rejected.` : "") + "\n\nFirst write `report`: a concise free-form prose diagnosis of what the traces show \u2014 what succeeded, what was suboptimal or failed \u2014 with concrete trace ids and numbers. THEN return the structured `findings` array (it MAY be empty when there is nothing to report). Call `final({ report, findings })` exactly once when done.";
-        const ax = agent(
-          "question:string -> report:string, findings:json[]",
-          {
-            agentIdentity: {
-              name: spec.id,
-              description: spec.description
-            },
-            contextFields: ["question"],
-            runtime: new AxJSRuntime({
-              permissions: [],
-              blockDynamicImport: true,
-              allowedModules: [],
-              freezeIntrinsics: true,
-              blockShadowRealm: true,
-              preventGlobalThisExtensions: false
-            }),
-            mode: maxDepth > 0 ? "advanced" : "simple",
-            recursionOptions: maxDepth > 0 ? { maxDepth } : void 0,
-            maxTurns: spec.maxTurns ?? 12,
-            maxRuntimeChars: spec.maxRuntimeChars ?? 6e3,
-            maxBatchedLlmQueryConcurrency: maxParallel,
-            promptLevel: "detailed",
-            // Trace analysis depends on exact prior tool results and runtime variables.
-            contextPolicy: { preset: "full", budget: "balanced" },
-            functions,
-            actorOptions: {
-              description: actorDescription,
-              model,
-              showThoughts: false,
-              thinkingTokenBudget: "none"
-            },
-            responderOptions: {
-              description: spec.responderDescription ?? "Pass through the actor's `report` prose verbatim, and format the `findings` array exactly as the actor produced it. Do not add, drop, or summarize entries.",
-              model,
-              showThoughts: false
-            },
-            bubbleErrors: [TraceFileMissingError]
-          }
-        );
+This kind requires at least ${minimumEvidenceCitations} evidence citations per finding; rows with fewer are rejected.` : "") + "\n\nFirst write `report`: a concise free-form prose diagnosis of what the traces show \u2014 what succeeded, what was suboptimal or failed \u2014 with concrete trace ids and numbers. THEN return the structured `findings` array (it MAY be empty when there is nothing to report).";
         ctx.log?.(`analyst.kind ${spec.id} forward`, {
-          max_depth: maxDepth,
+          max_subqueries: maxSubqueries,
           tool_count: tools.length,
           tags: ctx.tags
         });
-        const result = await ax.forward(meteredAi, { question: deriveQuestion(ctx, spec) });
+        const completed = await runTraceAnalysisLoop({
+          id: spec.id,
+          description: spec.description,
+          prompt: actorDescription,
+          question: deriveQuestion(ctx, spec),
+          ai: meteredAi,
+          model,
+          tools,
+          findingType: "object",
+          maxSubqueries,
+          maxParallelSubqueries: maxParallel,
+          maxTurns: spec.maxTurns ?? 12,
+          maxRuntimeChars: spec.maxRuntimeChars ?? 6e3,
+          ...ctx.signal ? { signal: ctx.signal } : {}
+        });
+        const { report, findings: submittedFindings } = completed;
         const expectedSubjects = KIND_EXPECTED_SUBJECTS[spec.id];
         const out = [];
-        const rawRows = Array.isArray(result.findings) ? result.findings : [];
+        const rawRows = submittedFindings;
         let rejectedWrongKind = 0;
         let rejectedInsufficientEvidence = 0;
         const processRow = (parsed) => {
@@ -973,7 +956,6 @@ This kind requires at least ${minimumEvidenceCitations} evidence citations per f
           rejected_wrong_subject: rejectedWrongKind,
           rejected_insufficient_evidence: rejectedInsufficientEvidence
         });
-        const report = typeof result.report === "string" ? result.report : "";
         if (out.length === 0 && report.trim().length >= 200) {
           if (opts.recovery) {
             const wrongKindBefore = rejectedWrongKind;
@@ -1039,6 +1021,23 @@ This kind requires at least ${minimumEvidenceCitations} evidence citations per f
     }
   };
 }
+function rejectRemovedKindOptions(spec) {
+  const supplied = spec;
+  const migrations = [
+    ["recursion", "subqueries"],
+    ["responderDescription", "actorDescription"],
+    ["maxDepth", "subqueries"],
+    ["maxParallelSubagents", "subqueries.maxParallel"],
+    ["subagentDescription", "actorDescription"]
+  ];
+  for (const [removed, replacement] of migrations) {
+    if (removed in supplied) {
+      throw new TypeError(
+        `createTraceAnalystKind: '${removed}' is unsupported; use '${replacement}'`
+      );
+    }
+  }
+}
 function deriveQuestion(ctx, spec) {
   const focus = ctx.tags?.focus?.trim();
   const task = `Analyze this trace dataset with the available tools and report ${spec.area} findings. ${spec.description}`;
@@ -1146,11 +1145,7 @@ DISCOVERY \u2192 CLUSTER \u2192 CITE protocol:
 
 If the dataset has no failures, return an empty findings array \u2014 do NOT pad with low-confidence speculation.
 
-**Delegate aggressively.** The recursion budget is there to be used:
-- After your first \`getDatasetOverview\` + \`queryTraces\` calls, you should have 3-6 candidate failure clusters in mind. Spawn one \`llmQuery\` per cluster in a single batch \u2014 they investigate in parallel.
-- A sub-investigator that finds its cluster is actually two distinct modes should split again at its own level. Recursion is meant to discover sub-modes, not to do trivial drilling that the parent could do in-line.
-- Pass narrow context to each subagent: { question: 'investigate the auth-revoked-mid-run cluster', context: { trace_ids: ['abc', 'def'], suspected_root_cause: 'token refresh skipped on idle sessions' } }. Subagents need enough context to skip re-discovery but not the whole conversation.
-- Each subagent returns candidate cluster evidence; the parent merges it into the final finding set.
+**Use subqueries over loaded evidence.** After the first scan, load representative span excerpts for each candidate cluster. Then send one bounded \`llmQuery\` per cluster in one batch, including the exact excerpts and asking it to classify the root cause. Subqueries cannot call trace tools. Merge or split clusters yourself from their classifications and the cited source evidence.
 
 OBSERVABILITY rules:
 - Each non-final turn must emit at least one \`console.log\` for evidence.
@@ -1159,17 +1154,17 @@ var FAILURE_MODE_KIND_SPEC = {
   id: "failure-mode",
   description: "Clusters trace-dataset failures into distinct failure modes with cited evidence and a short recommended action.",
   area: "failure-mode",
-  version: "1.1.0",
+  version: "1.2.0",
   actorDescription: ACTOR_PROMPT,
   buildTools: (store) => buildTraceToolsForGroup("all", store),
-  recursion: { maxDepth: 3, maxParallelSubagents: 4 },
+  subqueries: { maxCalls: 8, maxParallel: 4 },
   maxTurns: 24,
   cost: { kind: "llm" }
 };
 
 // src/analyst/kinds/improvement.ts
 var subjectGrammar2 = findingSubjectGrammarPromptFor("improvement");
-var ACTOR_PROMPT2 = `You are a recursive-self-improvement analyst. Your job is to propose **concrete, locus-named edits** the agent's runtime should adopt to fix the failure modes, knowledge gaps, and poisonings present in this dataset.
+var ACTOR_PROMPT2 = `You are a self-improvement analyst. Your job is to propose **concrete, locus-named edits** the agent's runtime should adopt to fix the failure modes, knowledge gaps, and poisonings present in this dataset.
 
 Upstream analysts have already classified the problems. Your job is to convert each problem into a *change to make* and grade its expected leverage. Each finding is one proposed edit.
 
@@ -1189,8 +1184,8 @@ DISCOVERY \u2192 CANDIDATE-FIXES \u2192 COMPETE \u2192 CITE protocol:
    - **Skill / MCP / hook / subagent** \u2014 change the reusable profile component responsible for the behavior
    - **Workflow / rollout policy** \u2014 change orchestration, budget, sampling, or stopping behavior
    - **Code** \u2014 change an implementation path when profile edits cannot repair the behavior
-3. **Compete candidate fixes via subagents.** For each failure cluster, spawn one \`llmQuery\` per candidate-fix axis you want to evaluate. Each subagent's job: simulate the fix on the cited traces and report (i) likely effect, (ii) side effects, (iii) implementation cost as small/medium/large. Pass the cluster's failing trace_ids and the candidate axis as context.
-4. After subagents return, **pick the winning candidate per cluster** based on (effect / cost) and emit ONE finding. Discard the losing candidates \u2014 the output is the recommendation, not the candidate set.
+3. **Compare candidate fixes with bounded subqueries.** Load the representative failure excerpts, then send one \`llmQuery\` per candidate-fix axis the same evidence. Ask for likely effect, side effects, and implementation scope. Subqueries cannot call trace tools; trace ids alone are insufficient context.
+4. After the comparisons return, **pick the winning candidate per cluster** based on expected effect and risk, then emit ONE finding. Keep the alternatives and rejection reasons in the rationale so the recommendation is auditable.
 5. **Cross-reference upstream findings.** Cite prior failure-mode or knowledge-gap findings as \`finding://<prior-finding-id>\`. This builds the dependency graph that lets the dashboard show "fix #X resolves failure modes A, B, C."
 
 For each winning recommendation, emit ONE finding. Use one exact locus from the subject grammar and state the edit in one sentence. Match leverage to the source failure's severity; use medium for quality-of-life changes and info for cleanup with no behavioral effect. Cite the targeted \`finding://<id>\` when available and the most representative span when useful. Quote the problem being fixed. Use confidence 0.85+ for a mechanical fix to a well-evidenced failure, 0.6-0.8 when judgment is required, and <0.5 for speculation. Explain in at most two sentences why this candidate beat its alternatives. The recommended action must be the literal diff, quoted replacement, tool description, or setting change.
@@ -1205,10 +1200,10 @@ var IMPROVEMENT_KIND_SPEC = {
   id: "improvement",
   description: "Converts upstream failure / gap / poisoning findings into concrete locus-named edits (prompt, tool-doc, RAG, scaffolding) with leverage grades.",
   area: "improvement",
-  version: "1.1.0",
+  version: "1.2.0",
   actorDescription: ACTOR_PROMPT2,
   buildTools: (store) => buildTraceToolsForGroup("all", store),
-  recursion: { maxDepth: 3, maxParallelSubagents: 4 },
+  subqueries: { maxCalls: 8, maxParallel: 4 },
   maxTurns: 30,
   maxRuntimeChars: 12e3,
   cost: { kind: "llm" }
@@ -1237,7 +1232,7 @@ DISCOVERY \u2192 ATTRIBUTE-TO-LAYER \u2192 CITE protocol:
 3. For each gap, identify the **layer of the runtime that should have prevented it** and use its exact locus from the subject grammar above.
 4. For each defensible gap, emit ONE finding. Use an exact locus from the subject grammar and name the missing or stale knowledge (for example, "wiki has no page on invoice line-item shape; agent re-derived it from raw spans"). Rate it high when it caused failure or a clarifying question, medium for unnecessary turns, and low for minor inefficiency. Cite the span where the question, correction, retrieval miss, or stale result surfaced and quote it exactly. Use confidence 0.85+ when the agent articulated the gap and 0.6-0.8 when inferred. Recommend a concrete wiki edit for an agent-knowledge locus or a prompt/tool-description edit otherwise.
 
-**Delegate per layer.** After your first scan, you should have candidates spread across \`agent-knowledge:*\`, \`websearch:outdated\`, \`tool-doc:*\`, \`system-prompt:*\`, and \`memory:*\`. Spawn one \`llmQuery\` per layer in parallel \u2014 each subagent runs a focused detection (e.g. the \`agent-knowledge\` subagent looks for both missing-pages AND stale-pages; the \`websearch\` subagent looks specifically for date staleness signals; the \`tool-doc\` subagent looks for tool-call argument errors a fuller description would have prevented). Merge their evidence into the final finding set.
+**Compare layers over loaded evidence.** After the first scan, load the exact excerpts behind candidates across \`agent-knowledge:*\`, \`websearch:outdated\`, \`tool-doc:*\`, \`system-prompt:*\`, and \`memory:*\`. Use one bounded \`llmQuery\` per layer to classify those excerpts. Subqueries cannot call trace tools. Merge their classifications into the final finding set only when the source excerpts support them.
 
 Do NOT report a gap that the agent later recovered from cleanly within the same turn \u2014 that's resilience, not a gap. Cite the *non-recovery* version when both exist.
 
@@ -1247,10 +1242,10 @@ var KNOWLEDGE_GAP_KIND_SPEC = {
   id: "knowledge-gap",
   description: "Identifies missing or stale pieces of knowledge \u2014 primarily against the agent-knowledge wiki \u2014 and attributes each to the runtime layer (wiki page, claim, raw source, websearch, tool-doc, system-prompt, memory) that should have held it.",
   area: "knowledge-gap",
-  version: "1.1.0",
+  version: "1.2.0",
   actorDescription: ACTOR_PROMPT3,
   buildTools: (store) => buildTraceToolsForGroup("discoveryAndSearch", store),
-  recursion: { maxDepth: 2, maxParallelSubagents: 4 },
+  subqueries: { maxCalls: 5, maxParallel: 4 },
   maxTurns: 18,
   cost: { kind: "llm" }
 };
@@ -1277,7 +1272,7 @@ DISCOVERY \u2192 DUAL-VERIFY \u2192 CITE protocol:
    - Confirm the belief is actually false in this trace's own evidence (cite the span that contradicts it)
    Only emit a finding when both halves are nailed down. If you can only nail one, drop it \u2014 single-evidence poisoning findings are too speculative to be useful.
 
-**Delegate the dual-verify.** Use the recursion budget so each candidate poisoning gets one subagent investigating "did the agent act?" and one investigating "is the belief false?". After your first scan, fire off N parallel \`llmQuery\` pairs (one cluster per pair). Subagents return their findings; you accept only the ones where BOTH halves of the pair were confirmed.
+**Independently assess both halves.** Load the action excerpt and contradicting excerpt yourself, then send bounded \`llmQuery\` calls the exact evidence for "did the agent act?" and "does the trace contradict the belief?" Subqueries cannot call trace tools. Accept a poisoning only when both assessments and the source excerpts support it.
 
 For each confirmed poisoning, emit ONE finding. Use the source of the false belief as the exact subject. State "agent believed X (from source S); trace evidence shows X is false." Rate it critical for a wrong user-visible action, high when caught internally after significant waste, and medium for inefficiency. Cite BOTH the action span and the contradicting span with exact quotes. Use confidence 0.85+ when both halves have exact quotes and 0.6-0.8 when one half is inferred. Recommend the literal source correction: update the wiki claim, invalidate and re-curate the raw source, or replace the stale prompt/tool instruction.
 
@@ -1289,10 +1284,10 @@ var KNOWLEDGE_POISONING_KIND_SPEC = {
   id: "knowledge-poisoning",
   description: "Identifies confident-but-wrong actions caused by stale memory, contradicting RAG, deprecated tool docs, or outdated system-prompt instructions.",
   area: "knowledge-poisoning",
-  version: "1.1.0",
+  version: "1.2.0",
   actorDescription: ACTOR_PROMPT4,
   buildTools: (store) => buildTraceToolsForGroup("all", store),
-  recursion: { maxDepth: 2, maxParallelSubagents: 4 },
+  subqueries: { maxCalls: 8, maxParallel: 4 },
   maxTurns: 20,
   minimumEvidenceCitations: 2,
   cost: { kind: "llm" }
@@ -1322,6 +1317,14 @@ var AnalystRegistry = class {
     if (!analyst.version) {
       throw new Error(`AnalystRegistry.register: analyst "${analyst.id}" must declare a version`);
     }
+    if (analyst.cost.kind === "deterministic" && analyst.cost.settlement_timeout_ms !== void 0) {
+      throw new TypeError(
+        `AnalystRegistry.register: deterministic analyst "${analyst.id}" cannot declare settlement_timeout_ms`
+      );
+    }
+    if (analyst.cost.settlement_timeout_ms !== void 0) {
+      validateUsageSettlementTimeout(analyst.cost.settlement_timeout_ms);
+    }
     this.analysts.set(analyst.id, analyst);
   }
   list() {
@@ -1356,7 +1359,10 @@ var AnalystRegistry = class {
     const hooks = this.options.hooks ?? {};
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const started = Date.now();
-    const deadlineMs = runOpts.timeoutMs ? started + runOpts.timeoutMs : void 0;
+    const timeoutMs = validateTimeout(runOpts.timeoutMs);
+    const deadlineMs = timeoutMs === void 0 ? void 0 : started + timeoutMs;
+    const timeoutSignal = timeoutMs === void 0 ? void 0 : AbortSignal.timeout(timeoutMs);
+    const runSignal = combineAbortSignals(runOpts.signal, timeoutSignal);
     const selected = this.selectAnalysts(runOpts);
     const budget = runOpts.budget ?? this.options.defaultBudget;
     validateBudgetPolicy(budget);
@@ -1380,9 +1386,16 @@ var AnalystRegistry = class {
     }
     for (const analyst of selected) {
       const t0 = Date.now();
+      if (runSignal?.aborted) {
+        const summary2 = abortedBeforeStartSummary(analyst, runSignal);
+        summaries.push(summary2);
+        log(`[analyst] skip ${analyst.id} \u2014 run aborted`, { runId, reason: summary2.reason });
+        yield { type: "analyst-skipped", summary: summary2 };
+        continue;
+      }
       const input = this.routeInput(analyst, inputs);
       if (input.kind === "missing") {
-        const summary = {
+        const summary2 = {
           analyst_id: analyst.id,
           status: "skipped",
           reason: `missing input of kind '${analyst.inputKind}'`,
@@ -1391,10 +1404,13 @@ var AnalystRegistry = class {
           cost_usd: 0,
           usage: zeroUsage()
         };
-        summaries.push(summary);
+        summaries.push(summary2);
         log(`[analyst] skip ${analyst.id} \u2014 missing input`, { runId, kind: analyst.inputKind });
-        await hooks.onAfterAnalyze?.({ analyst, summary, findings: [], runId });
-        yield { type: "analyst-skipped", summary };
+        await waitForHook(
+          hooks.onAfterAnalyze ? () => hooks.onAfterAnalyze?.({ analyst, summary: summary2, findings: [], runId }) : void 0,
+          runSignal
+        );
+        yield { type: "analyst-skipped", summary: summary2 };
         continue;
       }
       const perBudget = allocateBudget(budget, {
@@ -1414,7 +1430,7 @@ var AnalystRegistry = class {
         chat: this.options.chat,
         tags: runOpts.tags,
         log: (msg, fields) => log(`[${analyst.id}] ${msg}`, { runId, correlationId, ...fields }),
-        signal: runOpts.signal,
+        signal: runSignal,
         priorFindings: selectPriorFindings(runOpts.priorFindings, analyst.id),
         upstreamFindings: runOpts.chainFindings && allFindings.length > 0 ? [...allFindings] : void 0,
         recordUsage: (receipt) => {
@@ -1422,15 +1438,32 @@ var AnalystRegistry = class {
           usageReceipts.push(receipt);
         }
       };
-      await hooks.onBeforeAnalyze?.({ analyst, ctx, runId });
+      await waitForHook(
+        hooks.onBeforeAnalyze ? () => hooks.onBeforeAnalyze?.({ analyst, ctx, runId }) : void 0,
+        runSignal
+      );
+      if (runSignal?.aborted) {
+        const summary2 = abortedBeforeStartSummary(analyst, runSignal, Date.now() - t0);
+        summaries.push(summary2);
+        log(`[analyst] skip ${analyst.id} \u2014 run aborted`, { runId, reason: summary2.reason });
+        yield { type: "analyst-skipped", summary: summary2 };
+        continue;
+      }
       const effectiveBudget = validateEffectiveBudget(ctx.budgetUsd, remainingUsd, analyst.id);
       yield {
         type: "analyst-started",
         analyst_id: analyst.id,
         started_at: new Date(t0).toISOString()
       };
+      let findings;
+      let summary;
       try {
-        const findings = await analyst.analyze(input.value, ctx);
+        if (runSignal?.aborted) throw abortReason(runSignal);
+        findings = await waitForOperation(
+          analyst.analyze(input.value, ctx),
+          runSignal,
+          analystAbortGraceMs(analyst)
+        );
         const latency = Date.now() - t0;
         const usage = resolveUsage(analyst, findings, usageReceipts);
         const cost = knownCostUsd(usage);
@@ -1439,7 +1472,7 @@ var AnalystRegistry = class {
           remainingUsd = Math.max(0, remainingUsd - budgetDebit(usage, effectiveBudget));
         }
         allFindings.push(...findings);
-        const summary = {
+        summary = {
           analyst_id: analyst.id,
           status: "ok",
           findings_count: findings.length,
@@ -1464,12 +1497,10 @@ var AnalystRegistry = class {
             cost_captured: false
           });
         }
-        await hooks.onAfterAnalyze?.({ analyst, summary, findings, runId });
-        yield { type: "analyst-completed", summary, findings };
       } catch (err) {
         const latency = Date.now() - t0;
         const e = err instanceof Error ? err : new Error(String(err));
-        const hookFindings = await hooks.onError?.({ analyst, error: e, runId }) ?? [];
+        const hookFindings = runSignal?.aborted ? [] : await hooks.onError?.({ analyst, error: e, runId }) ?? [];
         if (hookFindings.length) allFindings.push(...hookFindings);
         const usage = resolveUsage(analyst, hookFindings, usageReceipts);
         const cost = knownCostUsd(usage);
@@ -1477,7 +1508,7 @@ var AnalystRegistry = class {
         if (typeof remainingUsd === "number") {
           remainingUsd = Math.max(0, remainingUsd - budgetDebit(usage, effectiveBudget));
         }
-        const summary = {
+        const summary2 = {
           analyst_id: analyst.id,
           status: "failed",
           findings_count: hookFindings.length,
@@ -1486,7 +1517,7 @@ var AnalystRegistry = class {
           usage,
           error: { class: e.constructor.name, message: e.message }
         };
-        summaries.push(summary);
+        summaries.push(summary2);
         log(`[analyst] FAIL ${analyst.id}`, {
           runId,
           error_class: e.constructor.name,
@@ -1501,9 +1532,18 @@ var AnalystRegistry = class {
             cost_captured: false
           });
         }
-        await hooks.onAfterAnalyze?.({ analyst, summary, findings: hookFindings, runId });
-        yield { type: "analyst-completed", summary, findings: hookFindings };
+        await waitForHook(
+          hooks.onAfterAnalyze ? () => hooks.onAfterAnalyze?.({ analyst, summary: summary2, findings: hookFindings, runId }) : void 0,
+          runSignal
+        );
+        yield { type: "analyst-completed", summary: summary2, findings: hookFindings };
+        continue;
       }
+      await waitForHook(
+        hooks.onAfterAnalyze ? () => hooks.onAfterAnalyze?.({ analyst, summary, findings, runId }) : void 0,
+        runSignal
+      );
+      yield { type: "analyst-completed", summary, findings };
     }
     const result = {
       run_id: runId,
@@ -1517,7 +1557,10 @@ var AnalystRegistry = class {
         summaries.map((summary) => summary.usage?.cost ?? { kind: "uncaptured", usd: null })
       )
     };
-    await hooks.onComplete?.({ result });
+    await waitForHook(
+      hooks.onComplete ? () => hooks.onComplete?.({ result }) : void 0,
+      runSignal
+    );
     yield { type: "run-completed", result };
   }
   selectAnalysts(opts) {
@@ -1549,6 +1592,95 @@ var AnalystRegistry = class {
     }
   }
 };
+function validateTimeout(timeoutMs) {
+  if (timeoutMs === void 0) return void 0;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) {
+    throw new TypeError(
+      "RegistryRunOpts.timeoutMs must be a positive safe integer no greater than 2147483647"
+    );
+  }
+  return timeoutMs;
+}
+function combineAbortSignals(caller, timeout) {
+  if (!caller) return timeout;
+  if (!timeout) return caller;
+  return AbortSignal.any([caller, timeout]);
+}
+async function waitForOperation(operation, signal, abortGraceMs) {
+  if (!signal) return operation;
+  if (signal.aborted) {
+    void operation.catch(() => {
+    });
+    throw abortReason(signal);
+  }
+  return new Promise((resolve, reject) => {
+    let settlementTimer;
+    const cleanup = () => {
+      signal.removeEventListener("abort", onAbort);
+      if (settlementTimer) clearTimeout(settlementTimer);
+    };
+    const onAbort = () => {
+      if (abortGraceMs === 0) {
+        cleanup();
+        reject(abortReason(signal));
+        return;
+      }
+      settlementTimer = setTimeout(() => {
+        cleanup();
+        reject(abortReason(signal));
+      }, abortGraceMs);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    operation.then(
+      (value) => {
+        cleanup();
+        if (signal.aborted) reject(abortReason(signal));
+        else resolve(value);
+      },
+      (error) => {
+        cleanup();
+        reject(signal.aborted ? abortReason(signal) : error);
+      }
+    );
+  });
+}
+async function waitForHook(operation, signal) {
+  if (operation === void 0 || signal?.aborted) return void 0;
+  try {
+    return await waitForOperation(
+      Promise.resolve().then(() => {
+        if (signal?.aborted) throw abortReason(signal);
+        return operation();
+      }),
+      signal,
+      0
+    );
+  } catch (error) {
+    if (signal?.aborted) return void 0;
+    throw error;
+  }
+}
+function analystAbortGraceMs(analyst) {
+  if (analyst.cost.kind === "deterministic") return 0;
+  const settlementMs = validateUsageSettlementTimeout(analyst.cost.settlement_timeout_ms);
+  if (settlementMs === 0) return 0;
+  return Math.min(settlementMs + 100, 2147483647);
+}
+function abortedBeforeStartSummary(analyst, signal, latencyMs = 0) {
+  const reason = abortReason(signal);
+  return {
+    analyst_id: analyst.id,
+    status: "skipped",
+    reason: `${reason.name}: ${reason.message}`,
+    findings_count: 0,
+    latency_ms: latencyMs,
+    cost_usd: 0,
+    usage: zeroUsage()
+  };
+}
+function abortReason(signal) {
+  return signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
+}
 function allocateBudget(policy, args) {
   if (!policy) return void 0;
   if (policy.allocate) {
@@ -2533,4 +2665,4 @@ export {
   aggregateRunScore,
   clamp012 as clamp01
 };
-//# sourceMappingURL=chunk-7A4LIMMY.js.map
+//# sourceMappingURL=chunk-S5TT5R3L.js.map