@tangle-network/agent-runtime 0.104.0 → 0.106.0

package/dist/intelligence.d.ts

@@ -1,26 +1,19 @@
-import { AgentProfileDiff, AgentProfile, AgentImprovementProposal, AgentProfileMcpServer, AgentImprovementActivationTarget, Sha256Digest, AgentImprovementSurface, AgentCandidateExperiment, AgentImprovementActivationIntent, AgentCandidateExperimentMaterial, AgentImprovementMeasuredComparison, AgentCandidateExperimentMeasurement, AgentImprovementReviewDecision, AgentCandidateBenchmarkCellRef, AgentImprovementReview, AgentImprovementActivation, CandidateExecutionEvidence, AgentImprovementActivationTargetState, AgentImprovementActivationTargetTransition } from '@tangle-network/agent-interface';
-export { AgentImprovementActivation, AgentImprovementActivationIntent, AgentImprovementActivationOutcome, AgentImprovementActivationResult, AgentImprovementMeasuredComparison, AgentImprovementProposal, AgentImprovementReview, AgentImprovementReviewDecision, CandidateExecutionEvidence, AgentCandidateProfileActivation as CandidateProfileMaterialization } from '@tangle-network/agent-interface';
-import { c as LoopTraceEvent } from './types-BCoemcXU.js';
-import { b as ToolSpec, c as RuntimeTelemetryOptions } from './sanitize-DEbPNtyI.js';
-import { R as RuntimeStreamEvent } from './types-BwoZWq-i.js';
-import { P as PrepareAgentCandidateExecutionOptions, E as ExecutePreparedAgentCandidateOptions, A as AgentCandidateExecutionClaimStore, C as CreateProtectedAgentCandidateModelPortOptions } from './protected-model-port-DzkUY3HQ.js';
-export { p as parseCandidateProfileMaterialization } from './protected-model-port-DzkUY3HQ.js';
-import { A as AgentImprovementActivationTargetPlan } from './activation-Cm-9MMX1.js';
-export { a as AgentImprovementActivationReconciliation, b as AgentImprovementActivationResultStore, c as AgentImprovementActivationTransition, d as AgentImprovementActivationTransitionInput, C as CreateAgentImprovementActivationResultOptions, E as ExecuteAgentImprovementActivationInput, e as ExecuteAgentImprovementActivationOptions, f as createAgentImprovementActivationResult, g as executeAgentImprovementActivation, v as verifyAgentImprovementActivationResult } from './activation-Cm-9MMX1.js';
-import { TraceStore } from '@tangle-network/agent-eval';
-import { CandidateExperimentExecutionInput, Scenario, CompareCandidateExperimentOptions } from '@tangle-network/agent-eval/contract';
-import { AgentExactProcessResources } from '@tangle-network/agent-interface/environment-provider';
-import { c as AgentCandidateRunFinalization, d as AgentCandidateTaskExecution, e as AgentCandidateExecutionPorts, a as AgentCandidateBenchmarkGraderPort, b as AgentCandidateOutputArtifactPort, A as AgentCandidateExecutorPort } from './types-Cbp72qyu.js';
-import { AgentEnvironmentProviderRef, AgentEnvironmentProviderRegistry } from './environment-provider.js';
-import { AnalystFinding } from '@tangle-network/agent-eval/analyst';
-import { R as RunAnalystLoopOpts, a as RunAnalystLoopResult } from './types-CmYCMbFT.js';
-import { I as ImproveOptions, a as ImproveResult } from './improve--2A0gK1-.js';
-import '@tangle-network/sandbox';
-import './types-CvNwMzQt.js';
-import '@tangle-network/agent-eval/campaign';
-import './local-harness-CtK9dSny.js';
-import 'node:child_process';
-
+import { x as RuntimeStreamEvent } from "./types-C9j4qg6l.js";
+import { d as RunAnalystLoopOpts, f as RunAnalystLoopResult } from "./types-Cja5OTGh.js";
+import { b as LoopTraceEvent } from "./types-BevOjfTY.js";
+import { a as AgentEnvironmentProviderRef, o as AgentEnvironmentProviderRegistry } from "./environment-provider-IUGU3epE.js";
+import { D as RuntimeTelemetryOptions, m as ToolSpec } from "./local-harness-Dh8PJ0ot.js";
+import { h as ExecutePreparedAgentCandidateOptions, o as CreateProtectedAgentCandidateModelPortOptions, p as PrepareAgentCandidateExecutionOptions, u as parseAgentCandidateProfileActivation, x as AgentCandidateExecutionClaimStore } from "./protected-model-port-BP6Z4eau.js";
+import { D as AgentCandidateTaskExecution, E as AgentCandidateRunFinalization, a as AgentCandidateExecutionPorts, c as AgentCandidateExecutorPort, r as AgentCandidateBenchmarkGraderPort, y as AgentCandidateOutputArtifactPort } from "./types-BaIpb0XT.js";
+import { S as ImproveResult, h as ImproveMethodResult, n as defaultRedactor, r as resolveRedactor, t as Redactor, v as ImproveOptions } from "./redact-kbIOjfjM.js";
+import { a as AgentImprovementActivationTransitionInput, c as CreateAgentImprovementActivationResultOptions, d as ProfileImprovementActivationTransitionInput, f as SealedCandidateActivationTransitionInput, h as verifyAgentImprovementActivationResult, i as AgentImprovementActivationTransition, l as ExecuteAgentImprovementActivationInput, m as executeAgentImprovementActivation, n as AgentImprovementActivationResultStore, o as AgentProfileImprovementActivationOperation, p as createAgentImprovementActivationResult, r as AgentImprovementActivationTargetPlan, s as AgentProfileImprovementActivationTargetPlan, t as AgentImprovementActivationReconciliation, u as ExecuteAgentImprovementActivationOptions } from "./activation-DyWB0K6E.js";
+import { TraceStore } from "@tangle-network/agent-eval";
+import { OptimizationMethodComparison, OptimizationPackageSource, OptimizationTokenUsage } from "@tangle-network/agent-eval/campaign";
+import { AgentCandidateBenchmarkCellRef, AgentCandidateBundle, AgentCandidateExperiment, AgentCandidateExperimentMaterial, AgentCandidateExperimentMeasurement, AgentCandidateProfileActivation as CandidateProfileMaterialization, AgentImprovementActivation, AgentImprovementActivation as AgentImprovementActivation$1, AgentImprovementActivationIntent, AgentImprovementActivationIntent as AgentImprovementActivationIntent$1, AgentImprovementActivationOutcome, AgentImprovementActivationResult, AgentImprovementActivationTarget, AgentImprovementActivationTargetState, AgentImprovementActivationTargetTransition, AgentImprovementEvaluation, AgentImprovementEvaluation as AgentImprovementEvaluation$1, AgentImprovementMeasuredComparison, AgentImprovementMeasuredComparison as AgentImprovementMeasuredComparison$1, AgentImprovementProposal, AgentImprovementProposal as AgentImprovementProposal$1, AgentImprovementReview, AgentImprovementReview as AgentImprovementReview$1, AgentImprovementReviewDecision, AgentImprovementReviewDecision as AgentImprovementReviewDecision$1, AgentImprovementSurface, AgentProfile as AgentProfile$1, AgentProfileDiff, AgentProfileImprovementChange, AgentProfileImprovementExperiment, AgentProfileMcpServer, CandidateExecutionEvidence, CandidateExecutionEvidence as CandidateExecutionEvidence$1, Sha256Digest } from "@tangle-network/agent-interface";
+import { CandidateExperimentExecutionInput, CompareCandidateExperimentOptions, Scenario as Scenario$1 } from "@tangle-network/agent-eval/contract";
+import { AnalystFinding as AnalystFinding$1 } from "@tangle-network/agent-eval/analyst";
+import { AgentExactProcessResources } from "@tangle-network/agent-interface/environment-provider";
+//#region src/intelligence/effort.d.ts
 /**
  *
  * EffortPolicy — pure data, no execution. Resolves a named tier into a flat
@@ -50,21 +43,21 @@ type CorpusAccess = 'off' | 'read' | 'read-write';
  * self-executing.
  */
 interface EffortSettings {
-    /** Whether trace-derived analyst diagnosis may spawn. `false` ⇒ no analyst. */
-    analysts: boolean;
-    /** Cross-run corpus access this tier permits. */
-    corpus: CorpusAccess;
-    /** Parallel candidate width. `1` ⇒ single-shot, no breadth. */
-    fanout: number;
-    /** Whether multi-step improvement loops (refine / fanout-vote) may run. */
-    loops: boolean;
-    /**
-     * Ceiling, in USD, for INTELLIGENCE-class spawns only (analysts, corpus,
-     * loops) — NOT base inference. `0` refuses every intelligence spawn; `null`
-     * means uncapped (the spend lands on the Pareto receipt). Base-stream
-     * inference is billed on its own channel and is never constrained here.
-     */
-    intelligenceBudgetUsd: number | null;
+  /** Whether trace-derived analyst diagnosis may spawn. `false` ⇒ no analyst. */
+  analysts: boolean;
+  /** Cross-run corpus access this tier permits. */
+  corpus: CorpusAccess;
+  /** Parallel candidate width. `1` ⇒ single-shot, no breadth. */
+  fanout: number;
+  /** Whether multi-step improvement loops (refine / fanout-vote) may run. */
+  loops: boolean;
+  /**
+   * Ceiling, in USD, for INTELLIGENCE-class spawns only (analysts, corpus,
+   * loops) — NOT base inference. `0` refuses every intelligence spawn; `null`
+   * means uncapped (the spend lands on the Pareto receipt). Base-stream
+   * inference is billed on its own channel and is never constrained here.
+   */
+  intelligenceBudgetUsd: number | null;
 }
 /** Per-field overrides applied on top of a tier preset. Any subset of the
  *  resolved settings; each provided field wins over the preset. */
@@ -112,14 +105,14 @@ declare function isIntelligenceOff(settings: EffortSettings): boolean;
  *    the billing clamp (passed verbatim; `0` refuses every intelligence spawn).
  */
 interface EffortOverridesCompiled {
-    /** Construct + pass a `ScopeAnalyst`? `false` ⇒ omit it (degrade to the base agent). */
-    withAnalyst: boolean;
-    /** `ShapeBudget.fanout` width to pass to `runPersonified`. */
-    fanout: number;
-    /** Run the multi-step improvement cycle, or no-op it for this run? */
-    withLoops: boolean;
-    /** Intelligence-class spend ceiling. `0` refuses every intelligence spawn; `null` uncapped. */
-    intelligenceBudgetUsd: number | null;
+  /** Construct + pass a `ScopeAnalyst`? `false` ⇒ omit it (degrade to the base agent). */
+  withAnalyst: boolean;
+  /** `ShapeBudget.fanout` width to pass to `runPersonified`. */
+  fanout: number;
+  /** Run the multi-step improvement cycle, or no-op it for this run? */
+  withLoops: boolean;
+  /** Intelligence-class spend ceiling. `0` refuses every intelligence spawn; `null` uncapped. */
+  intelligenceBudgetUsd: number | null;
 }
 /**
  * Compile resolved `EffortSettings` into the orchestration overrides above. Pure: same
@@ -133,93 +126,33 @@ interface EffortOverridesCompiled {
  * compile to `withAnalyst: true`, the tier's `fanout`, and `withLoops: true`.
  */
 declare function compileEffort(settings: EffortSettings): EffortOverridesCompiled;
