@tangle-network/agent-runtime 0.90.1 → 0.92.0

package/dist/{mcp-serve-verifier-XsX8rkB9.d.ts → agentic-generator-B8oeE2Yv.d.ts}

@@ -65,8 +65,12 @@ interface ImprovementDriverOptions {
     /** Base ref candidate worktrees fork from. Default `main`. */
     baseRef?: string;
 }
+interface ManagedImprovementDriver extends SurfaceProposer<AnalystFinding> {
+    /** Remove every finalized candidate except explicitly retained winners. */
+    cleanup(retainWorktreeRefs?: readonly string[]): Promise<void>;
+}
 /** The one reflective/agentic improvement proposer (`SurfaceProposer`): owns the candidate worktree lifecycle and delegates HOW a change is produced to a pluggable `CandidateGenerator`. */
-declare function improvementDriver(opts: ImprovementDriverOptions): SurfaceProposer<AnalystFinding>;
+declare function improvementDriver(opts: ImprovementDriverOptions): ManagedImprovementDriver;
 
 /**
  *
@@ -144,35 +148,4 @@ declare function agenticGenerator(opts?: AgenticGeneratorOptions): CandidateGene
  *  silent fallback). */
 declare function commandVerifier(command: string, args?: string[], timeoutMs?: number): Verifier;
 
-/**
- * `mcpServeVerifier` — the intrinsic verifier for a built MCP server: the
- * boot-and-probe checker named in docs/artifact-lifecycle-frontier.md. A
- * generated MCP server is only a candidate if it actually *serves* — so this
- * boots it over stdio (the default local MCP transport) and runs the real
- * handshake: `initialize` → `notifications/initialized` → `tools/list`, and
- * asserts the server answers with at least `minTools` tools.
- *
- * Outcomes follow the `Verifier` contract: a server that fails to start, exits
- * early, errors the handshake, times out, or exposes no tools is a FAILED
- * candidate (`{ok:false}`, fed back into the next generation shot); a missing
- * start binary or spawn fault THROWS (a setup bug, never a silent fallback).
- *
- * Protocol matches the runtime's own stdio MCP server (src/mcp/server.ts):
- * newline-delimited JSON-RPC 2.0, protocol version 2024-11-05.
- */
-
-interface McpServeSpec {
-    /** Command that starts the built MCP server in the worktree (stdio transport). */
-    command: string;
-    args?: string[];
-    /** Extra env for the server process (merged over `process.env`). */
-    env?: Record<string, string>;
-    /** Handshake timeout (ms). Default 30s. */
-    timeoutMs?: number;
-    /** Minimum tools the server must expose to pass. Default 1. */
-    minTools?: number;
-}
-/** Build a `Verifier` that boots a generated MCP server over stdio and checks it exposes tools. */
-declare function mcpServeVerifier(spec: McpServeSpec): Verifier;
-
-export { type AgenticGeneratorOptions as A, type CandidateGenerator as C, type ImprovementDriverOptions as I, type McpServeSpec as M, type Verifier as V, type VerifyResult as a, agenticGenerator as b, commandVerifier as c, improvementDriver as i, mcpServeVerifier as m };
+export { type AgenticGeneratorOptions as A, type CandidateGenerator as C, type ImprovementDriverOptions as I, type ManagedImprovementDriver as M, type Verifier as V, type VerifyResult as a, agenticGenerator as b, commandVerifier as c, improvementDriver as i };

package/dist/analyst-loop.d.ts

@@ -1,5 +1,5 @@
 import { TraceAnalystByteBudgets, TraceAnalysisStore } from '@tangle-network/agent-eval';
-import { I as Iteration } from './types-SyuwunY_.js';
+import { I as Iteration } from './types-B00NtbCs.js';
 import { R as RunAnalystLoopOpts, a as RunAnalystLoopResult } from './types-BC3bZpH0.js';
 export { A as AnalystLoopEvent, b as AnalystRegistryLike, c as AnalystRegistryStreamingLike, d as AutoApplyPolicy, F as FindingsStoreLike, I as ImprovementAdapter, e as ImprovementEditBatch, f as ImprovementReport, K as KnowledgeAdapter, g as KnowledgeProposalBatch, h as KnowledgeReport } from './types-BC3bZpH0.js';
 import '@tangle-network/sandbox';

