@adea-ai/runtime-sdk 1.22.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,5 +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,5 +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,4 +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;
@@ -155,6 +157,56 @@ export declare const PiDurableLeadProgressRequestSchema: z.ZodObject<{
         afterSequence: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>;
 }, z.core.$strict>;
+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;
+        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.events">;
+    parameters: z.ZodObject<{
+        dispatchId: typeof DispatchId;
+        messageId: z.ZodString;
+        afterSeq: z.ZodNumber;
+        waitMs: z.ZodNumber;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const PiDurableLeadTurnEventSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    eventId: z.ZodString;
+    runtimeSessionId: typeof PiDurableSessionIdSchema;
+    harnessRunId: z.ZodString;
+    generation: z.ZodLiteral<1>;
+    seq: z.ZodString;
+    occurredAt: z.ZodISODateTime;
+    receivedAt: z.ZodISODateTime;
+    source: z.ZodLiteral<"native">;
+    sourceEventId: z.ZodString;
+    confidence: z.ZodLiteral<"authoritative">;
+    classification: z.ZodEnum<{
+        restricted_local: "restricted_local";
+        workspace_private: "workspace_private";
+    }>;
+    kind: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+export declare const PiDurableLeadEventsDataSchema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<1>;
+    dispatchId: typeof DispatchId;
+    events: z.ZodArray<typeof PiDurableLeadTurnEventSchema>;
+    nextSeq: z.ZodNumber;
+    complete: z.ZodBoolean;
+}, z.core.$strict>;
 export declare const PiDurableLeadChildrenCursorSchema: z.ZodReadonly<z.ZodObject<{
     acceptedAt: z.ZodISODateTime;
     delegationId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"delegation ID">, string>>;
@@ -179,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;
@@ -215,6 +305,44 @@ export declare const PiDurableLeadCancelRequestSchema: z.ZodObject<{
         dispatchId: z.ZodString;
     }, z.core.$strict>;
 }, z.core.$strict>;
+export declare const PiDurableLeadQuestionAnswerRequestSchema: 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.question-answer">;
+    payload: z.ZodObject<{
+        dispatchId: typeof DispatchId;
+        requestId: typeof PiDurableQuestionRequestIdSchema;
+        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;
@@ -457,6 +585,137 @@ export declare const PiDurableLeadCancelResponseSchema: z.ZodObject<{
         status: typeof RuntimeExecutionStatusSchema;
     }, z.core.$strict>;
 }, z.core.$strict>;
+export declare const PiDurableLeadQuestionAnswerResponseSchema: 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>;
+        questionSchemaVersion: z.ZodLiteral<"pi-lead-question-answer/v1">;
+        requestId: typeof PiDurableQuestionRequestIdSchema;
+        requestEventId: z.ZodString;
+        outcome: z.ZodEnum<{
+            already_answered: "already_answered";
+            answered: "answered";
+            expired: "expired";
+        }>;
+        state: typeof RuntimeExecutionStateSchema;
+        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;
+        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: 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<{
@@ -482,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";
@@ -673,6 +933,13 @@ export declare const PiDurableLeadHttpContract: Readonly<{
         requestSchema: typeof PiDurableLeadProgressRequestSchema;
         responseSchema: typeof PiDurableLeadProgressResponseSchema;
     }>;
+    events: Readonly<{
+        route: "events";
+        operation: "pi-durable.lead.events";
+        scope: "execution:read";
+        requestSchema: typeof PiDurableLeadEventsRequestSchema;
+        responseSchema: typeof PiDurableLeadEventsResponseSchema;
+    }>;
     children: Readonly<{
         route: "children";
         operation: "pi-durable.lead.children";
@@ -687,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";
@@ -694,6 +975,20 @@ export declare const PiDurableLeadHttpContract: Readonly<{
         requestSchema: typeof PiDurableLeadCancelRequestSchema;
         responseSchema: typeof PiDurableLeadCancelResponseSchema;
     }>;
+    questionAnswer: Readonly<{
+        route: "questions/answer";
+        operation: "pi-durable.lead.question-answer";
+        scope: "execution:write";
+        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";
@@ -714,11 +1009,23 @@ export type PiDurableLeadStatusRequest = z.output<typeof PiDurableLeadStatusRequ
 export type PiDurableLeadStatusResponse = z.output<typeof PiDurableLeadStatusResponseSchema>;
 export type PiDurableLeadProgressRequest = z.output<typeof PiDurableLeadProgressRequestSchema>;
 export type PiDurableLeadProgressResponse = z.output<typeof PiDurableLeadProgressResponseSchema>;
+export type PiDurableLeadEventsRequest = z.output<typeof PiDurableLeadEventsRequestSchema>;
+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,4 +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();
@@ -101,6 +103,72 @@ export const PiDurableLeadProgressRequestSchema = PiDurableLeadReadEnvelopeSchem
     })
         .strict(),
 });
