@tangle-network/agent-runtime 0.8.0 → 0.11.0

package/dist/analyst-loop.js

@@ -0,0 +1,262 @@
+import "./chunk-DGUM43GV.js";
+
+// src/analyst-loop/run-analyst-loop.ts
+import { diffFindings } from "@tangle-network/agent-eval";
+async function runAnalystLoop(opts) {
+  const log = opts.log ?? defaultLog;
+  const strategy = opts.priorFindingsStrategy ?? "per-kind";
+  const emit = makeEmitter(opts.onEvent);
+  const startedAt = Date.now();
+  const baselineRunId = resolveBaselineRunId(opts);
+  const priorAll = baselineRunId ? opts.findingsStore?.loadRun(baselineRunId) ?? [] : [];
+  log("baseline resolved", { baselineRunId, prior_findings: priorAll.length });
+  await emit({
+    type: "baseline-resolved",
+    runId: opts.runId,
+    baselineRunId,
+    priorFindingCount: priorAll.length
+  });
+  const priorFindings = buildPriorFindingsInput(priorAll, strategy, opts.registry.list());
+  const analystResult = await runRegistry(opts, priorFindings, emit);
+  log("analyst run complete", {
+    findings: analystResult.findings.length,
+    cost_usd: analystResult.total_cost_usd,
+    per_analyst: analystResult.per_analyst.map((s) => ({
+      id: s.analyst_id,
+      status: s.status,
+      n: s.findings_count
+    }))
+  });
+  if (opts.findingsStore && analystResult.findings.length > 0) {
+    await opts.findingsStore.append(opts.runId, analystResult.findings);
+    await emit({
+      type: "findings-persisted",
+      runId: opts.runId,
+      count: analystResult.findings.length
+    });
+  }
+  let diff = null;
+  if (baselineRunId && analystResult.findings.length > 0) {
+    diff = diffFindings(
+      priorAll.map((f) => ({ ...f })),
+      analystResult.findings.map((f) => ({ ...f, run_id: opts.runId }))
+    );
+    log("diff vs baseline", {
+      appeared: diff.appeared.length,
+      disappeared: diff.disappeared.length,
+      persisted: diff.persisted.length,
+      changed: diff.changed.length
+    });
+    await emit({
+      type: "diff-computed",
+      runId: opts.runId,
+      baselineRunId,
+      appeared: diff.appeared.length,
+      disappeared: diff.disappeared.length,
+      persisted: diff.persisted.length,
+      changed: diff.changed.length
+    });
+  }
+  let knowledge = null;
+  if (opts.knowledgeAdapter) {
+    knowledge = await runKnowledgeAdapter(opts, analystResult.findings, log, emit);
+  }
+  let improvement = null;
+  if (opts.improvementAdapter) {
+    improvement = await runImprovementAdapter(opts, analystResult.findings, log, emit);
+  }
+  await emit({
+    type: "loop-completed",
+    runId: opts.runId,
+    durationMs: Date.now() - startedAt
+  });
+  return {
+    runId: opts.runId,
+    baselineRunId,
+    analystResult,
+    diff,
+    knowledge,
+    improvement
+  };
+}
+function makeEmitter(onEvent) {
+  if (!onEvent) return async () => {
+  };
+  return async (event) => {
+    await onEvent(event);
+  };
+}
+async function runRegistry(opts, priorFindings, emit) {
+  const reg = opts.registry;
+  if (typeof reg.runStream === "function" && opts.onEvent) {
+    let final = null;
+    for await (const ev of reg.runStream(opts.runId, opts.inputs, { priorFindings })) {
+      await emit({ type: "analyst", runId: opts.runId, event: ev });
+      if (ev.type === "run-completed") final = ev.result;
+    }
+    if (!final) {
+      throw new Error("runAnalystLoop: registry.runStream ended without run-completed event");
+    }
+    return final;
+  }
+  return opts.registry.run(opts.runId, opts.inputs, { priorFindings });
+}
+function resolveBaselineRunId(opts) {
+  if (opts.baselineRunId === null) return null;
+  if (typeof opts.baselineRunId === "string") return opts.baselineRunId;
+  if (!opts.findingsStore) return null;
+  const all = opts.findingsStore.loadAll();
+  let last = null;
+  for (const row of all) {
+    if (row.run_id === opts.runId) continue;
+    last = row.run_id;
+  }
+  return last;
+}
+function buildPriorFindingsInput(prior, strategy, registry) {
+  if (strategy === "none" || prior.length === 0) return void 0;
+  const stripped = prior.map(({ run_id: _run_id, ...rest }) => rest);
+  if (strategy === "wildcard") {
+    return { "*": stripped };
+  }
+  void registry;
+  return stripped;
+}
+async function runKnowledgeAdapter(opts, findings, log, emit) {
+  const adapter = opts.knowledgeAdapter;
+  const batch = await adapter.proposeFromFindings(findings);
+  log("knowledge.proposeFromFindings", {
+    proposals: batch.proposals.length,
+    skipped: batch.skipped,
+    errors: batch.errors.length
+  });
+  await emit({
+    type: "knowledge-proposed",
+    runId: opts.runId,
+    proposalCount: batch.proposals.length,
+    skipped: batch.skipped,
+    errors: batch.errors.length
+  });
+  const auto = opts.autoApply?.knowledge ?? false;
+  const threshold = opts.autoApply?.knowledgeConfidenceThreshold ?? 0.85;
+  if (!auto || !adapter.apply) {
+    await emit({
+      type: "knowledge-applied",
+      runId: opts.runId,
+      writtenCount: 0,
+      withheldForReview: batch.proposals.length
+    });
+    return {
+      proposals: batch.proposals,
+      applied: [],
+      skipped: batch.skipped,
+      errors: batch.errors,
+      withheld_for_review: batch.proposals.length
+    };
+  }
+  const findingsById = new Map(findings.map((f) => [f.finding_id, f]));
+  const safe = [];
+  let withheld = 0;
+  for (const p of batch.proposals) {
+    const src = p.sourceFindingId ? findingsById.get(p.sourceFindingId) : void 0;
+    if (!src) {
+      withheld += 1;
+      continue;
+    }
+    if (src.confidence < threshold) {
+      withheld += 1;
+      continue;
+    }
+    safe.push(p);
+  }
+  const result = await adapter.apply(safe);
+  log("knowledge.apply", {
+    applied: result.written.length,
+    withheld_for_review: withheld,
+    warnings: result.warnings.length
+  });
+  await emit({
+    type: "knowledge-applied",
+    runId: opts.runId,
+    writtenCount: result.written.length,
+    withheldForReview: withheld
+  });
+  return {
+    proposals: batch.proposals,
+    applied: result.written,
+    skipped: batch.skipped,
+    errors: batch.errors,
+    withheld_for_review: withheld
+  };
+}
+async function runImprovementAdapter(opts, findings, log, emit) {
+  const adapter = opts.improvementAdapter;
+  const batch = await adapter.proposeFromFindings(findings);
+  log("improvement.proposeFromFindings", {
+    edits: batch.edits.length,
+    skipped: batch.skipped,
+    errors: batch.errors.length
+  });
+  await emit({
+    type: "improvement-proposed",
+    runId: opts.runId,
+    editCount: batch.edits.length,
+    skipped: batch.skipped,
+    errors: batch.errors.length
+  });
+  const auto = opts.autoApply?.improvement ?? false;
+  const threshold = opts.autoApply?.improvementConfidenceThreshold ?? 0.9;
+  if (!auto || !adapter.apply) {
+    await emit({
+      type: "improvement-applied",
+      runId: opts.runId,
+      appliedCount: 0,
+      withheldForReview: batch.edits.length
+    });
+    return {
+      edits: batch.edits,
+      applied: [],
+      skipped: batch.skipped,
+      errors: batch.errors,
+      withheld_for_review: batch.edits.length
+    };
+  }
+  const findingsById = new Map(findings.map((f) => [f.finding_id, f]));
+  const safe = [];
+  let withheld = 0;
+  for (const e of batch.edits) {
+    const src = e.sourceFindingId ? findingsById.get(e.sourceFindingId) : void 0;
+    if (!src || src.confidence < threshold) {
+      withheld += 1;
+      continue;
+    }
+    safe.push(e);
+  }
+  const result = await adapter.apply(safe);
+  log("improvement.apply", {
+    applied: result.applied.length,
+    withheld_for_review: withheld,
+    warnings: result.warnings.length
+  });
+  await emit({
+    type: "improvement-applied",
+    runId: opts.runId,
+    appliedCount: result.applied.length,
+    withheldForReview: withheld
+  });
+  return {
+    edits: batch.edits,
+    applied: result.applied,
+    skipped: batch.skipped,
+    errors: batch.errors,
+    withheld_for_review: withheld
+  };
+}
+function defaultLog(msg, fields) {
+  if (fields) console.log(`[analyst-loop] ${msg}`, fields);
+  else console.log(`[analyst-loop] ${msg}`);
+}
+export {
+  runAnalystLoop
+};
+//# sourceMappingURL=analyst-loop.js.map

