@tangle-network/agent-runtime 0.94.13 → 0.95.0

package/dist/{supervise-DmYOug5f.d.ts → supervise-BLPI50-w.d.ts}

@@ -1,7 +1,7 @@
-import { S as Scope, a as ResultBlobStore, B as Budget, A as Agent, b as SupervisedResult } from './types-1d5QGK3t.js';
-import { M as MakeWorkerAgent, A as AnalystRegistry, E as ExecutorConfig } from './coordination-Dr_axlAf.js';
+import { S as Scope, a as ResultBlobStore, B as Budget, A as Agent, b as SupervisedResult } from './types-CmnA2iL3.js';
+import { M as MakeWorkerAgent, A as AnalystRegistry, E as ExecutorConfig } from './coordination-BFE3Den7.js';
 import { R as RouterConfig, T as ToolLoopChat, a as ToolLoopCompactionOptions } from './sanitize-BTSsdBXw.js';
-import { D as DeliverableSpec } from './completion-gate-D1gX1-hg.js';
+import { D as DeliverableSpec } from './completion-gate-C80jiRfN.js';
 
 /** The supervisor's profile — the subset of an `AgentProfile` that selects + shapes its brain.
  *  `harness` is the backend-as-data discriminant; `systemPrompt` is the standing instruction. */

package/dist/{types-ByAYqlVb.d.ts → types-B3vAW0Oq.d.ts}

@@ -799,4 +799,4 @@ interface ExecCtx {
     parentSpanId?: string;
 }
 
-export { type AgentRunSpec as A, type LoopIterationEndedPayload as B, type LoopIterationStartedPayload as C, type Driver as D, type ExecCtx as E, type LoopPlanDescription as F, type LoopPlanPayload as G, type LoopStartedPayload as H, type Iteration as I, type LoopTeardownFailedPayload as J, type MountManifestEntry as K, type LoopTokenUsage as L, type MountRecorder as M, type RunProvenance as N, type OutputAdapter as O, type ValidationCtx as P, type RuntimeHooks as R, type SandboxClient as S, type Validator as V, type LoopTraceEvent as a, type LoopSandboxPlacement as b, type RuntimeDecisionEvidenceRef as c, type RuntimeDecisionKind as d, type RuntimeDecisionPoint as e, type RuntimeHookContext as f, type RuntimeHookErrorContext as g, type RuntimeHookEvent as h, type RuntimeHookPhase as i, type RuntimeHookTarget as j, type RuntimeRunHandle as k, type RuntimeRunPersistenceAdapter as l, type RuntimeRunRow as m, composeRuntimeHooks as n, defineRuntimeHooks as o, notifyRuntimeDecisionPoint as p, notifyRuntimeHookEvent as q, type LoopTraceEmitter as r, startRuntimeRun as s, type LoopWinner as t, type LoopLineageOptions as u, type LoopResult as v, type SelectionReceipt as w, type LoopDecisionPayload as x, type LoopEndedPayload as y, type LoopIterationDispatchPayload as z };
+export { type AgentRunSpec as A, type LoopIterationEndedPayload as B, type LoopIterationStartedPayload as C, type Driver as D, type ExecCtx as E, type LoopPlanDescription as F, type LoopPlanPayload as G, type LoopStartedPayload as H, type Iteration as I, type LoopTeardownFailedPayload as J, type MountManifestEntry as K, type LoopTokenUsage as L, type MountRecorder as M, type RunProvenance as N, type OutputAdapter as O, type ValidationCtx as P, type RuntimeHooks as R, type SandboxClient as S, type Validator as V, type LoopSandboxPlacement as a, type LoopTraceEvent as b, type RuntimeDecisionEvidenceRef as c, type RuntimeDecisionKind as d, type RuntimeDecisionPoint as e, type RuntimeHookContext as f, type RuntimeHookErrorContext as g, type RuntimeHookEvent as h, type RuntimeHookPhase as i, type RuntimeHookTarget as j, type RuntimeRunHandle as k, type RuntimeRunPersistenceAdapter as l, type RuntimeRunRow as m, composeRuntimeHooks as n, defineRuntimeHooks as o, notifyRuntimeDecisionPoint as p, notifyRuntimeHookEvent as q, type LoopTraceEmitter as r, startRuntimeRun as s, type LoopWinner as t, type LoopLineageOptions as u, type LoopResult as v, type SelectionReceipt as w, type LoopDecisionPayload as x, type LoopEndedPayload as y, type LoopIterationDispatchPayload as z };

package/dist/{prepare-CtdtsFNG.d.ts → types-CWqfCO8s.d.ts}

@@ -1,10 +1,5 @@
-import { AgentCandidateBundle, AgentCandidateArtifactRef, AgentCandidateTermination, AgentCandidateTaskOutcomeEvidence, Sha256Digest, AgentCandidateContainer, AgentCandidateOciPlatform, AgentCandidateGitHubRepository, AgentCandidateWorkspaceSnapshotEvidence, AgentCandidateResolvedModel, AgentCandidateAttemptPolicy, AgentCandidateExecutionLimits, AgentCandidateModelAccessNetwork, AgentCandidateCapturedArtifact, AgentCandidateWorkspaceManifestMaterial, AgentCandidateProfilePlanEvidence, AgentCandidateExecutionPlanEvidence, AgentCandidateMaterializationReceipt, AgentCandidateInstructionDelivery, AgentCandidateKnowledgeRef, AgentCandidateEffectiveMemory, AgentCandidateRunReceipt, AgentCandidateSpend, ReasoningEffort } from '@tangle-network/agent-interface';
 import { BenchmarkEvaluation, TraceStore } from '@tangle-network/agent-eval';
