@tangle-network/agent-runtime 0.94.13 → 0.96.1

package/README.md

@@ -33,7 +33,7 @@ pnpm tsx examples/driver-loop/driver-loop.ts
 | Run a **chat turn** for a production product agent | `handleChatTurn(...)` |
 | Have one agent **supervise a team of agents** toward a goal | `supervise(profile, task, opts)` |
 | **Improve** an agent and prove the gain on fresh tasks | `improve(profile, findings, opts)` |
-| **Improve** a knowledge base with agents, checks, and safe promotion | `runKnowledgeImprovementJob(...)` |
+| Produce a measured knowledge-base candidate with agents and checks | `runKnowledgeImprovementJob(...)` |
 | Evaluate or train the same agent on **PrimeIntellect** | `createPrimeIntellectPackage(...)` |
 
 ### Run a chat turn
@@ -70,7 +70,7 @@ const result = await supervise(
 
 ### Improve an agent
 
-`improve` optimizes one part of an agent and **only ships a change if it beats the current agent on tasks it never practiced on**.
+`improve` optimizes one part of an agent and returns a detached winner plus a decision. The decision is `ship` only when the candidate beats the current agent on tasks it never practiced on.
 It accepts prompt, skill document, curated memory, tool, MCP, hook, subagent, whole-profile, and code surfaces through one call.
 Prompt, skill-document, and memory optimization have built-in generators; structured profile surfaces take an explicit generator, and code runs from isolated incumbent and candidate checkouts.
 Workflow and rollout-policy files use the code surface so the measured winner is an exact patch that can be sealed and executed; JSON parameter sweeps use agent-eval's `parameterSweepProposer` instead of a runtime-specific optimizer.
@@ -78,26 +78,74 @@ Workflow and rollout-policy files use the code surface so the measured winner is
 ```ts
 import { improve } from '@tangle-network/agent-runtime'
 
-const { profile, shipped, lift } = await improve(baseProfile, findings, {
-  surface: 'prompt',        // or skills/memory/tools/mcp/hooks/subagents/agent-profile/code
-  gate: 'holdout',          // certified on a held-back exam, never the practice set
-  scenarios, judge, agent,  // how to measure a candidate
+const { candidate, decision, lift } = await improve(baseProfile, findings, {
+  surface: 'prompt',
+  gate: 'holdout',
+  scenarios,
+  judge,
+  agent,
 })
+
+if (decision === 'ship') console.log({ candidate, lift })
 ```
 
-Curated memory is an external lesson document, not a knowledge store. Supply its current text and persist only the promoted winner:
+Skill and curated-memory candidates are exact profile changes, not free-floating text.
+Name one inline skill through `skills.resourceName`; curated memory uses `profile.resources.instructions`.
+Both require `profile.resources.failOnError: true` so an unsupported resource cannot silently disappear.
 
 ```ts
-await improve(baseProfile, findings, {
-  surface: 'memory',
-  memory: { document: currentLessons, writeBack: saveLessons },
+const skillResult = await improve(baseProfile, findings, {
+  surface: 'skills',
+  skills: { resourceName: 'incident-response' },
   scenarios, judge, agent,
 })
 ```
 
+`improve` is the search call.
+For production, `proposeAgentImprovement` adds trace analysis and reruns the exact frozen baseline and winner before creating a reviewable proposal.
+Runtime rejects a candidate bundle that differs from the search winner.
+
+```ts
+import {
+  createAgentImprovementActivation,
+  executeAgentImprovementActivation,
+  proposeAgentImprovement,
+  reviewAgentImprovementProposal,
+} from '@tangle-network/agent-runtime/intelligence'
+
+const result = await proposeAgentImprovement({
+  runId,
+  profile: liveProfile,
+  analysis,
+  improvement: { surface: 'prompt', scenarios, judge, agent },
+  buildExperiment: ({ improvement }) => freezeExperiment(liveProfile, improvement.candidate),
+  placeCell,
+})
+
+const review = reviewAgentImprovementProposal(result.proposal, {
+  decision: 'approve',
+  reviewedBy: user.id,
+  reason: 'The measured gain is worth the cost.',
+})
+const activation = createAgentImprovementActivation(result.proposal, review, {
+  intent: 'activate-candidate',
+  targets: [{ surface: 'prompt', identity: profileId }],
+  fundingOwner: tenantId,
+  authorizedBy: user.id,
+  expiresAt,
+})
+const outcome = await executeAgentImprovementActivation(
+  { proposal: result.proposal, review, activation },
+  { transition: commitProfileTransaction, reconcile: readCommittedResult },
+)
+```
+
+`freezeExperiment`, `placeCell`, and the transaction functions are application ports because storage and compute differ by product.
+Runtime owns candidate identity, measurement, review binding, expiry, retry identity, and result validation; the application owns its atomic write.
+
 ### Improve a knowledge base
 
-`runKnowledgeImprovementJob` is the runtime-owned front door for KB, wiki, memory-backed, and RAG improvement jobs. It creates a candidate copy, runs supervised agents against it, checks readiness through `@tangle-network/agent-knowledge`, measures spend and timing, and promotes only when the candidate passes. Use `improve(..., { surface: 'memory' })` for the agent's curated lesson document; use this job for source, retrieval, and knowledge-store changes.
+`runKnowledgeImprovementJob` is the runtime-owned front door for KB, wiki, memory-backed, and RAG improvement jobs. It creates a candidate copy, runs supervised agents against it, checks readiness through `@tangle-network/agent-knowledge`, and returns frozen baseline and candidate snapshots with spend and timing. It never changes the live knowledge base. Use `improve(..., { surface: 'memory' })` for the agent's curated lesson document; use this job for source, retrieval, and knowledge-store changes.
 
 ```ts
 import { runKnowledgeImprovementJob } from '@tangle-network/agent-runtime/knowledge'
@@ -110,10 +158,11 @@ const result = await runKnowledgeImprovementJob({
   backend,
 })
 
-console.log(result.promoted, result.measurement.supervisedSpent)
+console.log(result.knowledge?.reference.candidateHash, result.measurement.supervisedSpent)
 ```
 
-Use it when the product needs one knob for "make this knowledge base better" instead of wiring `improveKnowledgeBase`, a runtime supervisor, candidate workspaces, readiness checks, and promotion tracking by hand.
+Use it when the product needs one knob for "make this knowledge base better" instead of wiring `improveKnowledgeBase`, a runtime supervisor, candidate workspaces, and readiness checks by hand.
+Measure the returned bundle pair, record the review, then activate through `executeAgentImprovementActivation`; activation is the only write path.
 
 ### Run on PrimeIntellect
 
@@ -200,14 +249,14 @@ Runnable, grouped by what they show. Copy the one nearest your task:
 | Evaluate or train a runtime program on PrimeIntellect | `@tangle-network/agent-runtime/primeintellect` |
 | Study coordination vs raw compute | [`ablation-suite`](./examples/ablation-suite) |
 
-All 29 live in [`examples/`](./examples).
+All 28 live in [`examples/`](./examples).
 
 ## Where to go next
 
 - New here? [`docs/concepts.md`](./docs/concepts.md), the mental model in plain terms.
 - [`docs/canonical-api.md`](./docs/canonical-api.md), find the primitive: "I want to ___ → use ___".
 - [`docs/api/primitive-catalog.md`](./docs/api/primitive-catalog.md), every export in one generated, never-stale list with its import path. Check it before building anything new.
-- Import subpaths: the root export is the product surface (`handleChatTurn`, `improve`); deeper capabilities ship as subpaths: `/loops` (multi-agent + the loop kernel), `/conversation` (multi-turn conversations), `/knowledge` (KB improvement), `/primeintellect` (Prime task, runtime, and trace adapter), `/mcp` (tool servers), `/intelligence` (observability drop-in), `/lifecycle`, `/agent`, `/profiles`, `/platform`, `/analyst-loop`, `/environment-provider`.
+- Import subpaths: the root export is the product surface (`handleChatTurn`, `improve`); deeper capabilities ship as subpaths: `/loops` (multi-agent + the loop kernel), `/conversation` (multi-turn conversations), `/knowledge` (KB improvement), `/primeintellect` (Prime task, runtime, and trace adapter), `/mcp` (tool servers), `/intelligence` (observability drop-in), `/agent`, `/profiles`, `/platform`, `/analyst-loop`, `/environment-provider`.
 - [`docs/architecture.md`](./docs/architecture.md), the design, end to end.
 - [`bench/HARNESS.md`](./bench/HARNESS.md), the experiment harness and how to run a benchmark.
 

package/dist/activation-B0ZD7nfX.d.ts

@@ -0,0 +1,63 @@
+import { Sha256Digest, AgentImprovementActivationResult, AgentImprovementActivation, AgentCandidateBundle, AgentImprovementActivationTarget, AgentImprovementActivationOutcome, AgentImprovementProposal, AgentImprovementReview } from '@tangle-network/agent-interface';
+
+interface CreateAgentImprovementActivationResultOptions {
+    completedAt: string;
+    outcome: AgentImprovementActivationOutcome;
+}
+interface AgentImprovementActivationTargetPlan extends AgentImprovementActivationTarget {
+    desiredDigest: Sha256Digest;
+}
+interface AgentImprovementActivationTransitionInput {
+    activation: AgentImprovementActivation;
+    candidateBundle: AgentCandidateBundle;
+    bundle: AgentCandidateBundle;
+    targets: [AgentImprovementActivationTargetPlan, ...AgentImprovementActivationTargetPlan[]];
+    attemptedAt: string;
+    expired: boolean;
+}
+interface AgentImprovementActivationResultStore {
+    load(idempotencyKey: Sha256Digest): Promise<unknown | undefined>;
+    putIfAbsent(result: AgentImprovementActivationResult): Promise<unknown>;
+}
+/**
+ * Product-owned or Runtime-composed transition.
+ *
+ * Implementations resolve a stored result for `activation.digest`, compare
+ * every target, and make the write durably idempotent. Co-located targets store
+ * the all-or-none write with its result. Other targets throw when result
+ * storage fails so a retry can reconcile it. Runtime never invokes this write
+ * function after authorization expires.
+ */
+type AgentImprovementActivationTransition = (input: AgentImprovementActivationTransitionInput) => Promise<unknown>;
+/**
+ * Target-read-only check for a prior exact write.
+ * It may persist recovered result metadata, but must not change an activation target.
+ * Return undefined only when no target write can have committed.
+ */
+type AgentImprovementActivationReconciliation = (input: AgentImprovementActivationTransitionInput) => Promise<unknown | undefined>;
+interface ExecuteAgentImprovementActivationInput {
+    proposal: AgentImprovementProposal;
+    review: AgentImprovementReview;
+    activation: AgentImprovementActivation;
+}
+interface ExecuteAgentImprovementActivationOptions {
+    transition: AgentImprovementActivationTransition;
+    reconcile?: AgentImprovementActivationReconciliation;
+    now?: () => Date;
+}
+/** Create the exact result a product stores in the same transaction as its target write. */
+declare function createAgentImprovementActivationResult(transition: AgentImprovementActivationTransitionInput, options: CreateAgentImprovementActivationResultOptions): AgentImprovementActivationResult;
+/**
+ * Recompute one historical activation result against the exact measured proposal and authority.
+ * The result records that attempt; it is not a query of the target's current state.
+ */
+declare function verifyAgentImprovementActivationResult(input: {
+    proposal: unknown;
+    review: unknown;
+    activation: unknown;
+    result: unknown;
+}): AgentImprovementActivationResult;
+/** Validate and execute one product-owned activation transition. */
+declare function executeAgentImprovementActivation(input: ExecuteAgentImprovementActivationInput, options: ExecuteAgentImprovementActivationOptions): Promise<AgentImprovementActivationResult>;
+
+export { type AgentImprovementActivationReconciliation as A, type CreateAgentImprovementActivationResultOptions as C, type ExecuteAgentImprovementActivationInput as E, type AgentImprovementActivationResultStore as a, type AgentImprovementActivationTargetPlan as b, type AgentImprovementActivationTransition as c, type AgentImprovementActivationTransitionInput as d, type ExecuteAgentImprovementActivationOptions as e, createAgentImprovementActivationResult as f, executeAgentImprovementActivation as g, verifyAgentImprovementActivationResult as v };

package/dist/agent.d.ts

@@ -1,13 +1,12 @@
 import * as _tangle_network_agent_eval from '@tangle-network/agent-eval';
-import { TraceAnalystKindSpec, AnalystFinding } from '@tangle-network/agent-eval';
-import { A as ArtifactKind, C as CandidateGenerator, P as PromotionGate } from './generator-YkAQrOoD.js';
+import { TraceAnalystKindSpec } from '@tangle-network/agent-eval';
 import { R as RuntimeStreamEvent } from './types-BwoZWq-i.js';
-import { A as AgentSurfaces } from './improvement-adapter-BieWeK5J.js';
-export { C as CreateSurfaceImprovementAdapterOpts, D as DraftPatchInput, a as DraftPatchOutput, R as ResolvedSurface, S as SurfaceImprovementEdit, b as SurfaceValidationIssue, c as createSurfaceImprovementAdapter, r as renderSurfaceIssues, d as resolveSubjectPath, v as validateSurfaces } from './improvement-adapter-BieWeK5J.js';
-import { K as KnowledgeAdapter, a as RunAnalystLoopResult } from './types-BC3bZpH0.js';
+import { A as AgentSurfaces } from './improvement-adapter-HAZz-7vK.js';
+export { C as CreateSurfaceImprovementProposerOptions, D as DraftPatchInput, a as DraftPatchOutput, R as ResolvedSurface, S as SurfaceImprovementEdit, b as SurfaceValidationIssue, c as createSurfaceImprovementProposer, r as renderSurfaceIssues, d as resolveSubjectPath, v as validateSurfaces } from './improvement-adapter-HAZz-7vK.js';
 import { AgentProfile, AgentProfileFileMount, AgentProfileMcpServer } from '@tangle-network/agent-interface';
 import { SandboxEvent } from '@tangle-network/sandbox';
-import { S as SandboxClient, O as OutputAdapter, A as AgentRunSpec } from './types-ByAYqlVb.js';
+import { S as SandboxClient, O as OutputAdapter, A as AgentRunSpec } from './types-B3vAW0Oq.js';
+import './types-CmYCMbFT.js';
 
 /**
  * The full agent manifest. Each agent ships ONE of these.
@@ -82,48 +81,6 @@ interface AgentManifest<TPersona = unknown, TRunOutput = unknown> {
      * kinds (override per-kind via `analystKinds` if needed).
      */
     analyst: AnalystConfig;
-    /**
-     * Auto-apply policy. Knowledge / improvement edits land only when
-     * `enabled === true` AND the source finding's confidence meets the
-     * threshold. `mode` controls how applies happen: `'write'` mutates
-     * files in-place; `'open-pr'` writes to a branch and opens a PR.
-     *
-     * Default: knowledge auto-applies at confidence ≥0.85 in `'write'`
-     * mode (wiki edits are git-reversible); improvement stays at
-     * `enabled: false` until the agent author has measured precision.
-     */
-    autoApply?: AutoApplyPolicy;
-    /**
-     * Declarative per-surface artifact-lifecycle config the closed loop reads.
-     *
-     * Each entry names a profile surface (`skill` / `tool` / `prompt` / `mcp` /
-     * `hook` / `subagent`) and supplies the `CandidateGenerator` that grows it +
-     * the `PromotionGate` (the held-back exam) that decides promotion. `runLifecycle`
-     * consumes these: it pools the generators, measures each candidate's marginal
-     * lift on the held-back split, gates it, and stores the winners in an
-     * `ArtifactRegistry` — then `composeProfile` folds the top-`k` active artifacts
-     * back into this agent's profile.
-     *
-     * Optional — agents that don't self-improve their profile omit it. An empty or
-     * absent map means "no lifecycle"; the manifest is otherwise unchanged.
-     */
-    lifecycles?: ReadonlyArray<SurfaceLifecycle>;
-}
-/**
- * One profile surface's artifact-lifecycle wiring — the declarative config a
- * `defineAgent` manifest carries and `runLifecycle` reads. It is config, not
- * execution: it names the generator + gate; the loop runs them.
- */
-interface SurfaceLifecycle {
-    /** The profile surface this lifecycle grows. */
-    surface: ArtifactKind;
-    /** Produces fresh candidate artifacts for `surface` from the agent's history. */
-    generator: CandidateGenerator;
-    /** The held-back exam that decides promotion of a measured candidate. */
-    gate: PromotionGate;
-    /** Top-`k` budget for `composeProfile` when folding this surface's promoted
-     *  artifacts back in. Omit to fold in every active artifact. */
-    composeK?: number;
 }
 interface AgentRubric<TRunOutput> {
     /** Dimensions composing the weighted score. Weights sum to 1.0 by convention. */
@@ -251,18 +208,6 @@ interface AnalystConfig {
         baseUrl?: string;
     };
 }