+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
+        .object({
+        dispatchId: DispatchId,
+        messageId: z
+            .string()
+            .min(1)
+            .max(128)
+            .regex(/^[A-Za-z0-9._:-]+$/),
+        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 PiDurableLeadTurnEventSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    eventId: z.string().min(1).max(256),
+    runtimeSessionId: PiDurableSessionIdSchema,
+    harnessRunId: z.string().min(1).max(256),
+    generation: z.literal(1),
+    seq: z.string().regex(/^[1-9]\d*$/),
+    occurredAt: z.iso.datetime(),
+    receivedAt: z.iso.datetime(),
+    source: z.literal('native'),
+    sourceEventId: z.string().min(1).max(256),
+    confidence: z.literal('authoritative'),
+    classification: z.enum(['workspace_private', 'restricted_local']),
+    kind: z.string().min(1).max(64),
+    payload: z.record(z.string(), z.unknown()),
+})
+    .strict();
+export const PiDurableLeadEventsDataSchema = z
+    .object({
+    contractVersion: z.literal(PI_DURABLE_LEAD_EVENTS_CONTRACT_VERSION),
+    dispatchId: DispatchId,
+    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 !== `pi-lead:${value.dispatchId}`)
+            context.addIssue({
+                code: 'custom',
+                path: ['events', index],
+                message: 'Events must be the contiguous seqs of this dispatch ending at nextSeq',
+            });
+    });
+    if (first < 1)
+        context.addIssue({ code: 'custom', path: ['nextSeq'], message: 'nextSeq precedes the page' });
+});
 export const PiDurableLeadChildrenCursorSchema = z
     .object({ acceptedAt: z.iso.datetime(), delegationId: IdentifierSchemas.delegationId })
     .strict()
@@ -116,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
@@ -129,6 +219,20 @@ export const PiDurableLeadCancelRequestSchema = PiDurableLeadCommandEnvelopeSche
     operation: z.literal('pi-durable.lead.cancel'),
     payload: z.object({ dispatchId: DispatchId }).strict(),
 });
+export const PiDurableLeadQuestionAnswerRequestSchema = PiDurableLeadCommandEnvelopeSchema.extend({
+    operation: z.literal('pi-durable.lead.question-answer'),
+    payload: z
+        .object({
+        dispatchId: DispatchId,
+        requestId: PiDurableQuestionRequestIdSchema,
+        answers: PiDurableQuestionAnswersSchema,
+    })
+        .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
@@ -256,6 +360,106 @@ export const PiDurableLeadProgressResponseSchema = response.extend({
     }),
 });
 export const PiDurableLeadCancelResponseSchema = PiDurableLeadStatusResponseSchema;