-
-/** Exact candidate wire shape before the runtime computes its canonical digest. */
-type AgentCandidateBundleInput = Omit<AgentCandidateBundle, 'digest'>;
-/** Validate and content-address a candidate bundle before it crosses an approval boundary. */
-declare function sealAgentCandidateBundle(input: AgentCandidateBundleInput): AgentCandidateBundle;
+import { AgentCandidateArtifactRef, AgentCandidateTermination, AgentCandidateTaskOutcomeMaterial, AgentCandidateTaskOutcomeEvidence, AgentCandidateTaskOutputSpec, Sha256Digest, AgentCandidateContainer, AgentCandidateOciPlatform, AgentCandidateGitHubRepository, AgentCandidateWorkspaceSnapshotEvidence, AgentCandidateBundle, AgentCandidateResolvedModel, AgentCandidateAttemptPolicy, AgentCandidateExecutionLimits, AgentCandidateModelAccessNetwork, AgentCandidateModelSettlementCall, AgentCandidateCapturedArtifact, AgentCandidateWorkspaceManifestMaterial, AgentCandidateBenchmarkSuite, AgentCandidateBenchmarkTask, AgentCandidateProfilePlanEvidence, AgentCandidateProfileActivation, AgentCandidateExecutionPlanEvidence, AgentCandidateMaterializationReceipt, AgentCandidateInstructionDelivery, AgentCandidateKnowledgeRef, AgentCandidateEffectiveMemory, AgentCandidateRunReceipt, AgentCandidateFixedSpend, AgentCandidateRunCell } from '@tangle-network/agent-interface';
 
 declare const verifiedCandidateBrand: unique symbol;
 declare const preparedCandidateBrand: unique symbol;
@@ -13,7 +8,7 @@ declare const verifiedTaskOutcomeBrand: unique symbol;
 interface AgentCandidateArtifactPort {
     read(ref: AgentCandidateArtifactRef): Promise<Uint8Array>;
 }
