@tangle-network/agent-interface 1.7.1 → 1.9.0

package/dist/environment-interactive-start.d.ts

@@ -39,13 +39,13 @@ export declare const AgentInteractiveSessionStartSchema: z.ZodObject<{
             small: z.ZodOptional<z.ZodString>;
             provider: z.ZodOptional<z.ZodString>;
             reasoningEffort: z.ZodOptional<z.ZodEnum<{
-                none: "none";
-                minimal: "minimal";
+                high: "high";
                 low: "low";
                 medium: "medium";
-                high: "high";
-                xhigh: "xhigh";
+                minimal: "minimal";
+                none: "none";
                 ultracode: "ultracode";
+                xhigh: "xhigh";
             }>>;
             maxVisibleOutputTokens: z.ZodOptional<z.ZodNumber>;
             maxReasoningTokens: z.ZodOptional<z.ZodNumber>;
@@ -53,22 +53,22 @@ export declare const AgentInteractiveSessionStartSchema: z.ZodObject<{
             metadata: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
         }, z.core.$strict>>;
         harness: z.ZodOptional<z.ZodEnum<{
+            acp: "acp";
+            amp: "amp";
             "claude-code": "claude-code";
-            nanoclaw: "nanoclaw";
+            "cli-base": "cli-base";
             codex: "codex";
-            opencode: "opencode";
-            "kimi-code": "kimi-code";
-            pi: "pi";
-            prime: "prime";
+            cursor: "cursor";
+            "factory-droids": "factory-droids";
+            forge: "forge";
             gemini: "gemini";
             hermes: "hermes";
+            "kimi-code": "kimi-code";
+            nanoclaw: "nanoclaw";
             openclaw: "openclaw";
-            amp: "amp";
-            "factory-droids": "factory-droids";
-            forge: "forge";
-            cursor: "cursor";
-            acp: "acp";
-            "cli-base": "cli-base";
+            opencode: "opencode";
+            pi: "pi";
+            prime: "prime";
         }>>;
         permissions: z.ZodOptional<z.ZodType<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown, z.core.$ZodTypeInternals<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown>>>;
         tools: z.ZodOptional<z.ZodType<Record<string, boolean>, unknown, z.core.$ZodTypeInternals<Record<string, boolean>, unknown>>>;
@@ -179,7 +179,7 @@ export declare const AgentInteractiveSessionStartSchema: z.ZodObject<{
             } | {
                 kind: "secret-ref";
                 key: string;
-                format?: "raw" | "bearer" | undefined;
+                format?: "bearer" | "raw" | undefined;
             }> | undefined;
         }[]>, unknown, z.core.$ZodTypeInternals<Record<string, {
             command: string;
@@ -192,7 +192,7 @@ export declare const AgentInteractiveSessionStartSchema: z.ZodObject<{
             } | {
                 kind: "secret-ref";
                 key: string;
-                format?: "raw" | "bearer" | undefined;
+                format?: "bearer" | "raw" | undefined;
             }> | undefined;
         }[]>, unknown>>>;
         modes: z.ZodOptional<z.ZodType<Record<string, {

package/dist/environment-observation.d.ts

@@ -7,11 +7,11 @@ import { z } from "zod";
  */
 export type ObservationState = "known" | "stale" | "unavailable" | "redacted" | "unknown";
 export declare const ObservationStateSchema: z.ZodEnum<{
-    unknown: "unknown";
-    unavailable: "unavailable";
     known: "known";
-    stale: "stale";
     redacted: "redacted";
+    stale: "stale";
+    unavailable: "unavailable";
+    unknown: "unknown";
 }>;
 /** How a known or stale value was obtained, and when. */
 export interface ObservationProvenance {
@@ -102,31 +102,31 @@ export declare const ProviderIdentitySchema: z.ZodObject<{
     backend: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const AgentEnvironmentStatusSchema: z.ZodEnum<{
-    unknown: "unknown";
-    failed: "failed";
     expired: "expired";
-    stopped: "stopped";
+    failed: "failed";
     pending: "pending";
-    running: "running";
     provisioning: "provisioning";
+    running: "running";
+    stopped: "stopped";
+    unknown: "unknown";
 }>;
 /** Lifecycle, cleanup, continuity, and persistence of one environment. */
 export declare const EnvironmentLifecycleSchema: z.ZodObject<{
     status: z.ZodEnum<{
-        unknown: "unknown";
-        failed: "failed";
         expired: "expired";
-        stopped: "stopped";
+        failed: "failed";
         pending: "pending";
-        running: "running";
         provisioning: "provisioning";
+        running: "running";
+        stopped: "stopped";
+        unknown: "unknown";
     }>;
     cleanup: z.ZodOptional<z.ZodObject<{
         policy: z.ZodOptional<z.ZodEnum<{
-            manual: "manual";
             idle: "idle";
-            scheduled: "scheduled";
+            manual: "manual";
             "on-exit": "on-exit";
+            scheduled: "scheduled";
         }>>;
         scheduledAt: z.ZodOptional<z.ZodISODateTime>;
         confirmed: z.ZodOptional<z.ZodBoolean>;
@@ -134,17 +134,17 @@ export declare const EnvironmentLifecycleSchema: z.ZodObject<{
     continuity: z.ZodOptional<z.ZodObject<{
         resumable: z.ZodBoolean;
         mode: z.ZodOptional<z.ZodEnum<{
+            native: "native";
             none: "none";
             replayed: "replayed";
-            native: "native";
         }>>;
     }, z.core.$strict>>;
     persistence: z.ZodOptional<z.ZodObject<{
         durable: z.ZodBoolean;
         scope: z.ZodOptional<z.ZodEnum<{
-            session: "session";
             durable: "durable";
             ephemeral: "ephemeral";
+            session: "session";
         }>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
@@ -183,10 +183,10 @@ export type ResourceUseSample = z.infer<typeof ResourceUseSampleSchema>;
 /** Where an environment was requested or verified to run. */
 export declare const PlacementDescriptorSchema: z.ZodObject<{
     kind: z.ZodEnum<{
-        provider: "provider";
+        fleet: "fleet";
         local: "local";
+        provider: "provider";
         sandbox: "sandbox";
-        fleet: "fleet";
     }>;
     sandboxId: z.ZodOptional<z.ZodString>;
     fleetId: z.ZodOptional<z.ZodString>;
@@ -438,20 +438,20 @@ export declare const AgentEnvironmentObservationSchema: z.ZodObject<{
         state: z.ZodLiteral<"known">;
         value: z.ZodObject<{
             status: z.ZodEnum<{
-                unknown: "unknown";
-                failed: "failed";
                 expired: "expired";
-                stopped: "stopped";
+                failed: "failed";
                 pending: "pending";
-                running: "running";
                 provisioning: "provisioning";
+                running: "running";
+                stopped: "stopped";
+                unknown: "unknown";
             }>;
             cleanup: z.ZodOptional<z.ZodObject<{
                 policy: z.ZodOptional<z.ZodEnum<{
-                    manual: "manual";
                     idle: "idle";
-                    scheduled: "scheduled";
+                    manual: "manual";
                     "on-exit": "on-exit";
+                    scheduled: "scheduled";
                 }>>;
                 scheduledAt: z.ZodOptional<z.ZodISODateTime>;
                 confirmed: z.ZodOptional<z.ZodBoolean>;
@@ -459,17 +459,17 @@ export declare const AgentEnvironmentObservationSchema: z.ZodObject<{
             continuity: z.ZodOptional<z.ZodObject<{
                 resumable: z.ZodBoolean;
                 mode: z.ZodOptional<z.ZodEnum<{
+                    native: "native";
                     none: "none";
                     replayed: "replayed";
-                    native: "native";
                 }>>;
             }, z.core.$strict>>;
             persistence: z.ZodOptional<z.ZodObject<{
                 durable: z.ZodBoolean;
                 scope: z.ZodOptional<z.ZodEnum<{
-                    session: "session";
                     durable: "durable";
                     ephemeral: "ephemeral";
+                    session: "session";
                 }>>;
             }, z.core.$strict>>;
         }, z.core.$strict>;
@@ -486,20 +486,20 @@ export declare const AgentEnvironmentObservationSchema: z.ZodObject<{
         state: z.ZodLiteral<"stale">;
         value: z.ZodObject<{
             status: z.ZodEnum<{
-                unknown: "unknown";
-                failed: "failed";
                 expired: "expired";
-                stopped: "stopped";
+                failed: "failed";
                 pending: "pending";
-                running: "running";
                 provisioning: "provisioning";
+                running: "running";
+                stopped: "stopped";
+                unknown: "unknown";
             }>;
             cleanup: z.ZodOptional<z.ZodObject<{
                 policy: z.ZodOptional<z.ZodEnum<{
-                    manual: "manual";
                     idle: "idle";
-                    scheduled: "scheduled";
+                    manual: "manual";
                     "on-exit": "on-exit";
+                    scheduled: "scheduled";
                 }>>;
                 scheduledAt: z.ZodOptional<z.ZodISODateTime>;
                 confirmed: z.ZodOptional<z.ZodBoolean>;
@@ -507,17 +507,17 @@ export declare const AgentEnvironmentObservationSchema: z.ZodObject<{
             continuity: z.ZodOptional<z.ZodObject<{
                 resumable: z.ZodBoolean;
                 mode: z.ZodOptional<z.ZodEnum<{
+                    native: "native";
                     none: "none";
                     replayed: "replayed";
-                    native: "native";
                 }>>;
             }, z.core.$strict>>;
             persistence: z.ZodOptional<z.ZodObject<{
                 durable: z.ZodBoolean;
                 scope: z.ZodOptional<z.ZodEnum<{
-                    session: "session";
                     durable: "durable";
                     ephemeral: "ephemeral";
+                    session: "session";
                 }>>;
             }, z.core.$strict>>;
         }, z.core.$strict>;
@@ -587,10 +587,10 @@ export declare const AgentEnvironmentObservationSchema: z.ZodObject<{
     placement: z.ZodOptional<z.ZodObject<{
         requested: z.ZodOptional<z.ZodObject<{
             kind: z.ZodEnum<{
-                provider: "provider";
+                fleet: "fleet";
                 local: "local";
+                provider: "provider";
                 sandbox: "sandbox";
-                fleet: "fleet";
             }>;
             sandboxId: z.ZodOptional<z.ZodString>;
             fleetId: z.ZodOptional<z.ZodString>;
@@ -601,10 +601,10 @@ export declare const AgentEnvironmentObservationSchema: z.ZodObject<{
             state: z.ZodLiteral<"known">;
             value: z.ZodObject<{
                 kind: z.ZodEnum<{
-                    provider: "provider";
+                    fleet: "fleet";
                     local: "local";
+                    provider: "provider";
                     sandbox: "sandbox";
-                    fleet: "fleet";
                 }>;
                 sandboxId: z.ZodOptional<z.ZodString>;
                 fleetId: z.ZodOptional<z.ZodString>;
@@ -624,10 +624,10 @@ export declare const AgentEnvironmentObservationSchema: z.ZodObject<{
             state: z.ZodLiteral<"stale">;
             value: z.ZodObject<{
                 kind: z.ZodEnum<{
-                    provider: "provider";
+                    fleet: "fleet";
                     local: "local";
+                    provider: "provider";
                     sandbox: "sandbox";
-                    fleet: "fleet";
                 }>;
                 sandboxId: z.ZodOptional<z.ZodString>;
                 fleetId: z.ZodOptional<z.ZodString>;

package/dist/environment-runtime.d.ts

@@ -5,8 +5,8 @@ import type { InputPart } from "./parts.js";
 import type { StreamEvent } from "./stream-events.js";
 import type { TokenUsage } from "./execution-types.js";
 import { type InteractionAcknowledgement, type InteractionCapabilities, type InteractionResponseCommand, type RequestedInteractions } from "./interaction.js";
-import { type ContextTransferReceipt, type ContextTransferRequest, type NativeContextBoundaryProof, type NativeContextContinuationRequest, type NativeContextContinuationTurn } from "./portable-context.js";
-import { type AgentRunCancellationAcknowledgement, type AgentRunCancellationRequest, type AgentRunControlRef } from "./runtime-control.js";
+import { type ContextTransferReceipt, type ContextTransferRequest, type ContextTransferResult, type NativeContextBoundaryProof, type NativeContextContinuationRequest, type NativeContextContinuationTurn } from "./portable-context.js";
+import { type AgentExactRunControlRef, type AgentRunCancellationAcknowledgement, type AgentRunCancellationRequest, type AgentRunControlRef } from "./runtime-control.js";
 import type { AgentWorkspaceBranching, AgentWorkspaceBranchingProvider } from "./workspace-branching.js";
 import type { AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentProfileRef, AgentSessionStatus, CheckpointRef, CheckpointRequest, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from "./environment-requests.js";
 import type { AgentExactProcessEgressMode, AgentExactProcessProvider } from "./environment-exact-process.js";
@@ -92,9 +92,9 @@ export declare const AgentTurnInputSchema: z.ZodObject<{
                 messages: z.ZodArray<z.ZodObject<{
                     id: z.ZodString;
                     role: z.ZodEnum<{
-                        user: "user";
                         assistant: "assistant";
                         system: "system";
+                        user: "user";
                     }>;
                     parts: z.ZodArray<z.ZodCustom<unknown, unknown>>;
                     timestamp: z.ZodISODateTime;
@@ -128,9 +128,9 @@ export declare const AgentTurnInputSchema: z.ZodObject<{
                 parts: z.ZodArray<z.ZodObject<{
                     partIndex: z.ZodNumber;
                     action: z.ZodEnum<{
-                        transform: "transform";
                         include: "include";
                         omit: "omit";
+                        transform: "transform";
                     }>;
                     output: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
                         type: z.ZodLiteral<"text">;
@@ -171,9 +171,9 @@ export declare const AgentTurnInputSchema: z.ZodObject<{
                 messages: z.ZodArray<z.ZodObject<{
                     id: z.ZodString;
                     role: z.ZodEnum<{
-                        user: "user";
                         assistant: "assistant";
                         system: "system";
+                        user: "user";
                     }>;
                     parts: z.ZodArray<z.ZodCustom<unknown, unknown>>;
                     timestamp: z.ZodISODateTime;
@@ -197,8 +197,8 @@ export declare const AgentTurnInputSchema: z.ZodObject<{
             acceptedAt: z.ZodISODateTime;
             acceptedBy: z.ZodEnum<{
                 policy: "policy";
-                user: "user";
                 system: "system";
+                user: "user";
             }>;
         }, z.core.$strict>;
     }, z.core.$strict>>;
@@ -365,13 +365,13 @@ export declare const AgentNativeContextContinuationResultSchema: z.ZodUnion<read
         operationId: z.ZodString;
         requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
         status: z.ZodEnum<{
-            conflict: "conflict";
             accepted: "accepted";
-            transport_failure: "transport_failure";
-            replayed: "replayed";
             boundary_mismatch: "boundary_mismatch";
-            unverified: "unverified";
+            conflict: "conflict";
+            replayed: "replayed";
+            transport_failure: "transport_failure";
             unknown_session: "unknown_session";
+            unverified: "unverified";
         }>;
         historyMessagesSent: z.ZodNumber;
         existingRequestDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
@@ -524,13 +524,13 @@ export declare const AgentNativeContextContinuationResultSchema: z.ZodUnion<read
         operationId: z.ZodString;
         requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
         status: z.ZodEnum<{
-            conflict: "conflict";
             accepted: "accepted";
-            transport_failure: "transport_failure";
-            replayed: "replayed";
             boundary_mismatch: "boundary_mismatch";
-            unverified: "unverified";
+            conflict: "conflict";
+            replayed: "replayed";
+            transport_failure: "transport_failure";
             unknown_session: "unknown_session";
+            unverified: "unverified";
         }>;
         historyMessagesSent: z.ZodNumber;
         existingRequestDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
@@ -561,20 +561,69 @@ export declare const AgentNativeContextContinuationResultSchema: z.ZodUnion<read
         retryable: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>, z.ZodObject<{
         status: z.ZodEnum<{
+            boundary_mismatch: "boundary_mismatch";
             conflict: "conflict";
             transport_failure: "transport_failure";
-            boundary_mismatch: "boundary_mismatch";
-            unverified: "unverified";
             unknown_session: "unknown_session";
+            unverified: "unverified";
         }>;
     }, z.core.$strip>>;
 }, z.core.$strict>]>;
 export type AgentNativeContextContinuationResult = z.infer<typeof AgentNativeContextContinuationResultSchema>;
+/** Exact continued-run identity returned after durable admission. */
+export declare const AgentNativeContextContinuationAdmissionSchema: z.ZodObject<{
+    phase: z.ZodLiteral<"admitted">;
+    acknowledgement: z.ZodObject<{
+        operationId: z.ZodString;
+        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        historyMessagesSent: z.ZodLiteral<0>;
+        actualBoundary: z.ZodObject<{
+            runId: z.ZodString;
+            provider: z.ZodString;
+            environmentId: z.ZodString;
+            sessionId: z.ZodString;
+            executionId: z.ZodString;
+            requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            boundary: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"token">;
+                token: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"revision">;
+                revision: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"digest">;
+                digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"messages">;
+                messageIds: z.ZodArray<z.ZodString>;
+                digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            }, z.core.$strict>], "kind">;
+            observedAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    controlRef: z.ZodObject<{
+        runId: z.ZodString;
+        provider: z.ZodString;
+        environmentId: z.ZodString;
+        sessionId: z.ZodString;
+        executionId: z.ZodString;
+        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AgentNativeContextContinuationAdmission = z.infer<typeof AgentNativeContextContinuationAdmissionSchema>;
+/** Cross-check one early admission against its exact continuation request. */
+export declare function agentNativeContextContinuationAdmissionMatchesRequest(request: NativeContextContinuationRequest, admission: AgentNativeContextContinuationAdmission): boolean;
 /** Runtime-only controls kept outside the digest-bound user turn. */
 export interface AgentNativeContextContinuationOptions {
     turn: NativeContextContinuationTurn;
     timeoutMs?: number;
     signal?: AbortSignal;
+    /**
+     * Receives the exact new run identity after durable admission and before the
+     * provider waits for terminal output. Providers call this once only when
+     * `nativeContinuation.admissionControl` is true.
+     */
+    onAdmission?: (controlRef: AgentExactRunControlRef) => void;
 }
 /** Cross-check a successful native continuation against its retained session. */
 export declare function agentNativeContextContinuationResultMatchesRequest(request: NativeContextContinuationRequest, outcome: AgentNativeContextContinuationResult): boolean;
@@ -638,8 +687,8 @@ export interface AgentSession {
  */
 export type AgentEnvironmentCreation = "created" | "replayed";
 export declare const AgentEnvironmentCreationSchema: z.ZodEnum<{
-    replayed: "replayed";
     created: "created";
+    replayed: "replayed";
 }>;
 export interface AgentEnvironment {
     readonly id: string;
@@ -751,6 +800,14 @@ export interface AgentEnvironmentCapabilities {
     nativeContinuation?: {
         atomicBoundary: boolean;
         requestIdempotency: boolean;
+        /** The provider exposes the exact continued run before terminal output. */
+        admissionControl?: boolean;
+    };
+    /** Present only when fresh-session portable context transfer is durable. */
+    contextTransfer?: {
+        freshSession: boolean;
+        requestIdempotency: boolean;
+        lookup: boolean;
     };
     /** Absent when the provider cannot originate or answer interactions. */
     interactions?: InteractionCapabilities;
@@ -859,20 +916,26 @@ export declare const AgentEnvironmentCapabilitiesSchema: z.ZodObject<{
     nativeContinuation: z.ZodOptional<z.ZodObject<{
         atomicBoundary: z.ZodBoolean;
         requestIdempotency: z.ZodBoolean;
+        admissionControl: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    contextTransfer: z.ZodOptional<z.ZodObject<{
+        freshSession: z.ZodBoolean;
+        requestIdempotency: z.ZodBoolean;
+        lookup: z.ZodBoolean;
     }, z.core.$strict>>;
     interactions: z.ZodOptional<z.ZodObject<{
         kinds: z.ZodArray<z.ZodString>;
         answerFieldTypes: z.ZodArray<z.ZodEnum<{
-            number: "number";
             boolean: "boolean";
-            text: "text";
-            select: "select";
+            number: "number";
             secret: "secret";
+            select: "select";
+            text: "text";
         }>>;
         responseScopes: z.ZodArray<z.ZodEnum<{
             interaction: "interaction";
-            session: "session";
             persistent: "persistent";
+            session: "session";
         }>>;
         secretAnswers: z.ZodBoolean;
         concurrentRequests: z.ZodBoolean;
@@ -934,6 +997,8 @@ export declare const AgentEnvironmentCapabilitiesSchema: z.ZodObject<{
 }, z.core.$strict>;
 export interface CreateAgentEnvironmentInput {
     profile: AgentProfileRef;
+    /** Exact caller-owned id required by an accepted destination contract. */
+    requestedId?: string;
     /** Agent backend inside the provider, for example "opencode" or "codex". */
     backend?: string;
     workspace?: WorkspaceRequest;
@@ -997,6 +1062,8 @@ export declare function createAgentEnvironmentWithIdempotency<T extends object>(
 export interface AgentEnvironmentProvider {
     readonly name: string;
     readonly exactProcess?: AgentExactProcessProvider;
+    /** Durable fresh-session portable context admission, when supported. */
+    readonly contextTransfer?: AgentContextTransferProvider;
     /**
      * Reconstruct a source-scoped branching handle after a coordinator restart.
      *
@@ -1023,3 +1090,12 @@ export interface AgentEnvironmentProvider {
         signal?: AbortSignal;
     }): Promise<AgentEnvironmentSummary[]>;
 }
+/** Provider-owned portable context admission with retry-safe lookup. */
+export interface AgentContextTransferProvider {
+    transfer(request: ContextTransferRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<ContextTransferResult>;
+    lookup(request: ContextTransferRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<ContextTransferResult | undefined>;
+}

package/dist/environment-runtime.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { canonicalCandidateDigest } from "./agent-candidate-schema-common.js";
 import { InteractionCapabilitiesSchema, RequestedInteractionsSchema } from "./interaction.js";
-import { ContextTransferReceiptSchema, ContextTransferRequestSchema, NativeContextContinuationAcknowledgementSchema, NativeContextContinuationRequestSchema, nativeContextContinuationAcknowledgementMatches } from "./portable-context.js";
+import { ContextTransferReceiptSchema, ContextTransferRequestSchema, NativeContextBoundaryProofSchema, NativeContextContinuationAcknowledgementSchema, NativeContextContinuationRequestSchema, nativeContextContinuationAcknowledgementMatches } from "./portable-context.js";
 import { AgentExactRunControlRefSchema, AgentRunControlRefSchema, CanonicalStreamEventSchema } from "./runtime-control.js";
 import { AgentProfileCapabilitiesSchema } from "./environment-profile-capabilities.js";
 import { boundedIdentifierSchema, boundedJsonRecordSchema, boundedJsonSchema, boundedStringSchema, CONTRACT_MAX_ARRAY_LENGTH } from "./contract-limits.js";
@@ -92,6 +92,49 @@ export const AgentNativeContextContinuationResultSchema = z.union([
         }
     }),
 ]);
+/** Exact continued-run identity returned after durable admission. */
+export const AgentNativeContextContinuationAdmissionSchema = z
+    .strictObject({
+    phase: z.literal("admitted"),
+    acknowledgement: z.strictObject({
+        operationId: boundedIdentifierSchema,
+        requestDigest: AgentExactRunControlRefSchema.shape.requestDigest,
+        historyMessagesSent: z.literal(0),
+        actualBoundary: NativeContextBoundaryProofSchema,
+    }),
+    controlRef: AgentExactRunControlRefSchema,
+})
+    .superRefine((admission, refinement) => {
+    const source = admission.acknowledgement.actualBoundary;
+    const current = admission.controlRef;
+    if (source.provider !== current.provider ||
+        source.environmentId !== current.environmentId ||
+        source.sessionId !== current.sessionId) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["controlRef"],
+            message: "native continuation admission must stay in the retained session",
+        });
+    }
+});
+/** Cross-check one early admission against its exact continuation request. */
+export function agentNativeContextContinuationAdmissionMatchesRequest(request, admission) {
+    const parsedRequest = NativeContextContinuationRequestSchema.safeParse(request);
+    const parsedAdmission = AgentNativeContextContinuationAdmissionSchema.safeParse(admission);
+    if (!parsedRequest.success || !parsedAdmission.success)
+        return false;
+    const expected = parsedRequest.data;
+    const actual = parsedAdmission.data;
+    const boundary = actual.acknowledgement.actualBoundary;
+    return (actual.acknowledgement.operationId === expected.operationId &&
+        actual.acknowledgement.requestDigest === expected.requestDigest &&
+        boundary.runId === expected.run.runId &&
+        boundary.provider === expected.run.provider &&
+        boundary.environmentId === expected.run.environmentId &&
+        boundary.sessionId === expected.run.sessionId &&
+        boundary.executionId === expected.run.executionId &&
+        boundary.requestDigest === expected.run.requestDigest);
+}
 /** Cross-check a successful native continuation against its retained session. */
 export function agentNativeContextContinuationResultMatchesRequest(request, outcome) {
     const parsedRequest = NativeContextContinuationRequestSchema.safeParse(request);
@@ -144,6 +187,14 @@ export const AgentEnvironmentCapabilitiesSchema = z
         .strictObject({
         atomicBoundary: z.boolean(),
         requestIdempotency: z.boolean(),
+        admissionControl: z.boolean().optional(),
+    })
+        .optional(),
+    contextTransfer: z
+        .strictObject({
+        freshSession: z.boolean(),
+        requestIdempotency: z.boolean(),
+        lookup: z.boolean(),
     })
         .optional(),
     interactions: InteractionCapabilitiesSchema.optional(),
@@ -234,6 +285,24 @@ export const AgentEnvironmentCapabilitiesSchema = z
             message: "native continuation requires session continuation, atomic boundary admission, and request idempotency together",
         });
     }
+    if (capabilities.nativeContinuation?.admissionControl === true &&
+        capabilities.retainedControl === undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["nativeContinuation", "admissionControl"],
+            message: "native continuation requires retained control for early admission",
+        });
+    }
+    if (capabilities.contextTransfer !== undefined &&
+        (!capabilities.contextTransfer.freshSession ||
+            !capabilities.contextTransfer.requestIdempotency ||
+            !capabilities.contextTransfer.lookup)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["contextTransfer"],
+            message: "context transfer requires fresh-session admission, request idempotency, and lookup together",
+        });
+    }
     const durableBranching = [
         capabilities.branching.retrySafe ?? false,
         capabilities.branching.lookup ?? false,

package/dist/harness.d.ts

@@ -23,20 +23,20 @@ import { z } from "zod";
 export type HarnessType = "claude-code" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "pi" | "prime" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "forge" | "cursor" | "acp" | "cli-base";
 /** Runtime validator for {@link HarnessType}. Kept in lockstep with the type by the drift guard below. */
 export declare const harnessTypeSchema: z.ZodEnum<{
+    acp: "acp";
+    amp: "amp";
     "claude-code": "claude-code";
-    nanoclaw: "nanoclaw";
+    "cli-base": "cli-base";
     codex: "codex";
-    opencode: "opencode";
-    "kimi-code": "kimi-code";
-    pi: "pi";
-    prime: "prime";
+    cursor: "cursor";
+    "factory-droids": "factory-droids";
+    forge: "forge";
     gemini: "gemini";
     hermes: "hermes";
+    "kimi-code": "kimi-code";
+    nanoclaw: "nanoclaw";
     openclaw: "openclaw";
-    amp: "amp";
-    "factory-droids": "factory-droids";
-    forge: "forge";
-    cursor: "cursor";
-    acp: "acp";
-    "cli-base": "cli-base";
+    opencode: "opencode";
+    pi: "pi";
+    prime: "prime";
 }>;