-
-/**
- *
- * Redaction for Intelligence trace export. The trace carries the customer's
- * real input/output; before any of it leaves the process it passes through a
- * `Redactor`. The default scrubs the obvious leak classes (API keys, bearer
- * tokens, emails, private keys) from strings and walks nested objects/arrays,
- * but a customer with domain-specific PII supplies their own `redact` hook.
- *
- * This is intentionally narrower than `src/sanitize.ts` (which redacts the
- * runtime's *event envelope* field-by-field): here the value is opaque
- * customer payload, so the scrub is value-shaped, not schema-shaped.
- *
- * @experimental
- */
-/** A redactor maps an arbitrary trace value to a safe-to-export value. Pure;
- *  must not throw on cyclic input (the default tolerates cycles). */
-type Redactor = (value: unknown) => unknown;
-/**
- * The built-in redactor. Walks objects and arrays; replaces values under
- * secret-bearing keys wholesale; scrubs in-value patterns from every string.
- * Cycle-safe (a seen-set short-circuits self-referential payloads to
- * `'[circular]'`), depth-bounded, and total — never throws on customer input.
- */
-declare function defaultRedactor(value: unknown): unknown;
-/**
- * Resolve the redactor a client uses. A caller-supplied hook replaces the
- * default entirely (the customer owns their PII rules); absent one, the
- * built-in `defaultRedactor` runs. Returning `false` is the explicit opt-out —
- * NO redaction, for a caller who has already sanitized upstream and wants raw
- * fidelity. Opt-out is loud (an explicit `false`), never a silent default.
- */
-declare function resolveRedactor(redact: Redactor | false | undefined): Redactor;
-
-/**
- *
- * Tangle Intelligence — the RECEIVE half of the loop (pull-by-default).
- *
- * The sibling Observe path (`./index`) sends run records UP to the plane. This
- * module pulls certified artifacts DOWN: it reads the tenant's promoted,
- * gate-certified profile from the deployed Intelligence plane so an approved
- * improvement actually reaches the running agent. The pull carries three things
- * the plane already composes:
- *   - the certified PROMPT surface + prompt-folding artifacts (delivered into the
- *     system prompt via {@link composeCertifiedPrompt} — the promoted prompt);
- *   - the typed profile DIFFS the plane has promoted, each with its held-out
- *     provenance (surfaced as PROPOSALS — never auto-applied at runtime);
- *   - the composed `agentProfile` those diffs fold to, for inspection.
- *
- * Pull contract (deployed plane): GET /v1/profiles/:target/composed →
- *   { target, generatedAt,
- *     promptSurface: {surface,surfaceHash,version,lift}|null,
- *     artifacts: { <artifactType>: [{path,content,contentHash,version,lift,promotedAt}] },
- *     capabilities: [{id,iface:{surface},binding:{path,content},provenance}],
- *     agentProfileDiffs: [{diff, provenance:{version,lift,contentHash,promotedAt}}],
- *     agentProfile: AgentProfile|null }
- * Auth: Bearer <apiKey> (the one TANGLE_API_KEY shared by router + sandbox +
- * intelligence), resolved to a tenant by platform-api's key-verify S2S contract.
- *
- * @experimental
- */
-
+//#endregion
+//#region src/intelligence/delivery.d.ts
 /** A promoted, certified artifact (one entry in the composed profile). */
 interface CertifiedArtifact {
-    path: string | null;
-    content: string;
-    contentHash: string;
-    version: number | null;
-    /** Held-out gate lift attached at certification, e.g. "+3.1pp" — never a
-     *  within-run claim. `null` when the promotion carried no lift record. */
-    lift: string | null;
-    promotedAt: string;
+  path: string | null;
+  content: string;
+  contentHash: string;
+  version: number | null;
+  /** Held-out gate lift attached at certification, e.g. "+3.1pp" — never a
+   *  within-run claim. `null` when the promotion carried no lift record. */
+  lift: string | null;
+  promotedAt: string;
 }
 /** The active promoted prompt surface for a target. */
 interface CertifiedPromptSurface {
-    surface: string;
-    surfaceHash: string;
-    version: number | null;
-    lift: string | null;
+  surface: string;
+  surfaceHash: string;
+  version: number | null;
+  lift: string | null;
 }
 /** The held-out provenance the plane's certify step stamps on a promoted diff.
  *  `lift` is the held-out gate lift (e.g. "+3.1pp"), never a within-run claim. */
 interface DiffProvenance {
-    version: number | null;
-    lift: string | null;
-    contentHash: string;
-    promotedAt: string;
+  version: number | null;
+  lift: string | null;
+  contentHash: string;
+  promotedAt: string;
 }
 /**
  * A gate-certified profile diff the plane has already promoted, plus the
@@ -229,61 +162,61 @@ interface DiffProvenance {
  * into a shipped profile. It is NEVER auto-applied at runtime.
  */
 interface ProposedProfileDiff {
-    diff: AgentProfileDiff;
-    provenance: DiffProvenance;
+  diff: AgentProfileDiff;
+  provenance: DiffProvenance;
 }
 /** The composed endpoint's per-capability summary — the narrow shape on the
  *  wire (id + surface + path/content + provenance). Distinct from the richer
  *  `CertifiedCapability` the capability resolver lowers a manifest into. */
 interface CertifiedCapabilitySummary {
-    id: string;
-    iface: {
-        surface: string;
-    };
-    binding: {
-        path: string | null;
-        content: string;
-    };
-    provenance: DiffProvenance;
+  id: string;
+  iface: {
+    surface: string;
+  };
+  binding: {
+    path: string | null;
+    content: string;
+  };
+  provenance: DiffProvenance;
 }
 /** The composed certified profile — exactly the shape the plane's
  *  `GET /v1/profiles/:target/composed` returns. */
 interface CertifiedProfile {
-    target: string;
-    generatedAt: string;
-    promptSurface: CertifiedPromptSurface | null;
-    artifacts: Record<string, CertifiedArtifact[]>;
-    /** The typed profile diffs the plane has promoted, each with held-out
-     *  provenance. Surfaced as proposals; never auto-applied. Empty when none. */
-    agentProfileDiffs: ProposedProfileDiff[];
-    /** The composed capability summaries the plane returns. Empty when none. */
-    capabilities: CertifiedCapabilitySummary[];
-    /** The composed profile the promoted diffs fold to, for inspection. `null`
-     *  when no diffs are promoted. */
-    agentProfile: AgentProfile | null;
+  target: string;
+  generatedAt: string;
+  promptSurface: CertifiedPromptSurface | null;
+  artifacts: Record<string, CertifiedArtifact[]>;
+  /** The typed profile diffs the plane has promoted, each with held-out
+   *  provenance. Surfaced as proposals; never auto-applied. Empty when none. */
+  agentProfileDiffs: ProposedProfileDiff[];
+  /** The composed capability summaries the plane returns. Empty when none. */
+  capabilities: CertifiedCapabilitySummary[];
+  /** The composed profile the promoted diffs fold to, for inspection. `null`
+   *  when no diffs are promoted. */
+  agentProfile: AgentProfile$1 | null;
 }
 /** Typed outcome for the pull — inspect `succeeded` before `value`. A 404
  *  (nothing promoted yet) is a normal, non-error `succeeded: false`. */
 type PullOutcome = {
-    succeeded: true;
-    value: CertifiedProfile;
+  succeeded: true;
+  value: CertifiedProfile;
 } | {
-    succeeded: false;
-    error: string;
-    status?: number;
+  succeeded: false;
+  error: string;
+  status?: number;
 };
 interface PullCertifiedOptions {
-    /** The agent target certified artifacts are promoted under. */
-    target: string;
-    /** Bearer key. Defaults to `process.env.TANGLE_API_KEY`. */
-    apiKey?: string;
-    /** Plane base URL. Defaults to `process.env.TANGLE_INTELLIGENCE_URL` then
-     *  `https://intelligence.tangle.tools`. */
-    baseUrl?: string;
-    /** fetch impl (tests / non-global-fetch runtimes). Defaults to global fetch. */
-    fetchImpl?: typeof fetch;
-    /** Abort the request after this many ms. Default 10000. */
-    timeoutMs?: number;
+  /** The agent target certified artifacts are promoted under. */
+  target: string;
+  /** Bearer key. Defaults to `process.env.TANGLE_API_KEY`. */
+  apiKey?: string;
+  /** Plane base URL. Defaults to `process.env.TANGLE_INTELLIGENCE_URL` then
+   *  `https://intelligence.tangle.tools`. */
+  baseUrl?: string;
+  /** fetch impl (tests / non-global-fetch runtimes). Defaults to global fetch. */
+  fetchImpl?: typeof fetch;
+  /** Abort the request after this many ms. Default 10000. */
+  timeoutMs?: number;
 }
 /** What Runtime knows about a failed proposal submission.
  * `not-sent` means no request began, `rejected` means Intelligence returned a
@@ -292,29 +225,29 @@ interface PullCertifiedOptions {
 type AgentImprovementProposalSubmissionState = 'not-sent' | 'rejected' | 'unconfirmed';
 /** Submit a completed measured proposal for product-side review. */
 interface SubmitAgentImprovementProposalOptions {
-    proposal: AgentImprovementProposal;
-    /** Bearer key. Defaults to `process.env.TANGLE_API_KEY`. */
-    apiKey?: string;
-    /** Plane base URL. Defaults to `process.env.TANGLE_INTELLIGENCE_URL` then
-     * `https://intelligence.tangle.tools`. */
-    baseUrl?: string;
-    /** fetch impl (tests / non-global-fetch runtimes). Defaults to global fetch. */
-    fetchImpl?: typeof fetch;
-    /** Abort the request after this many ms. Default 10000. */
-    timeoutMs?: number;
+  proposal: AgentImprovementProposal$1;
+  /** Bearer key. Defaults to `process.env.TANGLE_API_KEY`. */
+  apiKey?: string;
+  /** Plane base URL. Defaults to `process.env.TANGLE_INTELLIGENCE_URL` then
+   * `https://intelligence.tangle.tools`. */
+  baseUrl?: string;
+  /** fetch impl (tests / non-global-fetch runtimes). Defaults to global fetch. */
+  fetchImpl?: typeof fetch;
+  /** Abort the request after this many ms. Default 10000. */
+  timeoutMs?: number;
 }
 /** Typed result for proposal submission. A successful result contains the
  * exact immutable proposal Intelligence recorded. */
 type SubmitAgentImprovementProposalOutcome = {
-    succeeded: true;
-    value: AgentImprovementProposal;
-    status: number;
+  succeeded: true;
+  value: AgentImprovementProposal$1;
+  status: number;
 } | {
-    succeeded: false;
-    submission: AgentImprovementProposalSubmissionState;
-    error: string;
-    status?: number;
-    code?: string;
+  succeeded: false;
+  submission: AgentImprovementProposalSubmissionState;
+  error: string;
+  status?: number;
+  code?: string;
 };
 /** Resolve the ONE Intelligence base URL — the single knob both the send and
  *  receive paths derive from. Env fallback: `TANGLE_INTELLIGENCE_URL`. */