-type AgentCandidateOutputPurpose = 'candidate-workspace-manifest' | 'candidate-workspace-archive' | 'task-manifest' | 'task-archive' | 'task-patch' | 'task-outcome' | 'memory-after-manifest' | 'memory-after-archive' | 'grader-evidence' | 'benchmark-result' | 'model-settlement' | 'trace' | 'executor-capture' | 'run-receipt' | 'failure-evidence';
+type AgentCandidateOutputPurpose = 'execution-plan' | 'materialization-receipt' | 'candidate-workspace-manifest' | 'candidate-workspace-archive' | 'task-manifest' | 'task-archive' | 'task-patch' | 'task-output' | 'task-outcome' | 'memory-after-manifest' | 'memory-after-archive' | 'grader-evidence' | 'benchmark-result' | 'model-settlement' | 'trace' | 'executor-native-evidence' | 'executor-capture' | 'run-receipt' | 'knowledge-retrieval-config' | 'knowledge-evaluation' | 'failure-evidence';
 /** Durable content-addressed evidence store controlled only by the evaluator. */
 interface AgentCandidateOutputArtifactPort extends AgentCandidateArtifactPort {
     /** Must be idempotent for identical bytes and return only a durable S3/IPFS locator. */
@@ -105,11 +100,6 @@ interface AgentCandidateModelPort {
 }
 /** Limits mechanically enforced by the evaluator-owned model gateway. */
 type AgentCandidateModelLimits = Pick<AgentCandidateExecutionLimits, 'maxModelCalls' | 'maxInputTokens' | 'maxOutputTokens' | 'maxCostUsd'>;
-interface AgentCandidateBenchmarkGraderIdentity {
-    name: string;
-    version: string;
-    artifact: AgentCandidateArtifactRef;
-}
 interface AgentCandidateProtectedModelReservation {
     preparationId: string;
     digest: Sha256Digest;
@@ -124,29 +114,11 @@ interface AgentCandidateProtectedModelActivation {
     /** Injected only into the trusted executor after all pre-launch checks pass. */
     env: Readonly<Record<string, string>>;
 }
-/** One evaluator-gateway call in the final, revoked model-access ledger. */
-interface AgentCandidateProtectedModelCall {
-    callId: string;
-    /** Router-generated public response identity. */
-    generationId: string;
-    /** Exact protected agent-eval LLM span produced from the router ledger. */
-    traceSpanId: string;
-    status: 'succeeded' | 'failed';
-    model: string;
-    startedAtMs: number;
-    endedAtMs: number;
-    inputTokens: number;
-    outputTokens: number;
-    cachedInputTokens: number;
-    reasoningTokens: number;
-    /** Integer billionths of one US dollar; avoids floating-point ledger drift. */
-    costUsdNanos: number;
-}
 interface AgentCandidateProtectedModelSettlement {
     preparationId: string;
     grantDigest: Sha256Digest;
     closed: true;
-    calls: readonly AgentCandidateProtectedModelCall[];
+    calls: readonly AgentCandidateModelSettlementCall[];
 }
 interface AgentCandidateMemoryResetResult {
     preparationId: string;
@@ -204,26 +176,12 @@ interface AgentCandidateExecutionPorts extends AgentCandidateVerificationPorts {
     models: AgentCandidateModelPort;
     memory: AgentCandidateMemoryPort;
 }
+/** Runtime placement for one exact cell from a signed candidate experiment. */
 interface AgentCandidateTaskExecution {
     executionId: string;
-    benchmark: string;
-    benchmarkVersion: string;
-    taskId: string;
-    splitDigest: Sha256Digest;
-    /** Exact agent-visible task instruction. The runtime rejects malformed Unicode. */
-    instruction: string;
-    repository: {
-        identity: string;
-        rootIdentity: string;
-        baseCommit: string;
-        baseTree: string;
-    };
-    attempt: AgentCandidateAttemptPolicy;
-    model: {
-        requested: string;
-        reasoningEffort: ReasoningEffort;
-    };
-    grader: AgentCandidateBenchmarkGraderIdentity;
+    runCell: AgentCandidateRunCell;
+    benchmarkSuite: AgentCandidateBenchmarkSuite;
+    task: AgentCandidateBenchmarkTask;
     /** Absolute paths inside the evaluator-owned execution environment. */
     executionRoots: {
         taskRoot: string;
@@ -235,9 +193,6 @@ interface AgentCandidateTaskExecution {
         candidateRoot?: string;
         profileRoot: string;
     };
-    workspace: AgentCandidateWorkspaceSnapshotEvidence;
-    evaluatorTaskContainer?: ResolvedAgentCandidateContainer;
-    limits: AgentCandidateExecutionLimits;
 }
 interface VerifiedAgentCandidate {
     readonly bundle: AgentCandidateBundle;
@@ -277,6 +232,10 @@ interface PreparedAgentCandidateTrace {
 }
 interface PreparedAgentCandidateExecution {
     readonly bundle: AgentCandidateBundle;
+    readonly benchmark: {
+        readonly suite: AgentCandidateBenchmarkSuite;
+        readonly task: AgentCandidateBenchmarkTask;
+    };
     readonly executionId: string;
     readonly roots: {
         execution: {
@@ -294,6 +253,7 @@ interface PreparedAgentCandidateExecution {
         bytes: Uint8Array;
         written: readonly string[];
     };
+    readonly profileActivation: AgentCandidateProfileActivation;
     readonly executionPlan: {
         value: AgentCandidateExecutionPlanEvidence;
         bytes: Uint8Array;
@@ -307,41 +267,61 @@ interface PreparedAgentCandidateExecution {
     readonly memory: AgentCandidateEffectiveMemory;
     readonly [preparedCandidateBrand]: true;
 }
+
 interface AgentCandidateProtectedRunCapture {
     executionId: string;
     termination: AgentCandidateTermination;
 }
 /** Raw evaluator capture made only after the candidate process is dead. */
-interface AgentCandidateExecutorTaskOutcomeCapture {
+type AgentCandidateExecutorTaskOutcomeCapture = {
+    readonly kind: 'workspace';
     /** Claimed final tree. The runtime recomputes it independently from `gitDiff`. */
-    resultTree: string;
+    readonly resultTree: string;
     /** Complete evaluator-captured workspace description after candidate execution. */
-    afterState: AgentCandidateWorkspaceManifestMaterial;
+    readonly afterState: AgentCandidateWorkspaceManifestMaterial;
     /** Reproducible workspace archive corresponding to `afterState`. */
-    archive: Uint8Array;
+    readonly archive: Uint8Array;
     /** Exact binary patch from the signed task base to `afterState`. */
-    gitDiff: Uint8Array;
-}
+    readonly gitDiff: Uint8Array;
+} | {
+    readonly kind: 'output';
+    /** Exact evaluator-captured final output bytes. */
+    readonly bytes: Uint8Array;
+};
 /** Raw isolated-memory capture made only after access has been revoked. */
 interface AgentCandidateExecutorMemoryCapture {
     readonly afterState: AgentCandidateWorkspaceManifestMaterial;
     readonly archive: Uint8Array;
 }
-/** Idempotent executor result after process death and trace drain. */
+/** Replayable evaluator result captured only after process death and trace drain. */
 interface AgentCandidateExecutorFinalCapture {
-    readonly stopped: true;
     readonly taskOutcome?: AgentCandidateExecutorTaskOutcomeCapture;
     /** Required only when the prepared candidate uses isolated task memory. */
     readonly memoryAfter?: AgentCandidateExecutorMemoryCapture;
+    /** Executor-native bytes preserved when a fresh worker cannot reconstruct a verified outcome. */
+    readonly evidence?: Uint8Array;
 }
-/** Branded task outcome that has survived independent patch and tree verification. */
-interface VerifiedAgentCandidateTaskOutcome {
-    readonly evidence: AgentCandidateTaskOutcomeEvidence & {
-        readonly artifact: AgentCandidateArtifactRef;
+type PersistedTaskOutcomeEvidence<Kind extends AgentCandidateTaskOutcomeMaterial['outcome']['kind']> = Omit<AgentCandidateTaskOutcomeEvidence, 'material'> & {
+    readonly artifact: AgentCandidateArtifactRef;
+    readonly material: Omit<AgentCandidateTaskOutcomeMaterial, 'outcome'> & {
+        readonly outcome: Extract<AgentCandidateTaskOutcomeMaterial['outcome'], {
+            kind: Kind;
+        }>;
     };
+};
+/** Branded task outcome that has survived independent evaluator verification. */
+type VerifiedAgentCandidateTaskOutcome = {
+    readonly kind: 'workspace';
+    readonly evidence: PersistedTaskOutcomeEvidence<'workspace'>;
     readonly patch: Uint8Array;
     readonly [verifiedTaskOutcomeBrand]: true;
-}
+} | {
+    readonly kind: 'output';
+    readonly evidence: PersistedTaskOutcomeEvidence<'output'>;
+    readonly spec: AgentCandidateTaskOutputSpec;
+    readonly bytes: Uint8Array;
+    readonly [verifiedTaskOutcomeBrand]: true;
+};
 /**
  * Evaluator-owned executable grader, pinned by immutable implementation bytes.
  *
@@ -384,6 +364,7 @@ interface AgentCandidateBenchmarkGraderPort {
 /** One detached request passed to the trusted environment-specific executor. */
 interface AgentCandidateExecutorRequest {
     readonly executionId: string;
+    readonly benchmark: PreparedAgentCandidateExecution['benchmark'];
     /** Immutable bytes from which the executor creates fresh isolated workspaces. */
     readonly inputs: {
         readonly task: AgentCandidateExecutorWorkspaceInput;
@@ -394,6 +375,7 @@ interface AgentCandidateExecutorRequest {
     };
     readonly roots: PreparedAgentCandidateExecution['roots']['execution'];
     readonly profilePlan: PreparedAgentCandidateExecution['profilePlan'];
+    readonly profileActivation: AgentCandidateProfileActivation;
     readonly executionPlan: PreparedAgentCandidateExecution['executionPlan'];
     readonly materializationReceipt: CanonicalCandidateDocument<AgentCandidateMaterializationReceipt>;
     readonly launch: PreparedAgentCandidateLaunch;
@@ -403,7 +385,7 @@ interface AgentCandidateExecutorRequest {
     readonly hardLimits: Pick<AgentCandidateExecutionLimits, 'timeoutMs'>;
     /** Validity bound checked against protected traces; generic black-box executors cannot preempt it. */
     readonly observedLimits: Pick<AgentCandidateExecutionLimits, 'maxSteps'>;
-    readonly knowledge?: PreparedAgentCandidateExecution['knowledge'];
+    readonly knowledge?: PreparedAgentCandidateKnowledge;
     readonly trace: PreparedAgentCandidateTrace;
     readonly memory: AgentCandidateEffectiveMemory;
 }
@@ -423,21 +405,29 @@ interface AgentCandidateExecutorPort {
         /** Absolute epoch-millisecond deadline owned by the runtime. */
         deadlineAtMs: number;
     }): Promise<AgentCandidateProtectedRunCapture>;
-    /**
-     * Kill any process/container still associated with the request, drain trace
-     * writes, and capture the final task workspace before teardown.
-     * The runtime calls this on success, failure, and timeout before model settlement.
-     * Implementations must be idempotent and concurrency-safe for this exact
-     * execution/plan pair because a fresh worker may repeat crash recovery.
-     */
-    stopAndCapture(request: AgentCandidateExecutorStopRequest, context: {
+    /** Kill the exact process/container and drain trace writes. Must be idempotent. */
+    stop(request: AgentCandidateExecutorStopRequest, context: {
         traceStore: TraceStore;
         reason: 'completed' | 'failed' | 'timeout';
         /** Aborted at the frozen execution deadline or evaluator cleanup deadline. */
         signal: AbortSignal;
         /** Absolute execution deadline; a later stop acknowledgement cannot produce success. */
         deadlineAtMs: number;
+    }): Promise<{
+        readonly stopped: true;
+    }>;
+    /** Capture immutable final evidence after stop. Must be replayable by a fresh worker. */
+    capture(request: AgentCandidateExecutorStopRequest, context: {
+        traceStore: TraceStore;
+        /** Aborted at the frozen execution deadline or evaluator cleanup deadline. */
+        signal: AbortSignal;
     }): Promise<AgentCandidateExecutorFinalCapture>;
+    /** Remove evaluator-owned execution resources after final capture. Must be idempotent. */
+    dispose?(request: AgentCandidateExecutorStopRequest, context: {
+        signal: AbortSignal;
+    }): Promise<{
+        readonly disposed: true;
+    }>;
 }
 /** Opaque process identity used for termination without re-exposing launch credentials. */
 interface AgentCandidateExecutorStopRequest {
@@ -453,6 +443,7 @@ interface AgentCandidateExecutorWorkspaceFile {
     readonly mode: number;
     readonly bytes: Uint8Array;
 }
+/** One exact profile file supplied to an evaluator-owned executor. */
 interface AgentCandidateExecutorProfileFile {
     readonly path: string;
     readonly mode: number;
@@ -479,7 +470,7 @@ type AgentCandidateRunFinalization = {
         termination?: AgentCandidateTermination;
     };
     /** Independent evaluator-gateway usage, even when execution or trace capture failed. */
-    usage: AgentCandidateSpend | null;
+    usage: AgentCandidateFixedSpend | null;
 };
 /** Protected trace tags that bind a run to one prepared candidate execution. */
 declare const CANDIDATE_TRACE_TAGS: {
@@ -497,226 +488,4 @@ declare const CANDIDATE_TRACE_ENV: {
     readonly traceRunId: "TANGLE_TRACE_RUN_ID";
 };
 
-/** Durable one-shot lifecycle for candidate execution attempts. */
-
-/** Non-secret identities a trusted recovery worker needs to close an abandoned attempt. */
-interface AgentCandidateExecutionCleanupHandles {
-    readonly preparationId: string;
-    readonly modelGrantDigest: Sha256Digest;
-    readonly resolvedModel: AgentCandidateResolvedModel;
-    readonly traceRunId: string;
-    readonly cleanupTimeoutMs: number;
-    readonly memory?: {
-        readonly accessDigest: Sha256Digest;
-        readonly effectiveNamespace: string;
-    };
-}
-/** Immutable signed identity stored for one execution attempt. */
-interface AgentCandidateExecutionClaim {
-    readonly executionId: string;
-    readonly attempt: number;
-    readonly maxAttempts: number;
-    readonly retryPolicy: AgentCandidateAttemptPolicy['retryPolicy'];
-    readonly bundleDigest: Sha256Digest;
-    readonly executionPlanDigest: Sha256Digest;
-    /** Frozen plan identity with only attempt number and per-attempt grant identity normalized. */
-    readonly retryLineageDigest: Sha256Digest;
-    /** The winning lease stops authorizing a new terminal write at this instant. */
-    readonly leaseExpiresAtMs: number;
-    /** Frozen budget for task verification, executable grading, and receipt construction. */
-    readonly resultTimeoutMs: number;
-    /** Non-secret handles retained so an expired attempt can be closed and reconciled. */
-    readonly cleanup: AgentCandidateExecutionCleanupHandles;
-}
-/** Secret capability required to finish the acquired attempt. */
-interface AgentCandidateExecutionLease {
-    readonly executionId: string;
-    readonly attempt: number;
-    readonly token: string;
-    readonly expiresAtMs: number;
-}
-/** Only the first class is retryable, and only when the closed model ledger has zero calls. */
-type AgentCandidateExecutionFailureClass = 'pre-model-infrastructure' | 'execution' | 'post-model-infrastructure' | 'unknown';
-/** Exact fixed-point usage proven by the closed evaluator model ledger. */
-interface AgentCandidateExecutionUsage {
-    readonly costUsdNanos: number;
-    readonly inputTokens: number;
-    readonly outputTokens: number;
-    readonly cachedInputTokens: number;
-    readonly reasoningTokens: number;
-    readonly modelCalls: number;
-}
-/** Evaluator-owned terminal facts staged durably before the terminal CAS. */
-type AgentCandidateExecutionTerminalResult = {
-    readonly schemaVersion: 1;
-    readonly status: 'succeeded';
-    readonly usage: AgentCandidateExecutionUsage;
-    readonly modelSettlement: AgentCandidateArtifactRef;
-    readonly taskOutcome: AgentCandidateArtifactRef;
-    readonly benchmarkResult: AgentCandidateArtifactRef;
-    readonly runReceipt: AgentCandidateArtifactRef;
-} | {
-    readonly schemaVersion: 1;
-    readonly status: 'failed';
-    readonly failureClass: AgentCandidateExecutionFailureClass;
-    readonly usage: AgentCandidateExecutionUsage;
-    readonly modelSettlement: AgentCandidateArtifactRef;
-    readonly failureEvidence?: AgentCandidateArtifactRef;
-};
-/** Durable terminal record for one acquired execution attempt. */
-type AgentCandidateExecutionTerminalRecord = AgentCandidateExecutionTerminalResult & {
-    readonly executionId: string;
-    readonly attempt: number;
-    readonly bundleDigest: Sha256Digest;
-    readonly executionPlanDigest: Sha256Digest;
-    /** RFC 8785 SHA-256 of this record with `terminalDigest` omitted. */
-    readonly terminalDigest: Sha256Digest;
-};
-/** Monotonic durable phase: the second value means candidate code could have started. */
-type AgentCandidateExecutionPhase = 'claimed' | 'candidate-may-run';
-/** Trusted, independently observed closure facts for one expired winning lease. */
-interface AgentCandidateExecutionRecoveryEvidence {
-    readonly failureClass: AgentCandidateExecutionFailureClass;
-    readonly usage: AgentCandidateExecutionUsage;
-    readonly modelSettlement: AgentCandidateArtifactRef;
-    readonly failureEvidence?: AgentCandidateArtifactRef;
-    readonly process: {
-        readonly stopped: true;
-        readonly executionPlanDigest: Sha256Digest;
-    };
-    readonly model: {
-        readonly closed: true;
-        readonly preparationId: string;
-        readonly grantDigest: Sha256Digest;
-    };
-    readonly memory?: {
-        readonly closed: true;
-        readonly preparationId: string;
-        readonly accessDigest: Sha256Digest;
-        readonly effectiveNamespace: string;
-    };
-}
-interface AgentCandidateExecutionAttemptRef {
-    readonly executionId: string;
-    readonly attempt: number;
-}
-/** Persisted state available to a fresh trusted recovery worker after a crash. */
-interface AgentCandidateExecutionAttemptRecord {
-    readonly claim: AgentCandidateExecutionClaim;
-    readonly phase: AgentCandidateExecutionPhase;
-    /** Durable outbox content written before the terminal compare-and-set. */
-    readonly staged?: AgentCandidateExecutionTerminalRecord;
-    readonly terminal?: AgentCandidateExecutionTerminalRecord;
-}
-/** Result of atomically claiming one execution attempt. */
-type AgentCandidateExecutionClaimResult = {
-    readonly acquired: true;
-    readonly claim: AgentCandidateExecutionClaim;
-    readonly lease: AgentCandidateExecutionLease;
-} | {
-    readonly acquired: false;
-    readonly reason: 'already-claimed';
-    /** The durable winner already occupying this execution-attempt slot. */
-    readonly claim: AgentCandidateExecutionClaim;
-    /** True only when every signed claim field matches the durable winner. */
-    readonly exactReplay: boolean;
-} | {
-    readonly acquired: false;
-    readonly reason: 'retry-not-eligible';
-    readonly claim: AgentCandidateExecutionClaim;
-    readonly detail: AgentCandidateRetryRejection;
-};
-/** Result of atomically recording an attempt's terminal facts. */
-type AgentCandidateExecutionFinishResult = {
-    readonly finished: true;
-    readonly terminal: AgentCandidateExecutionTerminalRecord;
-} | {
-    readonly finished: false;
-    readonly terminal: AgentCandidateExecutionTerminalRecord;
-    /** True when a repeated finish supplied the same terminal digest. */
-    readonly exactReplay: boolean;
-};
-/** Result of durably staging the one immutable terminal outbox entry. */
-type AgentCandidateExecutionStageResult = {
-    readonly staged: true;
-    readonly terminal: AgentCandidateExecutionTerminalRecord;
-} | {
-    readonly staged: false;
-    readonly terminal: AgentCandidateExecutionTerminalRecord;
-    readonly exactReplay: boolean;
-};
-/** Result of crossing the irreversible candidate-may-run boundary. */
-type AgentCandidateExecutionPhaseResult = {
-    readonly marked: true;
-    readonly phase: 'candidate-may-run';
-} | {
-    readonly marked: false;
-    readonly phase: 'candidate-may-run';
-};
-type AgentCandidateRetryRejection = 'prior-attempt-missing' | 'prior-attempt-running' | 'prior-attempt-succeeded' | 'prior-attempt-spent-model-calls' | 'prior-attempt-not-pre-model-infrastructure' | 'retry-lineage-mismatch';
-/**
- * Atomic one-shot store for candidate execution attempts.
- *
- * Implementations must linearize both methods across every process sharing the
- * store. Terminal publication is deliberately two-step: `stageTerminal`
- * fsyncs the complete immutable outbox record, then `finish` publishes exactly
- * those staged bytes by digest. A crash between the two leaves recoverable
- * evidence rather than an ambiguous completed run.
- */
-interface AgentCandidateExecutionClaimStore {
-    tryClaim(claim: AgentCandidateExecutionClaim): Promise<AgentCandidateExecutionClaimResult>;
-    getAttempt(attempt: AgentCandidateExecutionAttemptRef): Promise<AgentCandidateExecutionAttemptRecord | undefined>;
-    /** Persist the point after which candidate code may have run. */
-    markCandidateMayRun(lease: AgentCandidateExecutionLease): Promise<AgentCandidateExecutionPhaseResult>;
-    /** Fsync the complete terminal record into the durable outbox. */
-    stageTerminal(lease: AgentCandidateExecutionLease, result: AgentCandidateExecutionTerminalResult): Promise<AgentCandidateExecutionStageResult>;
-    /** Publish exactly the staged terminal identified by `terminalDigest`. */
-    finish(lease: AgentCandidateExecutionLease, terminalDigest: Sha256Digest): Promise<AgentCandidateExecutionFinishResult>;
-    /**
-     * Write a failed terminal only after the lease expired and a trusted worker
-     * independently proved process death plus model and memory closure.
-     */
-    recoverExpired(attempt: AgentCandidateExecutionAttemptRef, evidence: AgentCandidateExecutionRecoveryEvidence): Promise<AgentCandidateExecutionFinishResult>;
-}
-interface InMemoryAgentCandidateExecutionClaimStoreOptions {
-    /** Testable evaluator clock; defaults to `Date.now`. */
-    now?: () => number;
-}
-/** Single-process lifecycle implementation. */
-declare class InMemoryAgentCandidateExecutionClaimStore implements AgentCandidateExecutionClaimStore {
-    private readonly claims;
-    private readonly now;
-    constructor(options?: InMemoryAgentCandidateExecutionClaimStoreOptions);
-    tryClaim(requested: AgentCandidateExecutionClaim): Promise<AgentCandidateExecutionClaimResult>;
-    getAttempt(requestedAttempt: AgentCandidateExecutionAttemptRef): Promise<AgentCandidateExecutionAttemptRecord | undefined>;
-    markCandidateMayRun(requestedLease: AgentCandidateExecutionLease): Promise<AgentCandidateExecutionPhaseResult>;
-    stageTerminal(requestedLease: AgentCandidateExecutionLease, result: AgentCandidateExecutionTerminalResult): Promise<AgentCandidateExecutionStageResult>;
-    finish(requestedLease: AgentCandidateExecutionLease, requestedTerminalDigest: Sha256Digest): Promise<AgentCandidateExecutionFinishResult>;
-    recoverExpired(requestedAttempt: AgentCandidateExecutionAttemptRef, evidence: AgentCandidateExecutionRecoveryEvidence): Promise<AgentCandidateExecutionFinishResult>;
-    private requireClaim;
-}
-
-interface ExecutePreparedAgentCandidateOptions {
-    executor: AgentCandidateExecutorPort;
-    grader: AgentCandidateBenchmarkGraderPort;
-    outputArtifacts: AgentCandidateOutputArtifactPort;
-    traceStore: TraceStore;
-    /** Long-lived evaluator-owned store shared by every process that can run this benchmark. */
-    claimStore: AgentCandidateExecutionClaimStore;
-    /** Maximum time to prove process death and revoke protected access after a run ends. */
-    cleanupTimeoutMs?: number;
-    /** Maximum time for task verification, executable grading, and receipt construction. */
-    resultTimeoutMs?: number;
-}
-/** Executes and finalizes one durably claimed candidate without exposing an unproven result. */
-declare function executePreparedAgentCandidate(prepared: PreparedAgentCandidateExecution, options: ExecutePreparedAgentCandidateOptions): Promise<AgentCandidateRunFinalization>;
-
-interface PrepareAgentCandidateExecutionOptions {
-    cleanupTimeoutMs?: number;
-    /** Maximum time for task verification, executable grading, and receipt construction. */
-    resultTimeoutMs?: number;
-}
-/** Materializes a verified candidate into one immutable evaluator-owned execution plan. */
-declare function prepareAgentCandidateExecution(candidate: VerifiedAgentCandidate, task: AgentCandidateTaskExecution, ports: AgentCandidateExecutionPorts, options?: PrepareAgentCandidateExecutionOptions): Promise<PreparedAgentCandidateExecution>;
-
-export { InMemoryAgentCandidateExecutionClaimStore as $, type AgentCandidateBundleInput as A, type AgentCandidateExecutorProfileFile as B, type AgentCandidateExecutorRequest as C, type AgentCandidateExecutorStopRequest as D, type ExecutePreparedAgentCandidateOptions as E, type AgentCandidateExecutorTaskOutcomeCapture as F, type AgentCandidateExecutorWorkspaceFile as G, type AgentCandidateExecutorWorkspaceInput as H, type AgentCandidateMemoryPort as I, type AgentCandidateMemoryResetResult as J, type AgentCandidateModelLimits as K, type AgentCandidateModelPort as L, type AgentCandidateOutputArtifactPort as M, type AgentCandidateOutputPurpose as N, type AgentCandidateProtectedModelActivation as O, type PrepareAgentCandidateExecutionOptions as P, type AgentCandidateProtectedModelCall as Q, type AgentCandidateProtectedModelReservation as R, type AgentCandidateProtectedModelSettlement as S, type AgentCandidateProtectedRunCapture as T, type AgentCandidateRepositoryPort as U, type AgentCandidateRetryRejection as V, type AgentCandidateVerificationPorts as W, type AgentCandidateWorkspacePort as X, CANDIDATE_TRACE_ENV as Y, CANDIDATE_TRACE_TAGS as Z, type CanonicalCandidateDocument as _, type AgentCandidateTaskExecution as a, type PreparedAgentCandidateExecution as a0, type PreparedAgentCandidateInstruction as a1, type PreparedAgentCandidateKnowledge as a2, type PreparedAgentCandidateLaunch as a3, type PreparedAgentCandidateTrace as a4, type ResolvedAgentCandidateContainer as a5, type VerifiedAgentCandidate as a6, type VerifiedAgentCandidateTaskOutcome as a7, executePreparedAgentCandidate as a8, prepareAgentCandidateExecution as a9, sealAgentCandidateBundle as aa, type AgentCandidateExecutionPorts as b, type AgentCandidateRunFinalization as c, type AgentCandidateArtifactPort as d, type AgentCandidateBenchmarkGraderIdentity as e, type AgentCandidateBenchmarkGraderPort as f, type AgentCandidateContainerPort as g, type AgentCandidateExecutionAttemptRecord as h, type AgentCandidateExecutionAttemptRef as i, type AgentCandidateExecutionClaim as j, type AgentCandidateExecutionClaimResult as k, type AgentCandidateExecutionClaimStore as l, type AgentCandidateExecutionCleanupHandles as m, type AgentCandidateExecutionFailureClass as n, type AgentCandidateExecutionFinishResult as o, type AgentCandidateExecutionLease as p, type AgentCandidateExecutionPhase as q, type AgentCandidateExecutionPhaseResult as r, type AgentCandidateExecutionRecoveryEvidence as s, type AgentCandidateExecutionStageResult as t, type AgentCandidateExecutionTerminalRecord as u, type AgentCandidateExecutionTerminalResult as v, type AgentCandidateExecutionUsage as w, type AgentCandidateExecutorFinalCapture as x, type AgentCandidateExecutorMemoryCapture as y, type AgentCandidateExecutorPort as z };
+export { type AgentCandidateExecutorPort as A, type AgentCandidateWorkspacePort as B, CANDIDATE_TRACE_ENV as C, CANDIDATE_TRACE_TAGS as D, type CanonicalCandidateDocument as E, type PreparedAgentCandidateInstruction as F, type PreparedAgentCandidateKnowledge as G, type PreparedAgentCandidateLaunch as H, type PreparedAgentCandidateTrace as I, type VerifiedAgentCandidateTaskOutcome as J, type PreparedAgentCandidateExecution as P, type ResolvedAgentCandidateContainer as R, type VerifiedAgentCandidate as V, type AgentCandidateBenchmarkGraderPort as a, type AgentCandidateOutputArtifactPort as b, type AgentCandidateRunFinalization as c, type AgentCandidateTaskExecution as d, type AgentCandidateExecutionPorts as e, type AgentCandidateArtifactPort as f, type AgentCandidateContainerPort as g, type AgentCandidateExecutorFinalCapture as h, type AgentCandidateExecutorMemoryCapture as i, type AgentCandidateExecutorProfileFile as j, type AgentCandidateExecutorRequest as k, type AgentCandidateExecutorStopRequest as l, type AgentCandidateExecutorTaskOutcomeCapture as m, type AgentCandidateExecutorWorkspaceFile as n, type AgentCandidateExecutorWorkspaceInput as o, type AgentCandidateMemoryPort as p, type AgentCandidateMemoryResetResult as q, type AgentCandidateModelLimits as r, type AgentCandidateModelPort as s, type AgentCandidateOutputPurpose as t, type AgentCandidateProtectedModelActivation as u, type AgentCandidateProtectedModelReservation as v, type AgentCandidateProtectedModelSettlement as w, type AgentCandidateProtectedRunCapture as x, type AgentCandidateRepositoryPort as y, type AgentCandidateVerificationPorts as z };

package/dist/{types-1d5QGK3t.d.ts → types-CmnA2iL3.d.ts}

@@ -1,7 +1,7 @@
 import { DefaultVerdict } from '@tangle-network/agent-eval';
 import { AgentProfile } from '@tangle-network/agent-interface';
 import { BackendType } from '@tangle-network/sandbox';
-import { L as LoopTokenUsage, R as RuntimeHooks } from './types-ByAYqlVb.js';
+import { L as LoopTokenUsage, R as RuntimeHooks } from './types-B3vAW0Oq.js';
 
 /**
  *
@@ -385,8 +385,8 @@ type SpawnEvent = {
 };
 /**
  * The spawn-tree event source (mirrors `ConversationJournal`'s begin/append/load shape).
- * `loadTree` replays the full ordered event list for resume/replay; `appendEvent` is
- * called only AFTER the event is observed-committed (never speculative).
+ * `loadTree` returns events for inspection and completed-settlement replay, not live process
+ * recovery; `appendEvent` runs only AFTER the event is observed-committed (never speculative).
  */
 interface SpawnJournal {
     loadTree(root: NodeId): Promise<SpawnEvent[] | undefined>;

package/dist/{worktree-fanout-CPprU-qI.d.ts → worktree-fanout-DCA3G4bO.d.ts}

@@ -1,9 +1,9 @@
 import { AgentProfile } from '@tangle-network/agent-interface';
 import { AnalystFinding, DefaultVerdict } from '@tangle-network/agent-eval';
-import { d as AgentSpec, e as ExecutorRegistry, B as Budget, A as Agent, f as SpawnJournal, a as ResultBlobStore, g as RootHandle, b as SupervisedResult, N as NodeId, h as Settled, i as Spend, S as Scope, c as Executor } from './types-1d5QGK3t.js';
-import { R as RuntimeHooks, I as Iteration } from './types-ByAYqlVb.js';
+import { d as AgentSpec, e as ExecutorRegistry, B as Budget, A as Agent, f as SpawnJournal, a as ResultBlobStore, g as RootHandle, b as SupervisedResult, N as NodeId, h as Settled, i as Spend, S as Scope, c as Executor } from './types-CmnA2iL3.js';
+import { R as RuntimeHooks, I as Iteration } from './types-B3vAW0Oq.js';
 import { BackendType } from '@tangle-network/sandbox';
-import { W as WorktreeHarnessResult, G as GitRunner, a as WorktreeCheckRunner, D as DeliverableSpec } from './completion-gate-D1gX1-hg.js';
+import { W as WorktreeHarnessResult, G as GitRunner, a as WorktreeCheckRunner, D as DeliverableSpec } from './completion-gate-C80jiRfN.js';
 import { L as LocalHarness, r as runLocalHarness } from './local-harness-ZqCx51u7.js';
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-runtime",
-  "version": "0.94.13",
+  "version": "0.95.0",
   "description": "Shared task-lifecycle skeleton for agents: a recursive loop kernel for chat turns, one-shot tasks, and multi-attempt loops, with trace capture and eval-gated self-improvement. Domain behavior lives in adapters; scoring and ship-gates in @tangle-network/agent-eval.",
   "homepage": "https://github.com/tangle-network/agent-runtime#readme",
   "repository": {
@@ -100,13 +100,15 @@
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
-    "prepare": "(git rev-parse --git-dir > /dev/null 2>&1 && git config core.hooksPath .githooks) || true; tsup",
+    "prepublishOnly": "pnpm run build",
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "biome check src tests examples",
     "lint:fix": "biome check --write src tests examples",
     "typecheck": "tsc --noEmit && pnpm run typecheck:examples",
     "typecheck:examples": "tsc --noEmit -p tsconfig.examples.json",
+    "verify:bench": "pnpm --filter @tangle-network/agent-bench run typecheck:public && pnpm --filter @tangle-network/agent-bench test && pnpm --filter @tangle-network/agent-bench run verify:package:local-runtime",
+    "verify:bench:published": "pnpm --filter @tangle-network/agent-bench run typecheck:public && pnpm --filter @tangle-network/agent-bench test && pnpm --filter @tangle-network/agent-bench run verify:package",
     "verify:package": "node scripts/verify-package-exports.mjs",
     "verify:primeintellect": "pnpm build && node scripts/verify-primeintellect-v1.mjs",
     "verify:primeintellect:live": "pnpm build && node scripts/verify-primeintellect-live.mjs",
@@ -116,9 +118,9 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.15",
-    "@tangle-network/agent-eval": "0.120.1",
-    "@tangle-network/agent-interface": "0.26.1",
-    "@tangle-network/sandbox": "^0.9.7",
+    "@tangle-network/agent-eval": "0.122.1",
+    "@tangle-network/agent-interface": "0.30.0",
+    "@tangle-network/sandbox": "^0.11.1",
     "@types/node": "^25.9.3",
     "@types/tar-stream": "3.1.4",
     "playwright": "^1.61.0",
@@ -134,6 +136,7 @@
     "minimumReleaseAgeExclude": [
       "@tangle-network/agent-eval",
       "@tangle-network/agent-interface",
+      "@tangle-network/agent-knowledge",
       "@tangle-network/agent-profile-materialize",
       "@tangle-network/sandbox"
     ],
@@ -147,9 +150,9 @@
   "license": "MIT",
   "packageManager": "pnpm@10.28.0",
   "peerDependencies": {
-    "@tangle-network/agent-eval": ">=0.120.1 <0.121.0",
-    "@tangle-network/agent-interface": ">=0.26.1 <0.27.0",
-    "@tangle-network/sandbox": ">=0.8.0 <1.0.0",
+    "@tangle-network/agent-eval": ">=0.122.1 <0.123.0",
+    "@tangle-network/agent-interface": ">=0.30.0 <0.31.0",
+    "@tangle-network/sandbox": ">=0.11.1 <1.0.0",
     "playwright": "^1.40.0"
   },
   "peerDependenciesMeta": {
@@ -161,8 +164,8 @@
     }
   },
   "dependencies": {
-    "@tangle-network/agent-knowledge": "^1.12.1",
-    "@tangle-network/agent-profile-materialize": "0.3.2",
+    "@tangle-network/agent-knowledge": "^3.0.1",
+    "@tangle-network/agent-profile-materialize": "0.5.1",
     "tar-stream": "3.2.0"
   }
 }