-interface AutoApplyPolicy {
-    knowledge?: {
-        enabled: boolean;
-        confidenceThreshold?: number;
-        mode?: 'write' | 'open-pr';
-    };
-    improvement?: {
-        enabled: boolean;
-        confidenceThreshold?: number;
-        mode?: 'write' | 'open-pr';
-    };
-}
 /** Thrown when `defineAgent` finds a required surface missing on disk. */
 declare class AgentManifestError extends Error {
     readonly agentId: string;
@@ -284,138 +229,6 @@ declare class AgentManifestError extends Error {
  */
 declare function defineAgent<TPersona = unknown, TRunOutput = unknown>(manifest: AgentManifest<TPersona, TRunOutput>): AgentManifest<TPersona, TRunOutput>;
 
-/**
- * Substrate-default `KnowledgeAdapter` — wraps agent-knowledge's
- * `proposeFromFindings` + `applyKnowledgeWriteBlocks` with substrate
- * defaults (auto-lint after apply, source linkage via finding id).
- *
- * Every agent that ships a `.agent-knowledge/` tree uses this adapter
- * unmodified. Per-agent customization happens at the manifest level
- * (`autoApply.knowledge.confidenceThreshold`, etc.), not by writing a
- * new adapter.
- *
- * Lint discipline: after each apply we run agent-knowledge's
- * `lintKnowledgeIndex` to catch broken links / circular claims /
- * duplicate pages introduced by the new writes. Findings that fail the
- * post-apply lint are recorded in `warnings`; the apply itself is not
- * rolled back (lint failures are soft — humans review the wiki state).
- */
-
-interface CreateSurfaceKnowledgeAdapterOpts {
-    /** `.agent-knowledge/` root (absolute path the substrate writes blocks against). */
-    knowledgeRoot: string;
-}
-/**
- * Build the adapter. We accept the agent-knowledge functions as DI so
- * the substrate stays decoupled from a specific agent-knowledge
- * version — the agent author imports them in their manifest module
- * and hands them to the factory.
- *
- * `proposeFromFindings(findings)` returns
- *   `{ proposals: KnowledgeProposal[]; skipped: number; errors: ... }`.
- *
- * `applyKnowledgeWriteBlocks(root, content)` returns
- *   `{ written: string[]; warnings: string[] }`.
- *
- * `lintKnowledgeIndex(index)` (optional) returns `KnowledgeLintFinding[]`.
- */
-interface KnowledgeAdapterDeps<TProposal> {
-    proposeFromFindings: (findings: ReadonlyArray<AnalystFinding>) => {
-        proposals: TProposal[];
-        skipped: number;
-        errors: Array<{
-            findingId: string;
-            subject: string;
-            message: string;
-        }>;
-    };
-    applyKnowledgeWriteBlocks: (root: string, proposalText: string) => Promise<{
-        written: string[];
-        warnings: string[];
-    }>;
-    /**
-     * Optional post-apply lint hook. The substrate runs it after each
-     * batch of writes; failures land in `warnings` (the apply is not
-     * rolled back — lint signals drift to review, not block).
-     */
-    lintAfterApply?: (root: string) => Promise<ReadonlyArray<string>>;
-}
-/** Wire a surface-based `KnowledgeAdapter` that writes analyst proposals to agent surface files. */
-declare function createSurfaceKnowledgeAdapter<TProposal>(opts: CreateSurfaceKnowledgeAdapterOpts, deps: KnowledgeAdapterDeps<TProposal>): KnowledgeAdapter<TProposal>;
-
-/**
- * `OutcomeMeasurement` — the missing metric that turns the analyst
- * loop from "observability" into "self-improvement".
- *
- * Without this hook, the loop reports process counts (`findings: 42`,
- * `applied: 7`) and never proves the applied edits actually improved
- * anything. With this hook, the substrate re-runs the cohort against
- * the same personas after each apply pass and reports a composite
- * score delta. A negative delta is the substrate's strongest signal
- * to either roll back or surface for review.
- *
- * Wiring is intentionally simple: pass the manifest + the `runAgentEval`
- * function and a list of `personaIds` to re-run. The wrapper:
- *   1. Captures the baseline composite from the just-finished run.
- *   2. After `runAnalystLoop` returns, re-invokes `runAgentEval` against
- *      the same persona slice.
- *   3. Computes the delta and appends to `loop-report.json`.
- *   4. If `rollbackOnRegression` and delta < 0, reverts applied edits.
- */
-
-interface OutcomeMeasurement {
-    /** Baseline composite before applies — captured from the most-recent eval run. */
-    baselineComposite: number;
-    /** Composite after re-running the cohort with applied edits. */
-    afterComposite: number;
-    /** `afterComposite - baselineComposite`. Positive = the loop improved the agent. */
-    delta: number;
-    /** Per-persona deltas for finer-grained review. */
-    perPersona: ReadonlyArray<{
-        personaId: string;
-        before: number;
-        after: number;
-        delta: number;
-    }>;
-    /** When the substrate rolled back applies due to regression, the paths reverted. */
-    rolledBackPaths: ReadonlyArray<string>;
-}
-interface OutcomeMeasurementOpts {
-    /** Composite scores from the run that produced the findings. */
-    baseline: ReadonlyArray<{
-        personaId: string;
-        composite: number;
-    }>;
-    /**
-     * Re-run callback — the substrate invokes this after applies. The
-     * agent author provides their `runAgentEval`-equivalent so the
-     * substrate can ask "score this persona slice now."
-     *
-     * The callback SHOULD reuse the same cohort + judges + variant as
-     * the baseline run; only the agent's mutable surfaces have changed.
-     */
-    reRunCohort: (personaIds: ReadonlyArray<string>) => Promise<ReadonlyArray<{
-        personaId: string;
-        composite: number;
-    }>>;
-    /** When `true`, applied edits are reverted on negative delta. Default `false`. */
-    rollbackOnRegression?: boolean;
-    /** Callback to revert a list of paths (typically `git checkout HEAD --`). */
-    revert?: (paths: ReadonlyArray<string>) => Promise<void>;
-}
-/**
- * Run `runAnalystLoop` and stamp an `OutcomeMeasurement` onto the
- * result. The substrate calls this after each canonical eval; the
- * delta lands in `loop-report.json` for cross-run trend analysis.
- *
- * The function returns the original `RunAnalystLoopResult` enriched
- * with `outcome` so callers stay backwards-compatible (the field is
- * optional on the type; missing means no measurement was wired).
- */
-declare function measureOutcome<TProposal, TEdit>(result: RunAnalystLoopResult<TProposal, TEdit>, opts: OutcomeMeasurementOpts): Promise<RunAnalystLoopResult<TProposal, TEdit> & {
-    outcome: OutcomeMeasurement;
-}>;
-
 /** Known AgentProfile axes a run path may or may not carry into execution. */
 declare const AGENT_PROFILE_MATERIALIZATION_AXES: readonly ["identity", "name", "model", "prompt", "systemPrompt", "instructions", "resources", "files", "resourceInstructions", "skills", "resourceTools", "resourceAgents", "commands", "tools", "permissions", "mcp", "mcpConnections", "connections", "subagents", "hooks", "modes", "confidential", "metadata", "extensions"];
 type KnownAgentProfileMaterializationAxis = (typeof AGENT_PROFILE_MATERIALIZATION_AXES)[number];
@@ -531,4 +344,4 @@ interface CreateSandboxActOptions<TPersona, TRunOutput> {
  */
 declare function createSandboxAct<TPersona, TRunOutput>(options: CreateSandboxActOptions<TPersona, TRunOutput>): (persona: TPersona, ctx: AgentRunContext) => AgentRunInvocation<TRunOutput>;
 
-export { AGENT_PROFILE_MATERIALIZATION_AXES, type AgentManifest, AgentManifestError, type AgentProfileMaterializationAxis, type AgentRubric, type AgentRunContext, type AgentRunInvocation, type AgentRuntime, AgentSurfaces, type AnalystConfig, type AssertProfileMaterializationOptions, type AutoApplyPolicy, type CreateSandboxActOptions, type CreateSurfaceKnowledgeAdapterOpts, type DefineProfileMaterializationContractOptions, type JudgeConfig, type KnowledgeAdapterDeps, type KnownAgentProfileMaterializationAxis, type OutcomeMeasurement, type OutcomeMeasurementOpts, type ProfileMaterializationContract, type ProfileMaterializationIssue, type RubricDimension, type SurfaceLifecycle, type ValidateProfileMaterializationOptions, assertProfileMaterialization, collectAgentRun, createSandboxAct, createSurfaceKnowledgeAdapter, defineAgent, defineProfileMaterializationContract, measureOutcome, promptOnlyProfileMaterialization, promptResourceProfileMaterialization, renderProfileMaterializationIssues, sandboxActProfileMaterialization, unimplementedAgentRun, validateProfileMaterialization };
+export { AGENT_PROFILE_MATERIALIZATION_AXES, type AgentManifest, AgentManifestError, type AgentProfileMaterializationAxis, type AgentRubric, type AgentRunContext, type AgentRunInvocation, type AgentRuntime, AgentSurfaces, type AnalystConfig, type AssertProfileMaterializationOptions, type CreateSandboxActOptions, type DefineProfileMaterializationContractOptions, type JudgeConfig, type KnownAgentProfileMaterializationAxis, type ProfileMaterializationContract, type ProfileMaterializationIssue, type RubricDimension, type ValidateProfileMaterializationOptions, assertProfileMaterialization, collectAgentRun, createSandboxAct, defineAgent, defineProfileMaterializationContract, promptOnlyProfileMaterialization, promptResourceProfileMaterialization, renderProfileMaterializationIssues, sandboxActProfileMaterialization, unimplementedAgentRun, validateProfileMaterialization };