@@ -358,19 +291,19 @@ declare function composeCertifiedPrompt(base: string, certified: Pick<CertifiedP
  *  `refreshMs`, coalesces concurrent pulls, keeps the last-known profile on a
  *  failed/404 pull, never throws, never blocks past the pull timeout. */
 interface CertifiedPromptSource {
-    /** Refresh (window-respecting) then fold the certified additions into a
-     *  base system prompt. Returns `base` unchanged when nothing is promoted. */
-    compose(base: string): Promise<string>;
-    /** The certified profile currently in effect (`null` = none pulled yet). */
-    current(): CertifiedProfile | null;
-    /** Pull now if the refresh window has elapsed; coalesced and fail-closed. */
-    refresh(): Promise<void>;
+  /** Refresh (window-respecting) then fold the certified additions into a
+   *  base system prompt. Returns `base` unchanged when nothing is promoted. */
+  compose(base: string): Promise<string>;
+  /** The certified profile currently in effect (`null` = none pulled yet). */
+  current(): CertifiedProfile | null;
+  /** Pull now if the refresh window has elapsed; coalesced and fail-closed. */
+  refresh(): Promise<void>;
 }
 /** Options for {@link createCertifiedPromptSource} — the pull coordinates plus
  *  the refresh cadence. */
 interface CertifiedPromptSourceOptions extends PullCertifiedOptions {
-    /** Min interval between certified-profile pulls. Default 5m. */
-    refreshMs?: number;
+  /** Min interval between certified-profile pulls. Default 5m. */
+  refreshMs?: number;
 }
 /**
  * Create the cached certified-prompt source — the ONE module-scope-cache +
@@ -379,35 +312,8 @@ interface CertifiedPromptSourceOptions extends PullCertifiedOptions {
  * `withIntelligence` hook rides this same source for its prompt delivery.
  */
 declare function createCertifiedPromptSource(opts: CertifiedPromptSourceOptions): CertifiedPromptSource;
-
-/**
- *
- * The Capability-Delivery Manifest — the unified, future-proof structure for
- * delivering ONE certified unit of agent power = `{ interface, binding }`.
- *
- * The law that makes it future-proof: **interfaces are closed; bindings are
- * open.** The interface is the only thing the agent and the certify lane ever
- * reason about (a tool / an MCP toolset / a prompt-context / a retrieval surface
- * / a hook / a subagent). The binding is a tagged union over runtime kinds that
- * the resolver collapses (inline / file / http / sandbox-code / mcp-stdio /
- * mcp-remote / process-on-infra / rag-index / memory-store / wasm / a2a). A new
- * runtime kind = one new binding arm + one resolver case; nothing else moves.
- *
- * This module owns the manifest TYPES and the lowering of TODAY's wire
- * (`CertifiedProfile`) into a `CapabilityManifest`. The resolver — the single
- * place that knows binding kinds and produces a uniform `ResolvedSurface` — lives
- * in `./resolver`. The shipped prompt-only path (`composeCertifiedPrompt` in
- * `./delivery`) is preserved verbatim: a prompt is a `Capability{ surface:
- * 'context', binding:{ kind:'inline' } }`, so the existing
- * `pullCertified → composeCertifiedPrompt → fail-closed` lane is a strict subset.
- *
- * Layering: this depends DOWN on `@tangle-network/sandbox` (the SDK
- * `AgentProfileMcpServer` shape the mcp binding lowers to) and on the runtime's
- * own `ToolSpec`. It never imports agent-eval and never reaches upward.
- *
- * @experimental
- */
-
+//#endregion
+//#region src/intelligence/capability.d.ts
 /** A JSON Schema object describing a tool's parameters. Kept structural — the
  *  resolver forwards it verbatim into a `ToolSpec` / MCP `tools/list` check. */
 type JsonSchema = Record<string, unknown>;
@@ -416,32 +322,32 @@ type JsonSchema = Record<string, unknown>;
  * arm maps slot-for-slot onto `AgentProfile` + the host `RouterToolsSeam`.
  */
 type CapabilityInterface = {
-    surface: 'tool';
-    name: string;
-    description?: string;
-    parameters: JsonSchema;
-    returns?: JsonSchema;
+  surface: 'tool';
+  name: string;
+  description?: string;
+  parameters: JsonSchema;
+  returns?: JsonSchema;
 } | {
-    surface: 'mcp';
-    serverName: string;
-    toolset?: string[];
+  surface: 'mcp';
+  serverName: string;
+  toolset?: string[];
 } | {
-    surface: 'context';
-    kind: 'prompt-surface' | 'skill' | 'instructions';
-    name: string;
+  surface: 'context';
+  kind: 'prompt-surface' | 'skill' | 'instructions';
+  name: string;
 } | {
-    surface: 'retrieval';
-    name: string;
-    description?: string;
-    topK?: number;
+  surface: 'retrieval';
+  name: string;
+  description?: string;
+  topK?: number;
 } | {
-    surface: 'hook';
-    event: string;
-    matcher?: string;
+  surface: 'hook';
+  event: string;
+  matcher?: string;
 } | {
-    surface: 'subagent';
-    name: string;
-    description?: string;
+  surface: 'subagent';
+  name: string;
+  description?: string;
 };
 /** Every interface surface tag — the closed set the resolver fans into slots. */
 type CapabilitySurface = CapabilityInterface['surface'];
@@ -450,22 +356,22 @@ type CapabilitySurface = CapabilityInterface['surface'];
  * no inlined blob: `github`/`blob` are pointers resolved at provision time.
  */
 type ContentRef = {
-    kind: 'inline';
-    content: string;
+  kind: 'inline';
+  content: string;
 } | {
-    kind: 'github';
-    repository?: string;
-    path: string;
-    ref?: string;
+  kind: 'github';
+  repository?: string;
+  path: string;
+  ref?: string;
 } | {
-    kind: 'blob';
-    uri: string;
-    sha256: string;
-    bytes?: number;
+  kind: 'blob';
+  uri: string;
+  sha256: string;
+  bytes?: number;
 };
 /** A named secret a binding requires — declared, never carried. */
 interface CredentialRef {
-    key: string;
+  key: string;
 }
 /**
  * How a binding authenticates at resolve time. Declared as a REQUIREMENT in the
@@ -473,16 +379,16 @@ interface CredentialRef {
  * never inlined here.
  */
 type CapabilityAuth = {
-    mode: 'none';
+  mode: 'none';
 } | {
-    mode: 'tangle-key';
+  mode: 'tangle-key';
 } | {
-    mode: 'hub-connection';
-    providerId: string;
-    scopes?: string[];
+  mode: 'hub-connection';
+  providerId: string;
+  scopes?: string[];
 } | {
-    mode: 'secret-ref';
-    key: string;
+  mode: 'secret-ref';
+  key: string;
 };
 /**
  * The host a `process-on-infra` binding provisions before its inner binding.
@@ -491,12 +397,12 @@ type CapabilityAuth = {
  * cost; `ports` are the inner server's listen ports the host must expose.
  */
 interface HostSpec {
-    backend: 'sandbox' | 'router' | 'cli';
-    image?: string;
-    ports?: number[];
-    warm?: boolean;
-    idleTtlMs?: number;
-    costTag?: string;
+  backend: 'sandbox' | 'router' | 'cli';
+  image?: string;
+  ports?: number[];
+  warm?: boolean;
+  idleTtlMs?: number;
+  costTag?: string;
 }
 /**
  * How a capability is backed. OPEN tagged union — THE extension point. All arms
@@ -504,57 +410,57 @@ interface HostSpec {
  * throws {@link CapabilityNotAdmittedError} at resolve, never silently no-ops.
  */
 type DeliveryBinding = {
-    kind: 'inline';
-    content: ContentRef;
+  kind: 'inline';
+  content: ContentRef;
 } | {
-    kind: 'file';
-    path: string;
-    content: ContentRef;
-    executable?: boolean;
+  kind: 'file';
+  path: string;
+  content: ContentRef;
+  executable?: boolean;
 } | {
-    kind: 'http';
-    url: string;
-    method?: string;
-    auth?: CapabilityAuth;
+  kind: 'http';
+  url: string;
+  method?: string;
+  auth?: CapabilityAuth;
 } | {
-    kind: 'sandbox-code';
-    entry: string;
-    code: ContentRef;
-    runtime?: string;
-    harness?: string;
+  kind: 'sandbox-code';
+  entry: string;
+  code: ContentRef;
+  runtime?: string;
+  harness?: string;
 } | {
-    kind: 'mcp-stdio';
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
-    cwd?: string;
+  kind: 'mcp-stdio';
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
 } | {
-    kind: 'mcp-remote';
-    url: string;
-    transport: 'http' | 'sse';
-    headers?: Record<string, string>;
+  kind: 'mcp-remote';
+  url: string;
+  transport: 'http' | 'sse';
+  headers?: Record<string, string>;
 } | {
-    kind: 'process-on-infra';
-    host: HostSpec;
-    inner: DeliveryBinding;
+  kind: 'process-on-infra';
+  host: HostSpec;
+  inner: DeliveryBinding;
 } | {
-    kind: 'rag-index';
-    index: ContentRef;
-    embedModel: string;
-    topK?: number;
+  kind: 'rag-index';
+  index: ContentRef;
+  embedModel: string;
+  topK?: number;
 } | {
-    kind: 'memory-store';
-    provision: 'sqlite' | 'neo4j' | 'vector';
-    seed?: ContentRef;
+  kind: 'memory-store';
+  provision: 'sqlite' | 'neo4j' | 'vector';
+  seed?: ContentRef;
 } | {
-    kind: 'wasm';
-    module: ContentRef;
-    exports: string[];
+  kind: 'wasm';
+  module: ContentRef;
+  exports: string[];
 } | {
-    kind: 'a2a';
-    endpoint: string;
-    card: ContentRef;
-    auth?: CapabilityAuth;
+  kind: 'a2a';
+  endpoint: string;
+  card: ContentRef;
+  auth?: CapabilityAuth;
 };
 /** Every binding kind — the open set the resolver dispatches over. */
 type DeliveryBindingKind = DeliveryBinding['kind'];
@@ -572,19 +478,19 @@ type DeliveryBindingKind = DeliveryBinding['kind'];
  * mix of null-path and non-null-path artifacts.
  */
 interface CertProvenance {
-    contentHash: string;
-    version: number | null;
-    lift: string | null;
-    promotedAt: string;
-    sourcePath: string | null;
+  contentHash: string;
+  version: number | null;
+  lift: string | null;
+  promotedAt: string;
+  sourcePath: string | null;
 }
 /** One certified unit of agent power. */
 interface CertifiedCapability {
-    id: string;
-    iface: CapabilityInterface;
-    binding: DeliveryBinding;
-    auth: CapabilityAuth;
-    provenance: CertProvenance;
+  id: string;
+  iface: CapabilityInterface;
+  binding: DeliveryBinding;
+  auth: CapabilityAuth;
+  provenance: CertProvenance;
 }
 /**
  * The strict generalization of `CertifiedProfile`. `promptSurface` is kept
@@ -592,31 +498,31 @@ interface CertifiedCapability {
  * capabilities live in `capabilities`.
  */
 interface CapabilityManifest {
-    target: string;
-    generatedAt: string;
-    promptSurface: CertifiedPromptSurface | null;
-    capabilities: CertifiedCapability[];
+  target: string;
+  generatedAt: string;
+  promptSurface: CertifiedPromptSurface | null;
+  capabilities: CertifiedCapability[];
 }
 /** One retrieval handle. The agent never learns vector vs graph vs index. */
 interface ResolvedRetrieval {
-    name: string;
-    retrieve(query: string, k?: number): Promise<Array<{
-        text: string;
-        score?: number;
-    }>>;
+  name: string;
+  retrieve(query: string, k?: number): Promise<Array<{
+    text: string;
+    score?: number;
+  }>>;
 }
 /** One resolved hook — event + the command/matcher the seam folds into
  *  `AgentProfile.hooks`. */
 interface ResolvedHook {
-    event: string;
-    command: string;
-    matcher?: string;
+  event: string;
+  command: string;
+  matcher?: string;
 }
 /** One resolved subagent — folded into `AgentProfile.subagents`. */
 interface ResolvedSubagent {
-    name: string;
-    description?: string;
-    prompt?: string;
+  name: string;
+  description?: string;
+  prompt?: string;
 }
 /**
  * What `composeCertifiedProfile` produces. Every binding fans into the same
@@ -625,32 +531,32 @@ interface ResolvedSubagent {
  * `dispose()` tears provisioned hosts down in REVERSE dependency order.
  */
 interface ResolvedSurface {
-    /** Host-side tool defs → `RouterToolsSeam.tools` / agent-app `extraTools`. */
-    tools: ToolSpec[];
-    /** Host-side dispatch for a resolved tool. Throws when `name` is unknown so a
-     *  mis-dispatch is loud, never a silent empty string. */
-    execute(name: string, args: Record<string, unknown>, task: unknown): Promise<string>;
-    /** Sandbox-side tool delivery → `AgentProfile.mcp` / in-proc `createMcpEnvironment`. */
-    mcpConnections: Record<string, AgentProfileMcpServer>;
-    /** Prompt-context additions, byte-stable-ordered → folded system prompt. */
-    promptAdditions: string[];
-    /** Workspace files → `AgentProfile.resources.files`. */
-    files: Array<{
-        path: string;
-        content: string;
-        executable?: boolean;
-    }>;
-    /** Uniform retrieval handles. */
-    retrieval: ResolvedRetrieval[];
-    /** Hooks → `AgentProfile.hooks`. */
-    hooks: ResolvedHook[];
-    /** Subagents → `AgentProfile.subagents`. */
-    subagents: ResolvedSubagent[];
-    /** The folded system prompt — base + the byte-stable prompt additions, exactly
-     *  as `composeCertifiedPrompt` renders the inline/context capabilities. */
-    systemPrompt: string;
-    /** Tear down provisioned hosts (reverse dependency order). */
-    dispose(): Promise<void>;
+  /** Host-side tool defs → `RouterToolsSeam.tools` / agent-app `extraTools`. */
+  tools: ToolSpec[];
+  /** Host-side dispatch for a resolved tool. Throws when `name` is unknown so a
+   *  mis-dispatch is loud, never a silent empty string. */
+  execute(name: string, args: Record<string, unknown>, task: unknown): Promise<string>;
+  /** Sandbox-side tool delivery → `AgentProfile.mcp` / in-proc `createMcpEnvironment`. */
+  mcpConnections: Record<string, AgentProfileMcpServer>;
+  /** Prompt-context additions, byte-stable-ordered → folded system prompt. */
+  promptAdditions: string[];
+  /** Workspace files → `AgentProfile.resources.files`. */
+  files: Array<{
+    path: string;
+    content: string;
+    executable?: boolean;
+  }>;
+  /** Uniform retrieval handles. */
+  retrieval: ResolvedRetrieval[];
+  /** Hooks → `AgentProfile.hooks`. */
+  hooks: ResolvedHook[];
+  /** Subagents → `AgentProfile.subagents`. */
+  subagents: ResolvedSubagent[];
+  /** The folded system prompt — base + the byte-stable prompt additions, exactly
+   *  as `composeCertifiedPrompt` renders the inline/context capabilities. */
+  systemPrompt: string;
+  /** Tear down provisioned hosts (reverse dependency order). */
+  dispose(): Promise<void>;
 }
 /**
  * A binding kind whose resolver case is typed but not yet admitted (rag-index,
@@ -659,31 +565,32 @@ interface ResolvedSurface {
  * resolver grows them later behind their lifecycle + admission gate.
  */
 declare class CapabilityNotAdmittedError extends Error {
-    readonly kind: DeliveryBindingKind;
-    readonly capabilityId: string;
-    constructor(kind: DeliveryBindingKind, capabilityId: string, reason: string);
+  readonly kind: DeliveryBindingKind;
+  readonly capabilityId: string;
+  constructor(kind: DeliveryBindingKind, capabilityId: string, reason: string);
 }
 /**
  * Lower the EXISTING plane wire (`CertifiedProfile`) into a `CapabilityManifest`.
  * `prompt-surface`/`skill` artifacts → `context`/inline capabilities (the
  * shipped fold, generalized); any other artifact type → best-effort binding
- * inference (see {@link inferCapability}). `promptSurface` is carried through so
+ * inference. `promptSurface` is carried through so
  * the resolver folds it first, exactly as `composeCertifiedPrompt` does today.
  * This delivers the spine against today's wire before the plane changes.
  */
 declare function manifestFromProfile(profile: CertifiedProfile): CapabilityManifest;
-
+//#endregion
+//#region src/intelligence/improvement-surfaces.d.ts
 /** Agent improvement surfaces delivered as exact `AgentProfileDiff` replacements. */
 declare const AGENT_IMPROVEMENT_PROFILE_SURFACES: readonly ["prompt", "skills", "tools", "mcp", "hooks", "subagents"];
 type AgentImprovementProfileSurface = (typeof AGENT_IMPROVEMENT_PROFILE_SURFACES)[number];
 interface AgentImprovementTargetProfileDiffOptions {
-    id: string;
-    source?: AgentProfileDiff['source'];
-    metadata?: Record<string, unknown>;
+  id: string;
+  source?: AgentProfileDiff['source'];
+  metadata?: Record<string, unknown>;
 }
 type AgentImprovementActivationTargetIdentity = Pick<AgentImprovementActivationTarget, 'surface' | 'identity'>;
 /** Bind caller-owned target identities to the exact source state Runtime measured. */
-declare function buildAgentImprovementActivationTargets(surfaces: readonly AgentImprovementSurface[], experiment: AgentCandidateExperiment, intent: AgentImprovementActivationIntent, identities: readonly AgentImprovementActivationTargetIdentity[]): [AgentImprovementActivationTarget, ...AgentImprovementActivationTarget[]];
+declare function buildAgentImprovementActivationTargets(surfaces: readonly AgentImprovementSurface[], experiment: AgentImprovementEvaluation$1['experiment'], intent: AgentImprovementActivationIntent$1, identities: readonly AgentImprovementActivationTargetIdentity[]): [AgentImprovementActivationTarget, ...AgentImprovementActivationTarget[]];
 /** Return whether a measured surface can be delivered through an agent profile. */
 declare function isAgentImprovementProfileSurface(surface: AgentImprovementSurface): surface is AgentImprovementProfileSurface;
 /**
@@ -692,168 +599,169 @@ declare function isAgentImprovementProfileSurface(surface: AgentImprovementSurfa
  * Unrelated profile fields are excluded. The result matches `agentImprovementTargetInput` for the
  * same profile inside a candidate bundle.
  */
-declare function agentImprovementProfileSurfaceInput(profile: AgentProfile, surface: AgentImprovementProfileSurface): unknown;
+declare function agentImprovementProfileSurfaceInput(profile: AgentProfile$1, surface: AgentImprovementProfileSurface): unknown;
 /** Return the `Sha256Digest` of one profile surface using Runtime's canonical candidate digest. */
-declare function agentImprovementProfileSurfaceDigest(profile: AgentProfile, surface: AgentImprovementProfileSurface): Sha256Digest;
+declare function agentImprovementProfileSurfaceDigest(profile: AgentProfile$1, surface: AgentImprovementProfileSurface): Sha256Digest;
 /**
  * Replace one measured profile surface exactly, including array-valued resources.
  * Apply the returned diffs in order: a diff applies its set before its removal,
  * so exact replacement requires a reset record followed by a set record.
  */
 declare function agentImprovementTargetProfileDiffs(target: {
-    surface: AgentImprovementProfileSurface;
-    desiredInput: unknown;
+  surface: AgentImprovementProfileSurface;
+  desiredInput: unknown;
 }, options: AgentImprovementTargetProfileDiffOptions): [AgentProfileDiff, ...AgentProfileDiff[]];
-
+//#endregion
+//#region src/intelligence/improvement-cycle.d.ts
 interface AgentCandidateExperimentCellPlacement {
-    executionId: string;
-    attempt?: number;
-    executionRoots: AgentCandidateTaskExecution['executionRoots'];
-    stagingRoots: AgentCandidateTaskExecution['stagingRoots'];
-    ports: AgentCandidateExecutionPorts;
-    preparation?: PrepareAgentCandidateExecutionOptions;
-    execution: ExecutePreparedAgentCandidateOptions;
+  executionId: string;
+  attempt?: number;
+  executionRoots: AgentCandidateTaskExecution['executionRoots'];
+  stagingRoots: AgentCandidateTaskExecution['stagingRoots'];
+  ports: AgentCandidateExecutionPorts;
+  preparation?: PrepareAgentCandidateExecutionOptions;
+  execution: ExecutePreparedAgentCandidateOptions;
 }
 interface RunAgentCandidateExperimentOptions extends Omit<CompareCandidateExperimentOptions, 'experiment' | 'measurements'> {
-    experiment: AgentCandidateExperiment;
-    placeCell: (input: CandidateExperimentExecutionInput) => AgentCandidateExperimentCellPlacement | Promise<AgentCandidateExperimentCellPlacement>;
-    maxConcurrency?: number;
-    signal?: AbortSignal;
+  experiment: AgentCandidateExperiment;
+  placeCell: (input: CandidateExperimentExecutionInput) => AgentCandidateExperimentCellPlacement | Promise<AgentCandidateExperimentCellPlacement>;
+  maxConcurrency?: number;
+  signal?: AbortSignal;
 }
 interface RunAgentCandidateExperimentResult {
-    experiment: AgentCandidateExperiment;
-    measurements: AgentCandidateExperimentMeasurement[];
-    evaluation: AgentImprovementMeasuredComparison;
-}
-interface ExecuteAgentCandidateExperimentCellOptions extends CandidateExperimentExecutionInput, AgentCandidateExperimentCellPlacement {
+  experiment: AgentCandidateExperiment;
+  measurements: AgentCandidateExperimentMeasurement[];
+  evaluation: AgentImprovementMeasuredComparison$1;
 }
+interface ExecuteAgentCandidateExperimentCellOptions extends CandidateExperimentExecutionInput, AgentCandidateExperimentCellPlacement {}
 interface VerifyCandidateExecutionEvidenceOptions {
-    experiment: AgentCandidateExperiment;
-    arm: 'baseline' | 'candidate';
-    benchmarkCell: AgentCandidateBenchmarkCellRef;
-    seed: number;
-    attempt?: number;
-    resolvedResources?: ReadonlyMap<Sha256Digest, string>;
+  experiment: AgentCandidateExperiment;
+  arm: 'baseline' | 'candidate';
+  benchmarkCell: AgentCandidateBenchmarkCellRef;
+  seed: number;
+  attempt?: number;
+  resolvedResources?: ReadonlyMap<Sha256Digest, string>;
 }
 /** A failed baseline or candidate cell with its complete Runtime failure result. */
 declare class AgentCandidateExperimentCellExecutionError extends Error {
-    readonly finalization: Extract<AgentCandidateRunFinalization, {
-        succeeded: false;
-    }>;
-    constructor(finalization: Extract<AgentCandidateRunFinalization, {
-        succeeded: false;
-    }>);
+  readonly finalization: Extract<AgentCandidateRunFinalization, {
+    succeeded: false;
+  }>;
+  constructor(finalization: Extract<AgentCandidateRunFinalization, {
+    succeeded: false;
+  }>);
 }
 interface CreateAgentImprovementProposalOptions {
-    runId: string;
-    findings: readonly AnalystFinding[];
-    evaluation: AgentImprovementMeasuredComparison;
-    now?: () => Date;
+  runId: string;
+  findings: readonly AnalystFinding$1[];
+  evaluation: AgentImprovementEvaluation$1;
+  now?: () => Date;
 }
 type CreateAgentImprovementMeasuredComparisonOptions = CompareCandidateExperimentOptions;
 interface ReviewAgentImprovementInput {
-    decision: AgentImprovementReviewDecision;
-    reviewedBy: string;
-    reason: string;
-    feedback?: string;
-    now?: () => Date;
+  decision: AgentImprovementReviewDecision$1;
+  reviewedBy: string;
+  reason: string;
+  feedback?: string;
+  now?: () => Date;
 }
 interface CreateAgentImprovementActivationOptions {
-    intent: AgentImprovementActivationIntent;
-    /** Runtime derives each exact source digest; callers identify only the records to change. */
-    targets: [AgentImprovementActivationTargetIdentity, ...AgentImprovementActivationTargetIdentity[]];
-    fundingOwner: string;
-    authorizedBy: string;
-    expiresAt: string;
-    now?: () => Date;
+  intent: AgentImprovementActivationIntent$1;
+  /** Runtime derives each exact source digest; callers identify only the records to change. */
+  targets: [AgentImprovementActivationTargetIdentity, ...AgentImprovementActivationTargetIdentity[]];
+  fundingOwner: string;
+  authorizedBy: string;
+  expiresAt: string;
+  now?: () => Date;
 }
-interface ProposeAgentImprovementOptions<TScenario extends Scenario, TArtifact> {
-    runId: string;
-    profile: AgentProfile;
-    analysis: Omit<RunAnalystLoopOpts, 'runId' | 'improvementProposalSource'>;
-    improvement: ImproveOptions<TScenario, TArtifact>;
-    buildExperiment: (input: {
-        analysis: RunAnalystLoopResult;
-        improvement: ImproveResult<TScenario, TArtifact>;
-    }) => AgentImprovementExperimentMaterial | Promise<AgentImprovementExperimentMaterial>;
-    placeCell: RunAgentCandidateExperimentOptions['placeCell'];
-    maxConcurrency?: number;
-    signal?: AbortSignal;
-    candidate?: AgentImprovementMeasuredComparison['candidate'];
-    metadata?: AgentImprovementMeasuredComparison['metadata'];
-    now?: () => Date;
+interface ProposeAgentImprovementOptions<TScenario extends Scenario$1, TArtifact> {
+  runId: string;
+  profile: AgentProfile$1;
+  analysis: Omit<RunAnalystLoopOpts, 'runId' | 'improvementProposalSource'>;
+  improvement: ImproveOptions<TScenario, TArtifact>;
+  buildExperiment: (input: {
+    analysis: RunAnalystLoopResult;
+    improvement: ImproveResult<TScenario, TArtifact>;
+  }) => AgentImprovementExperimentMaterial | Promise<AgentImprovementExperimentMaterial>;
+  placeCell: RunAgentCandidateExperimentOptions['placeCell'];
+  maxConcurrency?: number;
+  signal?: AbortSignal;
+  candidate?: AgentImprovementMeasuredComparison$1['candidate'];
+  metadata?: AgentImprovementMeasuredComparison$1['metadata'];
+  now?: () => Date;
 }
 /** Product-supplied experiment material. Runtime supplies optimizer ancestry and the final digest. */
 type AgentImprovementExperimentMaterial = Omit<AgentCandidateExperimentMaterial, 'candidateLineage'>;
-interface ProposeAgentImprovementResult<TScenario extends Scenario, TArtifact> {
-    analysis: RunAnalystLoopResult;
-    improvement: ImproveResult<TScenario, TArtifact>;
-    experiment: AgentCandidateExperiment;
-    measurements: AgentCandidateExperimentMeasurement[];
-    proposal: AgentImprovementProposal;
+interface ProposeAgentImprovementResult<TScenario extends Scenario$1, TArtifact> {
+  analysis: RunAnalystLoopResult;
+  improvement: ImproveResult<TScenario, TArtifact>;
+  experiment: AgentCandidateExperiment;
+  measurements: AgentCandidateExperimentMeasurement[];
+  proposal: AgentImprovementProposal$1;
 }
 /** Execute both arms of one immutable experiment and derive its paired result. */
 declare function runAgentCandidateExperiment(options: RunAgentCandidateExperimentOptions): Promise<RunAgentCandidateExperimentResult>;
 /** Execute one exact arm, task, repetition, seed, and attempt through Runtime. */
-declare function executeAgentCandidateExperimentCell(options: ExecuteAgentCandidateExperimentCellOptions): Promise<CandidateExecutionEvidence>;
+declare function executeAgentCandidateExperimentCell(options: ExecuteAgentCandidateExperimentCellOptions): Promise<CandidateExecutionEvidence$1>;
 /** Delegate all statistics and promotion checks to agent-eval's receipt-based comparison. */
-declare function createAgentImprovementMeasuredComparison(options: CreateAgentImprovementMeasuredComparisonOptions): AgentImprovementMeasuredComparison;
+declare function createAgentImprovementMeasuredComparison(options: CreateAgentImprovementMeasuredComparisonOptions): AgentImprovementMeasuredComparison$1;
 /** Analyze, search, then remeasure the resulting exact candidate before proposing it. */
-declare function proposeAgentImprovement<TScenario extends Scenario, TArtifact>(options: ProposeAgentImprovementOptions<TScenario, TArtifact>): Promise<ProposeAgentImprovementResult<TScenario, TArtifact>>;
+declare function proposeAgentImprovement<TScenario extends Scenario$1, TArtifact>(options: ProposeAgentImprovementOptions<TScenario, TArtifact>): Promise<ProposeAgentImprovementResult<TScenario, TArtifact>>;
 /** Create the reviewable record only from a complete, recomputable experiment result. */
-declare function createAgentImprovementProposal(options: CreateAgentImprovementProposalOptions): AgentImprovementProposal;
+declare function createAgentImprovementProposal(options: CreateAgentImprovementProposalOptions): AgentImprovementProposal$1;
 /** Persist a human or tenant-policy decision bound to one exact proposal. */
-declare function reviewAgentImprovementProposal(inputProposal: AgentImprovementProposal, input: ReviewAgentImprovementInput): AgentImprovementReview;
+declare function reviewAgentImprovementProposal(inputProposal: AgentImprovementProposal$1, input: ReviewAgentImprovementInput): AgentImprovementReview$1;
 /** Authorize product-owned writes only after the exact candidate was measured and approved. */
-declare function createAgentImprovementActivation(inputProposal: AgentImprovementProposal, inputReview: AgentImprovementReview, options: CreateAgentImprovementActivationOptions): AgentImprovementActivation;
+declare function createAgentImprovementActivation(inputProposal: AgentImprovementProposal$1, inputReview: AgentImprovementReview$1, options: CreateAgentImprovementActivationOptions): AgentImprovementActivation$1;
 /** Validate a proposal and recompute every binding to its measured experiment. */
-declare function verifyAgentImprovementProposal(input: unknown): AgentImprovementProposal;
+declare function verifyAgentImprovementProposal(input: unknown): AgentImprovementProposal$1;
 /** Validate the canonical identity and wire shape of an improvement review. */
-declare function verifyAgentImprovementReview(input: unknown): AgentImprovementReview;
+declare function verifyAgentImprovementReview(input: unknown): AgentImprovementReview$1;
 /** Validate activation authority against the exact proposal, review, experiment, and base state. */
 declare function verifyAgentImprovementActivation(input: {
-    proposal: unknown;
-    review: unknown;
-    activation: unknown;
-}): AgentImprovementActivation;
+  proposal: unknown;
+  review: unknown;
+  activation: unknown;
+}): AgentImprovementActivation$1;
 /** Recheck one Runtime receipt against its exact signed experiment cell. */
-declare function verifyCandidateExecutionEvidence(input: unknown, options: VerifyCandidateExecutionEvidenceOptions): CandidateExecutionEvidence;
-
+declare function verifyCandidateExecutionEvidence(input: unknown, options: VerifyCandidateExecutionEvidenceOptions): CandidateExecutionEvidence$1;
+//#endregion
+//#region src/intelligence/exact-process-candidate.d.ts
 /** Candidate surfaces implemented by the neutral exact-process executor. */
 declare const exactProcessCandidateExperimentExecutionSupport: Readonly<{
-    outcomes: readonly ["output"];
-    outputMediaTypes: readonly ["text/*", "application/json", "*+json"];
-    code: readonly ["disabled"];
-    memory: readonly ["disabled"];
-    knowledge: true;
-    profile: Readonly<{
-        mcpTransports: readonly ["stdio"];
-        remoteMcp: false;
-        tools: false;
-        permissions: false;
-        modes: false;
-        confidential: false;
-    }>;
-    isolation: Readonly<{
-        freshEnvironment: true;
-        exactProcess: true;
-        egress: readonly ["blocked", "strict"];
-    }>;
+  outcomes: readonly ["output"];
+  outputMediaTypes: readonly ["text/*", "application/json", "*+json"];
+  code: readonly ["disabled"];
+  memory: readonly ["disabled"];
+  knowledge: true;
+  profile: Readonly<{
+    mcpTransports: readonly ["stdio"];
+    remoteMcp: false;
+    tools: false;
+    permissions: false;
+    modes: false;
+    confidential: false;
+  }>;
+  isolation: Readonly<{
+    freshEnvironment: true;
+    exactProcess: true;
+    egress: readonly ["blocked", "strict"];
+  }>;
 }>;
 interface CreateExactProcessCandidateExperimentExecutorOptions {
-    provider: AgentEnvironmentProviderRef;
-    providerRegistry?: AgentEnvironmentProviderRegistry;
-    resources: AgentExactProcessResources;
-    providerOptions?: Record<string, unknown>;
-    provisionTimeoutMs?: number;
-    recoveryRetentionMs?: number;
-    ports: AgentCandidateExecutionPorts;
-    grader: AgentCandidateBenchmarkGraderPort;
-    outputArtifacts: AgentCandidateOutputArtifactPort;
-    traceStore: TraceStore;
-    claimStore: AgentCandidateExecutionClaimStore;
-    cleanupTimeoutMs?: number;
-    resultTimeoutMs?: number;
+  provider: AgentEnvironmentProviderRef;
+  providerRegistry?: AgentEnvironmentProviderRegistry;
+  resources: AgentExactProcessResources;
+  providerOptions?: Record<string, unknown>;
+  provisionTimeoutMs?: number;
+  recoveryRetentionMs?: number;
+  ports: AgentCandidateExecutionPorts;
+  grader: AgentCandidateBenchmarkGraderPort;
+  outputArtifacts: AgentCandidateOutputArtifactPort;
+  traceStore: TraceStore;
+  claimStore: AgentCandidateExecutionClaimStore;
+  cleanupTimeoutMs?: number;
+  resultTimeoutMs?: number;
 }
 /** Product-owned candidate ports other than protected model access. */
 type AgentCandidateExecutionHostPorts = Omit<AgentCandidateExecutionPorts, 'models'>;
@@ -862,107 +770,138 @@ type AgentCandidateExecutionHostPorts = Omit<AgentCandidateExecutionPorts, 'mode
  * metered, and settled by the caller's grant service.
  */
 interface CreateProtectedExactProcessCandidateExperimentExecutorOptions extends Omit<CreateExactProcessCandidateExperimentExecutorOptions, 'ports'> {
-    hostPorts: AgentCandidateExecutionHostPorts;
-    model: CreateProtectedAgentCandidateModelPortOptions;
+  hostPorts: AgentCandidateExecutionHostPorts;
+  model: CreateProtectedAgentCandidateModelPortOptions;
 }
 interface ExactProcessCandidateExperimentExecution extends CandidateExperimentExecutionInput {
-    executionId: string;
-    attempt?: number;
-    executionRoots: AgentCandidateExperimentCellPlacement['executionRoots'];
-    stagingRoots: AgentCandidateExperimentCellPlacement['stagingRoots'];
-    preparation?: PrepareAgentCandidateExecutionOptions;
+  executionId: string;
+  attempt?: number;
+  executionRoots: AgentCandidateExperimentCellPlacement['executionRoots'];
+  stagingRoots: AgentCandidateExperimentCellPlacement['stagingRoots'];
+  preparation?: PrepareAgentCandidateExecutionOptions;
 }
 interface ExactProcessCandidateExperimentExecutor {
-    /** Runtime's expired-attempt path reuses this port only to stop and dispose. */
-    readonly executor: AgentCandidateExecutorPort;
-    execute(input: ExactProcessCandidateExperimentExecution): Promise<CandidateExecutionEvidence>;
+  /** Runtime's expired-attempt path reuses this port only to stop and dispose. */
+  readonly executor: AgentCandidateExecutorPort;
+  execute(input: ExactProcessCandidateExperimentExecution): Promise<CandidateExecutionEvidence$1>;
 }
 /** Exact-process executor plus the ports required for durable recovery. */
 interface ProtectedExactProcessCandidateExperimentExecutor extends ExactProcessCandidateExperimentExecutor {
-    readonly recoveryPorts: Pick<AgentCandidateExecutionPorts, 'models' | 'memory'>;
+  readonly recoveryPorts: Pick<AgentCandidateExecutionPorts, 'models' | 'memory'>;
 }
 /** Execute one signed experiment cell through any declared exact-process provider. */
 declare function createExactProcessCandidateExperimentExecutor(options: CreateExactProcessCandidateExperimentExecutorOptions): ExactProcessCandidateExperimentExecutor;
 /** Compose host-owned execution ports with protected model access for one exact-process run. */
 declare function createProtectedExactProcessCandidateExperimentExecutor(options: CreateProtectedExactProcessCandidateExperimentExecutorOptions): ProtectedExactProcessCandidateExperimentExecutor;
-
+//#endregion
+//#region src/intelligence/optimization-receipt.d.ts
+type OptimizationProvenance = NonNullable<OptimizationMethodComparison['best']['provenance']>;
+interface OptimizationActivationReceipt {
+  kind: 'optimization-activation-receipt';
+  method: string;
+  source: OptimizationPackageSource;
+  bridge?: OptimizationPackageSource;
+  modules?: OptimizationProvenance['modules'];
+  python?: OptimizationProvenance['python'];
+  models?: {
+    candidate?: NonNullable<AgentProfile$1['model']>;
+    optimizer?: string;
+  };
+  usage: {
+    optimizerEvaluations: number;
+    optimizerTokens?: OptimizationTokenUsage;
+  };
+  cost: {
+    optimization: OptimizationReceiptCost;
+    finalTest: OptimizationReceiptCost;
+    total: OptimizationReceiptCost;
+  };
+  invocation: {
+    runtimeInvocationId: string;
+    optimizerRunId: string;
+    compatibleOptimizerRunId?: string;
+    resumed: boolean;
+    artifactDir: string;
+  };
+  developmentDataDigest: Sha256Digest;
+  digest: Sha256Digest;
+}
+interface OptimizationReceiptCost {
+  totalUsd: number;
+  accountingComplete: boolean;
+  incompleteReasons: string[];
+}
+/** Build a detached receipt only for methods backed by an identified external optimizer. */
+declare function createOptimizationActivationReceipt(improvement: ImproveMethodResult): OptimizationActivationReceipt | undefined;
+/** Read and verify the optimizer evidence carried by a measured proposal. */
+declare function optimizationActivationReceiptFromMetadata(metadata: AgentImprovementMeasuredComparison$1['metadata']): OptimizationActivationReceipt | undefined;
+//#endregion
+//#region src/intelligence/profile-activation.d.ts
 type AgentImprovementProfileActivationTarget = Omit<AgentImprovementActivationTargetPlan, 'surface'> & {
-    surface: AgentImprovementProfileSurface;
+  surface: AgentImprovementProfileSurface;
 };
 type AgentImprovementProfileTargetState = Omit<AgentImprovementActivationTargetState, 'surface'> & {
-    surface: AgentImprovementProfileSurface;
+  surface: AgentImprovementProfileSurface;
 };
 type AgentImprovementProfileTargetTransition = Omit<AgentImprovementActivationTargetTransition, 'surface'> & {
-    surface: AgentImprovementProfileSurface;
+  surface: AgentImprovementProfileSurface;
 };
 interface AgentImprovementProfileReplacement {
-    identity: string;
-    profile: AgentProfile;
+  identity: string;
+  profile: AgentProfile$1;
+}
+interface AgentImprovementProfileStateDigestInput {
+  identity: string;
+  profile: AgentProfile$1;
 }
+/** Product-defined hash of the complete profile state that actually runs. */
+type AgentImprovementProfileStateDigest = (input: AgentImprovementProfileStateDigestInput) => Sha256Digest;
+interface AgentImprovementProfileStateResolverInput {
+  identity: string;
+  stateDigest: Sha256Digest;
+}
+/** Product-owned retained-state lookup used only for an explicit restore. */
+type AgentImprovementProfileStateResolver = (input: AgentImprovementProfileStateResolverInput) => AgentProfile$1 | undefined;
+type AgentImprovementProfileActivationInput = {
+  currentByIdentity: ReadonlyMap<string, AgentProfile$1>;
+  targets: readonly [AgentImprovementProfileActivationTarget, ...AgentImprovementProfileActivationTarget[]];
+} | {
+  currentByIdentity: ReadonlyMap<string, AgentProfile$1>;
+  profileTransition: ProfileImprovementActivationTransitionInput;
+  stateDigest: AgentImprovementProfileStateDigest;
+  resolveState?: AgentImprovementProfileStateResolver;
+};
 type AgentImprovementProfileActivationPreparation = {
-    status: 'missing';
-    identities: readonly string[];
+  status: 'missing';
+  identities: readonly string[];
+} | {
+  status: 'unavailable';
+  code: 'PROFILE_STATE_UNAVAILABLE';
+  identities: readonly string[];
+  requiredStateDigest: Sha256Digest;
 } | {
-    status: 'already-applied' | 'conflict';
-    targets: [AgentImprovementProfileTargetState, ...AgentImprovementProfileTargetState[]];
+  status: 'already-applied' | 'conflict';
+  targets: [AgentImprovementProfileTargetState, ...AgentImprovementProfileTargetState[]];
 } | {
-    status: 'apply';
-    replacements: [AgentImprovementProfileReplacement, ...AgentImprovementProfileReplacement[]];
-    targets: [
-        AgentImprovementProfileTargetTransition,
-        ...AgentImprovementProfileTargetTransition[]
-    ];
+  status: 'apply';
+  replacements: [AgentImprovementProfileReplacement, ...AgentImprovementProfileReplacement[]];
+  targets: [AgentImprovementProfileTargetTransition, ...AgentImprovementProfileTargetTransition[]];
 };
 /**
  * Compare product-owned profiles with an exact measured transition and prepare
- * the all-or-none replacements. The caller owns locking, persistence, and the
- * durable activation receipt; this function owns profile semantics only.
- * Profiles stay in product-owned stores, so this returns replacements instead
- * of owning the transition callbacks used by Runtime-owned knowledge stores.
- */
-declare function prepareAgentImprovementProfileActivation(input: {
-    currentByIdentity: ReadonlyMap<string, AgentProfile>;
-    targets: readonly [
-        AgentImprovementProfileActivationTarget,
-        ...AgentImprovementProfileActivationTarget[]
-    ];
-}): AgentImprovementProfileActivationPreparation;
-
-/**
- *
- * The capability resolver — the ONLY place that knows binding kinds. It lowers a
- * `CapabilityManifest` into a uniform `ResolvedSurface` consumed identically by
- * the in-process seam (`RouterToolsSeam.{tools, executeToolCall}` + a folded
- * prompt) and the sandbox seam (`AgentProfile`).
- *
- * The spine (zero new infra) resolves inline/file, mcp-stdio/mcp-remote, and
- * http tools for BOTH seams, reusing shipped primitives:
- *   - inline/context → `composeCertifiedPrompt` (delivery.ts) — byte-stable order;
- *   - http           → a `ToolSpec` + a host-side fetch `execute`;
- *   - mcp-stdio/remote → an `AgentProfileMcpServer` (the strict union widens to
- *     the SDK's flat shape — an always-valid lowering).
- *
- * The ladder rungs that need infra are INJECTED capabilities of the resolve
- * context (`runSandboxCode`, `provisionHost`), so the substrate-free caller wires
- * only what it can host — a binding that needs an absent provider throws loudly,
- * it is NEVER faked into a working surface. The not-yet-admitted arms (rag-index,
- * memory-store, wasm, a2a) throw {@link CapabilityNotAdmittedError}.
- *
- * Fail-closed by construction (mirroring `pullCertified`): a `null` manifest
- * returns the base surface only; a per-capability resolve failure DROPS that
- * capability (never a half-wired tool); a post-resolve drift check drops any tool
- * whose live names diverge from the certified interface.
- *
- * @experimental
+ * all-or-none replacements. The product owns locking, persistence, and retained
+ * state; Runtime owns the profile diff semantics and digest checks.
  */
-
+declare function prepareAgentImprovementProfileActivation(input: AgentImprovementProfileActivationInput): AgentImprovementProfileActivationPreparation;
+//#endregion
+//#region src/intelligence/resolver.d.ts
 /** A live, provisioned host the resolver tore up for a `process-on-infra` arm.
  *  `teardown()` runs at `dispose()` in reverse provisioning order. */
 interface ProvisionedHost {
-    /** Lower the inner binding's mcp connection now that the host is up; the URL/
-     *  command points at the host. Absent when the host serves a non-mcp inner. */
-    mcpConnection?: AgentProfileMcpServer;
-    teardown(): Promise<void>;
+  /** Lower the inner binding's mcp connection now that the host is up; the URL/
+   *  command points at the host. Absent when the host serves a non-mcp inner. */
+  mcpConnection?: AgentProfileMcpServer;
+  teardown(): Promise<void>;
 }
 /**
  * Per-call, per-tenant context the resolver reads. Everything that touches the
@@ -970,52 +909,52 @@ interface ProvisionedHost {
  * no live secret and the substrate-free caller wires only what it can host.
  */
 interface ResolveCtx {
-    /** Stable tenant id — namespaces billing + teardown (`tenant#target`). */
-    tenant?: string;
-    /** fetch impl for http tools. Defaults to global fetch; absent ⇒ http tools fail loud. */
-    fetchImpl?: typeof fetch;
-    /**
-     * Resolve a declared credential to a live secret for THIS tenant. Returns a
-     * typed outcome — inspect `succeeded` before `value`. Absent ⇒ a binding that
-     * declares non-`none` auth fails loud (never a request with no credential).
-     */
-    resolveSecret?: (auth: CapabilityAuth, tenant: string | undefined) => Promise<{
-        succeeded: true;
-        value: string;
-    } | {
-        succeeded: false;
-        error: string;
-    }>;
-    /**
-     * Run a `sandbox-code` body per call. Injected by the host that owns a sandbox
-     * client (the spine does not import the sandbox executor). Absent ⇒
-     * `sandbox-code` bindings fail loud.
-     */
-    runSandboxCode?: (code: ContentRef, entry: string, args: Record<string, unknown>, task: unknown) => Promise<string>;
-    /**
-     * Provision a host for a `process-on-infra` binding, then serve the inner
-     * binding inside it. Injected by the host that owns `createExecutor`. Absent ⇒
-     * `process-on-infra` bindings fail loud. The provider resolves the inner
-     * binding INSIDE the host and returns the connection + a teardown.
-     */
-    provisionHost?: (host: HostSpec, inner: DeliveryBinding, costTag: string) => Promise<ProvisionedHost>;
-    /**
-     * Drift probe: return the LIVE tool names a resolved surface exposes for a
-     * given capability id (a `tools/list` over an mcp connection, the agent's
-     * actual registered tool names for a host tool). When present, the post-resolve
-     * drift check drops any tool/mcp whose live names diverge from the certified
-     * interface — the only callable surfaces are gate-blessed ones. Absent ⇒ the
-     * check enforces only the host-side executor↔spec parity (no live probe).
-     */
-    probeLiveToolNames?: (capabilityId: string) => Promise<string[]>;
-    /**
-     * Observe a DROPPED capability — a per-capability resolve failure that is
-     * fail-closed (the capability is omitted, never half-wired). The drop is the
-     * contract; this surfaces the diagnostic so it is never silently erased. NOT
-     * called for {@link CapabilityNotAdmittedError} (that rethrows — a manifest
-     * carrying an un-admitted binding kind is a hard error, not a soft drop).
-     */
-    onDrop?: (capabilityId: string, error: Error) => void;
+  /** Stable tenant id — namespaces billing + teardown (`tenant#target`). */
+  tenant?: string;
+  /** fetch impl for http tools. Defaults to global fetch; absent ⇒ http tools fail loud. */
+  fetchImpl?: typeof fetch;
+  /**
+   * Resolve a declared credential to a live secret for THIS tenant. Returns a
+   * typed outcome — inspect `succeeded` before `value`. Absent ⇒ a binding that
+   * declares non-`none` auth fails loud (never a request with no credential).
+   */
+  resolveSecret?: (auth: CapabilityAuth, tenant: string | undefined) => Promise<{
+    succeeded: true;
+    value: string;
+  } | {
+    succeeded: false;
+    error: string;
+  }>;
+  /**
+   * Run a `sandbox-code` body per call. Injected by the host that owns a sandbox
+   * client (the spine does not import the sandbox executor). Absent ⇒
+   * `sandbox-code` bindings fail loud.
+   */
+  runSandboxCode?: (code: ContentRef, entry: string, args: Record<string, unknown>, task: unknown) => Promise<string>;
+  /**
+   * Provision a host for a `process-on-infra` binding, then serve the inner
+   * binding inside it. Injected by the host that owns `createExecutor`. Absent ⇒
+   * `process-on-infra` bindings fail loud. The provider resolves the inner
+   * binding INSIDE the host and returns the connection + a teardown.
+   */
+  provisionHost?: (host: HostSpec, inner: DeliveryBinding, costTag: string) => Promise<ProvisionedHost>;
+  /**
+   * Drift probe: return the LIVE tool names a resolved surface exposes for a
+   * given capability id (a `tools/list` over an mcp connection, the agent's
+   * actual registered tool names for a host tool). When present, the post-resolve
+   * drift check drops any tool/mcp whose live names diverge from the certified
+   * interface — the only callable surfaces are gate-blessed ones. Absent ⇒ the
+   * check enforces only the host-side executor↔spec parity (no live probe).
+   */
+  probeLiveToolNames?: (capabilityId: string) => Promise<string[]>;
+  /**
+   * Observe a DROPPED capability — a per-capability resolve failure that is
+   * fail-closed (the capability is omitted, never half-wired). The drop is the
+   * contract; this surfaces the diagnostic so it is never silently erased. NOT
+   * called for {@link CapabilityNotAdmittedError} (that rethrows — a manifest
+   * carrying an un-admitted binding kind is a hard error, not a soft drop).
+   */
+  onDrop?: (capabilityId: string, error: Error) => void;
 }
 /**
  * Compose a certified profile into a uniform `ResolvedSurface`. Additive over
@@ -1027,73 +966,41 @@ interface ResolveCtx {
  * Fail-closed: a `null` manifest returns the base surface only.
  */
 declare function composeCertifiedProfile(base: {
-    systemPrompt: string;
+  systemPrompt: string;
 }, manifest: CapabilityManifest | null, ctx?: ResolveCtx): Promise<ResolvedSurface>;
 /** Lower a plane `CertifiedProfile` straight into a `ResolvedSurface` via
  *  `manifestFromProfile` — the convenience the shipped pull lane calls when it
  *  already holds a `CertifiedProfile` (today's wire) rather than a manifest. */
 declare function composeCertifiedProfileFromWire(base: {
-    systemPrompt: string;
+  systemPrompt: string;
 }, profile: CertifiedProfile | null, ctx?: ResolveCtx): Promise<ResolvedSurface>;
-
-/**
- *
- * `withIntelligence` — the ONE agent-runtime hook that unifies Tangle
- * Intelligence send + receive.
- *
- * It does two things per call, both fail-open:
- *   1. RECEIVE — pull the tenant's certified profile from the deployed plane
- *      (cached + refreshed), hand the agent the certified prompt surface to fold
- *      (`applied.composePrompt`) and the promoted, gate-certified profile DIFFS
- *      as PROPOSALS (`applied.proposals` / `applied.applyProfile`).
- *   2. SEND — serialize a typed {@link RunRecord} for the call through the shipped
- *      OTLP builders to the plane's `/v1/otlp` ingest, best-effort.
- *
- * SAFETY — observe + deliver ONLY. This hook NEVER auto-applies a received diff
- * at runtime. A promoted diff is surfaced as a proposal; a human, or the gated
- * local `improve()` loop, turns a proposal into a shipped profile. That
- * preserves the held-out invariant the plane enforces — a runtime that silently
- * folded an un-gated diff into itself would defeat the very gate the diff cleared.
- *
- *   import { withIntelligence } from '@tangle-network/agent-runtime/intelligence'
- *
- *   export const agent = withIntelligence(
- *     async (input, applied) => {
- *       const out = await myAgent(input, { systemPrompt: applied.composePrompt(BASE) })
- *       applied.record({ success: true, usage: { inferenceUsd: 0.002, intelligenceUsd: 0 } })
- *       return out
- *     },
- *     { project: 'support-agent', target: 'support-agent' },
- *   )
- *
- * @experimental
- */
-
+//#endregion
+//#region src/intelligence/with-intelligence.d.ts
 /** What the hook hands the agent each run. Additive over the prompt-only
  *  delivery: `composePrompt` folds the certified prompt surface (as before);
  *  `proposals`/`applyProfile` surface the promoted profile DIFFS — never
  *  auto-applied; `record` enriches the {@link RunRecord} that is sent. */
 interface AppliedIntelligence {
-    /** Stable ids shared by the run span and every nested runtime/loop span. */
-    runId: string;
-    traceId: string;
-    /** The certified profile in effect (null when none promoted / pull failed —
-     *  fail-closed: the agent runs on its base surface). */
-    certified: CertifiedProfile | null;
-    /** Fold the certified prompt surface into a base system prompt (the promoted
-     *  prompt). The consumer opts in by calling it. */
-    composePrompt(base: string): string;
-    /** The promoted, gate-certified profile diffs — surfaced for a human or the
-     *  gated `improve()` loop. NEVER auto-applied by this hook. Empty when none. */
-    proposals: ProposedProfileDiff[];
-    /** Fold every proposal into `base` via `applyAgentProfileDiff`, in promotion
-     *  order, and return the result. The caller invokes this EXPLICITLY (it is the
-     *  human/gated apply step) — the hook never calls it on the run path. */
-    applyProfile(base: AgentProfile): AgentProfile;
-    /** Enrich the {@link RunRecord} sent for this call — outcome, usage split,
-     *  model/provider, and the loop event stream. Optional; an un-recorded run
-     *  still sends input/output with an inference-only zero usage split. */
-    record(report: RunReport): void;
+  /** Stable ids shared by the run span and every nested runtime/loop span. */
+  runId: string;
+  traceId: string;
+  /** The certified profile in effect (null when none promoted / pull failed —
+   *  fail-closed: the agent runs on its base surface). */
+  certified: CertifiedProfile | null;
+  /** Fold the certified prompt surface into a base system prompt (the promoted
+   *  prompt). The consumer opts in by calling it. */
+  composePrompt(base: string): string;
+  /** The promoted, gate-certified profile diffs — surfaced for a human or the
+   *  gated `improve()` loop. NEVER auto-applied by this hook. Empty when none. */
+  proposals: ProposedProfileDiff[];
+  /** Fold every proposal into `base` via `applyAgentProfileDiff`, in promotion
+   *  order, and return the result. The caller invokes this EXPLICITLY (it is the
+   *  human/gated apply step) — the hook never calls it on the run path. */
+  applyProfile(base: AgentProfile$1): AgentProfile$1;
+  /** Enrich the {@link RunRecord} sent for this call — outcome, usage split,
+   *  model/provider, and the loop event stream. Optional; an un-recorded run
+   *  still sends input/output with an inference-only zero usage split. */
+  record(report: RunReport): void;
 }
 /** An agent wrapped by {@link withIntelligence}: receives the input plus the
  *  intelligence delivered for this run. */
@@ -1102,25 +1009,25 @@ type IntelligenceAgent<I, O> = (input: I, applied: AppliedIntelligence) => Promi
  *  cadence, and a proposals callback. One base URL (`baseUrl` /
  *  `TANGLE_INTELLIGENCE_URL`) drives both the send and receive paths. */
 interface IntelligenceHookConfig extends IntelligenceConfig {
-    /** Pull target. Defaults to `project`. */
-    target?: string;
-    /** Min interval between certified-profile pulls. Default 5m. */
-    refreshMs?: number;
-    /** Per-pull timeout in ms (fail-closed on a hung plane). Default 10000. */
-    timeoutMs?: number;
-    /** fetch impl for the pull (tests). Defaults to global fetch. */
-    fetchImpl?: typeof fetch;
-    /** Notified when a refresh delivers a NEW set of promoted proposals (by
-     *  provenance content hash). Surfaces diffs without auto-applying them. */
-    onProposals?: (proposals: ProposedProfileDiff[]) => void;
+  /** Pull target. Defaults to `project`. */
+  target?: string;
+  /** Min interval between certified-profile pulls. Default 5m. */
+  refreshMs?: number;
+  /** Per-pull timeout in ms (fail-closed on a hung plane). Default 10000. */
+  timeoutMs?: number;
+  /** fetch impl for the pull (tests). Defaults to global fetch. */
+  fetchImpl?: typeof fetch;
+  /** Notified when a refresh delivers a NEW set of promoted proposals (by
+   *  provenance content hash). Surfaces diffs without auto-applying them. */
+  onProposals?: (proposals: ProposedProfileDiff[]) => void;
 }
 /** The wrapped agent — same `(input) => Promise<output>` shape, plus a manual
  *  `refresh()` and a `proposals()` accessor for the currently-promoted diffs. */
 type IntelligenceWrapped<I, O> = ((input: I) => Promise<O>) & {
-    refresh(): Promise<void>;
-    proposals(): ProposedProfileDiff[];
-    /** Flush buffered trace spans before a short-lived process exits. */
-    flush(): Promise<void>;
+  refresh(): Promise<void>;
+  proposals(): ProposedProfileDiff[];
+  /** Flush buffered trace spans before a short-lived process exits. */
+  flush(): Promise<void>;
 };
 /**
  * Wrap an agent so it (a) RECEIVES the tenant's certified profile — the prompt
@@ -1132,28 +1039,8 @@ type IntelligenceWrapped<I, O> = ((input: I) => Promise<O>) & {
  * thrown by the agent itself propagates unchanged.
  */
 declare function withIntelligence<I, O>(agent: IntelligenceAgent<I, O>, config: IntelligenceHookConfig): IntelligenceWrapped<I, O>;
-
-/**
- *
- * Tangle Intelligence SDK — trace capture plus reviewable improvement.
- *
- * The client keeps live-agent trace delivery best-effort. The separate
- * improvement-cycle exports analyze completed traces, run a signed baseline
- * versus candidate experiment, bind review to its result, and activate only
- * the exact measured candidate.
- *
- *   1. OBSERVE — wrap a generic agent and export one trace span per call to
- *      Tangle Intelligence, swallowing every export failure so a live agent
- *      never fails because Intelligence is down.
- *   2. MODE 0 / OFF — at `effort: 'off'`, run the agent as PURE PASSTHROUGH
- *      (zero intelligence spawns) with best-effort telemetry still on. The
- *      exported trace tags usage by class `{ inferenceUsd, intelligenceUsd }`,
- *      and at OFF `intelligenceUsd` is provably `0` — the mechanism that proves
- *      an OFF customer paid inference-only.
- *
- * @experimental
- */
-
+//#endregion
+//#region src/intelligence/index.d.ts
 /** Usage class for billing. Base-stream tokens bill `'inference'`; every
  *  intelligence spawn (analyst, corpus, loop) bills `'intelligence'`. The
  *  billing line falls on the spawn line. */
@@ -1164,10 +1051,10 @@ type UsageClass = 'inference' | 'intelligence';
  * bill. This is a classification on the trace, NOT a budget-pool split.
  */
 interface UsageSplit {
-    /** Base-stream (model) spend in USD. */
-    inferenceUsd: number;
-    /** Intelligence-spawn spend in USD. Provably `0` at the OFF tier. */
-    intelligenceUsd: number;
+  /** Base-stream (model) spend in USD. */
+  inferenceUsd: number;
+  /** Intelligence-spawn spend in USD. Provably `0` at the OFF tier. */
+  intelligenceUsd: number;
 }
 /**
  * The typed record `withIntelligence` sends per call — serialized through the
@@ -1177,44 +1064,44 @@ interface UsageSplit {
  * tree under the same `traceId`.
  */
 interface RunRecord {
-    runId: string;
-    traceId: string;
-    project: string;
-    target: string;
-    input: unknown;
-    output: unknown;
-    outcome: {
-        success?: boolean;
-        score?: number;
-        usage: UsageSplit;
-    };
-    model?: string;
-    provider?: string;
-    loopEvents?: LoopTraceEvent[];
-    runtimeEvents?: RuntimeStreamEvent[];
-    profile?: AgentProfile;
-    sessionId?: string;
-    harness?: string;
-    repository?: string;
-    commitSha?: string;
-    timing?: {
-        startedAt: number;
-        completedAt: number;
-        durationMs: number;
-    };
-    tokens?: {
-        input: number;
-        output: number;
-        cachedInput?: number;
-        reasoning?: number;
-    };
-    error?: {
-        name: string;
-        message: string;
-        code?: string;
-    };
-    /** Exact proposal → review → execution → receipt linkage for candidate runs. */
-    candidateExecution?: CandidateExecutionEvidence;
+  runId: string;
+  traceId: string;
+  project: string;
+  target: string;
+  input: unknown;
+  output: unknown;
+  outcome: {
+    success?: boolean;
+    score?: number;
+    usage: UsageSplit;
+  };
+  model?: string;
+  provider?: string;
+  loopEvents?: LoopTraceEvent[];
+  runtimeEvents?: RuntimeStreamEvent[];
+  profile?: AgentProfile$1;
+  sessionId?: string;
+  harness?: string;
+  repository?: string;
+  commitSha?: string;
+  timing?: {
+    startedAt: number;
+    completedAt: number;
+    durationMs: number;
+  };
+  tokens?: {
+    input: number;
+    output: number;
+    cachedInput?: number;
+    reasoning?: number;
+  };
+  error?: {
+    name: string;
+    message: string;
+    code?: string;
+  };
+  /** Exact proposal → review → execution → receipt linkage for candidate runs. */
+  candidateExecution?: CandidateExecutionEvidence$1;
 }
 /**
  * What an agent reports (via `applied.record`) to enrich the {@link RunRecord}
@@ -1223,91 +1110,91 @@ interface RunRecord {
  * as pure inference (the base stream).
  */
 interface RunReport {
-    success?: boolean;
-    score?: number;
-    usage?: Partial<UsageSplit>;
-    costUsd?: number;
-    model?: string;
-    provider?: string;
-    loopEvents?: LoopTraceEvent[];
-    runtimeEvents?: RuntimeStreamEvent[];
-    profile?: AgentProfile;
-    sessionId?: string;
-    harness?: string;
-    commitSha?: string;
-    tokens?: RunRecord['tokens'];
-    error?: RunRecord['error'];
-    candidateExecution?: CandidateExecutionEvidence;
+  success?: boolean;
+  score?: number;
+  usage?: Partial<UsageSplit>;
+  costUsd?: number;
+  model?: string;
+  provider?: string;
+  loopEvents?: LoopTraceEvent[];
+  runtimeEvents?: RuntimeStreamEvent[];
+  profile?: AgentProfile$1;
+  sessionId?: string;
+  harness?: string;
+  commitSha?: string;
+  tokens?: RunRecord['tokens'];
+  error?: RunRecord['error'];
+  candidateExecution?: CandidateExecutionEvidence$1;
 }
 /** Repo coordinates a product may declare for the (later) Gated-PR mode. The
  *  Observe slice only records their PRESENCE for `doctor()`; it never touches
  *  the repo. */
 interface RepoConfig {
-    owner: string;
-    name: string;
-    baseBranch: string;
+  owner: string;
+  name: string;
+  baseBranch: string;
 }
 /** Client configuration. `project` + `apiKey` are the Observe minimum; the
  *  rest tune effort, endpoint, redaction, and (for `doctor()` readiness)
  *  declare the surfaces/checks/repo a later PR mode would need. */
 interface IntelligenceConfig {
-    /** Stable project id — the tenant dimension every trace is tagged with. */
-    project: string;
-    /** Bearer key for the Intelligence ingest. Reads `TANGLE_API_KEY` when omitted. */
-    apiKey?: string;
-    /** Effort tier (default `'standard'`) plus optional per-field overrides. */
-    effort?: EffortTier | {
-        tier: EffortTier;
-        overrides?: EffortOverrides;
-    };
-    /**
-     * The ONE Tangle Intelligence base URL — both the send (OTLP `/v1/otlp`) and
-     * receive (`/v1/profiles/:target/composed`) paths derive from it. Reads
-     * `TANGLE_INTELLIGENCE_URL` when omitted, else `https://intelligence.tangle.tools`.
-     * Send is best-effort and only ships when an `apiKey` is present (the tenant
-     * key the ingest requires); absent a key, export is a no-op.
-     */
-    baseUrl?: string;
-    /**
-     * Redaction hook run over every exported input/output. A function replaces
-     * the default scrubber; `false` opts out entirely (raw fidelity, caller has
-     * sanitized upstream); omitted ⇒ the built-in `defaultRedactor`.
-     */
-    redact?: Redactor | false;
-    /** Mutable surfaces a later PR mode would edit. Recorded for `doctor()` only. */
-    surfaces?: string[];
-    /** Verification checks a later PR mode would gate on. Recorded for `doctor()` only. */
-    checks?: string[];
-    /** Repo access a later PR mode would need. Recorded for `doctor()` only. */
-    repo?: RepoConfig;
-    /** Full canonical profile used for this agent. Exported redacted with a stable hash. */
-    profile?: AgentProfile;
-    /** Commit that produced the running agent, when known. */
-    commitSha?: string;
-    /** Runtime-event payload policy. Tool inputs/results remain off unless explicitly enabled. */
-    runtimeTelemetry?: RuntimeTelemetryOptions;
-    /**
-     * Payloads are metadata-only by default: the run span carries a stable hash
-     * and UTF-8 byte count, but not the redacted content. Set `full` only when
-     * the configured OTLP destination is approved to receive complete redacted
-     * inputs, outputs, and profiles.
-     */
-    payloadAttributes?: 'metadata' | 'full';
+  /** Stable project id — the tenant dimension every trace is tagged with. */
+  project: string;
+  /** Bearer key for the Intelligence ingest. Reads `TANGLE_API_KEY` when omitted. */
+  apiKey?: string;
+  /** Effort tier (default `'standard'`) plus optional per-field overrides. */
+  effort?: EffortTier | {
+    tier: EffortTier;
+    overrides?: EffortOverrides;
+  };
+  /**
+   * The ONE Tangle Intelligence base URL — both the send (OTLP `/v1/otlp`) and
+   * receive (`/v1/profiles/:target/composed`) paths derive from it. Reads
+   * `TANGLE_INTELLIGENCE_URL` when omitted, else `https://intelligence.tangle.tools`.
+   * Send is best-effort and only ships when an `apiKey` is present (the tenant
+   * key the ingest requires); absent a key, export is a no-op.
+   */
+  baseUrl?: string;
+  /**
+   * Redaction hook run over every exported input/output. A function replaces
+   * the default scrubber; `false` opts out entirely (raw fidelity, caller has
+   * sanitized upstream); omitted ⇒ the built-in `defaultRedactor`.
+   */
+  redact?: Redactor | false;
+  /** Mutable surfaces a later PR mode would edit. Recorded for `doctor()` only. */
+  surfaces?: string[];
+  /** Verification checks a later PR mode would gate on. Recorded for `doctor()` only. */
+  checks?: string[];
+  /** Repo access a later PR mode would need. Recorded for `doctor()` only. */
+  repo?: RepoConfig;
+  /** Full canonical profile used for this agent. Exported redacted with a stable hash. */
+  profile?: AgentProfile$1;
+  /** Commit that produced the running agent, when known. */
+  commitSha?: string;
+  /** Runtime-event payload policy. Tool inputs/results remain off unless explicitly enabled. */
+  runtimeTelemetry?: RuntimeTelemetryOptions;
+  /**
+   * Payloads are metadata-only by default: the run span carries a stable hash
+   * and UTF-8 byte count, but not the redacted content. Set `full` only when
+   * the configured OTLP destination is approved to receive complete redacted
+   * inputs, outputs, and profiles.
+   */
+  payloadAttributes?: 'metadata' | 'full';
 }
 /** Metadata describing one traced run. `runId`/`traceId` default to fresh ids. */
 interface TraceMeta {
-    /** The run's input — exported through the redactor. */
-    input?: unknown;
-    /** Stable run id. Defaults to a fresh id. */
-    runId?: string;
-    /** 32-hex trace id. Defaults to a fresh id. */
-    traceId?: string;
-    /** Model id, when known — stamped on the span. */
-    model?: string;
-    /** Provider name, when known — stamped on the span. */
-    provider?: string;
-    /** Arbitrary extra labels (string/number/boolean) stamped on the span. */
-    labels?: Record<string, string | number | boolean>;
+  /** The run's input — exported through the redactor. */
+  input?: unknown;
+  /** Stable run id. Defaults to a fresh id. */
+  runId?: string;
+  /** 32-hex trace id. Defaults to a fresh id. */
+  traceId?: string;
+  /** Model id, when known — stamped on the span. */
+  model?: string;
+  /** Provider name, when known — stamped on the span. */
+  provider?: string;
+  /** Arbitrary extra labels (string/number/boolean) stamped on the span. */
+  labels?: Record<string, string | number | boolean>;
 }
 /**
  * The trace handle a `traceRun` body records into. `recordOutput` captures the
@@ -1316,104 +1203,104 @@ interface TraceMeta {
  * an un-recorded run still exports a span with whatever was set.
  */
 interface TraceHandle {
-    /** Capture the run's output. Exported through the redactor. */
-    recordOutput(output: unknown): void;
-    /**
-     * Capture the run's outcome. `usage` defaults to inference-only
-     * (`intelligenceUsd: 0`) — the OFF baseline; an intelligence-enabled run
-     * fills `intelligenceUsd` itself. `costUsd`, when given without a split, is
-     * treated as pure inference.
-     */
-    recordOutcome(outcome: {
-        success?: boolean;
-        score?: number;
-        costUsd?: number;
-        usage?: Partial<UsageSplit>;
-    }): void;
+  /** Capture the run's output. Exported through the redactor. */
+  recordOutput(output: unknown): void;
+  /**
+   * Capture the run's outcome. `usage` defaults to inference-only
+   * (`intelligenceUsd: 0`) — the OFF baseline; an intelligence-enabled run
+   * fills `intelligenceUsd` itself. `costUsd`, when given without a split, is
+   * treated as pure inference.
+   */
+  recordOutcome(outcome: {
+    success?: boolean;
+    score?: number;
+    costUsd?: number;
+    usage?: Partial<UsageSplit>;
+  }): void;
 }
 /** Metadata for {@link IntelligenceClient.recordTrace}. */
 interface RecordTraceMeta {
-    /** 32-hex trace id to anchor every span to. Defaults to a fresh id. */
-    traceId?: string;
-    /** Span id of an enclosing span the loop root should parent under (e.g. a
-     *  `traceRun` span). Omitted ⇒ the loop root is the trace root. */
-    rootParentSpanId?: string;
+  /** 32-hex trace id to anchor every span to. Defaults to a fresh id. */
+  traceId?: string;
+  /** Span id of an enclosing span the loop root should parent under (e.g. a
+   *  `traceRun` span). Omitted ⇒ the loop root is the trace root. */
+  rootParentSpanId?: string;
 }
 /** The resolved outcome of one traced run, surfaced on the export span and
  *  available to the caller for downstream billing assertions. */
 interface TraceOutcome {
-    runId: string;
-    traceId: string;
-    project: string;
-    /** The resolved effort settings this run executed under. */
-    effort: EffortSettings;
-    /** True when this run ran as pure passthrough (the OFF floor). */
-    intelligenceOff: boolean;
-    success?: boolean;
-    score?: number;
-    /** Per-class billing split. `intelligenceUsd` is `0` at the OFF tier. */
-    usage: UsageSplit;
+  runId: string;
+  traceId: string;
+  project: string;
+  /** The resolved effort settings this run executed under. */
+  effort: EffortSettings;
+  /** True when this run ran as pure passthrough (the OFF floor). */
+  intelligenceOff: boolean;
+  success?: boolean;
+  score?: number;
+  /** Per-class billing split. `intelligenceUsd` is `0` at the OFF tier. */
+  usage: UsageSplit;
 }
 /** The Observe-mode Intelligence client. */
 interface IntelligenceClient {
-    /** The resolved project id. */
-    readonly project: string;
-    /** The resolved effort settings. */
-    readonly effort: EffortSettings;
-    /**
-     * Run `fn` under a trace, export one span best-effort, and return whatever
-     * `fn` returns. Telemetry-export failures are swallowed; an error THROWN by
-     * `fn` propagates to the caller (the agent's own failures are not masked).
-     */
-    traceRun<T>(meta: TraceMeta, fn: (trace: TraceHandle) => Promise<T>): Promise<T>;
-    /**
-     * Export a run's full loop topology — the ordered `LoopTraceEvent` stream a
-     * `runAgentRounds`/`Supervisor` run emits — as a nested OTLP span tree (loop → round →
-     * iteration) into ONE trace. Reuses the shipped `buildLoopOtelSpans` builder
-     * (NO second span builder), so the topology a viewer renders matches the
-     * kernel's. `traceId` defaults to a fresh id; `rootParentSpanId` parents the
-     * loop root under an enclosing span (e.g. a `traceRun` span) when given.
-     * Best-effort: export failures are swallowed. Returns the resolved `traceId`.
-     */
-    recordTrace(events: ReadonlyArray<LoopTraceEvent>, meta?: RecordTraceMeta): string;
-    /**
-     * Send one typed {@link RunRecord} — the run's flat span (input/output/outcome/
-     * usage/model/provider, redacted) plus, when `loopEvents` are present, the
-     * nested loop topology under the same `traceId`. Reuses the shipped
-     * `flatOtelSpan` + `buildLoopOtelSpans` builders (no second builder).
-     * Best-effort: export failures are swallowed. Returns the record's `traceId`.
-     */
-    exportRunRecord(record: RunRecord): string;
-    /** Mint a fresh run id (`run-<hex>`). */
-    freshRunId(): string;
-    /** Mint a fresh 32-hex trace id. */
-    freshTraceId(): string;
-    /**
-     * Network-free readiness report: which adoption modes are reachable given
-     * this config. Observe is always reachable; Recommend needs outcomes; PR
-     * needs checks + surfaces + repo.
-     */
-    doctor(): DoctorReport;
-    /** Flush any pending export spans. Best-effort; resolves even if export fails. */
-    flush(): Promise<void>;
+  /** The resolved project id. */
+  readonly project: string;
+  /** The resolved effort settings. */
+  readonly effort: EffortSettings;
+  /**
+   * Run `fn` under a trace, export one span best-effort, and return whatever
+   * `fn` returns. Telemetry-export failures are swallowed; an error THROWN by
+   * `fn` propagates to the caller (the agent's own failures are not masked).
+   */
+  traceRun<T>(meta: TraceMeta, fn: (trace: TraceHandle) => Promise<T>): Promise<T>;
+  /**
+   * Export a run's full loop topology — the ordered `LoopTraceEvent` stream a
+   * `runAgentRounds`/`Supervisor` run emits — as a nested OTLP span tree (loop → round →
+   * iteration) into ONE trace. Reuses the shipped `buildLoopOtelSpans` builder
+   * (NO second span builder), so the topology a viewer renders matches the
+   * kernel's. `traceId` defaults to a fresh id; `rootParentSpanId` parents the
+   * loop root under an enclosing span (e.g. a `traceRun` span) when given.
+   * Best-effort: export failures are swallowed. Returns the resolved `traceId`.
+   */
+  recordTrace(events: ReadonlyArray<LoopTraceEvent>, meta?: RecordTraceMeta): string;
+  /**
+   * Send one typed {@link RunRecord} — the run's flat span (input/output/outcome/
+   * usage/model/provider, redacted) plus, when `loopEvents` are present, the
+   * nested loop topology under the same `traceId`. Reuses the shipped
+   * `flatOtelSpan` + `buildLoopOtelSpans` builders (no second builder).
+   * Best-effort: export failures are swallowed. Returns the record's `traceId`.
+   */
+  exportRunRecord(record: RunRecord): string;
+  /** Mint a fresh run id (`run-<hex>`). */
+  freshRunId(): string;
+  /** Mint a fresh 32-hex trace id. */
+  freshTraceId(): string;
+  /**
+   * Network-free readiness report: which adoption modes are reachable given
+   * this config. Observe is always reachable; Recommend needs outcomes; PR
+   * needs checks + surfaces + repo.
+   */
+  doctor(): DoctorReport;
+  /** Flush any pending export spans. Best-effort; resolves even if export fails. */
+  flush(): Promise<void>;
 }
 /** One mode's readiness verdict. */
 interface ModeReadiness {
-    ready: boolean;
-    /** Inputs this mode still needs, when not ready. Empty when ready. */
-    missing: string[];
+  ready: boolean;
+  /** Inputs this mode still needs, when not ready. Empty when ready. */
+  missing: string[];
 }
 /** The `doctor()` readiness report — Mode-readiness without any network call. */
 interface DoctorReport {
-    project: string;
-    effort: EffortSettings;
-    /** True when an OTLP endpoint is configured (export will actually ship). */
-    exportConfigured: boolean;
-    modes: {
-        observe: ModeReadiness;
-        recommend: ModeReadiness;
-        pr: ModeReadiness;
-    };
+  project: string;
+  effort: EffortSettings;
+  /** True when an OTLP endpoint is configured (export will actually ship). */
+  exportConfigured: boolean;
+  modes: {
+    observe: ModeReadiness;
+    recommend: ModeReadiness;
+    pr: ModeReadiness;
+  };
 }
 /**
  * Create an Observe-mode Intelligence client. Resolves effort, the base URL, and
@@ -1422,5 +1309,6 @@ interface DoctorReport {
  * and best-effort export must never spam an unauthenticated plane).
  */
 declare function createIntelligenceClient(config: IntelligenceConfig): IntelligenceClient;
-
-export { AGENT_IMPROVEMENT_PROFILE_SURFACES, type AgentCandidateExecutionHostPorts, AgentCandidateExperimentCellExecutionError, type AgentCandidateExperimentCellPlacement, type AgentImprovementActivationTargetIdentity, AgentImprovementActivationTargetPlan, type AgentImprovementExperimentMaterial, type AgentImprovementProfileActivationPreparation, type AgentImprovementProfileActivationTarget, type AgentImprovementProfileReplacement, type AgentImprovementProfileSurface, type AgentImprovementProfileTargetState, type AgentImprovementProfileTargetTransition, type AgentImprovementProposalSubmissionState, type AgentImprovementTargetProfileDiffOptions, type AppliedIntelligence, type CapabilityAuth, type CapabilityInterface, type CapabilityManifest, CapabilityNotAdmittedError, type CapabilitySurface, type CertProvenance, type CertifiedArtifact, type CertifiedCapability, type CertifiedCapabilitySummary, type CertifiedProfile, type CertifiedPromptSource, type CertifiedPromptSourceOptions, type CertifiedPromptSurface, type ContentRef, type CorpusAccess, type CreateAgentImprovementActivationOptions, type CreateAgentImprovementProposalOptions, type CreateExactProcessCandidateExperimentExecutorOptions, type CreateProtectedExactProcessCandidateExperimentExecutorOptions, type CredentialRef, type DeliveryBinding, type DeliveryBindingKind, type DiffProvenance, type DoctorReport, type EffortOverrides, type EffortOverridesCompiled, type EffortSettings, type EffortTier, type ExactProcessCandidateExperimentExecution, type ExactProcessCandidateExperimentExecutor, type ExecuteAgentCandidateExperimentCellOptions, type HostSpec, type IntelligenceAgent, type IntelligenceClient, type IntelligenceConfig, type IntelligenceHookConfig, type IntelligenceWrapped, type JsonSchema, type ModeReadiness, type ProposeAgentImprovementOptions, type ProposeAgentImprovementResult, type ProposedProfileDiff, type ProtectedExactProcessCandidateExperimentExecutor, type ProvisionedHost, type PullCertifiedOptions, type PullOutcome, type RecordTraceMeta, type Redactor, type RepoConfig, type ResolveCtx, type ResolvedHook, type ResolvedRetrieval, type ResolvedSubagent, type ResolvedSurface, type ReviewAgentImprovementInput, type RunAgentCandidateExperimentOptions, type RunAgentCandidateExperimentResult, type RunRecord, type RunReport, type SubmitAgentImprovementProposalOptions, type SubmitAgentImprovementProposalOutcome, type TraceHandle, type TraceMeta, type TraceOutcome, type UsageClass, type UsageSplit, type VerifyCandidateExecutionEvidenceOptions, agentImprovementProfileSurfaceDigest, agentImprovementProfileSurfaceInput, agentImprovementTargetProfileDiffs, buildAgentImprovementActivationTargets, compileEffort, composeCertifiedProfile, composeCertifiedProfileFromWire, composeCertifiedPrompt, createAgentImprovementActivation, createAgentImprovementMeasuredComparison, createAgentImprovementProposal, createCertifiedPromptSource, createExactProcessCandidateExperimentExecutor, createIntelligenceClient, createProtectedExactProcessCandidateExperimentExecutor, defaultEffortTier, defaultRedactor, exactProcessCandidateExperimentExecutionSupport, executeAgentCandidateExperimentCell, isAgentImprovementProfileSurface, isIntelligenceOff, manifestFromProfile, normalizeCertifiedProfile, prepareAgentImprovementProfileActivation, proposeAgentImprovement, pullCertified, resolveEffort, resolveIntelligenceBaseUrl, resolveRedactor, reviewAgentImprovementProposal, runAgentCandidateExperiment, submitAgentImprovementProposal, verifyAgentImprovementActivation, verifyAgentImprovementProposal, verifyAgentImprovementReview, verifyCandidateExecutionEvidence, withIntelligence };
+//#endregion
+export { AGENT_IMPROVEMENT_PROFILE_SURFACES, type AgentCandidateExecutionHostPorts, AgentCandidateExperimentCellExecutionError, type AgentCandidateExperimentCellPlacement, type AgentImprovementActivation, type AgentImprovementActivationIntent, type AgentImprovementActivationOutcome, type AgentImprovementActivationReconciliation, type AgentImprovementActivationResult, type AgentImprovementActivationResultStore, type AgentImprovementActivationTargetIdentity, type AgentImprovementActivationTargetPlan, type AgentImprovementActivationTransition, type AgentImprovementActivationTransitionInput, type AgentImprovementEvaluation, type AgentImprovementExperimentMaterial, type AgentImprovementMeasuredComparison, type AgentImprovementProfileActivationInput, type AgentImprovementProfileActivationPreparation, type AgentImprovementProfileActivationTarget, type AgentImprovementProfileReplacement, type AgentImprovementProfileStateDigest, type AgentImprovementProfileStateDigestInput, type AgentImprovementProfileStateResolver, type AgentImprovementProfileStateResolverInput, type AgentImprovementProfileSurface, type AgentImprovementProfileTargetState, type AgentImprovementProfileTargetTransition, type AgentImprovementProposal, type AgentImprovementProposalSubmissionState, type AgentImprovementReview, type AgentImprovementReviewDecision, type AgentImprovementTargetProfileDiffOptions, type AgentProfileImprovementActivationOperation, type AgentProfileImprovementActivationTargetPlan, type AppliedIntelligence, type CandidateExecutionEvidence, type CandidateProfileMaterialization, type CapabilityAuth, type CapabilityInterface, type CapabilityManifest, CapabilityNotAdmittedError, type CapabilitySurface, type CertProvenance, type CertifiedArtifact, type CertifiedCapability, type CertifiedCapabilitySummary, type CertifiedProfile, type CertifiedPromptSource, type CertifiedPromptSourceOptions, type CertifiedPromptSurface, type ContentRef, type CorpusAccess, type CreateAgentImprovementActivationOptions, type CreateAgentImprovementActivationResultOptions, type CreateAgentImprovementProposalOptions, type CreateExactProcessCandidateExperimentExecutorOptions, type CreateProtectedExactProcessCandidateExperimentExecutorOptions, type CredentialRef, type DeliveryBinding, type DeliveryBindingKind, type DiffProvenance, DoctorReport, type EffortOverrides, type EffortOverridesCompiled, type EffortSettings, type EffortTier, type ExactProcessCandidateExperimentExecution, type ExactProcessCandidateExperimentExecutor, type ExecuteAgentCandidateExperimentCellOptions, type ExecuteAgentImprovementActivationInput, type ExecuteAgentImprovementActivationOptions, type HostSpec, type IntelligenceAgent, IntelligenceClient, IntelligenceConfig, type IntelligenceHookConfig, type IntelligenceWrapped, type JsonSchema, ModeReadiness, type OptimizationActivationReceipt, type OptimizationReceiptCost, type ProfileImprovementActivationTransitionInput, type ProposeAgentImprovementOptions, type ProposeAgentImprovementResult, type ProposedProfileDiff, type ProtectedExactProcessCandidateExperimentExecutor, type ProvisionedHost, type PullCertifiedOptions, type PullOutcome, RecordTraceMeta, type Redactor, RepoConfig, type ResolveCtx, type ResolvedHook, type ResolvedRetrieval, type ResolvedSubagent, type ResolvedSurface, type ReviewAgentImprovementInput, type RunAgentCandidateExperimentOptions, type RunAgentCandidateExperimentResult, RunRecord, RunReport, type SealedCandidateActivationTransitionInput, type SubmitAgentImprovementProposalOptions, type SubmitAgentImprovementProposalOutcome, TraceHandle, TraceMeta, TraceOutcome, UsageClass, UsageSplit, type VerifyCandidateExecutionEvidenceOptions, agentImprovementProfileSurfaceDigest, agentImprovementProfileSurfaceInput, agentImprovementTargetProfileDiffs, buildAgentImprovementActivationTargets, compileEffort, composeCertifiedProfile, composeCertifiedProfileFromWire, composeCertifiedPrompt, createAgentImprovementActivation, createAgentImprovementActivationResult, createAgentImprovementMeasuredComparison, createAgentImprovementProposal, createCertifiedPromptSource, createExactProcessCandidateExperimentExecutor, createIntelligenceClient, createOptimizationActivationReceipt, createProtectedExactProcessCandidateExperimentExecutor, defaultEffortTier, defaultRedactor, exactProcessCandidateExperimentExecutionSupport, executeAgentCandidateExperimentCell, executeAgentImprovementActivation, isAgentImprovementProfileSurface, isIntelligenceOff, manifestFromProfile, normalizeCertifiedProfile, optimizationActivationReceiptFromMetadata, parseAgentCandidateProfileActivation as parseCandidateProfileMaterialization, prepareAgentImprovementProfileActivation, proposeAgentImprovement, pullCertified, resolveEffort, resolveIntelligenceBaseUrl, resolveRedactor, reviewAgentImprovementProposal, runAgentCandidateExperiment, submitAgentImprovementProposal, verifyAgentImprovementActivation, verifyAgentImprovementActivationResult, verifyAgentImprovementProposal, verifyAgentImprovementReview, verifyCandidateExecutionEvidence, withIntelligence };
+//# sourceMappingURL=intelligence.d.ts.map