+export const PiDurableLeadQuestionAnswerResponseSchema = response.extend({
+    data: PiDurableLeadReceiptResponseSchema.extend({
+        questionSchemaVersion: z.literal('pi-lead-question-answer/v1'),
+        requestId: PiDurableQuestionRequestIdSchema,
+        requestEventId: z.string().min(1).max(256),
+        outcome: z.enum(['answered', 'already_answered', 'expired']),
+        state: RuntimeExecutionStateSchema,
+        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()
@@ -280,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',
@@ -458,6 +663,13 @@ export const PiDurableLeadHttpContract = Object.freeze({
         requestSchema: PiDurableLeadProgressRequestSchema,
         responseSchema: PiDurableLeadProgressResponseSchema,
     }),
+    events: Object.freeze({
+        route: 'events',
+        operation: 'pi-durable.lead.events',
+        scope: 'execution:read',
+        requestSchema: PiDurableLeadEventsRequestSchema,
+        responseSchema: PiDurableLeadEventsResponseSchema,
+    }),
     children: Object.freeze({
         route: 'children',
         operation: 'pi-durable.lead.children',
@@ -472,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',
@@ -479,6 +705,20 @@ export const PiDurableLeadHttpContract = Object.freeze({
         requestSchema: PiDurableLeadCancelRequestSchema,
         responseSchema: PiDurableLeadCancelResponseSchema,
     }),
+    questionAnswer: Object.freeze({
+        route: 'questions/answer',
+        operation: 'pi-durable.lead.question-answer',
+        scope: 'execution:write',
+        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/pi-durable-questions.d.ts

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+export declare const PI_QUESTION_TIMEOUT_DEFAULT_SECONDS: number;
+export declare const PI_QUESTION_TIMEOUT_MIN_SECONDS = 60;
+export declare const PI_QUESTION_TIMEOUT_MAX_SECONDS: number;
+export declare const PI_QUESTIONS_MAX = 8;
+export declare const PI_QUESTION_OPTIONS_MAX = 16;
+export declare const PI_QUESTION_CONTENT_BYTES_MAX: number;
+export declare const PiDurableQuestionRequestIdSchema: z.ZodString;
+export declare const PiDurableQuestionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    prompt: z.ZodString;
+    required: z.ZodBoolean;
+    kind: z.ZodLiteral<"text">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    prompt: z.ZodString;
+    required: z.ZodBoolean;
+    kind: z.ZodLiteral<"choice">;
+    multiple: z.ZodBoolean;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "kind">;
+export type PiDurableQuestion = z.output<typeof PiDurableQuestionSchema>;
+export declare const PiDurableQuestionsSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    prompt: z.ZodString;
+    required: z.ZodBoolean;
+    kind: z.ZodLiteral<"text">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    prompt: z.ZodString;
+    required: z.ZodBoolean;
+    kind: z.ZodLiteral<"choice">;
+    multiple: z.ZodBoolean;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "kind">>;
+export declare const PiDurableQuestionAnswerSchema: z.ZodUnion<readonly [z.ZodObject<{
+    questionId: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    questionId: z.ZodString;
+    optionIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    questionId: z.ZodString;
+    skipped: z.ZodLiteral<true>;
+}, z.core.$strict>]>;
+export type PiDurableQuestionAnswer = z.output<typeof PiDurableQuestionAnswerSchema>;
+export declare const PiDurableQuestionAnswersSchema: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    questionId: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    questionId: z.ZodString;
+    optionIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    questionId: z.ZodString;
+    skipped: z.ZodLiteral<true>;
+}, z.core.$strict>]>>;
+export declare const PiDurableQuestionRequestSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    callId: z.ZodString;
+    questions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        prompt: z.ZodString;
+        required: z.ZodBoolean;
+        kind: z.ZodLiteral<"text">;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        prompt: z.ZodString;
+        required: z.ZodBoolean;
+        kind: z.ZodLiteral<"choice">;
+        multiple: z.ZodBoolean;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">>;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type PiDurableQuestionRequest = z.output<typeof PiDurableQuestionRequestSchema>;
+export declare const PiDurableQuestionOutcomeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    decision: z.ZodLiteral<"answered">;
+    answers: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        questionId: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        questionId: z.ZodString;
+        optionIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        questionId: z.ZodString;
+        skipped: z.ZodLiteral<true>;
+    }, z.core.$strict>]>>;
+    decidedAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    decision: z.ZodLiteral<"expired">;
+    decidedAt: z.ZodISODateTime;
+}, z.core.$strict>], "decision">;
+export type PiDurableQuestionOutcome = z.output<typeof PiDurableQuestionOutcomeSchema>;
+export declare function questionAnswersProblem(questions: readonly PiDurableQuestion[], input: unknown): string | undefined;

package/dist/pi-durable-questions.js

@@ -0,0 +1,109 @@
+import { z } from 'zod';
+export const PI_QUESTION_TIMEOUT_DEFAULT_SECONDS = 60 * 60;
+export const PI_QUESTION_TIMEOUT_MIN_SECONDS = 60;
+export const PI_QUESTION_TIMEOUT_MAX_SECONDS = 24 * 60 * 60;
+export const PI_QUESTIONS_MAX = 8;
+export const PI_QUESTION_OPTIONS_MAX = 16;
+export const PI_QUESTION_CONTENT_BYTES_MAX = 32 * 1024;
+const Id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/);
+export const PiDurableQuestionRequestIdSchema = z.string().regex(/^pi-question:[a-f0-9]{32}$/);
+const OptionSchema = z.strictObject({
+    id: Id,
+    label: z.string().trim().min(1).max(512),
+    description: z.string().trim().min(1).max(2048).optional(),
+});
+export const PiDurableQuestionSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        id: Id,
+        prompt: z.string().trim().min(1).max(4096),
+        required: z.boolean(),
+        kind: z.literal('text'),
+    }),
+    z.strictObject({
+        id: Id,
+        prompt: z.string().trim().min(1).max(4096),
+        required: z.boolean(),
+        kind: z.literal('choice'),
+        multiple: z.boolean(),
+        options: z
+            .array(OptionSchema)
+            .min(1)
+            .max(PI_QUESTION_OPTIONS_MAX)
+            .refine((options) => unique(options.map((option) => option.id)), 'duplicate option id'),
+    }),
+]);
+export const PiDurableQuestionsSchema = z
+    .array(PiDurableQuestionSchema)
+    .min(1)
+    .max(PI_QUESTIONS_MAX)
+    .refine((questions) => unique(questions.map((question) => question.id)), 'duplicate question id')
+    .refine((questions) => fits(questions), 'questions too large');
+export const PiDurableQuestionAnswerSchema = z.union([
+    z.strictObject({ questionId: Id, text: z.string().min(1).max(16_384) }),
+    z.strictObject({
+        questionId: Id,
+        optionIds: z
+            .array(Id)
+            .min(1)
+            .max(PI_QUESTION_OPTIONS_MAX)
+            .refine((ids) => unique(ids), 'duplicate option id'),
+    }),
+    z.strictObject({ questionId: Id, skipped: z.literal(true) }),
+]);
+export const PiDurableQuestionAnswersSchema = z
+    .array(PiDurableQuestionAnswerSchema)
+    .max(PI_QUESTIONS_MAX)
+    .refine((answers) => unique(answers.map((answer) => answer.questionId)), 'duplicate question id')
+    .refine((answers) => fits(answers), 'answers too large');
+export const PiDurableQuestionRequestSchema = z.strictObject({
+    requestId: PiDurableQuestionRequestIdSchema,
+    callId: z.string().min(1).max(256),
+    questions: PiDurableQuestionsSchema,
+    expiresAt: z.iso.datetime(),
+});
+export const PiDurableQuestionOutcomeSchema = z.discriminatedUnion('decision', [
+    z.strictObject({
+        decision: z.literal('answered'),
+        answers: PiDurableQuestionAnswersSchema,
+        decidedAt: z.iso.datetime(),
+    }),
+    z.strictObject({ decision: z.literal('expired'), decidedAt: z.iso.datetime() }),
+]);
+export function questionAnswersProblem(questions, input) {
+    const parsed = PiDurableQuestionAnswersSchema.safeParse(input);
+    if (!parsed.success)
+        return 'answers are malformed';
+    const answers = new Map(parsed.data.map((answer) => [answer.questionId, answer]));
+    for (const question of questions) {
+        const answer = answers.get(question.id);
+        answers.delete(question.id);
+        if (!answer || 'skipped' in answer) {
+            if (question.required)
+                return 'a required question is unanswered';
+        }
+        else if (question.kind === 'text') {
+            if (!('text' in answer))
+                return 'a text question needs a text answer';
+        }
+        else {
+            if (!('optionIds' in answer))
+                return 'a choice question needs option ids';
+            if (!question.multiple && answer.optionIds.length !== 1)
+                return 'expected a single choice';
+            const known = new Set(question.options.map((option) => option.id));
+            if (answer.optionIds.some((id) => !known.has(id)))
+                return 'unknown option id';
+        }
+    }
+    return answers.size ? 'unknown question id' : undefined;
+}
+function unique(values) {
+    return new Set(values).size === values.length;
+}
+function fits(value) {
+    return Buffer.byteLength(JSON.stringify(value), 'utf8') <= PI_QUESTION_CONTENT_BYTES_MAX;
+}

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.22.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": "^1.26.1",
+    "@adea-ai/contracts": "^3.1.0",
     "zod": "4.6.6"
   },
   "engines": {