@tangle-network/agent-eval 0.125.0 → 0.126.1

package/dist/{chunk-DT7OXY3C.js → chunk-LUNF2SEL.js}

@@ -1,25 +1,30 @@
 import {
+  executionTrackByLane
+} from "./chunk-HHWE3POT.js";
+import {
+  combineAbortSignals
+} from "./chunk-WGXIEX7P.js";
+import {
+  LlmClient,
   callLlm,
   costReceiptFromLlm,
   costReceiptFromLlmError,
   maximumChargeForLlmRequest
-} from "./chunk-EQUK3RFS.js";
+} from "./chunk-J5SQWP6Y.js";
 import {
   CostLedger
-} from "./chunk-GRCDRKII.js";
+} from "./chunk-WS3NZZQQ.js";
 import {
   buildTraceAnalystTools,
-  runTraceAnalysisLoop
+  runTraceAnalysisLoop,
+  spanEpochMillis
 } from "./chunk-IR3KBHOY.js";
 import {
-  validateAgentProfileCell
-} from "./chunk-GC4ATIKK.js";
-import {
-  canonicalize
-} from "./chunk-VSMTAMNK.js";
-import {
-  ValidationError
-} from "./chunk-ONWEPEDO.js";
+  LLM_CONTEXT_TOKENS,
+  LLM_INPUT_TOKEN_ATTR_KEYS,
+  LLM_OUTPUT_TOKEN_ATTR_KEYS,
+  TOOL_NAME_ATTR_KEYS
+} from "./chunk-K4DBDHLK.js";
 
 // src/analyst/ax-service.ts
 import { ai } from "@ax-llm/ax";
@@ -56,6 +61,405 @@ function resolveAnalystModel(service, override) {
   return model;
 }
 