package/dist/analyst-loop.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/analyst-loop/run-analyst-loop.ts"],"sourcesContent":["/**\n * `runAnalystLoop` — the one call agent apps reach for to close the\n * recursive-self-improvement loop.\n *\n *   1. Load baseline findings (last run, or the slice the caller specifies)\n *   2. Run the analyst registry with priorFindings injected\n *   3. Persist the new run's findings to the ledger\n *   4. Diff the new run against the baseline\n *   5. Hand the findings to the knowledge adapter → proposals (and\n *      optionally apply them) → wiki edits\n *   6. Hand the findings to the improvement adapter → prompt / tool /\n *      scaffolding edits (review-only by default)\n *   7. Return a single report the consumer renders / persists / acts on.\n *\n * Adapters are optional: the loop works as a \"run + diff + report\"\n * primitive when no adapters are wired; it closes end-to-end when\n * both adapters are wired.\n */\n\nimport type { AnalystFinding, AnalystRunResult, FindingsDiff } from '@tangle-network/agent-eval'\nimport { diffFindings } from '@tangle-network/agent-eval'\n\nimport type {\n  AnalystLoopEvent,\n  AnalystRegistryStreamingLike,\n  ImprovementReport,\n  KnowledgeReport,\n  RunAnalystLoopOpts,\n  RunAnalystLoopResult,\n} from './types'\n\nexport async function runAnalystLoop<TProposal = unknown, TEdit = unknown>(\n  opts: RunAnalystLoopOpts,\n): Promise<RunAnalystLoopResult<TProposal, TEdit>> {\n  const log = opts.log ?? defaultLog\n  const strategy = opts.priorFindingsStrategy ?? 'per-kind'\n  const emit = makeEmitter(opts.onEvent)\n  const startedAt = Date.now()\n\n  // 1. Resolve baseline + load prior findings.\n  const baselineRunId = resolveBaselineRunId(opts)\n  const priorAll: ReadonlyArray<AnalystFinding & { run_id: string }> = baselineRunId\n    ? (opts.findingsStore?.loadRun(baselineRunId) ?? [])\n    : []\n  log('baseline resolved', { baselineRunId, prior_findings: priorAll.length })\n  await emit({\n    type: 'baseline-resolved',\n    runId: opts.runId,\n    baselineRunId,\n    priorFindingCount: priorAll.length,\n  })\n\n  // 2. Run the registry. Strategy controls how analysts see priors.\n  //    When the registry exposes runStream, forward each event verbatim\n  //    so subscribers see per-analyst progress in real time.\n  const priorFindings = buildPriorFindingsInput(priorAll, strategy, opts.registry.list())\n  const analystResult = await runRegistry(opts, priorFindings, emit)\n  log('analyst run complete', {\n    findings: analystResult.findings.length,\n    cost_usd: analystResult.total_cost_usd,\n    per_analyst: analystResult.per_analyst.map((s) => ({\n      id: s.analyst_id,\n      status: s.status,\n      n: s.findings_count,\n    })),\n  })\n\n  // 3. Persist the new run before any side-effecting adapter runs so\n  //    the ledger is the source of truth even if an adapter throws.\n  if (opts.findingsStore && analystResult.findings.length > 0) {\n    await opts.findingsStore.append(opts.runId, analystResult.findings)\n    await emit({\n      type: 'findings-persisted',\n      runId: opts.runId,\n      count: analystResult.findings.length,\n    })\n  }\n\n  // 4. Diff vs baseline.\n  let diff: FindingsDiff | null = null\n  if (baselineRunId && analystResult.findings.length > 0) {\n    diff = diffFindings(\n      priorAll.map((f) => ({ ...f })),\n      analystResult.findings.map((f) => ({ ...f, run_id: opts.runId })),\n    )\n    log('diff vs baseline', {\n      appeared: diff.appeared.length,\n      disappeared: diff.disappeared.length,\n      persisted: diff.persisted.length,\n      changed: diff.changed.length,\n    })\n    await emit({\n      type: 'diff-computed',\n      runId: opts.runId,\n      baselineRunId,\n      appeared: diff.appeared.length,\n      disappeared: diff.disappeared.length,\n      persisted: diff.persisted.length,\n      changed: diff.changed.length,\n    })\n  }\n\n  // 5. Knowledge adapter — proposals + optional auto-apply.\n  let knowledge: KnowledgeReport<TProposal> | null = null\n  if (opts.knowledgeAdapter) {\n    knowledge = await runKnowledgeAdapter(opts, analystResult.findings, log, emit)\n  }\n\n  // 6. Improvement adapter — prompt / tool / scaffolding edits.\n  let improvement: ImprovementReport<TEdit> | null = null\n  if (opts.improvementAdapter) {\n    improvement = await runImprovementAdapter(opts, analystResult.findings, log, emit)\n  }\n\n  await emit({\n    type: 'loop-completed',\n    runId: opts.runId,\n    durationMs: Date.now() - startedAt,\n  })\n\n  return {\n    runId: opts.runId,\n    baselineRunId,\n    analystResult,\n    diff,\n    knowledge,\n    improvement,\n  }\n}\n\ntype Emitter = (event: AnalystLoopEvent) => Promise<void>\n\nfunction makeEmitter(onEvent: RunAnalystLoopOpts['onEvent']): Emitter {\n  if (!onEvent) return async () => {}\n  return async (event) => {\n    await onEvent(event)\n  }\n}\n\nasync function runRegistry(\n  opts: RunAnalystLoopOpts,\n  priorFindings: ReturnType<typeof buildPriorFindingsInput>,\n  emit: Emitter,\n): Promise<AnalystRunResult> {\n  const reg = opts.registry as AnalystRegistryStreamingLike\n  if (typeof reg.runStream === 'function' && opts.onEvent) {\n    let final: AnalystRunResult | null = null\n    for await (const ev of reg.runStream(opts.runId, opts.inputs, { priorFindings })) {\n      await emit({ type: 'analyst', runId: opts.runId, event: ev })\n      if (ev.type === 'run-completed') final = ev.result\n    }\n    if (!final) {\n      throw new Error('runAnalystLoop: registry.runStream ended without run-completed event')\n    }\n    return final\n  }\n  return opts.registry.run(opts.runId, opts.inputs, { priorFindings })\n}\n\nfunction resolveBaselineRunId(opts: RunAnalystLoopOpts): string | null {\n  if (opts.baselineRunId === null) return null\n  if (typeof opts.baselineRunId === 'string') return opts.baselineRunId\n  if (!opts.findingsStore) return null\n  const all = opts.findingsStore.loadAll()\n  let last: string | null = null\n  for (const row of all) {\n    if (row.run_id === opts.runId) continue\n    last = row.run_id\n  }\n  return last\n}\n\nfunction buildPriorFindingsInput(\n  prior: ReadonlyArray<AnalystFinding & { run_id: string }>,\n  strategy: 'per-kind' | 'wildcard' | 'none',\n  registry: ReadonlyArray<{ id: string }>,\n): ReadonlyArray<AnalystFinding> | Record<string, ReadonlyArray<AnalystFinding>> | undefined {\n  if (strategy === 'none' || prior.length === 0) return undefined\n  const stripped = prior.map(({ run_id: _run_id, ...rest }) => rest as AnalystFinding)\n  if (strategy === 'wildcard') {\n    return { '*': stripped }\n  }\n  void registry\n  return stripped\n}\n\nasync function runKnowledgeAdapter<TProposal>(\n  opts: RunAnalystLoopOpts,\n  findings: ReadonlyArray<AnalystFinding>,\n  log: NonNullable<RunAnalystLoopOpts['log']>,\n  emit: Emitter,\n): Promise<KnowledgeReport<TProposal>> {\n  const adapter = opts.knowledgeAdapter!\n  const batch = await adapter.proposeFromFindings(findings)\n  log('knowledge.proposeFromFindings', {\n    proposals: batch.proposals.length,\n    skipped: batch.skipped,\n    errors: batch.errors.length,\n  })\n  await emit({\n    type: 'knowledge-proposed',\n    runId: opts.runId,\n    proposalCount: batch.proposals.length,\n    skipped: batch.skipped,\n    errors: batch.errors.length,\n  })\n\n  const auto = opts.autoApply?.knowledge ?? false\n  const threshold = opts.autoApply?.knowledgeConfidenceThreshold ?? 0.85\n\n  if (!auto || !adapter.apply) {\n    await emit({\n      type: 'knowledge-applied',\n      runId: opts.runId,\n      writtenCount: 0,\n      withheldForReview: batch.proposals.length,\n    })\n    return {\n      proposals: batch.proposals as TProposal[],\n      applied: [],\n      skipped: batch.skipped,\n      errors: batch.errors,\n      withheld_for_review: batch.proposals.length,\n    }\n  }\n\n  const findingsById = new Map(findings.map((f) => [f.finding_id, f]))\n  const safe: TProposal[] = []\n  let withheld = 0\n  for (const p of batch.proposals as Array<TProposal & { sourceFindingId?: string }>) {\n    const src = p.sourceFindingId ? findingsById.get(p.sourceFindingId) : undefined\n    if (!src) {\n      withheld += 1\n      continue\n    }\n    if (src.confidence < threshold) {\n      withheld += 1\n      continue\n    }\n    safe.push(p)\n  }\n  const result = await adapter.apply(safe)\n  log('knowledge.apply', {\n    applied: result.written.length,\n    withheld_for_review: withheld,\n    warnings: result.warnings.length,\n  })\n  await emit({\n    type: 'knowledge-applied',\n    runId: opts.runId,\n    writtenCount: result.written.length,\n    withheldForReview: withheld,\n  })\n  return {\n    proposals: batch.proposals as TProposal[],\n    applied: result.written,\n    skipped: batch.skipped,\n    errors: batch.errors,\n    withheld_for_review: withheld,\n  }\n}\n\nasync function runImprovementAdapter<TEdit>(\n  opts: RunAnalystLoopOpts,\n  findings: ReadonlyArray<AnalystFinding>,\n  log: NonNullable<RunAnalystLoopOpts['log']>,\n  emit: Emitter,\n): Promise<ImprovementReport<TEdit>> {\n  const adapter = opts.improvementAdapter!\n  const batch = await adapter.proposeFromFindings(findings)\n  log('improvement.proposeFromFindings', {\n    edits: batch.edits.length,\n    skipped: batch.skipped,\n    errors: batch.errors.length,\n  })\n  await emit({\n    type: 'improvement-proposed',\n    runId: opts.runId,\n    editCount: batch.edits.length,\n    skipped: batch.skipped,\n    errors: batch.errors.length,\n  })\n\n  const auto = opts.autoApply?.improvement ?? false\n  const threshold = opts.autoApply?.improvementConfidenceThreshold ?? 0.9\n\n  if (!auto || !adapter.apply) {\n    await emit({\n      type: 'improvement-applied',\n      runId: opts.runId,\n      appliedCount: 0,\n      withheldForReview: batch.edits.length,\n    })\n    return {\n      edits: batch.edits as TEdit[],\n      applied: [],\n      skipped: batch.skipped,\n      errors: batch.errors,\n      withheld_for_review: batch.edits.length,\n    }\n  }\n\n  const findingsById = new Map(findings.map((f) => [f.finding_id, f]))\n  const safe: TEdit[] = []\n  let withheld = 0\n  for (const e of batch.edits as Array<TEdit & { sourceFindingId?: string }>) {\n    const src = e.sourceFindingId ? findingsById.get(e.sourceFindingId) : undefined\n    if (!src || src.confidence < threshold) {\n      withheld += 1\n      continue\n    }\n    safe.push(e)\n  }\n  const result = await adapter.apply(safe)\n  log('improvement.apply', {\n    applied: result.applied.length,\n    withheld_for_review: withheld,\n    warnings: result.warnings.length,\n  })\n  await emit({\n    type: 'improvement-applied',\n    runId: opts.runId,\n    appliedCount: result.applied.length,\n    withheldForReview: withheld,\n  })\n  return {\n    edits: batch.edits as TEdit[],\n    applied: result.applied,\n    skipped: batch.skipped,\n    errors: batch.errors,\n    withheld_for_review: withheld,\n  }\n}\n\nfunction defaultLog(msg: string, fields?: Record<string, unknown>): void {\n  if (fields) console.log(`[analyst-loop] ${msg}`, fields)\n  else console.log(`[analyst-loop] ${msg}`)\n}\n"],"mappings":";;;AAoBA,SAAS,oBAAoB;AAW7B,eAAsB,eACpB,MACiD;AACjD,QAAM,MAAM,KAAK,OAAO;AACxB,QAAM,WAAW,KAAK,yBAAyB;AAC/C,QAAM,OAAO,YAAY,KAAK,OAAO;AACrC,QAAM,YAAY,KAAK,IAAI;AAG3B,QAAM,gBAAgB,qBAAqB,IAAI;AAC/C,QAAM,WAA+D,gBAChE,KAAK,eAAe,QAAQ,aAAa,KAAK,CAAC,IAChD,CAAC;AACL,MAAI,qBAAqB,EAAE,eAAe,gBAAgB,SAAS,OAAO,CAAC;AAC3E,QAAM,KAAK;AAAA,IACT,MAAM;AAAA,IACN,OAAO,KAAK;AAAA,IACZ;AAAA,IACA,mBAAmB,SAAS;AAAA,EAC9B,CAAC;AAKD,QAAM,gBAAgB,wBAAwB,UAAU,UAAU,KAAK,SAAS,KAAK,CAAC;AACtF,QAAM,gBAAgB,MAAM,YAAY,MAAM,eAAe,IAAI;AACjE,MAAI,wBAAwB;AAAA,IAC1B,UAAU,cAAc,SAAS;AAAA,IACjC,UAAU,cAAc;AAAA,IACxB,aAAa,cAAc,YAAY,IAAI,CAAC,OAAO;AAAA,MACjD,IAAI,EAAE;AAAA,MACN,QAAQ,EAAE;AAAA,MACV,GAAG,EAAE;AAAA,IACP,EAAE;AAAA,EACJ,CAAC;AAID,MAAI,KAAK,iBAAiB,cAAc,SAAS,SAAS,GAAG;AAC3D,UAAM,KAAK,cAAc,OAAO,KAAK,OAAO,cAAc,QAAQ;AAClE,UAAM,KAAK;AAAA,MACT,MAAM;AAAA,MACN,OAAO,KAAK;AAAA,MACZ,OAAO,cAAc,SAAS;AAAA,IAChC,CAAC;AAAA,EACH;AAGA,MAAI,OAA4B;AAChC,MAAI,iBAAiB,cAAc,SAAS,SAAS,GAAG;AACtD,WAAO;AAAA,MACL,SAAS,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE;AAAA,MAC9B,cAAc,SAAS,IAAI,CAAC,OAAO,EAAE,GAAG,GAAG,QAAQ,KAAK,MAAM,EAAE;AAAA,IAClE;AACA,QAAI,oBAAoB;AAAA,MACtB,UAAU,KAAK,SAAS;AAAA,MACxB,aAAa,KAAK,YAAY;AAAA,MAC9B,WAAW,KAAK,UAAU;AAAA,MAC1B,SAAS,KAAK,QAAQ;AAAA,IACxB,CAAC;AACD,UAAM,KAAK;AAAA,MACT,MAAM;AAAA,MACN,OAAO,KAAK;AAAA,MACZ;AAAA,MACA,UAAU,KAAK,SAAS;AAAA,MACxB,aAAa,KAAK,YAAY;AAAA,MAC9B,WAAW,KAAK,UAAU;AAAA,MAC1B,SAAS,KAAK,QAAQ;AAAA,IACxB,CAAC;AAAA,EACH;AAGA,MAAI,YAA+C;AACnD,MAAI,KAAK,kBAAkB;AACzB,gBAAY,MAAM,oBAAoB,MAAM,cAAc,UAAU,KAAK,IAAI;AAAA,EAC/E;AAGA,MAAI,cAA+C;AACnD,MAAI,KAAK,oBAAoB;AAC3B,kBAAc,MAAM,sBAAsB,MAAM,cAAc,UAAU,KAAK,IAAI;AAAA,EACnF;AAEA,QAAM,KAAK;AAAA,IACT,MAAM;AAAA,IACN,OAAO,KAAK;AAAA,IACZ,YAAY,KAAK,IAAI,IAAI;AAAA,EAC3B,CAAC;AAED,SAAO;AAAA,IACL,OAAO,KAAK;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAIA,SAAS,YAAY,SAAiD;AACpE,MAAI,CAAC,QAAS,QAAO,YAAY;AAAA,EAAC;AAClC,SAAO,OAAO,UAAU;AACtB,UAAM,QAAQ,KAAK;AAAA,EACrB;AACF;AAEA,eAAe,YACb,MACA,eACA,MAC2B;AAC3B,QAAM,MAAM,KAAK;AACjB,MAAI,OAAO,IAAI,cAAc,cAAc,KAAK,SAAS;AACvD,QAAI,QAAiC;AACrC,qBAAiB,MAAM,IAAI,UAAU,KAAK,OAAO,KAAK,QAAQ,EAAE,cAAc,CAAC,GAAG;AAChF,YAAM,KAAK,EAAE,MAAM,WAAW,OAAO,KAAK,OAAO,OAAO,GAAG,CAAC;AAC5D,UAAI,GAAG,SAAS,gBAAiB,SAAQ,GAAG;AAAA,IAC9C;AACA,QAAI,CAAC,OAAO;AACV,YAAM,IAAI,MAAM,sEAAsE;AAAA,IACxF;AACA,WAAO;AAAA,EACT;AACA,SAAO,KAAK,SAAS,IAAI,KAAK,OAAO,KAAK,QAAQ,EAAE,cAAc,CAAC;AACrE;AAEA,SAAS,qBAAqB,MAAyC;AACrE,MAAI,KAAK,kBAAkB,KAAM,QAAO;AACxC,MAAI,OAAO,KAAK,kBAAkB,SAAU,QAAO,KAAK;AACxD,MAAI,CAAC,KAAK,cAAe,QAAO;AAChC,QAAM,MAAM,KAAK,cAAc,QAAQ;AACvC,MAAI,OAAsB;AAC1B,aAAW,OAAO,KAAK;AACrB,QAAI,IAAI,WAAW,KAAK,MAAO;AAC/B,WAAO,IAAI;AAAA,EACb;AACA,SAAO;AACT;AAEA,SAAS,wBACP,OACA,UACA,UAC2F;AAC3F,MAAI,aAAa,UAAU,MAAM,WAAW,EAAG,QAAO;AACtD,QAAM,WAAW,MAAM,IAAI,CAAC,EAAE,QAAQ,SAAS,GAAG,KAAK,MAAM,IAAsB;AACnF,MAAI,aAAa,YAAY;AAC3B,WAAO,EAAE,KAAK,SAAS;AAAA,EACzB;AACA,OAAK;AACL,SAAO;AACT;AAEA,eAAe,oBACb,MACA,UACA,KACA,MACqC;AACrC,QAAM,UAAU,KAAK;AACrB,QAAM,QAAQ,MAAM,QAAQ,oBAAoB,QAAQ;AACxD,MAAI,iCAAiC;AAAA,IACnC,WAAW,MAAM,UAAU;AAAA,IAC3B,SAAS,MAAM;AAAA,IACf,QAAQ,MAAM,OAAO;AAAA,EACvB,CAAC;AACD,QAAM,KAAK;AAAA,IACT,MAAM;AAAA,IACN,OAAO,KAAK;AAAA,IACZ,eAAe,MAAM,UAAU;AAAA,IAC/B,SAAS,MAAM;AAAA,IACf,QAAQ,MAAM,OAAO;AAAA,EACvB,CAAC;AAED,QAAM,OAAO,KAAK,WAAW,aAAa;AAC1C,QAAM,YAAY,KAAK,WAAW,gCAAgC;AAElE,MAAI,CAAC,QAAQ,CAAC,QAAQ,OAAO;AAC3B,UAAM,KAAK;AAAA,MACT,MAAM;AAAA,MACN,OAAO,KAAK;AAAA,MACZ,cAAc;AAAA,MACd,mBAAmB,MAAM,UAAU;AAAA,IACrC,CAAC;AACD,WAAO;AAAA,MACL,WAAW,MAAM;AAAA,MACjB,SAAS,CAAC;AAAA,MACV,SAAS,MAAM;AAAA,MACf,QAAQ,MAAM;AAAA,MACd,qBAAqB,MAAM,UAAU;AAAA,IACvC;AAAA,EACF;AAEA,QAAM,eAAe,IAAI,IAAI,SAAS,IAAI,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;AACnE,QAAM,OAAoB,CAAC;AAC3B,MAAI,WAAW;AACf,aAAW,KAAK,MAAM,WAA8D;AAClF,UAAM,MAAM,EAAE,kBAAkB,aAAa,IAAI,EAAE,eAAe,IAAI;AACtE,QAAI,CAAC,KAAK;AACR,kBAAY;AACZ;AAAA,IACF;AACA,QAAI,IAAI,aAAa,WAAW;AAC9B,kBAAY;AACZ;AAAA,IACF;AACA,SAAK,KAAK,CAAC;AAAA,EACb;AACA,QAAM,SAAS,MAAM,QAAQ,MAAM,IAAI;AACvC,MAAI,mBAAmB;AAAA,IACrB,SAAS,OAAO,QAAQ;AAAA,IACxB,qBAAqB;AAAA,IACrB,UAAU,OAAO,SAAS;AAAA,EAC5B,CAAC;AACD,QAAM,KAAK;AAAA,IACT,MAAM;AAAA,IACN,OAAO,KAAK;AAAA,IACZ,cAAc,OAAO,QAAQ;AAAA,IAC7B,mBAAmB;AAAA,EACrB,CAAC;AACD,SAAO;AAAA,IACL,WAAW,MAAM;AAAA,IACjB,SAAS,OAAO;AAAA,IAChB,SAAS,MAAM;AAAA,IACf,QAAQ,MAAM;AAAA,IACd,qBAAqB;AAAA,EACvB;AACF;AAEA,eAAe,sBACb,MACA,UACA,KACA,MACmC;AACnC,QAAM,UAAU,KAAK;AACrB,QAAM,QAAQ,MAAM,QAAQ,oBAAoB,QAAQ;AACxD,MAAI,mCAAmC;AAAA,IACrC,OAAO,MAAM,MAAM;AAAA,IACnB,SAAS,MAAM;AAAA,IACf,QAAQ,MAAM,OAAO;AAAA,EACvB,CAAC;AACD,QAAM,KAAK;AAAA,IACT,MAAM;AAAA,IACN,OAAO,KAAK;AAAA,IACZ,WAAW,MAAM,MAAM;AAAA,IACvB,SAAS,MAAM;AAAA,IACf,QAAQ,MAAM,OAAO;AAAA,EACvB,CAAC;AAED,QAAM,OAAO,KAAK,WAAW,eAAe;AAC5C,QAAM,YAAY,KAAK,WAAW,kCAAkC;AAEpE,MAAI,CAAC,QAAQ,CAAC,QAAQ,OAAO;AAC3B,UAAM,KAAK;AAAA,MACT,MAAM;AAAA,MACN,OAAO,KAAK;AAAA,MACZ,cAAc;AAAA,MACd,mBAAmB,MAAM,MAAM;AAAA,IACjC,CAAC;AACD,WAAO;AAAA,MACL,OAAO,MAAM;AAAA,MACb,SAAS,CAAC;AAAA,MACV,SAAS,MAAM;AAAA,MACf,QAAQ,MAAM;AAAA,MACd,qBAAqB,MAAM,MAAM;AAAA,IACnC;AAAA,EACF;AAEA,QAAM,eAAe,IAAI,IAAI,SAAS,IAAI,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;AACnE,QAAM,OAAgB,CAAC;AACvB,MAAI,WAAW;AACf,aAAW,KAAK,MAAM,OAAsD;AAC1E,UAAM,MAAM,EAAE,kBAAkB,aAAa,IAAI,EAAE,eAAe,IAAI;AACtE,QAAI,CAAC,OAAO,IAAI,aAAa,WAAW;AACtC,kBAAY;AACZ;AAAA,IACF;AACA,SAAK,KAAK,CAAC;AAAA,EACb;AACA,QAAM,SAAS,MAAM,QAAQ,MAAM,IAAI;AACvC,MAAI,qBAAqB;AAAA,IACvB,SAAS,OAAO,QAAQ;AAAA,IACxB,qBAAqB;AAAA,IACrB,UAAU,OAAO,SAAS;AAAA,EAC5B,CAAC;AACD,QAAM,KAAK;AAAA,IACT,MAAM;AAAA,IACN,OAAO,KAAK;AAAA,IACZ,cAAc,OAAO,QAAQ;AAAA,IAC7B,mBAAmB;AAAA,EACrB,CAAC;AACD,SAAO;AAAA,IACL,OAAO,MAAM;AAAA,IACb,SAAS,OAAO;AAAA,IAChB,SAAS,MAAM;AAAA,IACf,QAAQ,MAAM;AAAA,IACd,qBAAqB;AAAA,EACvB;AACF;AAEA,SAAS,WAAW,KAAa,QAAwC;AACvE,MAAI,OAAQ,SAAQ,IAAI,kBAAkB,GAAG,IAAI,MAAM;AAAA,MAClD,SAAQ,IAAI,kBAAkB,GAAG,EAAE;AAC1C;","names":[]}

package/dist/chunk-DGUM43GV.js

@@ -0,0 +1,11 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};
+//# sourceMappingURL=chunk-DGUM43GV.js.map