package/dist/candidate-execution/index.d.ts

@@ -0,0 +1,104 @@
+import { $ as PreparedAgentCandidateExecution, i as AgentCandidateExecutionClaim, k as AgentCandidateExecutionClaimStore, j as AgentCandidateExecutionClaimResult, h as AgentCandidateExecutionAttemptRef, g as AgentCandidateExecutionAttemptRecord, o as AgentCandidateExecutionLease, q as AgentCandidateExecutionPhaseResult, u as AgentCandidateExecutionTerminalResult, s as AgentCandidateExecutionStageResult, n as AgentCandidateExecutionFinishResult, r as AgentCandidateExecutionRecoveryEvidence, L as AgentCandidateOutputArtifactPort, M as AgentCandidateOutputPurpose, K as AgentCandidateModelPort, Q as AgentCandidateProtectedModelReservation, N as AgentCandidateProtectedModelActivation, R as AgentCandidateProtectedModelSettlement, y as AgentCandidateExecutorPort, a as AgentCandidateExecutionPorts, V as AgentCandidateVerificationPorts, a4 as VerifiedAgentCandidate } from '../prepare-Z08a4heC.js';
+export { c as AgentCandidateArtifactPort, d as AgentCandidateBenchmarkGraderIdentity, e as AgentCandidateBenchmarkGraderPort, f as AgentCandidateContainerPort, l as AgentCandidateExecutionCleanupHandles, m as AgentCandidateExecutionFailureClass, p as AgentCandidateExecutionPhase, t as AgentCandidateExecutionTerminalRecord, v as AgentCandidateExecutionUsage, w as AgentCandidateExecutorFinalCapture, x as AgentCandidateExecutorMemoryCapture, z as AgentCandidateExecutorProfileFile, B as AgentCandidateExecutorRequest, C as AgentCandidateExecutorStopRequest, D as AgentCandidateExecutorTaskOutcomeCapture, F as AgentCandidateExecutorWorkspaceFile, G as AgentCandidateExecutorWorkspaceInput, H as AgentCandidateMemoryPort, I as AgentCandidateMemoryResetResult, J as AgentCandidateModelLimits, O as AgentCandidateProtectedModelCall, S as AgentCandidateProtectedRunCapture, T as AgentCandidateRepositoryPort, U as AgentCandidateRetryRejection, b as AgentCandidateRunFinalization, A as AgentCandidateTaskExecution, W as AgentCandidateWorkspacePort, X as CANDIDATE_TRACE_ENV, Y as CANDIDATE_TRACE_TAGS, Z as CanonicalCandidateDocument, E as ExecutePreparedAgentCandidateOptions, _ as InMemoryAgentCandidateExecutionClaimStore, P as PrepareAgentCandidateExecutionOptions, a0 as PreparedAgentCandidateInstruction, a1 as PreparedAgentCandidateLaunch, a2 as PreparedAgentCandidateTrace, a3 as ResolvedAgentCandidateContainer, a5 as VerifiedAgentCandidateTaskOutcome, a6 as executePreparedAgentCandidate, a7 as prepareAgentCandidateExecution } from '../prepare-Z08a4heC.js';
+import { Sha256Digest, AgentCandidateArtifactRef } from '@tangle-network/agent-interface';
+import { TraceStore } from '@tangle-network/agent-eval';
+
+/** Extract the complete durable claim from a prepared execution. */
+declare function candidateExecutionClaim(prepared: PreparedAgentCandidateExecution): AgentCandidateExecutionClaim;
+
+interface FileAgentCandidateExecutionClaimStoreOptions {
+    /** Evaluator-owned directory shared by every process allowed to execute candidates. */
+    directory: string;
+    /** Testable evaluator clock; defaults to `Date.now`. */
+    now?: () => number;
+}
+/** Cross-process lifecycle implemented as fsynced, create-if-absent records. */
+declare class FileAgentCandidateExecutionClaimStore implements AgentCandidateExecutionClaimStore {
+    private readonly directory;
+    private readonly now;
+    constructor(options: FileAgentCandidateExecutionClaimStoreOptions);
+    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 storedAttempt;
+    private transitionState;
+    private retryFailure;
+    private ownerPublication;
+    private claimPath;
+    private terminalPath;
+    private transitionPath;
+}
+
+interface DisposePreparedAgentCandidateOptions {
+    cleanupTimeoutMs?: number;
+}
+/** Revoke reservations held by a prepared candidate that will not be executed. */
+declare function disposePreparedAgentCandidateExecution(prepared: PreparedAgentCandidateExecution, options?: DisposePreparedAgentCandidateOptions): Promise<{
+    disposed: true;
+}>;
+
+/** Persist evaluator evidence, read it back, and bind the returned locator to the exact bytes. */
+declare function persistCandidateOutputArtifact(port: AgentCandidateOutputArtifactPort, input: {
+    executionId: string;
+    purpose: AgentCandidateOutputPurpose;
+    bytes: Uint8Array;
+    signal?: AbortSignal;
+}): Promise<AgentCandidateArtifactRef>;
+
+type AgentCandidateModelGrantReserveInput = Parameters<AgentCandidateModelPort['reserveGrant']>[0];
+type AgentCandidateModelGrantActivateInput = Parameters<AgentCandidateModelPort['activateGrant']>[0];
+type AgentCandidateModelGrantSettleInput = Parameters<AgentCandidateModelPort['settleGrant']>[0];
+/** Secret-free response from the service's reservation endpoint. */
+type AgentCandidateModelGrantReservation = AgentCandidateProtectedModelReservation;
+/**
+ * Narrow transport contract for a service that owns scoped model credentials
+ * and the authoritative per-call usage ledger.
+ *
+ * An HTTP client can bind these methods to control-plane endpoints. Keeping
+ * transport out of the runtime prevents parent credentials, endpoint paths,
+ * and retry policy from becoming part of the portable candidate contract.
+ */
+interface AgentCandidateModelGrantClient {
+    reserve(input: AgentCandidateModelGrantReserveInput): Promise<AgentCandidateModelGrantReservation>;
+    activate(input: AgentCandidateModelGrantActivateInput): Promise<AgentCandidateProtectedModelActivation>;
+    settle(input: AgentCandidateModelGrantSettleInput): Promise<AgentCandidateProtectedModelSettlement>;
+}
+interface CreateProtectedAgentCandidateModelPortOptions {
+    client: AgentCandidateModelGrantClient;
+    /** Catalog/snapshot resolution stays separate from credential issuance. */
+    resolveModel: AgentCandidateModelPort['resolve'];
+    /** The only public DNS name candidate processes may reach for inference. */
+    gatewayDomain: string;
+    /** Exact environment names the activation endpoint must return, no more or fewer. */
+    activationEnvNames: readonly string[];
+}
+/**
+ * Bind a protected model-grant service to the immutable candidate runtime.
+ *
+ * The service remains the authority for expiry, admission, revocation, and
+ * metering. This adapter independently checks every response before allowing
+ * it to cross into candidate execution or durable receipt finalization.
+ */
+declare function createProtectedAgentCandidateModelPort(options: CreateProtectedAgentCandidateModelPortOptions): AgentCandidateModelPort;
+
+interface RecoverExpiredAgentCandidateOptions {
+    attempt: AgentCandidateExecutionAttemptRef;
+    claimStore: AgentCandidateExecutionClaimStore;
+    executor: AgentCandidateExecutorPort;
+    traceStore: TraceStore;
+    ports: Pick<AgentCandidateExecutionPorts, 'models' | 'memory'>;
+    outputArtifacts: AgentCandidateOutputArtifactPort;
+    cleanupTimeoutMs?: number;
+    /** Evaluator clock; must be the same clock used by the claim store. */
+    now?: () => number;
+}
+/** Close an expired crashed attempt from persisted non-secret handles, then record failure. */
+declare function recoverExpiredAgentCandidateExecution(options: RecoverExpiredAgentCandidateOptions): Promise<AgentCandidateExecutionFinishResult>;
+
+/** Verifies every digest, resource, workspace, and Git object in a candidate bundle. */
+declare function verifyAgentCandidateBundle(input: unknown, ports: AgentCandidateVerificationPorts): Promise<VerifiedAgentCandidate>;
+
+export { AgentCandidateExecutionAttemptRecord, AgentCandidateExecutionAttemptRef, AgentCandidateExecutionClaim, AgentCandidateExecutionClaimResult, AgentCandidateExecutionClaimStore, AgentCandidateExecutionFinishResult, AgentCandidateExecutionLease, AgentCandidateExecutionPhaseResult, AgentCandidateExecutionPorts, AgentCandidateExecutionRecoveryEvidence, AgentCandidateExecutionStageResult, AgentCandidateExecutionTerminalResult, AgentCandidateExecutorPort, type AgentCandidateModelGrantActivateInput, type AgentCandidateModelGrantClient, type AgentCandidateModelGrantReservation, type AgentCandidateModelGrantReserveInput, type AgentCandidateModelGrantSettleInput, AgentCandidateModelPort, AgentCandidateOutputArtifactPort, AgentCandidateOutputPurpose, AgentCandidateProtectedModelActivation, AgentCandidateProtectedModelReservation, AgentCandidateProtectedModelSettlement, AgentCandidateVerificationPorts, type CreateProtectedAgentCandidateModelPortOptions, type DisposePreparedAgentCandidateOptions, FileAgentCandidateExecutionClaimStore, type FileAgentCandidateExecutionClaimStoreOptions, PreparedAgentCandidateExecution, type RecoverExpiredAgentCandidateOptions, VerifiedAgentCandidate, candidateExecutionClaim, createProtectedAgentCandidateModelPort, disposePreparedAgentCandidateExecution, persistCandidateOutputArtifact, recoverExpiredAgentCandidateExecution, verifyAgentCandidateBundle };

