@tangle-network/agent-interface 1.8.0 → 2.0.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-provider.d.ts

@@ -5,3 +5,4 @@ export * from "./environment-observation.js";
 export * from "./environment-terminal.js";
 export * from "./environment-runtime.js";
 export * from "./environment-command-turn.js";
+export * from "./workspace-cwd.js";

package/dist/environment-provider.js

@@ -5,3 +5,4 @@ export * from "./environment-observation.js";
 export * from "./environment-terminal.js";
 export * from "./environment-runtime.js";
 export * from "./environment-command-turn.js";
+export * from "./workspace-cwd.js";

package/dist/environment-requests.d.ts

@@ -1,3 +1,5 @@
+import { z } from "zod";
+import type { WorkspaceCwd } from "./workspace-cwd.js";
 import type { AgentProfile } from "./agent-profile.js";
 /** Portable profile reference: inline profile or provider catalog id. */
 export type AgentProfileRef = AgentProfile | string;
@@ -12,11 +14,29 @@ export interface WorkspaceRequest {
     repoUrl?: string;
     /** Git ref for {@link repoUrl}. */
     gitRef?: string;
-    /** Initial working directory inside the environment. */
-    cwd?: string;
+    /**
+     * Explicitly based working directory inside the environment or on the host.
+     * Repository paths use `base: "repository"`; host paths use `base: "host"`.
+     */
+    cwd?: WorkspaceCwd;
     /** Opaque provider-native workspace fields. */
     providerOptions?: Record<string, unknown>;
 }
+/** Runtime contract for the portable workspace request carried by providers. */
+export declare const WorkspaceRequestSchema: z.ZodObject<{
+    environment: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+    repoUrl: z.ZodOptional<z.ZodString>;
+    gitRef: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        base: z.ZodLiteral<"repository">;
+        path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        base: z.ZodLiteral<"host">;
+        path: z.ZodString;
+    }, z.core.$strict>], "base">>;
+    providerOptions: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+}, z.core.$strict>;
 export interface ResourceRequest {
     cpu?: number;
     memoryMb?: number;

package/dist/environment-requests.js

@@ -1 +1,29 @@
-export {};
+import { z } from "zod";
+import { boundedIdentifierSchema, boundedJsonRecordSchema, boundedStringSchema, } from "./contract-limits.js";
+import { workspaceCwdSchema } from "./workspace-cwd.js";
+/** Runtime contract for the portable workspace request carried by providers. */
+export const WorkspaceRequestSchema = z
+    .strictObject({
+    environment: boundedIdentifierSchema.optional(),
+    image: boundedStringSchema.min(1).optional(),
+    repoUrl: boundedStringSchema.min(1).optional(),
+    gitRef: boundedIdentifierSchema.optional(),
+    cwd: workspaceCwdSchema.optional(),
+    providerOptions: boundedJsonRecordSchema.optional(),
+})
+    .superRefine((workspace, refinement) => {
+    if (workspace.environment !== undefined && workspace.image !== undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["image"],
+            message: "workspace cannot specify both environment and image",
+        });
+    }
+    if (workspace.gitRef !== undefined && workspace.repoUrl === undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["gitRef"],
+            message: "workspace gitRef requires repoUrl",
+        });
+    }
+});

package/dist/environment-runtime.d.ts

@@ -5,7 +5,7 @@ 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 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";
@@ -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,11 +561,11 @@ 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>]>;
@@ -687,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;
@@ -803,6 +803,12 @@ export interface AgentEnvironmentCapabilities {
         /** 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;
     workspace: {
@@ -812,6 +818,11 @@ export interface AgentEnvironmentCapabilities {
         git: boolean;
         upload: boolean;
         download: boolean;
+        /** Path bases accepted by the provider's workspace create contract. */
+        cwdBases?: {
+            repository: boolean;
+            host: boolean;
+        };
     };
     branching: {
         checkpoint: boolean;
@@ -912,19 +923,24 @@ export declare const AgentEnvironmentCapabilitiesSchema: z.ZodObject<{
         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;
@@ -938,6 +954,10 @@ export declare const AgentEnvironmentCapabilitiesSchema: z.ZodObject<{
         git: z.ZodBoolean;
         upload: z.ZodBoolean;
         download: z.ZodBoolean;
+        cwdBases: z.ZodOptional<z.ZodObject<{
+            repository: z.ZodBoolean;
+            host: z.ZodBoolean;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
     branching: z.ZodObject<{
         checkpoint: z.ZodBoolean;
@@ -986,6 +1006,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;
@@ -1049,6 +1071,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.
      *
@@ -1075,3 +1099,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

@@ -190,6 +190,13 @@ export const AgentEnvironmentCapabilitiesSchema = z
         admissionControl: z.boolean().optional(),
     })
         .optional(),
+    contextTransfer: z
+        .strictObject({
+        freshSession: z.boolean(),
+        requestIdempotency: z.boolean(),
+        lookup: z.boolean(),
+    })
+        .optional(),
     interactions: InteractionCapabilitiesSchema.optional(),
     workspace: z.strictObject({
         read: z.boolean(),
@@ -198,6 +205,12 @@ export const AgentEnvironmentCapabilitiesSchema = z
         git: z.boolean(),
         upload: z.boolean(),
         download: z.boolean(),
+        cwdBases: z
+            .strictObject({
+            repository: z.boolean(),
+            host: z.boolean(),
+        })
+            .optional(),
     }),
     branching: z.strictObject({
         checkpoint: z.boolean(),
@@ -286,6 +299,16 @@ export const AgentEnvironmentCapabilitiesSchema = z
             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";
 }>;