+// src/analyst/chat-client.ts
+function createChatClient(opts) {
+  switch (opts.transport) {
+    case "router":
+      return wrapLlmClient(
+        opts.transport,
+        opts.defaultModel,
+        new LlmClient({
+          baseUrl: opts.baseUrl ?? "https://router.tangle.tools/v1",
+          apiKey: opts.apiKey,
+          maxRetries: opts.maximumAttempts
+        })
+      );
+    case "cli-bridge":
+      return wrapLlmClient(
+        opts.transport,
+        opts.defaultModel,
+        new LlmClient({
+          baseUrl: opts.baseUrl ?? "http://127.0.0.1:3344/v1",
+          apiKey: opts.bearer ?? "",
+          maxRetries: opts.maximumAttempts
+        })
+      );
+    case "direct-provider":
+      return wrapLlmClient(
+        opts.transport,
+        opts.defaultModel,
+        new LlmClient({
+          baseUrl: opts.baseUrl,
+          apiKey: opts.apiKey,
+          maxRetries: opts.maximumAttempts
+        })
+      );
+    case "sandbox-sdk":
+      return {
+        transport: "sandbox-sdk",
+        defaultModel: opts.defaultModel,
+        maximumAttempts: opts.maximumAttempts,
+        chat: async (req, callOpts) => opts.chat(resolveModel(req, opts.defaultModel), callOpts)
+      };
+    case "mock":
+      return {
+        transport: "mock",
+        defaultModel: opts.defaultModel,
+        maximumAttempts: 1,
+        chat: async (req, callOpts) => opts.handler(resolveModel(req, opts.defaultModel), callOpts)
+      };
+  }
+}
+function wrapLlmClient(transport, defaultModel, inner) {
+  return {
+    transport,
+    defaultModel,
+    maximumAttempts: inner.maximumAttempts,
+    chat: (req, callOpts) => {
+      const resolved = resolveModel(req, defaultModel);
+      const request = {
+        model: resolved.model,
+        messages: req.messages,
+        jsonMode: req.jsonMode,
+        jsonSchema: req.jsonSchema,
+        temperature: req.temperature,
+        maxTokens: req.maxTokens,
+        timeoutMs: req.timeoutMs
+      };
+      return inner.call(request, {
+        signal: callOpts?.signal,
+        idempotencyKey: callOpts?.idempotencyKey
+      });
+    }
+  };
+}
+function resolveModel(req, defaultModel) {
+  if (req.model) return req;
+  if (!defaultModel) {
+    throw new Error(
+      "ChatClient.chat: no model on request and no defaultModel on the client. Either pass req.model or bind defaultModel at createChatClient()."
+    );
+  }
+  return { ...req, model: defaultModel };
+}
+
+// src/trace-analyst/behavioral-metrics.ts
+var INPUT_GROWTH_FACTOR = 3;
+var MIN_TOOL_CALLS = 3;
+var VERIFY_RE = /verif|eval|inspect|check|assert|validat|review|confirm|read|grep|glob|search|view|\blist\b|\bls\b|\bcat\b|\bfind\b|diff|status|\btest|lint|typecheck/i;
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function numAttr(attrs, keys) {
+  for (const key of keys) {
+    const value = num(attrs[key]);
+    if (value !== null) return value;
+  }
+  return null;
+}
+function inputTokensOf(s) {
+  const exactContext = num(s.attributes[LLM_CONTEXT_TOKENS]);
+  if (exactContext !== null) return exactContext;
+  return numAttr(s.attributes, LLM_INPUT_TOKEN_ATTR_KEYS) ?? num(s.attributes["llm.usage.input_tokens"]);
+}
+function outputTokensOf(s) {
+  return numAttr(s.attributes, LLM_OUTPUT_TOKEN_ATTR_KEYS) ?? num(s.attributes["llm.usage.output_tokens"]);
+}
+function stepOf(s) {
+  return num(s.attributes.step);
+}
+function toolNameOf(s) {
+  if (s.tool_name) return s.tool_name;
+  for (const key of TOOL_NAME_ATTR_KEYS) {
+    const t = s.attributes[key];
+    if (typeof t === "string" && t.length > 0) return t;
+  }
+  return null;
+}
+function computeTraceMetrics(spans) {
+  const traceIds = new Set(spans.map((span) => span.trace_id));
+  if (traceIds.size > 1) {
+    throw new Error(
+      `computeTraceMetrics: expected spans from one trace, received ${traceIds.size} traces`
+    );
+  }
+  const traceId = traceIds.values().next().value ?? null;
+  const samples = spans.map((span) => ({
+    span,
+    input: inputTokensOf(span),
+    output: outputTokensOf(span),
+    step: stepOf(span)
+  }));
+  const llmSamples = samples.filter((sample) => sample.span.kind === "LLM");
+  const tokenSamples = llmSamples.length > 0 ? llmSamples : samples.filter((sample) => sample.input !== null || sample.output !== null);
+  const tokenSequences = buildTokenSequences(tokenSamples, spans);
+  const primarySequence = tokenSequences[0];
+  const inputTokenTrajectory = primarySequence?.inputTokenTrajectory.filter((value) => value !== null) ?? [];
+  const outputTokenTrajectory = primarySequence?.outputTokenTrajectory.filter((value) => value !== null) ?? [];
+  const toolHistogram = {};
+  let hasSelfVerification = false;
+  for (const s of spans) {
+    const tool = toolNameOf(s);
+    if (tool) {
+      toolHistogram[tool] = (toolHistogram[tool] ?? 0) + 1;
+      if (VERIFY_RE.test(tool)) hasSelfVerification = true;
+    }
+  }
+  const totalToolCalls = Object.values(toolHistogram).reduce((a, b) => a + b, 0);
+  const distinctTools = Object.keys(toolHistogram).length;
+  const toolDiversityRatio = totalToolCalls === 0 ? 1 : distinctTools / totalToolCalls;
+  const signals = [];
+  const seenTokenSignals = /* @__PURE__ */ new Set();
+  for (const sequence of tokenSequences) {
+    for (const signal of tokenSignals(sequence)) {
+      if (seenTokenSignals.has(signal.code)) continue;
+      seenTokenSignals.add(signal.code);
+      signals.push(signal);
+    }
+  }
+  if (totalToolCalls >= MIN_TOOL_CALLS && distinctTools === 1) {
+    const only = Object.keys(toolHistogram)[0];
+    signals.push({
+      code: "single-tool-dependency",
+      severity: "medium",
+      detail: `All ${totalToolCalls} observed tool calls are \`${only}\`; no alternate tool call was observed.`,
+      evidence: { tool: only, calls: totalToolCalls, distinct_tools: 1 }
+    });
+  }
+  if (totalToolCalls >= MIN_TOOL_CALLS && !hasSelfVerification) {
+    signals.push({
+      code: "no-self-verification",
+      severity: "medium",
+      detail: `${totalToolCalls} tool calls were observed without a verification-named tool call.`,
+      evidence: { tool_calls: totalToolCalls, verification_calls: 0 }
+    });
+  }
+  return {
+    traceId,
+    llmCallCount: tokenSamples.length,
+    tokenSequences,
+    inputTokenTrajectory,
+    outputTokenTrajectory,
+    toolHistogram,
+    totalToolCalls,
+    distinctTools,
+    toolDiversityRatio,
+    hasSelfVerification,
+    signals
+  };
+}
+function buildTokenSequences(samples, spans) {
+  const spansById = new Map(spans.map((span) => [span.span_id, span]));
+  const executionScopeFor = createTokenExecutionScopeResolver(spansById);
+  const scopedSamples = samples.map((sample) => ({
+    sample,
+    ...executionScopeFor(sample.span)
+  }));
+  const trackByLane = executionTrackByLane(scopedSamples);
+  const byTrack = /* @__PURE__ */ new Map();
+  for (const scoped of scopedSamples) {
+    const trackId = trackByLane.get(scoped.key);
+    const track = byTrack.get(trackId) ?? { scopeId: scoped.scopeId, samples: [] };
+    track.samples.push(scoped.sample);
+    byTrack.set(trackId, track);
+  }
+  const sequences = [];
+  for (const { scopeId, samples: tracked } of byTrack.values()) {
+    const runs = serialTokenRuns([...tracked].sort(compareTokenSamples));
+    runs.forEach((run, index) => {
+      sequences.push({
+        scopeId: runs.length === 1 ? scopeId : `${scopeId}#${index + 1}`,
+        spanIds: run.map((sample) => sample.span.span_id),
+        inputTokenTrajectory: run.map((sample) => sample.input),
+        outputTokenTrajectory: run.map((sample) => sample.output)
+      });
+    });
+  }
+  return sequences.sort(
+    (a, b) => b.spanIds.length - a.spanIds.length || a.scopeId.localeCompare(b.scopeId) || a.spanIds[0].localeCompare(b.spanIds[0])
+  );
+}
+function createTokenExecutionScopeResolver(spansById) {
+  const cache = /* @__PURE__ */ new Map();
+  return (span) => {
+    const ancestry = resolveAncestorScope(span.parent_span_id, spansById, cache);
+    const rootId = ancestry.rootId;
+    const scopeId = ancestry.agentId ? `span:${ancestry.agentId}` : ancestry.missingParentId ? `parent:${ancestry.missingParentId}` : rootId ? `root:${rootId}` : span.agent_name ? `agent:${span.agent_name}` : `trace:${span.trace_id}`;
+    const scopeSpanId = ancestry.agentId ?? ancestry.missingParentId ?? rootId;
+    const laneSpan = ancestry.laneSpanId ? spansById.get(ancestry.laneSpanId) : void 0;
+    const direct = scopeSpanId === null || ancestry.laneSpanId === scopeSpanId;
+    const timedSpan = direct ? span : laneSpan;
+    return {
+      key: JSON.stringify([scopeId, direct ? span.span_id : ancestry.laneSpanId]),
+      scopeKey: scopeId,
+      scopeId,
+      start: timedSpan ? spanEpochMillis(timedSpan.start_time) : null,
+      end: timedSpan ? spanEpochMillis(timedSpan.end_time) : null
+    };
+  };
+}
+function resolveAncestorScope(startId, spansById, cache) {
+  const empty = {
+    agentId: null,
+    rootId: null,
+    missingParentId: null,
+    laneSpanId: null
+  };
+  if (!startId) return empty;
+  const path = [];
+  const pathIndex = /* @__PURE__ */ new Map();
+  let currentId = startId;
+  let resolved = empty;
+  while (currentId) {
+    const cached = cache.get(currentId);
+    if (cached) {
+      resolved = cached;
+      break;
+    }
+    const cycleStart = pathIndex.get(currentId);
+    if (cycleStart !== void 0) {
+      resolved = {
+        agentId: null,
+        rootId: [...path.slice(cycleStart)].sort()[0],
+        missingParentId: null,
+        laneSpanId: [...path.slice(cycleStart)].sort()[0]
+      };
+      break;
+    }
+    const current = spansById.get(currentId);
+    if (!current) {
+      resolved = {
+        agentId: null,
+        rootId: null,
+        missingParentId: currentId,
+        laneSpanId: currentId
+      };
+      break;
+    }
+    if (current.kind === "AGENT") {
+      resolved = {
+        agentId: current.span_id,
+        rootId: null,
+        missingParentId: null,
+        laneSpanId: current.span_id
+      };
+      break;
+    }
+    pathIndex.set(currentId, path.length);
+    path.push(currentId);
+    currentId = current.parent_span_id;
+  }
+  for (let index = path.length - 1; index >= 0; index -= 1) {
+    if (resolved.agentId === null && resolved.rootId === null) {
+      resolved = { ...resolved, rootId: path[index], laneSpanId: path[index] };
+    } else if (resolved.laneSpanId === (resolved.agentId ?? resolved.missingParentId ?? resolved.rootId)) {
+      resolved = { ...resolved, laneSpanId: path[index] };
+    }
+    cache.set(path[index], resolved);
+  }
+  return resolved;
+}
+function compareTokenSamples(a, b) {
+  const aStart = spanEpochMillis(a.span.start_time);
+  const bStart = spanEpochMillis(b.span.start_time);
+  if (aStart === null && bStart !== null) return 1;
+  if (aStart !== null && bStart === null) return -1;
+  if (aStart !== null && bStart !== null && aStart !== bStart) return aStart - bStart;
+  if (a.step !== null && b.step !== null && a.step !== b.step) return a.step - b.step;
+  return a.span.span_id.localeCompare(b.span.span_id);
+}
+function serialTokenRuns(ordered) {
+  const runs = [];
+  let serial = [];
+  let overlap = [];
+  let overlapEnd = Number.NEGATIVE_INFINITY;
+  const flushSerial = () => {
+    if (serial.length > 0) runs.push(serial);
+    serial = [];
+  };
+  const flushOverlap = () => {
+    if (overlap.length === 1) {
+      serial.push(overlap[0]);
+    } else if (overlap.length > 1) {
+      flushSerial();
+      for (const sample of overlap) runs.push([sample]);
+    }
+    overlap = [];
+    overlapEnd = Number.NEGATIVE_INFINITY;
+  };
+  for (const sample of ordered) {
+    const start = spanEpochMillis(sample.span.start_time);
+    const end = spanEpochMillis(sample.span.end_time);
+    if (start === null || end === null || sample.span.duration_ms <= 0 || end < start) {
+      flushOverlap();
+      flushSerial();
+      runs.push([sample]);
+      continue;
+    }
+    if (overlap.length > 0 && start >= overlapEnd) flushOverlap();
+    overlap.push(sample);
+    overlapEnd = Math.max(overlapEnd, end);
+  }
+  flushOverlap();
+  flushSerial();
+  return runs;
+}
+function tokenSignals(sequence) {
+  const signals = [];
+  const inputs = sequence.inputTokenTrajectory;
+  const outputs = sequence.outputTokenTrajectory;
+  if (inputs.length >= 3 && inputs.every((value) => value !== null)) {
+    const first = inputs[0];
+    const last = inputs[inputs.length - 1];
+    const isMonotonic = everyAdjacent(inputs, (previous, current) => current >= previous);
+    const growthFromZero = first === 0 && last > 0;
+    const growth = growthFromZero ? Infinity : first > 0 ? last / first : 0;
+    if (isMonotonic && last > first && growth >= INPUT_GROWTH_FACTOR) {
+      const growthLabel = growthFromZero ? "0\u2192nonzero (unbounded)" : `${growth.toFixed(1)}x`;
+      signals.push({
+        code: "monotonic-input-growth",
+        severity: "high",
+        detail: `LLM input tokens grew ${growthLabel} (${first}\u2192${last}) across ${inputs.length} serial calls without an intervening decrease.`,
+        evidence: {
+          first,
+          last,
+          growth_x: growthFromZero ? "unbounded" : Number(growth.toFixed(2)),
+          calls: inputs.length,
+          scope: sequence.scopeId,
+          first_span_id: sequence.spanIds[0],
+          last_span_id: sequence.spanIds[sequence.spanIds.length - 1]
+        }
+      });
+    }
+  }
+  if (inputs.length >= 3 && inputs.length === outputs.length && inputs.every((value) => value !== null) && outputs.every((value) => value !== null)) {
+    const first = outputs[0];
+    const last = outputs[outputs.length - 1];
+    const inputIsMonotonic = everyAdjacent(inputs, (previous, current) => current >= previous);
+    const outputIsMonotonic = everyAdjacent(outputs, (previous, current) => current <= previous);
+    const inputGrew = inputs[inputs.length - 1] > inputs[0];
+    if (inputIsMonotonic && inputGrew && outputIsMonotonic && last < first) {
+      signals.push({
+        code: "output-length-decay",
+        severity: "medium",
+        detail: `LLM output tokens shrank ${first}\u2192${last} over ${outputs.length} serial calls while input tokens increased monotonically.`,
+        evidence: {
+          first,
+          last,
+          calls: outputs.length,
+          scope: sequence.scopeId,
+          first_span_id: sequence.spanIds[0],
+          last_span_id: sequence.spanIds[sequence.spanIds.length - 1]
+        }
+      });
+    }
+  }
+  return signals;
+}
+function everyAdjacent(values, predicate) {
+  return values.slice(1).every((current, index) => predicate(values[index], current));
+}
+
 // src/analyst/types.ts
 import { createHash } from "crypto";
 function computeFindingId(input) {
@@ -86,6 +490,112 @@ function makeFinding(init) {
   };
 }
 