package/dist/candidate-execution/index.js

@@ -0,0 +1,34 @@
+import {
+  FileAgentCandidateExecutionClaimStore,
+  createProtectedAgentCandidateModelPort,
+  disposePreparedAgentCandidateExecution,
+  recoverExpiredAgentCandidateExecution
+} from "../chunk-PH65PR4F.js";
+import {
+  CANDIDATE_TRACE_ENV,
+  CANDIDATE_TRACE_TAGS,
+  InMemoryAgentCandidateExecutionClaimStore,
+  candidateExecutionClaim,
+  executePreparedAgentCandidate,
+  persistCandidateOutputArtifact,
+  prepareAgentCandidateExecution,
+  verifyAgentCandidateBundle
+} from "../chunk-A62TP7SK.js";
+import "../chunk-3D2RHC4K.js";
+import "../chunk-3MDZX7YU.js";
+import "../chunk-DGUM43GV.js";
+export {
+  CANDIDATE_TRACE_ENV,
+  CANDIDATE_TRACE_TAGS,
+  FileAgentCandidateExecutionClaimStore,
+  InMemoryAgentCandidateExecutionClaimStore,
+  candidateExecutionClaim,
+  createProtectedAgentCandidateModelPort,
+  disposePreparedAgentCandidateExecution,
+  executePreparedAgentCandidate,
+  persistCandidateOutputArtifact,
+  prepareAgentCandidateExecution,
+  recoverExpiredAgentCandidateExecution,
+  verifyAgentCandidateBundle
+};
+//# sourceMappingURL=index.js.map

package/dist/candidate-execution/index.js.map

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