package/dist/chunk-DGUM43GV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { ControlEvalResult, KnowledgeRequirement, ControlBudget, KnowledgeReadinessReport, ControlStep, ControlDecision, UserQuestion, DataAcquisitionPlan, ControlRunResult, RunRecord, TraceStore, AgentEvalError, TraceEvent } from '@tangle-network/agent-eval';
 export { AgentEvalError, AgentEvalErrorCode, CaptureIntegrityError, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, ReplayError, RunRecord, UserQuestion, ValidationError, VerificationError } from '@tangle-network/agent-eval';
+import { AgentProfilePrompt, AgentProfileResources, AgentSubagentProfile, AgentProfile, SandboxInstance } from '@tangle-network/sandbox';
 
 /**
  * @stable
@@ -427,6 +428,105 @@ declare function createOpenAICompatibleBackend<TInput extends AgentBackendInput
     fetchImpl?: typeof fetch;
 }): AgentExecutionBackend<TInput>;
 
+/**
+ * Send an AgentProfile to a sandbox runtime for one chat turn. Composes
+ * the per-turn overlay (user message, prior history, knowledge flags)
+ * via `mergeAgentProfiles`, POSTs the full profile to the runtime's
+ * `/runtime/agents/run/stream` endpoint, and yields `RuntimeStreamEvent`s
+ * from the SSE response. The full profile — subagents, MCP servers,
+ * permissions, file mounts — reaches the sandbox by construction.
+ */
+
+/** A message in the chat turn's prior context. Provider-neutral. */
+interface ChatTurnMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    /** Optional metadata the consumer wants threaded through (timestamps, msg id, etc). */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Per-turn profile overlay. The caller's profile is the durable contract;
+ * the overlay carries volatile per-turn context (workspace facts, dynamic-
+ * advisor instructions, RAG hits) that the runtime should see but that
+ * doesn't belong in the canonical profile. Composed via `mergeAgentProfiles`.
+ */
+interface ChatTurnOverlay {
+    /** Volatile prompt additions: dynamic-advisor context, intake gate output, RAG citations. */
+    promptOverlay?: AgentProfilePrompt;
+    /** Per-turn additional file mounts (vault docs, recent uploads). */
+    resourcesOverlay?: AgentProfileResources;
+    /** Override or augment the subagent map for this turn (rare). */
+    subagentsOverlay?: Record<string, AgentSubagentProfile>;
+    /** Free-form metadata threaded into the runtime call. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Sandbox runtime contract — the subset of `SandboxInstance` `runChatTurn`
+ * actually invokes. Defined as an interface so consumers can inject a
+ * stub in tests without standing up a real sandbox.
+ */
+interface ChatTurnSandbox {
+    /** Sandbox identifier used in the runtime URL. */
+    readonly id: string;
+    /** Base URL of the sandbox runtime, e.g. `https://sandbox.tangle.tools/v1/sandboxes/&lt;id&gt;`. */
+    readonly runtimeUrl: string;
+    /** Optional bearer for the runtime call (sidecar auth). */
+    readonly authHeader?: {
+        name: string;
+        value: string;
+    };
+}
+interface RunChatTurnOptions {
+    /** Canonical agent profile — the durable contract. */
+    profile: AgentProfile;
+    /** Volatile per-turn additions. */
+    overlay?: ChatTurnOverlay;
+    /** Current user message. */
+    message: string;
+    /** Prior conversation. */
+    priorMessages: readonly ChatTurnMessage[];
+    /** Sandbox the turn should run inside. */
+    sandbox: ChatTurnSandbox;
+    /** Override model for this turn (otherwise profile.model.default is used). */
+    modelOverride?: string;
+    /** AbortSignal for cancellation (timeouts, client disconnect, etc). */
+    signal?: AbortSignal;
+    /** Override fetch (for tests). */
+    fetch?: typeof fetch;
+}
+/**
+ * Compose the per-turn profile via `mergeAgentProfiles(profile, overlay)`,
+ * POST the FULL composed profile to the sandbox's runtime streaming endpoint,
+ * and yield parsed `RuntimeStreamEvent`s. The runtime resolves prompt,
+ * subagents, MCP servers, and permissions from the profile — callers do not
+ * hand-craft a `backend.profile` shape.
+ *
+ *     for await (const event of runChatTurn({ profile, overlay, message, priorMessages, sandbox })) {
+ *       // event.type === 'message' / 'tool_call' / 'task_complete' / etc.
+ *     }
+ */
+declare function runChatTurn(options: RunChatTurnOptions): AsyncIterable<RuntimeStreamEvent>;
+/**
+ * Compose the per-turn AgentProfile. Public-and-pure so consumers can
+ * preview/log/persist the composed shape without firing a runtime call.
+ */
+declare function composeTurnProfile(base: AgentProfile, overlay: ChatTurnOverlay): AgentProfile;
+declare class ChatTurnError extends Error {
+    readonly status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}
+/**
+ * Convenience: build a `ChatTurnSandbox` from a full `SandboxInstance`. Most
+ * callers already have one of these from `client.create()`. The runtime URL
+ * is derived from the instance's transport configuration.
+ */
+declare function sandboxAsChatTurnTarget(instance: SandboxInstance, opts?: {
+    authHeader?: {
+        name: string;
+        value: string;
+    };
+}): ChatTurnSandbox;
+
 /**
  * @stable
  *
@@ -492,6 +592,124 @@ declare class RuntimeRunStateError extends AgentEvalError {
     });
 }
 
+/**
+ * Classify a user message against a profile's subagent map. Routes are
+ * declared on each `AgentSubagentProfile.metadata.matchers` (keywords +
+ * regex patterns); `classifyIntent` scores every subagent against the
+ * message and returns a typed result. Pure scoring — no LLM call. Caller
+ * decides whether the score is high enough to dispatch the subagent.
+ */
+
+/** Matcher shape attached to `subagent.metadata.matchers`. */
+interface SubagentMatcher {
+    /** Literal keywords (case-insensitive substring match). +1 per match unless `weight` overrides. */
+    keywords?: readonly string[];
+    /** Regex patterns (case-insensitive). +`weight` per match (default 1.5). */
+    patterns?: readonly (string | RegExp)[];
+    /** Per-rule weight override. */
+    weight?: number;
+    /** Minimum score for this subagent to be considered "matched". Default 1. */
+    minScore?: number;
+}
+interface ClassifyIntentResult {
+    /** Best-scoring subagent id; null if no subagent crossed `minScore`. */
+    id: string | null;
+    /** Best subagent's `AgentSubagentProfile`; null if no match. */
+    subagent: AgentSubagentProfile | null;
+    /** Score of the chosen subagent. */
+    score: number;
+    /** All subagent scores keyed by id — useful for telemetry / debugging. */
+    scores: Record<string, number>;
+    /** The matchers checked, for debugging "why didn't X route?" */
+    evaluated: Record<string, {
+        keywordHits: number;
+        patternHits: number;
+        minScore: number;
+    }>;
+}
+interface ClassifyIntentOptions {
+    /** Override the global default `minScore` (used when a subagent omits its own). */
+    defaultMinScore?: number;
+    /** Subagent ids to skip (e.g. scaffold-only subagents with `metadata.status === 'scaffold'`). */
+    skip?: readonly string[];
+    /** Only consider subagents whose metadata predicate returns true (e.g. `m =&gt; m.status === 'full'`). */
+    filter?: (subagent: AgentSubagentProfile, id: string) => boolean;
+}
+/**
+ * Pure intent classifier.
+ *
+ * For each subagent in `profile.subagents`: read `metadata.matchers`,
+ * score keyword + pattern hits against the user message, return the
+ * highest-scoring subagent (or null if none crossed `minScore`). No LLM
+ * call, no side effects. The runtime decides what to do with the result.
+ */
+declare function classifyIntent(profile: AgentProfile, message: string, opts?: ClassifyIntentOptions): ClassifyIntentResult;
+
+/**
+ * Validate an AgentProfile against canonical conformance rules: tool keys
+ * must map to an MCP server entry (not be shell capabilities masquerading
+ * as tools), subagents marked `metadata.status: 'scaffold'` must not be
+ * dispatchable, system prompts must be substantive. Pure — no I/O — so
+ * callers run it in a unit test or at module load to fail-fast on
+ * misconfiguration.
+ */
+
+interface ConformanceIssue {
+    severity: 'error' | 'warn';
+    /** Stable kebab-case code, useful for CI matching. */
+    code: string;
+    /** Profile path the issue is anchored to, e.g. `tools.bash` or `subagents.foo`. */
+    path: string;
+    /** Human-readable failure reason. */
+    message: string;
+}
+interface ConformanceResult {
+    valid: boolean;
+    errors: ConformanceIssue[];
+    warnings: ConformanceIssue[];
+}
+interface ConformanceOptions {
+    /**
+     * Shell-style capabilities that may appear in `permissions` but NEVER in
+     * `tools`. Declaring these as tools is decorative — the runtime doesn't
+     * dispatch them as MCP servers. Default covers the observed offenders.
+     */
+    knownShellCapabilities?: readonly string[];
+    /**
+     * If true, treat `subagents[id].metadata.status === 'scaffold'` as an
+     * error rather than a warning. Default false — scaffolds are honest
+     * stubs as long as the router skips them.
+     */
+    strictNoScaffolds?: boolean;
+    /**
+     * Names that may appear in `tools` without a corresponding MCP server or
+     * resource mount. Default empty — kills decorative-tool anti-pattern.
+     */
+    toolsAllowedWithoutMcp?: readonly string[];
+    /**
+     * Minimum length of `prompt.systemPrompt`. Profiles below this are
+     * likely incomplete. Default 800 chars (rough lower bound for the
+     * partner-tier prompts the product agents target).
+     */
+    minSystemPromptChars?: number;
+}
+/**
+ * Run all conformance checks against a profile. Designed to be called from
+ * a unit test:
+ *
+ *     it('legalAgentProfile passes conformance', () => {
+ *       const result = assertProfileConformance(legalAgentProfile, {
+ *         toolsAllowedWithoutMcp: ['agent-knowledge:query'],  // in-process function
+ *       })
+ *       expect(result.valid).toBe(true)
+ *       expect(result.errors).toEqual([])
+ *     })
+ *
+ * Issues carry `path` + `code` so tests can pinpoint failures rather than
+ * collapse to a generic "validation failed."
+ */
+declare function assertProfileConformance(profile: AgentProfile, opts?: ConformanceOptions): ConformanceResult;
+
 /**
  * @stable
  *
@@ -534,34 +752,27 @@ declare function runAgentTaskStream<TInput extends AgentBackendInput = AgentBack
 /**
  * @stable
  *
- * Canonical production-run lifecycle. ONE abstraction for "the agent did a
- * thing on behalf of a customer; record what it did, what it cost, and how it
- * ended." Consumer agents (legal, tax, gtm, creative, agent-builder) reach for
- * `startRuntimeRun` instead of inventing their own `agentRuns`-row helpers.
+ * Production-run lifecycle: record what the agent did on behalf of a customer,
+ * what it cost, and how it ended.
  *
  * Three concerns live in this module:
  *
  *  1. **Lifecycle state machine** — `running` -> `completed | failed | cancelled`,
- *     enforced by `RuntimeRunStateError`. Completion is idempotent (a second
- *     `complete()` call with the same status is a no-op so retries / cleanup
- *     paths don't double-fire side effects). A different terminal status is a
- *     state error.
+ *     enforced by `RuntimeRunStateError`. Completion is idempotent for the same
+ *     status (a second `complete()` call is a no-op so retries / cleanup paths
+ *     don't double-fire side effects). A different terminal status is a state
+ *     error.
  *
  *  2. **Cost ledger** — every `llm_call` event the handle observes contributes
  *     `tokensIn`, `tokensOut`, `costUsd`, and bumps `llmCalls`. Wall time is
  *     measured from `startRuntimeRun()` to `complete()`. Surface via
- *     `handle.cost()` for "cost per customer task" dashboards.
+ *     `handle.cost()` for cost-per-task dashboards.
  *
  *  3. **Persistence adapter** — `RuntimeRunPersistenceAdapter` is the seam
  *     consumers plug in to write a `RuntimeRunRow` to their D1 / postgres /
  *     KV store. The adapter receives a sanitized row shape; no telemetry
  *     payload bytes flow through it unless the consumer opts in via
  *     `RuntimeRunOptions.telemetryEvents`.
- *
- * The pattern replaces legal-agent's bespoke `completeProductionAgentRun` /
- * `persistRuntimeRun` pair from `eval-evidence.ts` + `api.chat.ts`. Both are
- * marked `@deprecated` in this release; consumers ditch them on their own
- * version bumps.
  */
 
 /** @stable */
@@ -770,16 +981,12 @@ declare function createRuntimeEventCollector<TState = unknown, TAction = unknown
 /**
  * @stable
  *
- * Streaming-event counterpart of `createRuntimeEventCollector`. Use this with
- * `runAgentTaskStream` — pass each yielded event through `onEvent` and read
- * the sanitized copies off `events`. The same `RuntimeTelemetryOptions`
- * redaction flags apply.
- *
- * Stream and non-stream events have different field shapes (timestamps,
- * sessions, text/tool deltas) so this is a sibling factory rather than an
- * overload of `createRuntimeEventCollector`; the unified-union alternative
- * was rejected because dispatching on `type` alone would silently misroute
- * events whose `type` literals overlap (`task_start`, `readiness_end`, etc.).
+ * Streaming-event counterpart of `createRuntimeEventCollector`. Pass each
+ * event yielded by `runAgentTaskStream` through `onEvent` and read the
+ * sanitized copies off `events`; the same `RuntimeTelemetryOptions` redaction
+ * flags apply. Kept distinct from `createRuntimeEventCollector` because the
+ * stream and non-stream event shapes overlap on `type` literals — dispatching
+ * on `type` alone would misroute events.
  */
 declare function createRuntimeStreamEventCollector(options?: RuntimeTelemetryOptions): RuntimeStreamEventCollector;
 
@@ -829,17 +1036,10 @@ declare function runtimeStreamServerSentEvent(event: RuntimeStreamEvent, options
 /**
  * @stable
  *
- * Bridge from runtime stream events to the agent-eval trace schema.
- *
- * Before this module, consumers (legal-agent's chat.ts, gtm-agent's runtime
- * route) hand-rolled an adapter from `RuntimeStreamEvent` -> `TraceEvent` per
- * repo. The mapping is mechanical and the destination schema is owned by
- * agent-eval, so the adapter belongs in runtime, not in N consumer repos.
+ * One-way bridge from `RuntimeStreamEvent` to agent-eval's `TraceEvent`.
  *
- * The bridge is intentionally one-way (runtime -> agent-eval). The reverse
- * mapping is degenerate (agent-eval events have no session / task affinity)
- * and would invite consumers to round-trip through agent-eval, defeating the
- * point of the runtime-specific shape.
+ * The reverse direction is intentionally unsupported — agent-eval events
+ * have no session / task affinity, so round-tripping would erase information.
  */
 
 /** @stable */
@@ -890,4 +1090,4 @@ declare function createTraceBridge(options: TraceBridgeOptions): TraceBridge;
  */
 declare function toAgentEvalTrace(event: RuntimeStreamEvent, options: TraceBridgeOptions): TraceEvent | undefined;
 
-export { type AgentAdapter, type AgentBackendContext, type AgentBackendInput, type AgentExecutionBackend, type AgentKnowledgeProvider, type AgentRuntimeEvent, type AgentRuntimeEventSink, type AgentTaskContext, type AgentTaskRunResult, type AgentTaskRunSummary, type AgentTaskSpec, type AgentTaskStatus, BackendTransportError, InMemoryRuntimeSessionStore, type KnowledgeReadinessDecision, type RunAgentTaskOptions, type RunAgentTaskStreamOptions, type RuntimeEventCollector, type RuntimeRunCompleteInput, type RuntimeRunCost, type RuntimeRunHandle, type RuntimeRunOptions, type RuntimeRunPersistenceAdapter, type RuntimeRunRow, RuntimeRunStateError, type RuntimeRunStatus, type RuntimeSession, type RuntimeSessionStore, type RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeStreamEventSink, type RuntimeStreamEventSummary, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SanitizedKnowledgeRequirement, type ServerSentEventOptions, SessionMismatchError, type TraceBridge, type TraceBridgeOptions, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, createTraceBridge, decideKnowledgeReadiness, encodeServerSentEvent, readinessServerSentEvent, runAgentTask, runAgentTaskStream, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, startRuntimeRun, summarizeAgentTaskRun, toAgentEvalTrace };
+export { type AgentAdapter, type AgentBackendContext, type AgentBackendInput, type AgentExecutionBackend, type AgentKnowledgeProvider, type AgentRuntimeEvent, type AgentRuntimeEventSink, type AgentTaskContext, type AgentTaskRunResult, type AgentTaskRunSummary, type AgentTaskSpec, type AgentTaskStatus, BackendTransportError, ChatTurnError, type ChatTurnMessage, type ChatTurnOverlay, type ChatTurnSandbox, type ClassifyIntentOptions, type ClassifyIntentResult, type ConformanceIssue, type ConformanceOptions, type ConformanceResult, InMemoryRuntimeSessionStore, type KnowledgeReadinessDecision, type RunAgentTaskOptions, type RunAgentTaskStreamOptions, type RunChatTurnOptions, type RuntimeEventCollector, type RuntimeRunCompleteInput, type RuntimeRunCost, type RuntimeRunHandle, type RuntimeRunOptions, type RuntimeRunPersistenceAdapter, type RuntimeRunRow, RuntimeRunStateError, type RuntimeRunStatus, type RuntimeSession, type RuntimeSessionStore, type RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeStreamEventSink, type RuntimeStreamEventSummary, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SanitizedKnowledgeRequirement, type ServerSentEventOptions, SessionMismatchError, type SubagentMatcher, type TraceBridge, type TraceBridgeOptions, assertProfileConformance, classifyIntent, composeTurnProfile, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, createTraceBridge, decideKnowledgeReadiness, encodeServerSentEvent, readinessServerSentEvent, runAgentTask, runAgentTaskStream, runChatTurn, runtimeStreamServerSentEvent, sandboxAsChatTurnTarget, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, startRuntimeRun, summarizeAgentTaskRun, toAgentEvalTrace };