+// src/analyst/behavioral-analyst.ts
+var RECOMMENDED_ACTION = {
+  "monotonic-input-growth": "Inspect context assembly; if prior history is repeatedly included, summarize completed work before the next model call.",
+  "output-length-decay": "Check late-step completeness; if shorter responses omit required work, add explicit completion criteria to the agent instructions.",
+  "single-tool-dependency": "Test whether an inspect or verification tool improves outcomes after the repeated call fails or returns no progress.",
+  "no-self-verification": "After state-changing actions, require an observable check before the agent proceeds."
+};
+var ANALYST_ID = "efficiency-behavioral";
+var AGGREGATE_CLAIM = {
+  "monotonic-input-growth": (observed, analyzed) => `${observed}/${analyzed} analyzed traces showed input tokens grow from zero to nonzero or to at least 3x their initial value across at least 3 serial model calls without a decrease.`,
+  "output-length-decay": (observed, analyzed) => `${observed}/${analyzed} analyzed traces showed output tokens decrease while input tokens increased monotonically across at least 3 serial model calls.`,
+  "single-tool-dependency": (observed, analyzed) => `${observed}/${analyzed} analyzed traces used only one named tool across at least 3 tool calls.`,
+  "no-self-verification": (observed, analyzed) => `${observed}/${analyzed} analyzed traces had at least 3 tool calls without a verification-named tool call.`
+};
+function deriveEfficiencyFindings(metrics, opts = {}) {
+  const analystId = opts.analystId ?? ANALYST_ID;
+  const traceId = metrics.traceId;
+  return metrics.signals.map(
+    (sig) => makeFinding({
+      analyst_id: analystId,
+      area: "efficiency",
+      subject: sig.code,
+      claim: sig.detail,
+      severity: sig.severity,
+      // Deterministic arithmetic over spans, not a model judgment → certain.
+      confidence: 1,
+      evidence_refs: [
+        {
+          kind: "metric",
+          uri: traceId ? `metric://trace/${encodeURIComponent(traceId)}/efficiency/${sig.code}` : `metric://efficiency/${sig.code}`,
+          excerpt: JSON.stringify(sig.evidence)
+        }
+      ],
+      recommended_action: RECOMMENDED_ACTION[sig.code],
+      metadata: {
+        deterministic: true,
+        evidence: sig.evidence,
+        ...traceId ? { trace_id: traceId } : {}
+      },
+      id_basis: sig.code,
+      ...opts.producedAt ? { produced_at: opts.producedAt } : {}
+    })
+  );
+}
+function behavioralAnalyst() {
+  return {
+    id: ANALYST_ID,
+    description: "Deterministic behavioral/efficiency findings over OTLP spans \u2014 token-growth, output-decay, tool-monoculture, missing self-verification. Zero LLM; model-agnostic by construction.",
+    inputKind: "trace-store",
+    cost: { kind: "deterministic" },
+    version: "2.0.0",
+    async analyze(store) {
+      const overview = await store.getOverview();
+      const analyzedTraceIds = [...new Set(overview.sample_trace_ids)].sort();
+      const findingsById = /* @__PURE__ */ new Map();
+      for (const traceId of analyzedTraceIds) {
+        const viewed = await store.viewTrace({ trace_id: traceId });
+        if (viewed.trace_id !== traceId) {
+          throw new Error(
+            `behavioralAnalyst: requested trace '${traceId}', received '${viewed.trace_id}'`
+          );
+        }
+        if (!viewed.spans) {
+          throw new Error(
+            `behavioralAnalyst: trace '${traceId}' is oversized; complete spans are required`
+          );
+        }
+        const metrics = computeTraceMetrics(viewed.spans);
+        if (metrics.traceId !== null && metrics.traceId !== traceId) {
+          throw new Error(
+            `behavioralAnalyst: requested trace '${traceId}', received '${metrics.traceId}'`
+          );
+        }
+        for (const finding of deriveEfficiencyFindings(metrics)) {
+          const current = findingsById.get(finding.finding_id);
+          if (!current) {
+            findingsById.set(finding.finding_id, {
+              finding,
+              traceIds: [traceId],
+              evidence: [...finding.evidence_refs]
+            });
+            continue;
+          }
+          current.traceIds.push(traceId);
+          current.evidence.push(...finding.evidence_refs);
+        }
+      }
+      return [...findingsById.values()].map(({ finding, traceIds, evidence }) => ({
+        ...finding,
+        claim: AGGREGATE_CLAIM[finding.subject](
+          traceIds.length,
+          analyzedTraceIds.length
+        ),
+        rationale: `${traceIds.length}/${analyzedTraceIds.length} analyzed traces exhibited this pattern.`,
+        evidence_refs: evidence,
+        metadata: {
+          deterministic: true,
+          trace_ids: traceIds,
+          observed_trace_count: traceIds.length,
+          analyzed_trace_count: analyzedTraceIds.length
+        }
+      }));
+    }
+  };
+}
+
 // src/analyst/finding-subject.ts
 import { z } from "zod";
 var FINDING_SUBJECT_KINDS = [
@@ -1601,11 +2111,6 @@ function validateTimeout(timeoutMs) {
   }
   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) {
@@ -1863,825 +2368,29 @@ function selectPriorFindings(source, analystId) {
   return merged.length > 0 ? merged : void 0;
 }
 
-// src/concurrency.ts
-var Mutex = class {
-  locked = false;
-  waiters = [];
-  async acquire() {
-    if (!this.locked) {
-      this.locked = true;
-      return () => this.release();
-    }
-    return new Promise((resolve) => {
-      this.waiters.push(() => {
-        resolve(() => this.release());
-      });
-    });
-  }
-  release() {
-    const next = this.waiters.shift();
-    if (next) {
-      next();
-    } else {
-      this.locked = false;
-    }
-  }
-  async runExclusive(fn) {
-    const release = await this.acquire();
-    try {
-      return await fn();
-    } finally {
-      release();
-    }
-  }
-  /** True iff someone holds the lock right now. Diagnostics only. */
-  get isLocked() {
-    return this.locked;
-  }
-  /** Pending waiter count. Diagnostics only. */
-  get pending() {
-    return this.waiters.length;
-  }
-};
-async function mapConcurrent(items, concurrency, map) {
-  if (!Number.isInteger(concurrency) || concurrency < 1) {
-    throw new Error(`mapConcurrent: concurrency must be a positive integer, got ${concurrency}`);
-  }
-  if (items.length === 0) return [];
-  const results = new Array(items.length);
-  let nextIndex = 0;
-  let stopped = false;
-  let failed = false;
-  let failure;
-  const worker = async () => {
-    while (!stopped) {
-      const index = nextIndex;
-      nextIndex += 1;
-      if (index >= items.length) return;
-      try {
-        results[index] = await map(items[index], index);
-      } catch (error) {
-        stopped = true;
-        if (!failed) {
-          failed = true;
-          failure = error;
-        }
-      }
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
-  if (failed) throw failure;
-  return results;
-}
-
-// src/analyst/steer-firewall.ts
-var OBSERVABLE_KINDS = /* @__PURE__ */ new Set([
-  "span",
-  "event",
-  "artifact"
-]);
-function isTraceObservable(finding) {
-  return finding.evidence_refs.some((ref) => OBSERVABLE_KINDS.has(ref.kind));
-}
-function isJudgeVerdict(finding) {
-  return finding.derived_from_judge === true;
-}
-function assertNoJudgeVerdict(findings, context = "steer") {
-  const leaks = findings.filter(isJudgeVerdict);
-  if (leaks.length > 0) {
-    throw new Error(
-      `${context}: a judge verdict cannot be admitted as steering input \u2014 that is the held-out judge leaking into the loop. Offending judge-derived findings: [${leaks.map((f) => f.finding_id).join(", ")}]. Steering consumes observations of behavior, never acceptance verdicts.`
-    );
-  }
-  return findings;
-}
-
-// src/analyst/policy-edit.ts
-import { createHash as createHash2 } from "crypto";
-var POLICY_EDIT_AXES = [
-  "carrier",
-  "representation",
-  "budget",
-  "sampling",
-  "output_contract",
-  "tool_contract",
-  "routing",
-  "memory",
-  "agent_profile",
-  "deployment_target"
-];
-var POLICY_EDIT_TARGET_SURFACES = [
-  "prompt",
-  "tool-contract",
-  "runtime-config",
-  "memory",
-  "agent-profile",
-  "code",
-  "deployment"
-];
-var POLICY_EDIT_CANDIDATE_RECORD_SCHEMA = "tangle.policy-edit-candidate.v1";
-var PolicyEditValidationError = class extends ValidationError {
-  path;
-  constructor(message, path = "") {
-    super(path ? `${message} (at ${path})` : message);
-    this.path = path;
-  }
-};
-var DEFAULT_MIN_SCORE = 0.7;
-var DEFAULT_MIN_EXPECTED_GAIN = 0.01;
-var POLICY_EDIT_ID = /^policy-edit:sha256:[0-9a-f]{64}$/;
-function makePolicyEdit(init) {
-  const normalized = normalizePolicyEdit({
-    schemaVersion: "policy-edit/v1",
-    ...init,
-    source: normalizeSource(init.source)
-  });
-  const edit = {
-    ...normalized,
-    editId: init.editId ?? computePolicyEditId(normalized)
-  };
-  return validatePolicyEdit(edit);
-}
-function computePolicyEditId(edit) {
-  const { editId: _editId, schemaVersion, ...material } = edit;
-  void _editId;
-  const canonical = JSON.stringify(canonicalize({ schemaVersion, ...material }));
-  return `policy-edit:sha256:${createHash2("sha256").update(canonical).digest("hex")}`;
-}
-function validatePolicyEdit(input) {
-  if (input === null || typeof input !== "object") {
-    throw new PolicyEditValidationError("expected object");
-  }
-  const obj = input;
-  expectLiteral(obj.schemaVersion, "policy-edit/v1", "schemaVersion");
-  expectString(obj.editId, "editId");
-  if (!POLICY_EDIT_ID.test(obj.editId)) {
-    throw new PolicyEditValidationError(
-      "editId must match policy-edit:sha256:<64 lowercase hex chars>",
-      "editId"
-    );
-  }
-  expectOneOf(obj.axis, POLICY_EDIT_AXES, "axis");
-  validateTarget(obj.target);
-  validateChange(obj.change);
-  expectString(obj.claim, "claim");
-  validateExpectedGain(obj.expectedGain);
-  expectConfidence(obj.confidence, "confidence");
-  expectOneOf(obj.risk, ["low", "medium", "high", "unknown"], "risk");
-  validateSource(obj.source);
-  if (obj.rationale !== void 0) expectString(obj.rationale, "rationale");
-  if (obj.validationPlan !== void 0) expectString(obj.validationPlan, "validationPlan");
-  if (obj.metadata !== void 0 && (obj.metadata === null || typeof obj.metadata !== "object")) {
-    throw new PolicyEditValidationError("expected object", "metadata");
-  }
-  const expectedId = computePolicyEditId(obj);
-  if (obj.editId !== expectedId) {
-    throw new PolicyEditValidationError("editId does not match policy edit content", "editId");
-  }
-  return obj;
-}
-function makePolicyEditCandidateRecord(edit) {
-  return validatePolicyEditCandidateRecord({
-    schema: POLICY_EDIT_CANDIDATE_RECORD_SCHEMA,
-    policyEdit: edit
-  });
-}
-function validatePolicyEditCandidateRecord(input) {
-  if (input === null || typeof input !== "object" || Array.isArray(input)) {
-    throw new PolicyEditValidationError("expected object", "candidateRecord");
-  }
-  const obj = input;
-  const keys = Object.keys(obj).sort();
-  if (keys.length !== 2 || keys[0] !== "policyEdit" || keys[1] !== "schema") {
-    throw new PolicyEditValidationError("expected exactly schema and policyEdit", "candidateRecord");
-  }
-  expectLiteral(obj.schema, POLICY_EDIT_CANDIDATE_RECORD_SCHEMA, "candidateRecord.schema");
-  const policyEdit = validatePolicyEdit(obj.policyEdit);
-  assertJsonSafe(policyEdit, "candidateRecord.policyEdit");
-  const snapshot = JSON.parse(JSON.stringify(policyEdit));
-  return {
-    schema: POLICY_EDIT_CANDIDATE_RECORD_SCHEMA,
-    policyEdit: validatePolicyEdit(snapshot)
-  };
-}
-function isPolicyEdit(input) {
-  try {
-    validatePolicyEdit(input);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function policyEditsFromFindings(findings, opts = {}) {
-  assertNoJudgeVerdict(findings, "policyEditsFromFindings");
-  const edits = [];
-  for (const finding of findings) {
-    const edit = policyEditFromFinding(finding, opts);
-    if (edit) edits.push(edit);
-  }
-  return edits;
-}
-function policyEditFromFinding(finding, opts = {}) {
-  assertNoJudgeVerdict([finding], "policyEditFromFinding");
-  if (!finding.recommended_action?.trim()) return null;
-  const expectedGain = resolveExpectedGain(finding, opts);
-  if (!expectedGain) return null;
-  const routed = routeFindingSubject(finding.subject, opts);
-  const risk = resolveRisk(finding, opts);
-  return makePolicyEdit({
-    axis: routed.axis,
-    target: routed.target,
-    change: { kind: "text", mode: "append", value: finding.recommended_action.trim() },
-    claim: finding.claim,
-    rationale: finding.rationale,
-    expectedGain,
-    confidence: finding.confidence,
-    risk,
-    validationPlan: finding.validation_plan,
-    source: {
-      findingIds: [finding.finding_id],
-      analystIds: [finding.analyst_id],
-      evidenceRefs: finding.evidence_refs,
-      derivedFromJudge: finding.derived_from_judge
+// src/analyst/default-registry.ts
+function buildDefaultAnalystRegistry(opts = {}) {
+  const registry = new AnalystRegistry(opts.registry);
+  if (opts.includeBehavioral !== false) {
+    registry.register(behavioralAnalyst());
+  }
+  if (opts.ai) {
+    const kinds = opts.kinds ?? DEFAULT_TRACE_ANALYST_KINDS;
+    for (const spec of kinds) {
+      registry.register(createTraceAnalystKind(spec, { ai: opts.ai, model: opts.model }));
     }
-  });
-}
-function scorePolicyEditReadiness(edit, opts = {}) {
-  validatePolicyEdit(edit);
-  const minExpectedGain = opts.minExpectedGain ?? DEFAULT_MIN_EXPECTED_GAIN;
-  const evidenceScore = Math.min(1, edit.source.evidenceRefs.length / 2);
-  const confidenceScore = clamp01(edit.confidence);
-  const gainScore = clamp01(
-    Math.abs(edit.expectedGain.amount) / Math.max(minExpectedGain * 5, 1e-3)
-  );
-  const targetScore = targetSpecificityScore(edit);
-  const riskPenalty = edit.risk === "high" && opts.allowHighRisk !== true ? 0.35 : edit.risk === "unknown" ? 0.2 : 0;
-  return clamp01(
-    0.3 * evidenceScore + 0.25 * confidenceScore + 0.25 * gainScore + 0.2 * targetScore - riskPenalty
-  );
-}
-function admitPolicyEdit(edit, opts = {}) {
-  const validated = validatePolicyEdit(edit);
-  const score = scorePolicyEditReadiness(validated, opts);
-  const reasons = [];
-  const minExpectedGain = opts.minExpectedGain ?? DEFAULT_MIN_EXPECTED_GAIN;
-  const requireEvidence = opts.requireEvidence ?? true;
-  if (validated.source.derivedFromJudge) {
-    reasons.push("source is judge-derived; judge verdicts cannot steer policy edits");
-  }
-  if (requireEvidence && validated.source.evidenceRefs.length === 0) {
-    reasons.push("missing evidence refs");
-  }
-  if (Math.abs(validated.expectedGain.amount) < minExpectedGain) {
-    reasons.push(`expected gain below ${minExpectedGain}`);
-  }
-  if (validated.risk === "high" && opts.allowHighRisk !== true) {
-    reasons.push("high-risk edit requires explicit allowHighRisk");
   }
-  if (score < (opts.minScore ?? DEFAULT_MIN_SCORE)) {
-    reasons.push(
-      `readiness score ${score.toFixed(3)} below ${(opts.minScore ?? DEFAULT_MIN_SCORE).toFixed(3)}`
-    );
-  }
-  return {
-    edit: validated,
-    decision: reasons.length === 0 ? "admit" : "reject",
-    score,
-    reasons
-  };
-}
-function applyPolicyEditToSurface(surface, edit) {
-  const validated = validatePolicyEdit(edit);
-  if (validated.change.kind === "text") return applyTextChange(surface, validated.change);
-  return applyJsonChange(surface, validated.change);
-}
-function routeFindingSubject(subject, opts) {
-  const parsed = parseFindingSubject(subject);
-  if (!parsed) {
-    return {
-      axis: opts.defaultAxis ?? "representation",
-      target: { surface: opts.defaultTargetSurface ?? "prompt" }
-    };
-  }
-  return routeParsedSubject(parsed);
-}
-function routeParsedSubject(subject) {
-  switch (subject.kind) {
-    case "system-prompt":
-      return {
-        axis: "representation",
-        target: { surface: "prompt", path: `system-prompt:${subject.section}` }
-      };
-    case "skill":
-      return {
-        axis: "agent_profile",
-        target: { surface: "agent-profile", path: `skill:${subject.name}` }
-      };
-    case "tool-doc":
-      return {
-        axis: "tool_contract",
-        target: {
-          surface: "tool-contract",
-          path: subject.aspect ? `tool-doc:${subject.tool}:${subject.aspect}` : `tool-doc:${subject.tool}`
-        }
-      };
-    case "new-tool":
-      return {
-        axis: "tool_contract",
-        target: { surface: "tool-contract", path: `new-tool:${subject.name}` }
-      };
-    case "mcp":
-      return {
-        axis: "tool_contract",
-        target: {
-          surface: "agent-profile",
-          path: subject.tool ? `mcp:${subject.server}:${subject.tool}` : `mcp:${subject.server}`
-        }
-      };
-    case "hook":
-      return {
-        axis: "agent_profile",
-        target: { surface: "agent-profile", path: `hook:${subject.name}` }
-      };
-    case "subagent":
-      return {
-        axis: "routing",
-        target: { surface: "agent-profile", path: `subagent:${subject.name}` }
-      };
-    case "workflow":
-      return {
-        axis: "routing",
-        target: { surface: "runtime-config", path: `workflow:${subject.name}` }
-      };
-    case "rollout-policy":
-      return {
-        axis: rolloutPolicyAxis(subject.field),
-        target: { surface: "runtime-config", path: `rollout-policy:${subject.field}` }
-      };
-    case "agent-profile":
-      return {
-        axis: "agent_profile",
-        target: { surface: "agent-profile", path: `agent-profile:${subject.field}` }
-      };
-    case "code":
-      return {
-        axis: "representation",
-        target: { surface: "code", path: `code:${subject.path}` }
-      };
-    case "rag":
-      return {
-        axis: "memory",
-        target: { surface: "memory", path: `rag:${subject.corpus}:${subject.docId}` }
-      };
-    case "memory":
-      return { axis: "memory", target: { surface: "memory", path: `memory:${subject.key}` } };
-    case "scaffolding":
-      return {
-        axis: "routing",
-        target: { surface: "runtime-config", path: `scaffolding:${subject.concern}` }
-      };
-    case "output-schema":
-      return {
-        axis: "output_contract",
-        target: { surface: "runtime-config", path: `output-schema:${subject.field}` }
-      };
-    case "knowledge.wiki":
-      return {
-        axis: "memory",
-        target: {
-          surface: "memory",
-          path: `agent-knowledge:wiki:${subject.slug}${subject.heading ? `#${subject.heading}` : ""}`
-        }
-      };
-    case "knowledge.claim":
-      return {
-        axis: "memory",
-        target: { surface: "memory", path: `agent-knowledge:claim:${subject.topic}` }
-      };
-    case "knowledge.raw":
-      return {
-        axis: "memory",
-        target: { surface: "memory", path: `agent-knowledge:raw:${subject.sourceId}` }
-      };
-    case "knowledge.stale":
-      return {
-        axis: "memory",
-        target: { surface: "memory", path: `agent-knowledge:stale:${subject.slug}` }
-      };
-    case "websearch.outdated":
-      return {
-        axis: "memory",
-        target: { surface: "memory", path: `websearch:outdated:${subject.topic}` }
-      };
-    case "prior-run-summary":
-      return {
-        axis: "memory",
-        target: { surface: "memory", path: `prior-run-summary:${subject.topic}` }
-      };
-    case "cluster":
-      return { axis: "representation", target: { surface: "prompt", path: subject.label } };
-  }
-}
-function rolloutPolicyAxis(field) {
-  const normalized = field.toLowerCase();
-  if (/budget|max(?:imum)?[-_. ]?(?:turns?|tokens?|cost)|timeout|deadline/.test(normalized)) {
-    return "budget";
-  }
-  if (/temperature|top[-_. ]?p|sampling|seed|shots?|parallel|concurrency/.test(normalized)) {
-    return "sampling";
-  }
-  if (/output|schema|format/.test(normalized)) return "output_contract";
-  return "routing";
-}
-function resolveExpectedGain(finding, opts) {
-  if (typeof opts.expectedGain === "function") return opts.expectedGain(finding) ?? null;
-  if (opts.expectedGain) return opts.expectedGain;
-  return readExpectedGainFromMetadata(finding.metadata);
-}
-function readExpectedGainFromMetadata(metadata) {
-  const raw = readPolicyEditMetadata(metadata)?.expectedGain ?? readPolicyEditMetadata(metadata)?.expected_gain;
-  if (!raw || typeof raw !== "object") return null;
-  const obj = raw;
-  if (typeof obj.metric !== "string" || obj.direction !== "increase" && obj.direction !== "decrease" || typeof obj.amount !== "number") {
-    return null;
-  }
-  const out = {
-    metric: obj.metric,
-    direction: obj.direction,
-    amount: obj.amount
-  };
-  if (obj.unit === "absolute" || obj.unit === "relative" || obj.unit === "percent" || obj.unit === "score") {
-    out.unit = obj.unit;
-  }
-  if (typeof obj.rationale === "string") out.rationale = obj.rationale;
-  return out;
-}
-function readPolicyEditMetadata(metadata) {
-  const raw = metadata?.policyEdit ?? metadata?.policy_edit;
-  return raw && typeof raw === "object" ? raw : null;
-}
-function resolveRisk(finding, opts) {
-  if (typeof opts.risk === "function") return opts.risk(finding);
-  if (opts.risk) return opts.risk;
-  const raw = readPolicyEditMetadata(finding.metadata)?.risk;
-  if (raw === "low" || raw === "medium" || raw === "high" || raw === "unknown") return raw;
-  if (finding.severity === "critical" || finding.severity === "high") return "medium";
-  return "low";
-}
-function applyTextChange(surface, change) {
-  if (typeof surface !== "string") {
-    throw new PolicyEditValidationError("text policy edits require a string surface", "change");
-  }
-  if (change.mode === "append") {
-    if (hasExactTextBlock(surface, change.value)) return surface;
-    return `${surface.trimEnd()}
-
-${change.value}`.trimStart();
-  }
-  if (change.mode === "prepend") {
-    if (hasExactTextBlock(surface, change.value)) return surface;
-    return `${change.value}
-
-${surface.trimStart()}`.trimEnd();
-  }
-  const find = expectNonEmpty(change.find, "change.find");
-  if (!surface.includes(find)) {
-    throw new PolicyEditValidationError("replace target not found in surface", "change.find");
-  }
-  return surface.replace(find, change.value);
-}
-function applyJsonChange(surface, change) {
-  const root = parseJsonSurface(surface);
-  const path = splitPath(change.path);
-  if (change.mode === "remove") return setJsonAtPath(root, path, void 0, "remove");
-  if (change.mode === "set") return setJsonAtPath(root, path, change.value ?? null, "set");
-  const prior = readJsonAtPath(root, path);
-  const merged = prior && typeof prior === "object" && !Array.isArray(prior) && change.value && typeof change.value === "object" && !Array.isArray(change.value) ? { ...prior, ...change.value } : change.value ?? null;
-  return setJsonAtPath(root, path, merged, "set");
-}
-function parseJsonSurface(surface) {
-  if (typeof surface === "string") {
-    try {
-      return JSON.parse(surface);
-    } catch {
-      throw new PolicyEditValidationError(
-        "json policy edits require a JSON string surface",
-        "change"
-      );
-    }
-  }
-  assertJson(surface, "surface");
-  return surface;
-}
-function readJsonAtPath(root, path) {
-  let cursor = root;
-  for (const part of path) {
-    if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) return void 0;
-    cursor = cursor[part];
-  }
-  return cursor;
-}
-function setJsonAtPath(root, path, value, mode) {
-  if (path.length === 0) {
-    if (mode === "remove") return null;
-    return value ?? null;
-  }
-  if (root === null || typeof root !== "object" || Array.isArray(root)) {
-    throw new PolicyEditValidationError("json edit root must be an object", "change.path");
-  }
-  const out = { ...root };
-  let cursor = out;
-  for (let i = 0; i < path.length - 1; i++) {
-    const key = path[i];
-    const existing = cursor[key];
-    if (mode === "remove" && (!existing || typeof existing !== "object" || Array.isArray(existing))) {
-      return out;
-    }
-    const next = existing && typeof existing === "object" && !Array.isArray(existing) ? { ...existing } : {};
-    cursor[key] = next;
-    cursor = next;
-  }
-  const leaf = path[path.length - 1];
-  if (mode === "remove") delete cursor[leaf];
-  else cursor[leaf] = value ?? null;
-  return out;
-}
-function normalizePolicyEdit(input) {
-  const out = {
-    schemaVersion: "policy-edit/v1",
-    axis: input.axis,
-    target: normalizeTarget(input.target),
-    change: normalizeChange(input.change),
-    claim: input.claim.trim(),
-    expectedGain: normalizeExpectedGain(input.expectedGain),
-    confidence: input.confidence,
-    risk: input.risk,
-    source: normalizeSource(input.source)
-  };
-  if (input.rationale?.trim()) out.rationale = input.rationale.trim();
-  if (input.validationPlan?.trim()) out.validationPlan = input.validationPlan.trim();
-  if (input.metadata) out.metadata = input.metadata;
-  return out;
-}
-function assertJsonSafe(value, path, ancestors = /* @__PURE__ */ new WeakSet()) {
-  if (value === null || typeof value === "string" || typeof value === "boolean") return;
-  if (typeof value === "number") {
-    if (Number.isFinite(value)) return;
-    throw new PolicyEditValidationError("expected finite JSON number", path);
-  }
-  if (typeof value !== "object") {
-    throw new PolicyEditValidationError("expected JSON-safe value", path);
-  }
-  if (ancestors.has(value)) {
-    throw new PolicyEditValidationError("cyclic value is not JSON-safe", path);
-  }
-  ancestors.add(value);
-  if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      if (!(i in value)) {
-        throw new PolicyEditValidationError("sparse array is not JSON-safe", `${path}.${i}`);
-      }
-      assertJsonSafe(value[i], `${path}.${i}`, ancestors);
-    }
-  } else {
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
-      throw new PolicyEditValidationError("expected plain JSON object", path);
-    }
-    if (Object.getOwnPropertySymbols(value).length > 0) {
-      throw new PolicyEditValidationError("symbol keys are not JSON-safe", path);
-    }
-    for (const [key, child] of Object.entries(value)) {
-      assertJsonSafe(child, `${path}.${key}`, ancestors);
-    }
-  }
-  ancestors.delete(value);
-}
-function normalizeTarget(target) {
-  const out = { surface: target.surface };
-  if (target.path?.trim()) out.path = target.path.trim();
-  if (target.agentProfileCell)
-    out.agentProfileCell = validateAgentProfileCell(target.agentProfileCell);
-  if (target.label?.trim()) out.label = target.label.trim();
-  return out;
-}
-function normalizeChange(change) {
-  if (change.kind === "text") {
-    const out2 = {
-      kind: "text",
-      mode: change.mode,
-      value: change.value.trim()
-    };
-    if (change.find?.trim()) out2.find = change.find.trim();
-    return out2;
-  }
-  const out = {
-    kind: "json",
-    mode: change.mode,
-    path: change.path.trim()
-  };
-  if (change.value !== void 0) out.value = change.value;
-  return out;
-}
-function normalizeExpectedGain(gain) {
-  const out = {
-    metric: gain.metric.trim(),
-    direction: gain.direction,
-    amount: gain.amount
-  };
-  if (gain.unit) out.unit = gain.unit;
-  if (gain.rationale?.trim()) out.rationale = gain.rationale.trim();
-  return out;
-}
-function normalizeSource(source) {
-  const out = {
-    findingIds: uniqueSorted(source.findingIds.map((s) => s.trim()).filter(Boolean)),
-    analystIds: uniqueSorted(source.analystIds.map((s) => s.trim()).filter(Boolean)),
-    evidenceRefs: source.evidenceRefs
-  };
-  if (source.derivedFromJudge) out.derivedFromJudge = true;
-  return out;
-}
-function validateTarget(target) {
-  if (!target || typeof target !== "object")
-    throw new PolicyEditValidationError("expected object", "target");
-  const obj = target;
-  expectOneOf(obj.surface, POLICY_EDIT_TARGET_SURFACES, "target.surface");
-  if (obj.path !== void 0) expectString(obj.path, "target.path");
-  if (obj.label !== void 0) expectString(obj.label, "target.label");
-  if (obj.agentProfileCell !== void 0) validateAgentProfileCell(obj.agentProfileCell);
-}
-function validateChange(change) {
-  if (!change || typeof change !== "object")
-    throw new PolicyEditValidationError("expected object", "change");
-  const obj = change;
-  if (obj.kind !== "text" && obj.kind !== "json") {
-    throw new PolicyEditValidationError("kind must be text or json", "change.kind");
-  }
-  if (obj.kind === "text") {
-    expectOneOf(obj.mode, ["append", "prepend", "replace"], "change.mode");
-    expectString(obj.value, "change.value");
-    if (obj.mode === "replace") expectString(obj.find, "change.find");
-    return;
-  }
-  expectOneOf(obj.mode, ["set", "merge", "remove"], "change.mode");
-  expectString(obj.path, "change.path");
-  if (obj.value !== void 0) assertJson(obj.value, "change.value");
-}
-function validateExpectedGain(gain) {
-  if (!gain || typeof gain !== "object")
-    throw new PolicyEditValidationError("expected object", "expectedGain");
-  const obj = gain;
-  expectString(obj.metric, "expectedGain.metric");
-  expectOneOf(obj.direction, ["increase", "decrease"], "expectedGain.direction");
-  if (!Number.isFinite(obj.amount) || obj.amount <= 0) {
-    throw new PolicyEditValidationError(
-      "amount must be a positive finite number",
-      "expectedGain.amount"
-    );
-  }
-  if (obj.unit !== void 0) {
-    expectOneOf(
-      obj.unit,
-      ["absolute", "relative", "percent", "score"],
-      "expectedGain.unit"
-    );
-  }
-  if (obj.rationale !== void 0) expectString(obj.rationale, "expectedGain.rationale");
-}
-function validateSource(source) {
-  if (!source || typeof source !== "object")
-    throw new PolicyEditValidationError("expected object", "source");
-  const obj = source;
-  expectNonEmptyStringArray(obj.findingIds, "source.findingIds");
-  expectNonEmptyStringArray(obj.analystIds, "source.analystIds");
-  if (!Array.isArray(obj.evidenceRefs)) {
-    throw new PolicyEditValidationError("expected array", "source.evidenceRefs");
-  }
-  for (const [i, ref] of obj.evidenceRefs.entries())
-    validateEvidenceRef(ref, `source.evidenceRefs.${i}`);
-  if (obj.derivedFromJudge !== void 0 && typeof obj.derivedFromJudge !== "boolean") {
-    throw new PolicyEditValidationError("expected boolean", "source.derivedFromJudge");
-  }
-}
-function validateEvidenceRef(ref, path) {
-  if (!ref || typeof ref !== "object") throw new PolicyEditValidationError("expected object", path);
-  const obj = ref;
-  expectOneOf(obj.kind, ["span", "event", "artifact", "finding", "metric"], `${path}.kind`);
-  expectString(obj.uri, `${path}.uri`);
-  if (obj.excerpt !== void 0) expectString(obj.excerpt, `${path}.excerpt`);
-}
-function assertJson(value, path) {
-  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const [i, item] of value.entries()) assertJson(item, `${path}.${i}`);
-    return;
-  }
-  if (typeof value === "object") {
-    for (const [key, item] of Object.entries(value)) {
-      if (!key) throw new PolicyEditValidationError("empty object key", path);
-      assertJson(item, `${path}.${key}`);
-    }
-    return;
-  }
-  throw new PolicyEditValidationError("expected JSON-compatible value", path);
-}
-function targetSpecificityScore(edit) {
-  let score = 0.4;
-  if (edit.target.path) score += 0.25;
-  if (edit.target.agentProfileCell) score += 0.15;
-  if (edit.change.kind === "json" || edit.change.mode === "replace") score += 0.2;
-  else if (edit.change.value.length > 0) score += 0.1;
-  return clamp01(score);
-}
-function splitPath(path) {
-  const parts = path.split(".").map((p) => p.trim()).filter(Boolean);
-  if (parts.length === 0)
-    throw new PolicyEditValidationError("path must not be empty", "change.path");
-  return parts;
-}
-function expectLiteral(value, expected, path) {
-  if (value !== expected) throw new PolicyEditValidationError(`expected ${expected}`, path);
-}
-function expectString(value, path) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new PolicyEditValidationError("expected non-empty string", path);
-  }
-}
-function expectNonEmpty(value, path) {
-  expectString(value, path);
-  return value;
-}
-function expectConfidence(value, path) {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
-    throw new PolicyEditValidationError("expected finite number in [0,1]", path);
-  }
-}
-function hasExactTextBlock(surface, value) {
-  const needle = normalizeTextBlock(value);
-  const normalizedSurface = surface.replace(/\r\n/g, "\n");
-  return [...normalizedSurface.split(/\n{2,}/), ...normalizedSurface.split("\n")].some(
-    (block) => normalizeTextBlock(block) === needle
-  );
-}
-function normalizeTextBlock(value) {
-  return value.replace(/\r\n/g, "\n").trim();
-}
-function expectOneOf(value, allowed, path) {
-  if (typeof value !== "string" || !allowed.includes(value)) {
-    throw new PolicyEditValidationError(`expected one of ${allowed.join(", ")}`, path);
-  }
-}
-function expectStringArray(value, path) {
-  if (!Array.isArray(value)) throw new PolicyEditValidationError("expected array", path);
-  for (const [i, item] of value.entries()) expectString(item, `${path}.${i}`);
-}
-function expectNonEmptyStringArray(value, path) {
-  expectStringArray(value, path);
-  if (value.length === 0) throw new PolicyEditValidationError("expected non-empty array", path);
-}
-function uniqueSorted(values) {
-  return [...new Set(values)].sort();
-}
-function clamp01(n) {
-  if (!Number.isFinite(n)) return 0;
-  if (n < 0) return 0;
-  if (n > 1) return 1;
-  return n;
-}
-
-// src/run-score.ts
-var DEFAULT_RUN_SCORE_WEIGHTS = {
-  success: 4,
-  goalProgress: 2,
-  repoGroundedness: 1.5,
-  driftPenalty: -1.5,
-  toolUseQuality: 1,
-  patchQuality: 1.25,
-  testReality: 1.5,
-  finalGate: 3,
-  reviewerBlockers: -2,
-  costUsd: -0.2,
-  wallSeconds: -0.1
-};
-function aggregateRunScore(score, weights = {}) {
-  const w = { ...DEFAULT_RUN_SCORE_WEIGHTS, ...weights };
-  return w.success * clamp012(score.success) + w.goalProgress * clamp012(score.goalProgress) + w.repoGroundedness * clamp012(score.repoGroundedness) + w.driftPenalty * clamp012(score.driftPenalty) + w.toolUseQuality * clamp012(score.toolUseQuality) + w.patchQuality * clamp012(score.patchQuality) + w.testReality * clamp012(score.testReality) + w.finalGate * clamp012(score.finalGate) + w.reviewerBlockers * clamp012(score.reviewerBlockers) + w.costUsd * Math.max(0, finiteOrZero(score.costUsd)) + w.wallSeconds * Math.max(0, finiteOrZero(score.wallSeconds) / 60);
-}
-function clamp012(value) {
-  if (!Number.isFinite(value)) return 0;
-  return Math.max(0, Math.min(1, value));
-}
-function finiteOrZero(value) {
-  return Number.isFinite(value) ? value : 0;
+  return registry;
 }
 
 export {
   createAnalystAi,
+  createChatClient,
+  computeTraceMetrics,
   computeFindingId,
   makeFinding,
+  deriveEfficiencyFindings,
+  behavioralAnalyst,
   FINDING_SUBJECT_KINDS,
   parseFindingSubject,
   renderFindingSubject,
@@ -2714,28 +2423,6 @@ export {
   KNOWLEDGE_POISONING_KIND_SPEC,
   DEFAULT_TRACE_ANALYST_KINDS,
   AnalystRegistry,
-  Mutex,
-  mapConcurrent,
-  isTraceObservable,
-  isJudgeVerdict,
-  assertNoJudgeVerdict,
-  POLICY_EDIT_AXES,
-  POLICY_EDIT_TARGET_SURFACES,
-  POLICY_EDIT_CANDIDATE_RECORD_SCHEMA,
-  PolicyEditValidationError,
-  makePolicyEdit,
-  computePolicyEditId,
-  validatePolicyEdit,
-  makePolicyEditCandidateRecord,
-  validatePolicyEditCandidateRecord,
-  isPolicyEdit,
-  policyEditsFromFindings,
-  policyEditFromFinding,
-  scorePolicyEditReadiness,
-  admitPolicyEdit,
-  applyPolicyEditToSurface,
-  DEFAULT_RUN_SCORE_WEIGHTS,
-  aggregateRunScore,
-  clamp012 as clamp01
+  buildDefaultAnalystRegistry
 };
-//# sourceMappingURL=chunk-DT7OXY3C.js.map
+//# sourceMappingURL=chunk-LUNF2SEL.js.map