@adea-ai/runtime-sdk 1.23.0 → 1.24.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

@@ -78,7 +78,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;
@@ -166,7 +165,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/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/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();
@@ -106,6 +107,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 +130,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 +184,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 +229,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 +370,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 +484,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 +684,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 +712,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/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": "1.24.0",
   "description": "SDK for building Control Plane runtimes: adapters, capabilities, conformance, discovery, eligibility, health, sessions, transport, and routing.",
   "keywords": [
     "adapter",
@@ -31,8 +31,7 @@
     }
   },
   "publishConfig": {
-    "access": "public",
-    "provenance": true
+    "access": "public"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -43,7 +42,7 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "@adea-ai/contracts": "^3.0.0",
+    "@adea-ai/contracts": "^3.1.0",
     "zod": "4.6.6"
   },
   "engines": {