@adea-ai/runtime-sdk 1.23.0 → 2.0.0

package/README.md

@@ -1,13 +1,11 @@
 # @control-plane/runtime-sdk
 
 SDK for building runtimes that plug into the Control Plane: implement the
-adapter interface, declare capabilities, pass conformance, and speak the
-gateway protocol — without touching Control Plane internals.
+adapter interface, declare capabilities, and pass conformance — without
+touching Control Plane internals.
 
 Depends only on [`@adea-ai/contracts`](https://www.npmjs.com/package/@adea-ai/contracts)
-and Zod. Pair it with
-[`@adea-ai/runtime-gateway-protocol`](https://www.npmjs.com/package/@adea-ai/runtime-gateway-protocol)
-for the wire protocol and [`@adea-ai/contracts`](https://www.npmjs.com/package/@adea-ai/contracts)
+and Zod. Pair it with [`@adea-ai/contracts`](https://www.npmjs.com/package/@adea-ai/contracts)
 for the service boundary.
 
 ## What's inside
@@ -20,8 +18,8 @@ for the service boundary.
 - **Conformance & compatibility** — versioned conformance suites and
   compatibility checks for runtime implementations.
 - **Sessions & routing** — external session types and routing decisions.
-- **Transport** — transport ports with deterministic in-memory doubles
-  (`mock.ts`, `fixtures.ts`) for testing adapters without a live gateway.
+- **Transport** — the co-located transport port with deterministic in-memory
+  doubles (`mock.ts`, `fixtures.ts`) for testing adapters.
 
 Runtime usage accounting distinguishes HQ-funded API usage (`hq_managed`),
 user-funded API usage (`byo_api`), and external subscriptions

package/dist/adapter.d.ts

@@ -12,7 +12,6 @@ export declare const RuntimeAdapterMetadataSchema: z.ZodObject<{
     harnessVersion: z.ZodString;
     transportKind: z.ZodOptional<z.ZodEnum<{
         "direct-local": "direct-local";
-        "remote-gateway": "remote-gateway";
     }>>;
 }, z.core.$strict>;
 export declare const RuntimeAdapterInspectionSchema: z.ZodObject<{
@@ -28,7 +27,6 @@ export declare const RuntimeAdapterInspectionSchema: z.ZodObject<{
         harnessVersion: z.ZodString;
         transportKind: z.ZodOptional<z.ZodEnum<{
             "direct-local": "direct-local";
-            "remote-gateway": "remote-gateway";
         }>>;
     }, z.core.$strict>;
     health: z.ZodEnum<{

package/dist/adapter.js

@@ -23,7 +23,7 @@ export const RuntimeAdapterMetadataSchema = z
         .regex(/^[a-z][a-z0-9-]*$/),
     driverVersion: SemanticVersionSchema,
     harnessVersion: SemanticVersionSchema,
-    transportKind: z.enum(['direct-local', 'remote-gateway']).optional(),
+    transportKind: z.enum(['direct-local']).optional(),
 })
     .strict();
 const CapabilityEvaluationSchema = z

package/dist/channel-ownership.d.ts

@@ -13,10 +13,6 @@ export declare const RuntimeChannelOwnershipSchema: z.ZodObject<{
     lastHeartbeatAt: z.ZodISODateTime;
 }, z.core.$strict>;
 export type RuntimeChannelOwnership = z.output<typeof RuntimeChannelOwnershipSchema>;
-export interface RuntimeChannelOwnershipCredentialFence {
-    readonly credentialId: string;
-    readonly revocationVersion: number;
-}
 export declare const RuntimeChannelSequenceRequestSchema: z.ZodObject<{
     channel: z.ZodObject<{
         nodeId: z.ZodString;
@@ -38,12 +34,3 @@ export type RuntimeChannelSequenceRequest = z.output<typeof RuntimeChannelSequen
 export interface RuntimeChannelSequenceRepository {
     reserve(request: RuntimeChannelSequenceRequest): Promise<number>;
 }
-export interface RuntimeChannelOwnershipRepository {
-    claim(record: RuntimeChannelOwnership, credentialFence?: RuntimeChannelOwnershipCredentialFence): Promise<{
-        accepted: boolean;
-        previous?: RuntimeChannelOwnership;
-    }>;
-    lookup(nodeId: string): Promise<RuntimeChannelOwnership | undefined>;
-    heartbeat(record: RuntimeChannelOwnership, credentialFence?: RuntimeChannelOwnershipCredentialFence): Promise<boolean>;
-    release(record: RuntimeChannelOwnership): Promise<boolean>;
-}

package/dist/compatibility.d.ts

@@ -13,7 +13,6 @@ export declare const RuntimeCertificationSchema: z.ZodObject<{
     runtimeFamily: z.ZodString;
     connectionType: z.ZodEnum<{
         external_local: "external_local";
-        managed_cloud: "managed_cloud";
         managed_local: "managed_local";
     }>;
     classification: z.ZodEnum<{
@@ -67,7 +66,6 @@ export declare const RuntimeCertificationSchema: z.ZodObject<{
             x64: "x64";
         }>;
         location: z.ZodEnum<{
-            agent_hq_cloud: "agent_hq_cloud";
             local_device: "local_device";
         }>;
         environment: z.ZodString;
@@ -78,7 +76,6 @@ export declare const RuntimeCertificationSchema: z.ZodObject<{
             "direct-local-transport-integration": "direct-local-transport-integration";
             "hosted-runtime-integration": "hosted-runtime-integration";
             "runtime-adapter-conformance": "runtime-adapter-conformance";
-            "runtime-gateway-integration": "runtime-gateway-integration";
         }>;
         source: z.ZodString;
         command: z.ZodString;
@@ -101,7 +98,6 @@ export declare const RuntimeCompatibilityMatrixSchema: z.ZodObject<{
         runtimeFamily: z.ZodString;
         connectionType: z.ZodEnum<{
             external_local: "external_local";
-            managed_cloud: "managed_cloud";
             managed_local: "managed_local";
         }>;
         classification: z.ZodEnum<{
@@ -155,7 +151,6 @@ export declare const RuntimeCompatibilityMatrixSchema: z.ZodObject<{
                 x64: "x64";
             }>;
             location: z.ZodEnum<{
-                agent_hq_cloud: "agent_hq_cloud";
                 local_device: "local_device";
             }>;
             environment: z.ZodString;
@@ -166,7 +161,6 @@ export declare const RuntimeCompatibilityMatrixSchema: z.ZodObject<{
                 "direct-local-transport-integration": "direct-local-transport-integration";
                 "hosted-runtime-integration": "hosted-runtime-integration";
                 "runtime-adapter-conformance": "runtime-adapter-conformance";
-                "runtime-gateway-integration": "runtime-gateway-integration";
             }>;
             source: z.ZodString;
             command: z.ZodString;

package/dist/compatibility.js

@@ -54,7 +54,6 @@ export const RuntimeCertificationSchema = z
         suite: z.enum([
             'runtime-adapter-conformance',
             'direct-local-transport-integration',
-            'runtime-gateway-integration',
             'hosted-runtime-integration',
         ]),
         source: z
@@ -73,7 +72,8 @@ export const RuntimeCertificationSchema = z
     .superRefine((certification, context) => {
     if (certification.classification === 'supported' &&
         (!certification.evidence.some((entry) => entry.suite === 'runtime-adapter-conformance') ||
-            !certification.evidence.some((entry) => ['direct-local-transport-integration', 'runtime-gateway-integration'].includes(entry.suite) || entry.suite === 'hosted-runtime-integration'))) {
+            !certification.evidence.some((entry) => entry.suite === 'direct-local-transport-integration' ||
+                entry.suite === 'hosted-runtime-integration'))) {
         context.addIssue({
             code: 'custom',
             path: ['evidence'],

package/dist/discovery.d.ts

@@ -6,7 +6,7 @@ export interface RuntimeConnectionDiscoveryProjectionInput {
     readonly connection: RuntimeConnection;
     readonly family: string;
     readonly node?: unknown;
-    readonly nodeHealth: 'online' | 'offline' | 'unknown' | 'revoked' | 'not_applicable';
+    readonly nodeHealth: 'online' | 'offline' | 'unknown' | 'revoked';
     readonly evaluatedAt: string;
     readonly localProjectGrant: {
         readonly required: boolean;

package/dist/discovery.js

@@ -7,15 +7,12 @@ import { ExternalSessionAssessmentSchema, ExternalSessionSchema, } from './sessi
 export function projectRuntimeConnectionDiscovery(inputValue) {
     const connection = RuntimeConnectionSchema.parse(inputValue.connection);
     const evaluatedAt = RuntimeTimestampSchema.parse(inputValue.evaluatedAt);
-    const nodeHealth = inputValue.nodeHealth === 'not_applicable'
-        ? 'not_applicable'
-        : RuntimeNodeHealthStatusSchema.parse(inputValue.nodeHealth);
+    const nodeHealth = RuntimeNodeHealthStatusSchema.parse(inputValue.nodeHealth);
     const node = inputValue.node === undefined ? undefined : RuntimeNodeRefSchema.parse(inputValue.node);
-    const local = connection.connectionType !== 'managed_cloud';
-    if (local !== (node !== undefined) || local !== (nodeHealth !== 'not_applicable')) {
+    if (node === undefined) {
         throw new Error('RUNTIME_DISCOVERY_NODE_SCOPE_MISMATCH');
     }
-    if (node && node.runtimeNodeRefId !== connection.runtimeNodeRefId) {
+    if (node.runtimeNodeRefId !== connection.runtimeNodeRefId) {
         throw new Error('RUNTIME_DISCOVERY_NODE_ID_MISMATCH');
     }
     const requiredCapabilities = (inputValue.requiredCapabilities ?? []).map((capability) => RuntimeCapabilityNameSchema.parse(capability));

package/dist/eligibility.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
-export declare const RuntimeEligibilityNodeStatusSchema: z.ZodUnion<readonly [z.ZodEnum<{
+export declare const RuntimeEligibilityNodeStatusSchema: z.ZodEnum<{
     offline: "offline";
     online: "online";
     revoked: "revoked";
     unknown: "unknown";
-}>, z.ZodLiteral<"not_applicable">]>;
+}>;
 export declare const RuntimeEligibilityInputSchema: z.ZodObject<{
     eligibilityVersion: z.ZodLiteral<1>;
     evaluatedAt: z.ZodISODateTime;
@@ -47,24 +47,22 @@ export declare const RuntimeEligibilityInputSchema: z.ZodObject<{
     }, z.core.$strict>;
     candidate: z.ZodObject<{
         family: z.ZodString;
-        nodeStatus: z.ZodUnion<readonly [z.ZodEnum<{
+        nodeStatus: z.ZodEnum<{
             offline: "offline";
             online: "online";
             revoked: "revoked";
             unknown: "unknown";
-        }>, z.ZodLiteral<"not_applicable">]>;
+        }>;
         connection: z.ZodObject<{
             runtimeConnectionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-connection ID">, string>>;
             identityDigest: z.ZodString;
             connectionType: z.ZodEnum<{
                 external_local: "external_local";
-                managed_cloud: "managed_cloud";
                 managed_local: "managed_local";
             }>;
             runtimeNodeRefId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-node reference ID">, string>>>;
             runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-definition ID">, string>>;
             location: z.ZodEnum<{
-                agent_hq_cloud: "agent_hq_cloud";
                 local_device: "local_device";
             }>;
             opaqueNativeRef: z.ZodOptional<z.ZodString>;
@@ -164,7 +162,6 @@ export declare const RuntimeEligibilityInputSchema: z.ZodObject<{
         }, z.core.$strict>;
         allowedFamilies: z.ZodArray<z.ZodString>;
         allowedLocations: z.ZodArray<z.ZodEnum<{
-            agent_hq_cloud: "agent_hq_cloud";
             local_device: "local_device";
         }>>;
         deniedRuntimeConnectionIds: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-connection ID">, string>>>;

package/dist/eligibility.js

@@ -16,10 +16,7 @@ const PolicyReasonCodeSchema = z
     .min(1)
     .max(128)
     .regex(/^[A-Z][A-Z0-9_]*$/);
-export const RuntimeEligibilityNodeStatusSchema = z.union([
-    RuntimeNodeHealthStatusSchema,
-    z.literal('not_applicable'),
-]);
+export const RuntimeEligibilityNodeStatusSchema = RuntimeNodeHealthStatusSchema;
 export const RuntimeEligibilityInputSchema = z
     .object({
     eligibilityVersion: z.literal(1),
@@ -85,17 +82,7 @@ export const RuntimeEligibilityInputSchema = z
         .strict()
         .optional(),
 })
-    .strict()
-    .superRefine((input, context) => {
-    const managedCloud = input.candidate.connection.connectionType === 'managed_cloud';
-    if (managedCloud !== (input.candidate.nodeStatus === 'not_applicable')) {
-        context.addIssue({
-            code: 'custom',
-            path: ['candidate', 'nodeStatus'],
-            message: 'Managed-cloud candidates must not invent RuntimeNode health',
-        });
-    }
-});
+    .strict();
 export const RuntimeEligibilityReasonCodeSchema = z.enum([
     'CAPABILITY_SNAPSHOT_MISSING',
     'CAPABILITY_SNAPSHOT_STALE',

package/dist/fixtures.d.ts

@@ -5,7 +5,7 @@ export declare const RuntimeFixtures: Readonly<{
         adapterVersion: string;
         driverVersion: string;
         harnessVersion: string;
-        location: "agent_hq_cloud" | "local_device" | "remote_host";
+        location: "local_device";
         health: "degraded" | "healthy" | "unavailable";
         lifecycle: "active" | "deprecated" | "revoked";
         capabilities: {
@@ -34,7 +34,7 @@ export declare const RuntimeFixtures: Readonly<{
         adapterVersion: string;
         driverVersion: string;
         harnessVersion: string;
-        location: "agent_hq_cloud" | "local_device" | "remote_host";
+        location: "local_device";
         health: "degraded" | "healthy" | "unavailable";
         lifecycle: "active" | "deprecated" | "revoked";
         capabilities: {
@@ -63,7 +63,7 @@ export declare const RuntimeFixtures: Readonly<{
         adapterVersion: string;
         driverVersion: string;
         harnessVersion: string;
-        location: "agent_hq_cloud" | "local_device" | "remote_host";
+        location: "local_device";
         health: "degraded" | "healthy" | "unavailable";
         lifecycle: "active" | "deprecated" | "revoked";
         capabilities: {

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from './adapter.js';
 export * from './pi-durable-lead.js';
 export * from './pi-durable-questions.js';
+export * from './pi-durable-approvals.js';
 export * from './agent-plugins.js';
 export * from './channel-ownership.js';
 export * from './capabilities.js';

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from './adapter.js';
 export * from './pi-durable-lead.js';
 export * from './pi-durable-questions.js';
+export * from './pi-durable-approvals.js';
 export * from './agent-plugins.js';
 export * from './channel-ownership.js';
 export * from './capabilities.js';

package/dist/models.d.ts

@@ -3,9 +3,7 @@ import { type CapabilityRequirement } from './capabilities.js';
 export declare const RuntimeTimestampSchema: z.ZodISODateTime;
 export declare const RuntimeSemanticVersionSchema: z.ZodString;
 export declare const RuntimeLocationSchema: z.ZodEnum<{
-    agent_hq_cloud: "agent_hq_cloud";
     local_device: "local_device";
-    remote_host: "remote_host";
 }>;
 export declare const RuntimeHealthSchema: z.ZodEnum<{
     degraded: "degraded";
@@ -42,9 +40,7 @@ export declare const RuntimeDefinitionSchema: z.ZodObject<{
     driverVersion: z.ZodString;
     harnessVersion: z.ZodString;
     location: z.ZodEnum<{
-        agent_hq_cloud: "agent_hq_cloud";
         local_device: "local_device";
-        remote_host: "remote_host";
     }>;
     health: z.ZodEnum<{
         degraded: "degraded";
@@ -112,9 +108,7 @@ export declare const RuntimeNodeRefSchema: z.ZodObject<{
     authority: z.ZodLiteral<"agent_hq">;
     displayName: z.ZodString;
     location: z.ZodEnum<{
-        agent_hq_cloud: "agent_hq_cloud";
         local_device: "local_device";
-        remote_host: "remote_host";
     }>;
     status: z.ZodEnum<{
         offline: "offline";
@@ -124,12 +118,10 @@ export declare const RuntimeNodeRefSchema: z.ZodObject<{
     observedAt: z.ZodISODateTime;
 }, z.core.$strip>;
 export declare const RuntimeConnectionLocationSchema: z.ZodEnum<{
-    agent_hq_cloud: "agent_hq_cloud";
     local_device: "local_device";
 }>;
 export declare const RuntimeConnectionTypeSchema: z.ZodEnum<{
     external_local: "external_local";
-    managed_cloud: "managed_cloud";
     managed_local: "managed_local";
 }>;
 export declare const RuntimeConnectionStatusSchema: z.ZodEnum<{
@@ -172,13 +164,11 @@ export declare const RuntimeConnectionSchema: z.ZodObject<{
     identityDigest: z.ZodString;
     connectionType: z.ZodEnum<{
         external_local: "external_local";
-        managed_cloud: "managed_cloud";
         managed_local: "managed_local";
     }>;
     runtimeNodeRefId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-node reference ID">, string>>>;
     runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-definition ID">, string>>;
     location: z.ZodEnum<{
-        agent_hq_cloud: "agent_hq_cloud";
         local_device: "local_device";
     }>;
     opaqueNativeRef: z.ZodOptional<z.ZodString>;

package/dist/models.js

@@ -12,7 +12,7 @@ const RuntimeFamilySchema = z
     .max(64)
     .regex(/^[a-z][a-z0-9-]*$/);
 const uniqueCapabilities = (capabilities) => new Set(capabilities.map((capability) => capability.name)).size === capabilities.length;
-export const RuntimeLocationSchema = z.enum(['local_device', 'remote_host', 'agent_hq_cloud']);
+export const RuntimeLocationSchema = z.enum(['local_device']);
 export const RuntimeHealthSchema = z.enum(['healthy', 'degraded', 'unavailable']);
 export const RuntimeLifecycleSchema = z.enum(['active', 'deprecated', 'revoked']);
 export const RuntimeCompatibilityMetadataSchema = z.object({
@@ -46,12 +46,8 @@ export const RuntimeNodeRefSchema = z.object({
     status: z.enum(['online', 'offline', 'revoked']),
     observedAt: RuntimeTimestampSchema,
 });
-export const RuntimeConnectionLocationSchema = z.enum(['local_device', 'agent_hq_cloud']);
-export const RuntimeConnectionTypeSchema = z.enum([
-    'managed_cloud',
-    'managed_local',
-    'external_local',
-]);
+export const RuntimeConnectionLocationSchema = z.enum(['local_device']);
+export const RuntimeConnectionTypeSchema = z.enum(['managed_local', 'external_local']);
 export const RuntimeConnectionStatusSchema = z.enum([
     'connected',
     'degraded',
@@ -127,13 +123,8 @@ export const RuntimeConnectionSchema = z
 })
     .strict()
     .superRefine((connection, context) => {
-    const local = connection.connectionType !== 'managed_cloud';
-    if (local !== (connection.runtimeNodeRefId !== undefined)) {
-        context.addIssue({ code: 'custom', message: 'Only local connections require a RuntimeNode' });
-    }
-    const expectedLocation = local ? 'local_device' : 'agent_hq_cloud';
-    if (connection.location !== expectedLocation) {
-        context.addIssue({ code: 'custom', message: 'Connection type and location must agree' });
+    if (connection.runtimeNodeRefId === undefined) {
+        context.addIssue({ code: 'custom', message: 'A connection requires a RuntimeNode' });
     }
     const unavailable = ['unavailable', 'disconnected', 'expired', 'revoked'].includes(connection.status);
     if (unavailable !== (connection.health === 'unavailable')) {

package/dist/pi-durable-approvals.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { IdentifierSchemas } from '@adea-ai/contracts';
+export declare const PiDurableApprovalEffectDigestSchema: z.ZodString;
+export declare const PiDurableApprovalDecisionIdSchema: z.ZodString;
+export declare const PiDurableApprovalAnswerSchema: z.ZodObject<{
+    dispatchId: z.ZodString;
+    approvalId: typeof IdentifierSchemas.interactionId;
+    effectDigest: z.ZodString;
+    decision: z.ZodEnum<{
+        approve: "approve";
+        deny: "deny";
+    }>;
+    decisionId: z.ZodString;
+}, z.core.$strict>;
+export declare const PiDurableApprovalAttestationSchema: z.ZodObject<{
+    decidedBy: z.ZodString;
+    senderKeyId: z.ZodString;
+    keyringRevision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const PiDurableApprovalDecisionSchema: z.ZodObject<{
+    decidedBy: z.ZodString;
+    senderKeyId: z.ZodString;
+    keyringRevision: z.ZodNumber;
+    schemaVersion: z.ZodLiteral<"pi-lead-approval-decision/v1">;
+    workspaceId: typeof IdentifierSchemas.workspaceId;
+    dispatchId: z.ZodString;
+    executionId: typeof IdentifierSchemas.executionId;
+    attemptId: typeof IdentifierSchemas.attemptId;
+    approvalId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"interaction ID">, string>>;
+    effectDigest: z.ZodString;
+    decision: z.ZodEnum<{
+        approve: "approve";
+        deny: "deny";
+    }>;
+    decisionId: z.ZodString;
+    decidedAt: z.ZodISODateTime;
+    deadlineAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type PiDurableApprovalAnswer = z.output<typeof PiDurableApprovalAnswerSchema>;
+export type PiDurableApprovalAttestation = z.output<typeof PiDurableApprovalAttestationSchema>;
+export type PiDurableApprovalDecision = z.output<typeof PiDurableApprovalDecisionSchema>;
+export interface PiDurableApprovalDecisionAuthority {
+    readonly principalId: string;
+    authorize(decision: PiDurableApprovalDecision): Promise<boolean>;
+    publish?(decision: PiDurableApprovalDecision): Promise<void>;
+}
+export declare function samePiDurableApprovalDecision(left: PiDurableApprovalDecision, right: PiDurableApprovalDecision): boolean;

package/dist/pi-durable-approvals.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { canonicalJsonStringify, IdentifierSchemas } from '@adea-ai/contracts';
+export const PiDurableApprovalEffectDigestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+export const PiDurableApprovalDecisionIdSchema = z.string().regex(/^pi-decision:[a-f0-9]{32}$/);
+const Reference = z
+    .string()
+    .min(1)
+    .max(256)
+    .regex(/^[A-Za-z0-9._:-]+$/);
+export const PiDurableApprovalAnswerSchema = z.strictObject({
+    dispatchId: z.string().regex(/^dispatch_[a-f0-9]{32}$/),
+    approvalId: IdentifierSchemas.interactionId,
+    effectDigest: PiDurableApprovalEffectDigestSchema,
+    decision: z.enum(['approve', 'deny']),
+    decisionId: PiDurableApprovalDecisionIdSchema,
+});
+export const PiDurableApprovalAttestationSchema = z.strictObject({
+    decidedBy: Reference,
+    senderKeyId: Reference,
+    keyringRevision: z.number().int().min(1),
+});
+export const PiDurableApprovalDecisionSchema = z.strictObject({
+    schemaVersion: z.literal('pi-lead-approval-decision/v1'),
+    workspaceId: IdentifierSchemas.workspaceId,
+    dispatchId: PiDurableApprovalAnswerSchema.shape.dispatchId,
+    executionId: IdentifierSchemas.executionId,
+    attemptId: IdentifierSchemas.attemptId,
+    approvalId: PiDurableApprovalAnswerSchema.shape.approvalId,
+    effectDigest: PiDurableApprovalEffectDigestSchema,
+    decision: PiDurableApprovalAnswerSchema.shape.decision,
+    decisionId: PiDurableApprovalDecisionIdSchema,
+    ...PiDurableApprovalAttestationSchema.shape,
+    decidedAt: z.iso.datetime(),
+    deadlineAt: z.iso.datetime(),
+});
+export function samePiDurableApprovalDecision(left, right) {
+    const { decidedAt: _left, ...a } = left;
+    const { decidedAt: _right, ...b } = right;
+    return canonicalJsonStringify(a) === canonicalJsonStringify(b);
+}

package/dist/pi-durable-lead.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { PiDurableQuestionAnswersSchema, PiDurableQuestionRequestIdSchema } from './pi-durable-questions.js';
+import { PiDurableApprovalAnswerSchema, PiDurableApprovalAttestationSchema } from './pi-durable-approvals.js';
 import { IdentifierSchemas, ModelSelectionRefSchema } from '@adea-ai/contracts';
 import { RuntimeExecutionProgressSchema, RuntimeExecutionStatusSchema, RuntimeExecutionStateSchema, RuntimeObservedGenerationSchema } from './adapter.js';
 declare const IntentId: z.ZodUUID;
@@ -159,6 +160,7 @@ export declare const PiDurableLeadProgressRequestSchema: z.ZodObject<{
 export declare const PI_DURABLE_LEAD_EVENTS_CONTRACT_VERSION = 1;
 export declare const PI_DURABLE_LEAD_EVENTS_MAX_PAGE = 256;
 export declare const PI_DURABLE_LEAD_EVENTS_MAX_WAIT_MS = 8000;
+export declare const PiDurableSessionIdSchema: z.ZodString;
 export declare const PiDurableLeadEventsRequestSchema: z.ZodObject<{
     contractVersion: z.ZodObject<{
         major: z.ZodNumber;
@@ -182,7 +184,7 @@ export declare const PiDurableLeadEventsRequestSchema: z.ZodObject<{
 export declare const PiDurableLeadTurnEventSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     eventId: z.ZodString;
-    runtimeSessionId: z.ZodString;
+    runtimeSessionId: typeof PiDurableSessionIdSchema;
     harnessRunId: z.ZodString;
     generation: z.ZodLiteral<1>;
     seq: z.ZodString;
@@ -229,6 +231,44 @@ export declare const PiDurableLeadChildrenRequestSchema: z.ZodObject<{
         limit: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>;
 }, z.core.$strict>;
+export declare const PI_DURABLE_SESSIONS_MAX_PAGE = 256;
+export declare const PiDurableSessionsRequestSchema: z.ZodObject<{
+    contractVersion: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"request ID">, string>>;
+    workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"workspace ID">, string>>;
+    projectId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"project ID">, string>>>;
+    requestedAt: z.ZodISODateTime;
+    caller: typeof Caller;
+    correlation: typeof Correlation;
+    operation: z.ZodLiteral<"pi-durable.lead.sessions">;
+    parameters: z.ZodObject<{
+        runtimeSessionId: z.ZodOptional<typeof PiDurableSessionIdSchema>;
+        after: z.ZodOptional<typeof PiDurableSessionIdSchema>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const PiDurableSessionEventsRequestSchema: z.ZodObject<{
+    contractVersion: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"request ID">, string>>;
+    workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"workspace ID">, string>>;
+    projectId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"project ID">, string>>>;
+    requestedAt: z.ZodISODateTime;
+    caller: typeof Caller;
+    correlation: typeof Correlation;
+    operation: z.ZodLiteral<"pi-durable.lead.session-events">;
+    parameters: z.ZodObject<{
+        runtimeSessionId: typeof PiDurableSessionIdSchema;
+        afterSeq: z.ZodNumber;
+        waitMs: z.ZodNumber;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export declare const PiDurableLeadChildTargetRequestSchema: z.ZodObject<{
     contractVersion: z.ZodObject<{
         major: z.ZodNumber;
@@ -286,6 +326,23 @@ export declare const PiDurableLeadQuestionAnswerRequestSchema: z.ZodObject<{
         answers: typeof PiDurableQuestionAnswersSchema;
     }, z.core.$strict>;
 }, z.core.$strict>;
+export declare const PiDurableLeadApprovalAnswerRequestSchema: z.ZodObject<{
+    contractVersion: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"request ID">, string>>;
+    workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"workspace ID">, string>>;
+    projectId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"project ID">, string>>>;
+    commandId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"command ID">, string>>;
+    idempotencyKey: z.ZodString;
+    payloadHash: z.ZodString;
+    issuedAt: z.ZodISODateTime;
+    caller: typeof Caller;
+    correlation: typeof Correlation;
+    operation: z.ZodLiteral<"pi-durable.lead.approval-answer">;
+    payload: z.ZodObject<typeof PiDurableApprovalAnswerSchema.shape & typeof PiDurableApprovalAttestationSchema.shape, z.core.$strict>;
+}, z.core.$strict>;
 export declare const PiDurableLeadChildCancelRequestSchema: z.ZodObject<{
     contractVersion: z.ZodObject<{
         major: z.ZodNumber;
@@ -560,6 +617,42 @@ export declare const PiDurableLeadQuestionAnswerResponseSchema: z.ZodObject<{
         status: typeof RuntimeExecutionStatusSchema;
     }, z.core.$strict>;
 }, z.core.$strict>;
+export declare const PiDurableLeadApprovalAnswerResponseSchema: z.ZodObject<{
+    contractVersion: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"request ID">, string>>;
+    correlation: z.ZodObject<{
+        traceId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"trace ID">, string>>;
+        causationCommandId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"command ID">, string>>>;
+        parentEventId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"event ID">, string>>>;
+    }, z.core.$strict>;
+    data: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"pi-lead-dispatch/v1">;
+        dispatchId: typeof DispatchId;
+        intentId: typeof IntentId;
+        executionId: typeof IdentifierSchemas.executionId;
+        attemptId: typeof IdentifierSchemas.attemptId;
+        runtimeSessionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"external-session ID">, string>>;
+        requestedTarget: z.ZodOptional<typeof PiDurableLeadRequestedTargetSchema>;
+        observedTarget: z.ZodOptional<typeof PiDurableLeadObservedTargetSchema>;
+        approvalSchemaVersion: z.ZodLiteral<"pi-lead-approval-answer/v1">;
+        approvalId: typeof IdentifierSchemas.interactionId;
+        decisionId: z.ZodString;
+        requestEventId: z.ZodString;
+        decision: z.ZodEnum<{
+            approve: "approve";
+            deny: "deny";
+        }>;
+        outcome: z.ZodEnum<{
+            already_decided: "already_decided";
+            decided: "decided";
+        }>;
+        state: typeof RuntimeExecutionStateSchema;
+        status: typeof RuntimeExecutionStatusSchema;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export declare const PiDurableLeadEventsResponseSchema: z.ZodObject<{
     contractVersion: z.ZodObject<{
         major: z.ZodNumber;
@@ -573,6 +666,56 @@ export declare const PiDurableLeadEventsResponseSchema: z.ZodObject<{
     }, z.core.$strict>;
     data: typeof PiDurableLeadEventsDataSchema;
 }, z.core.$strict>;
+export declare const PiDurableSessionSchema: z.ZodObject<{
+    runtimeSessionId: typeof PiDurableSessionIdSchema;
+    role: z.ZodEnum<{
+        child: "child";
+        lead: "lead";
+    }>;
+    dispatchId: typeof DispatchId;
+    intentId: typeof IntentId;
+    delegationId: z.ZodOptional<typeof IdentifierSchemas.delegationId>;
+    executionId: typeof IdentifierSchemas.executionId;
+    attemptId: typeof IdentifierSchemas.attemptId;
+    state: typeof RuntimeExecutionStateSchema;
+    startedAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const PiDurableSessionsResponseSchema: z.ZodObject<{
+    contractVersion: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"request ID">, string>>;
+    correlation: z.ZodObject<{
+        traceId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"trace ID">, string>>;
+        causationCommandId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"command ID">, string>>>;
+        parentEventId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"event ID">, string>>>;
+    }, z.core.$strict>;
+    data: z.ZodObject<{
+        sessions: z.ZodArray<typeof PiDurableSessionSchema>;
+        next: z.ZodOptional<typeof PiDurableSessionIdSchema>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const PiDurableSessionEventsResponseSchema: z.ZodObject<{
+    contractVersion: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"request ID">, string>>;
+    correlation: z.ZodObject<{
+        traceId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"trace ID">, string>>;
+        causationCommandId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"command ID">, string>>>;
+        parentEventId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"event ID">, string>>>;
+    }, z.core.$strict>;
+    data: z.ZodObject<{
+        contractVersion: z.ZodLiteral<1>;
+        runtimeSessionId: typeof PiDurableSessionIdSchema;
+        events: z.ZodArray<typeof PiDurableLeadTurnEventSchema>;
+        nextSeq: z.ZodNumber;
+        complete: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 declare const ChildReference: z.ZodString;
 export declare const PiDurableLeadChildOutcomeSchema: z.ZodObject<{
     state: z.ZodEnum<{
@@ -598,6 +741,7 @@ export declare const PiDurableLeadChildSchema: z.ZodObject<{
     delegationId: typeof IdentifierSchemas.delegationId;
     childExecutionId: typeof IdentifierSchemas.executionId;
     childAttemptId: z.ZodOptional<typeof IdentifierSchemas.attemptId>;
+    runtimeSessionId: z.ZodOptional<typeof IdentifierSchemas.externalSessionId>;
     role: typeof ChildReference;
     state: z.ZodEnum<{
         awaiting_input: "awaiting_input";
@@ -810,6 +954,20 @@ export declare const PiDurableLeadHttpContract: Readonly<{
         requestSchema: typeof PiDurableLeadChildTargetRequestSchema;
         responseSchema: typeof PiDurableLeadChildTargetResponseSchema;
     }>;
+    sessions: Readonly<{
+        route: "sessions";
+        operation: "pi-durable.lead.sessions";
+        scope: "execution:read";
+        requestSchema: typeof PiDurableSessionsRequestSchema;
+        responseSchema: typeof PiDurableSessionsResponseSchema;
+    }>;
+    sessionEvents: Readonly<{
+        route: "session-events";
+        operation: "pi-durable.lead.session-events";
+        scope: "execution:read";
+        requestSchema: typeof PiDurableSessionEventsRequestSchema;
+        responseSchema: typeof PiDurableSessionEventsResponseSchema;
+    }>;
     cancel: Readonly<{
         route: "cancel";
         operation: "pi-durable.lead.cancel";
@@ -824,6 +982,13 @@ export declare const PiDurableLeadHttpContract: Readonly<{
         requestSchema: typeof PiDurableLeadQuestionAnswerRequestSchema;
         responseSchema: typeof PiDurableLeadQuestionAnswerResponseSchema;
     }>;
+    approvalAnswer: Readonly<{
+        route: "approvals/answer";
+        operation: "pi-durable.lead.approval-answer";
+        scope: "execution:write";
+        requestSchema: typeof PiDurableLeadApprovalAnswerRequestSchema;
+        responseSchema: typeof PiDurableLeadApprovalAnswerResponseSchema;
+    }>;
     childCancel: Readonly<{
         route: "child-cancel";
         operation: "pi-durable.lead.child-cancel";
@@ -848,12 +1013,19 @@ export type PiDurableLeadEventsRequest = z.output<typeof PiDurableLeadEventsRequ
 export type PiDurableLeadEventsResponse = z.output<typeof PiDurableLeadEventsResponseSchema>;
 export type PiDurableLeadTurnEvent = z.output<typeof PiDurableLeadTurnEventSchema>;
 export type PiDurableLeadChildrenRequest = z.output<typeof PiDurableLeadChildrenRequestSchema>;
+export type PiDurableSession = z.output<typeof PiDurableSessionSchema>;
+export type PiDurableSessionsRequest = z.output<typeof PiDurableSessionsRequestSchema>;
+export type PiDurableSessionsResponse = z.output<typeof PiDurableSessionsResponseSchema>;
+export type PiDurableSessionEventsRequest = z.output<typeof PiDurableSessionEventsRequestSchema>;
+export type PiDurableSessionEventsResponse = z.output<typeof PiDurableSessionEventsResponseSchema>;
 export type PiDurableLeadChildrenResponse = z.output<typeof PiDurableLeadChildrenResponseSchema>;
 export type PiDurableLeadChild = z.output<typeof PiDurableLeadChildSchema>;
 export type PiDurableLeadCancelRequest = z.output<typeof PiDurableLeadCancelRequestSchema>;
 export type PiDurableLeadCancelResponse = z.output<typeof PiDurableLeadCancelResponseSchema>;
 export type PiDurableLeadQuestionAnswerRequest = z.output<typeof PiDurableLeadQuestionAnswerRequestSchema>;
 export type PiDurableLeadQuestionAnswerResponse = z.output<typeof PiDurableLeadQuestionAnswerResponseSchema>;
+export type PiDurableLeadApprovalAnswerRequest = z.output<typeof PiDurableLeadApprovalAnswerRequestSchema>;
+export type PiDurableLeadApprovalAnswerResponse = z.output<typeof PiDurableLeadApprovalAnswerResponseSchema>;
 export type PiDurableLeadChildCancelRequest = z.output<typeof PiDurableLeadChildCancelRequestSchema>;
 export type PiDurableLeadChildCancelResponse = z.output<typeof PiDurableLeadChildCancelResponseSchema>;
 export type PiDurableLeadChildTargetRequest = z.output<typeof PiDurableLeadChildTargetRequestSchema>;

package/dist/pi-durable-lead.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { PiDurableQuestionAnswersSchema, PiDurableQuestionRequestIdSchema, } from './pi-durable-questions.js';
+import { PiDurableApprovalAnswerSchema, PiDurableApprovalAttestationSchema, PiDurableApprovalDecisionIdSchema, } from './pi-durable-approvals.js';
 import { ContractVersionSchema, IdentifierSchemas, ModelSelectionFundingViewSchema, ModelSelectionRefSchema, PublicContractManifest, ReadRequestEnvelopeSchema, StateChangingCommandEnvelopeSchema, SuccessResponseEnvelopeSchema, negotiateContractVersion, } from '@adea-ai/contracts';
 import { RuntimeExecutionHandleSchema, RuntimeExecutionProgressSchema, RuntimeExecutionStatusSchema, RuntimeExecutionStateSchema, RuntimeObservedGenerationSchema, } from './adapter.js';
 const IntentId = z.uuid();
@@ -29,32 +30,34 @@ export const PiDurableLeadObservedTargetSchema = z
     generation: RuntimeObservedGenerationSchema.optional(),
 })
     .readonly();
+function contractIncludes(negotiated, introduced) {
+    return (negotiated.major > introduced.major ||
+        (negotiated.major === introduced.major && negotiated.minor >= introduced.minor));
+}
 export const PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION = { major: 3, minor: 1 };
 export function supportsPiDurableObservedGeneration(consumerVersion) {
     const consumer = ContractVersionSchema.safeParse(consumerVersion);
     if (!consumer.success)
         return false;
-    const negotiated = negotiateContractVersion([PublicContractManifest.current], [consumer.data]);
-    if (negotiated === undefined)
-        return false;
-    return (negotiated.major === PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION.major &&
-        negotiated.minor >= PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION.minor);
+    const negotiated = negotiateContractVersion(PublicContractManifest.supported, [consumer.data]);
+    return (negotiated !== undefined &&
+        contractIncludes(negotiated, PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION));
 }
 export const PI_DURABLE_REMOTE_SESSION_REFERENCE_CONTRACT_VERSION = { major: 3, minor: 2 };
 export function supportsPiDurableRemoteSessionReference(consumerVersion) {
     const consumer = ContractVersionSchema.safeParse(consumerVersion);
     if (!consumer.success)
         return false;
-    const negotiated = negotiateContractVersion([PublicContractManifest.current], [consumer.data]);
-    return (negotiated?.major === PI_DURABLE_REMOTE_SESSION_REFERENCE_CONTRACT_VERSION.major &&
-        negotiated.minor >= PI_DURABLE_REMOTE_SESSION_REFERENCE_CONTRACT_VERSION.minor);
+    const negotiated = negotiateContractVersion(PublicContractManifest.supported, [consumer.data]);
+    return (negotiated !== undefined &&
+        contractIncludes(negotiated, PI_DURABLE_REMOTE_SESSION_REFERENCE_CONTRACT_VERSION));
 }
 export function supportsPiDurableRemoteOwnerObservation(consumerVersion) {
     const consumer = ContractVersionSchema.safeParse(consumerVersion);
     if (!consumer.success)
         return false;
-    const negotiated = negotiateContractVersion([PublicContractManifest.current], [consumer.data]);
-    return negotiated?.major === 3 && negotiated.minor >= 3;
+    const negotiated = negotiateContractVersion(PublicContractManifest.supported, [consumer.data]);
+    return negotiated !== undefined && contractIncludes(negotiated, { major: 3, minor: 3 });
 }
 function fenceForeignGeneration(receipt, context) {
     const foreign = (generation) => generation !== undefined && generation.attemptId !== receipt.attemptId;
@@ -106,6 +109,9 @@ export const PI_DURABLE_LEAD_EVENTS_CONTRACT_VERSION = 1;
 export const PI_DURABLE_LEAD_EVENTS_MAX_PAGE = 256;
 export const PI_DURABLE_LEAD_EVENTS_MAX_WAIT_MS = 8000;
 const LeadEventSeq = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+export const PiDurableSessionIdSchema = z
+    .string()
+    .regex(/^(?:pi-lead:dispatch_[a-f0-9]{32}|ses_[0-9A-HJKMNP-TV-Z]{26})$/);
 export const PiDurableLeadEventsRequestSchema = PiDurableLeadReadEnvelopeSchema.extend({
     operation: z.literal('pi-durable.lead.events'),
     parameters: z
@@ -126,7 +132,7 @@ export const PiDurableLeadTurnEventSchema = z
     .object({
     schemaVersion: z.literal(1),
     eventId: z.string().min(1).max(256),
-    runtimeSessionId: z.string().regex(/^pi-lead:dispatch_[a-f0-9]{32}$/),
+    runtimeSessionId: PiDurableSessionIdSchema,
     harnessRunId: z.string().min(1).max(256),
     generation: z.literal(1),
     seq: z.string().regex(/^[1-9]\d*$/),
@@ -180,6 +186,28 @@ export const PiDurableLeadChildrenRequestSchema = PiDurableLeadReadEnvelopeSchem
     })
         .strict(),
 });
+export const PI_DURABLE_SESSIONS_MAX_PAGE = 256;
+export const PiDurableSessionsRequestSchema = PiDurableLeadReadEnvelopeSchema.extend({
+    operation: z.literal('pi-durable.lead.sessions'),
+    parameters: z
+        .object({
+        runtimeSessionId: PiDurableSessionIdSchema.optional(),
+        after: PiDurableSessionIdSchema.optional(),
+        limit: z.number().int().min(1).max(PI_DURABLE_SESSIONS_MAX_PAGE).optional(),
+    })
+        .strict(),
+});
+export const PiDurableSessionEventsRequestSchema = PiDurableLeadReadEnvelopeSchema.extend({
+    operation: z.literal('pi-durable.lead.session-events'),
+    parameters: z
+        .object({
+        runtimeSessionId: PiDurableSessionIdSchema,
+        afterSeq: LeadEventSeq,
+        waitMs: z.number().int().min(0).max(PI_DURABLE_LEAD_EVENTS_MAX_WAIT_MS),
+        limit: z.number().int().min(1).max(PI_DURABLE_LEAD_EVENTS_MAX_PAGE).optional(),
+    })
+        .strict(),
+});
 export const PiDurableLeadChildTargetRequestSchema = PiDurableLeadReadEnvelopeSchema.extend({
     operation: z.literal('pi-durable.lead.child-target'),
     parameters: z
@@ -203,6 +231,10 @@ export const PiDurableLeadQuestionAnswerRequestSchema = PiDurableLeadCommandEnve
     })
         .strict(),
 });
+export const PiDurableLeadApprovalAnswerRequestSchema = PiDurableLeadCommandEnvelopeSchema.extend({
+    operation: z.literal('pi-durable.lead.approval-answer'),
+    payload: PiDurableApprovalAnswerSchema.extend(PiDurableApprovalAttestationSchema.shape),
+});
 export const PiDurableLeadChildCancelRequestSchema = PiDurableLeadCommandEnvelopeSchema.extend({
     operation: z.literal('pi-durable.lead.child-cancel'),
     payload: z
@@ -340,9 +372,96 @@ export const PiDurableLeadQuestionAnswerResponseSchema = response.extend({
         status: RuntimeExecutionStatusSchema,
     }),
 });
+export const PiDurableLeadApprovalAnswerResponseSchema = response.extend({
+    data: PiDurableLeadReceiptResponseSchema.extend({
+        approvalSchemaVersion: z.literal('pi-lead-approval-answer/v1'),
+        approvalId: IdentifierSchemas.interactionId,
+        decisionId: PiDurableApprovalDecisionIdSchema,
+        requestEventId: z.string().min(1).max(256),
+        decision: z.enum(['approve', 'deny']),
+        outcome: z.enum(['decided', 'already_decided']),
+        state: RuntimeExecutionStateSchema,
+        status: RuntimeExecutionStatusSchema,
+    }),
+});
 export const PiDurableLeadEventsResponseSchema = response.extend({
     data: PiDurableLeadEventsDataSchema,
 });
+export const PiDurableSessionSchema = z
+    .object({
+    runtimeSessionId: PiDurableSessionIdSchema,
+    role: z.enum(['lead', 'child']),
+    dispatchId: DispatchId,
+    intentId: IntentId,
+    delegationId: IdentifierSchemas.delegationId.optional(),
+    executionId: IdentifierSchemas.executionId,
+    attemptId: IdentifierSchemas.attemptId,
+    state: RuntimeExecutionStateSchema,
+    startedAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    const lead = value.runtimeSessionId === `pi-lead:${value.dispatchId}`;
+    if ((value.role === 'lead') !== lead ||
+        (value.role === 'lead') !== (value.delegationId === undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'A lead session is its dispatch; a child session names its delegation',
+        });
+});
+export const PiDurableSessionsResponseSchema = response.extend({
+    data: z
+        .object({
+        sessions: z.array(PiDurableSessionSchema).max(PI_DURABLE_SESSIONS_MAX_PAGE),
+        next: PiDurableSessionIdSchema.optional(),
+    })
+        .strict()
+        .superRefine((value, context) => {
+        value.sessions.forEach((session, index) => {
+            const previous = value.sessions[index - 1];
+            if (previous && previous.runtimeSessionId >= session.runtimeSessionId)
+                context.addIssue({
+                    code: 'custom',
+                    path: ['sessions', index],
+                    message: 'Sessions are unique and sorted by runtimeSessionId',
+                });
+        });
+        if (value.next !== undefined && value.next !== value.sessions.at(-1)?.runtimeSessionId)
+            context.addIssue({ code: 'custom', path: ['next'], message: 'next is the last session' });
+    }),
+});
+export const PiDurableSessionEventsResponseSchema = response.extend({
+    data: z
+        .object({
+        contractVersion: z.literal(PI_DURABLE_LEAD_EVENTS_CONTRACT_VERSION),
+        runtimeSessionId: PiDurableSessionIdSchema,
+        events: z
+            .array(PiDurableLeadTurnEventSchema)
+            .max(PI_DURABLE_LEAD_EVENTS_MAX_PAGE),
+        nextSeq: LeadEventSeq,
+        complete: z.boolean(),
+    })
+        .strict()
+        .superRefine((value, context) => {
+        const first = value.nextSeq - value.events.length + 1;
+        value.events.forEach((event, index) => {
+            if (event.seq !== String(first + index) ||
+                event.runtimeSessionId !== value.runtimeSessionId)
+                context.addIssue({
+                    code: 'custom',
+                    path: ['events', index],
+                    message: 'Events must be the contiguous seqs of this session ending at nextSeq',
+                });
+        });
+        if (first < 1)
+            context.addIssue({
+                code: 'custom',
+                path: ['nextSeq'],
+                message: 'nextSeq precedes the page',
+            });
+    }),
+});
 const ChildReference = z
     .string()
     .trim()
@@ -367,6 +486,7 @@ export const PiDurableLeadChildSchema = z
     delegationId: IdentifierSchemas.delegationId,
     childExecutionId: IdentifierSchemas.executionId,
     childAttemptId: IdentifierSchemas.attemptId.optional(),
+    runtimeSessionId: IdentifierSchemas.externalSessionId.optional(),
     role: ChildReference,
     state: z.enum([
         'requested',
@@ -566,6 +686,20 @@ export const PiDurableLeadHttpContract = Object.freeze({
         requestSchema: PiDurableLeadChildTargetRequestSchema,
         responseSchema: PiDurableLeadChildTargetResponseSchema,
     }),
+    sessions: Object.freeze({
+        route: 'sessions',
+        operation: 'pi-durable.lead.sessions',
+        scope: 'execution:read',
+        requestSchema: PiDurableSessionsRequestSchema,
+        responseSchema: PiDurableSessionsResponseSchema,
+    }),
+    sessionEvents: Object.freeze({
+        route: 'session-events',
+        operation: 'pi-durable.lead.session-events',
+        scope: 'execution:read',
+        requestSchema: PiDurableSessionEventsRequestSchema,
+        responseSchema: PiDurableSessionEventsResponseSchema,
+    }),
     cancel: Object.freeze({
         route: 'cancel',
         operation: 'pi-durable.lead.cancel',
@@ -580,6 +714,13 @@ export const PiDurableLeadHttpContract = Object.freeze({
         requestSchema: PiDurableLeadQuestionAnswerRequestSchema,
         responseSchema: PiDurableLeadQuestionAnswerResponseSchema,
     }),
+    approvalAnswer: Object.freeze({
+        route: 'approvals/answer',
+        operation: 'pi-durable.lead.approval-answer',
+        scope: 'execution:write',
+        requestSchema: PiDurableLeadApprovalAnswerRequestSchema,
+        responseSchema: PiDurableLeadApprovalAnswerResponseSchema,
+    }),
     childCancel: Object.freeze({
         route: 'child-cancel',
         operation: 'pi-durable.lead.child-cancel',

package/dist/registry.d.ts

@@ -5,13 +5,11 @@ export declare const RuntimeConnectionRegistrationSchema: z.ZodObject<{
     identityDigest: z.ZodString;
     connectionType: z.ZodEnum<{
         external_local: "external_local";
-        managed_cloud: "managed_cloud";
         managed_local: "managed_local";
     }>;
     runtimeNodeRefId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-node reference ID">, string>>>;
     runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"runtime-definition ID">, string>>;
     location: z.ZodEnum<{
-        agent_hq_cloud: "agent_hq_cloud";
         local_device: "local_device";
     }>;
     opaqueNativeRef: z.ZodOptional<z.ZodString>;

package/dist/sessions.js

@@ -292,10 +292,7 @@ const ExternalSessionAssessmentContextSchema = z
     nodeStatus: RuntimeEligibilityNodeStatusSchema,
     evaluatedAt: RuntimeTimestampSchema,
 })
-    .strict()
-    .refine((context) => context.connection === undefined ||
-    (context.connection.connectionType === 'managed_cloud') ===
-        (context.nodeStatus === 'not_applicable'), 'Managed-cloud sessions must not invent RuntimeNode health');
+    .strict();
 export function assessExternalSession(sessionValue, contextValue) {
     const session = ExternalSessionSchema.parse(sessionValue);
     const context = ExternalSessionAssessmentContextSchema.parse(contextValue);

package/dist/transport.d.ts

@@ -1,5 +1,5 @@
 import type { RuntimeAdapter, RuntimeAdapterInspection, RuntimeApprovalRequest, RuntimeCancelRequest, RuntimeExecutionHandle, RuntimeExecutionProgress, RuntimeExecutionStatus, RuntimeInputRequest, RuntimeProgressOptions, RuntimeSessionOperation, RuntimeSessionResult, RuntimeStartRequest } from './adapter.js';
-export type RuntimeTransportKind = 'direct-local' | 'remote-gateway';
+export type RuntimeTransportKind = 'direct-local';
 export type RuntimeDriver = RuntimeAdapter;
 export interface RuntimeTransport extends RuntimeAdapter {
     readonly kind: RuntimeTransportKind;
@@ -34,7 +34,4 @@ export declare class TransportedRuntimeAdapter extends DelegatingRuntimeAdapter
 export declare class DirectLocalRuntimeTransport extends DelegatingRuntimeTransport {
     readonly kind: 'direct-local';
 }
-export declare class RemoteRuntimeGatewayTransport extends DelegatingRuntimeTransport {
-    readonly kind: 'remote-gateway';
-}
 export {};

package/dist/transport.js

@@ -61,6 +61,3 @@ export class TransportedRuntimeAdapter extends DelegatingRuntimeAdapter {
 export class DirectLocalRuntimeTransport extends DelegatingRuntimeTransport {
     kind = 'direct-local';
 }
-export class RemoteRuntimeGatewayTransport extends DelegatingRuntimeTransport {
-    kind = 'remote-gateway';
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adea-ai/runtime-sdk",
-  "version": "1.23.0",
+  "version": "2.0.0",
   "description": "SDK for building Control Plane runtimes: adapters, capabilities, conformance, discovery, eligibility, health, sessions, transport, and routing.",
   "keywords": [
     "adapter",
@@ -43,7 +43,7 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "@adea-ai/contracts": "^3.0.0",
+    "@adea-ai/contracts": "^4.0.0",
     "zod": "4.6.6"
   },
   "engines": {