@adea-ai/runtime-sdk 1.17.2 → 1.19.0

package/dist/adapter.d.ts

@@ -185,10 +185,6 @@ export declare const RuntimeExecutionHandleSchema: z.ZodObject<{
     externalSessionId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"external-session ID">, string>>>;
     startedAt: z.ZodISODateTime;
 }, z.core.$strict>;
-/**
- * Reported runtime accounting provenance, not funding authorization. Consumers
- * must verify `sourceId` against a trusted authority before charging.
- */
 export declare const RuntimeUsageAccountingSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     sourceId: z.ZodString;
@@ -293,20 +289,6 @@ export declare const RuntimeExecutionStateSchema: z.ZodEnum<{
     timed_out: "timed_out";
     unknown: "unknown";
 }>;
-/**
- * The runtime's own observed generation identity for the execution's current
- * turn.
- *
- * Observed by construction: the runtime reports the generation it authorized
- * for this attempt, never a generation a caller claimed. A control that names
- * a generation the runtime did not observe is not bound to it, so this shape
- * is an identity, not a counter the caller can advance.
- *
- * The identity is self-verifying: the inference key is the turn's key extended
- * by the inference id, exactly as the runtime retained it. A key that names a
- * different turn or inference is refused here rather than accepted as an
- * observation of something else.
- */
 export declare const RuntimeObservedGenerationSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"runtime-observed-generation/v1">;
     attemptId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"attempt ID">, string>>;
@@ -464,7 +446,6 @@ export declare const RuntimeExecutionPlanSnapshotSchema: z.ZodObject<{
         }>>;
     }, z.core.$strip>>;
 }, z.core.$catchall<z.ZodUnknown>>;
-/** Allocation under an accepted allowance; not prepaid funds or charge authority. */
 export declare const RuntimeAttemptBudgetAuthoritySchema: z.ZodReadonly<z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@adea-ai/contracts").OpaqueIdentifier<"workspace ID">, string>>;

package/dist/adapter.js

@@ -42,7 +42,6 @@ export const RuntimeAdapterInspectionSchema = z
     health: z.enum(['healthy', 'degraded', 'unavailable']),
     capabilities: z.array(RuntimeCapabilitySchema).max(64),
     limitations: z.array(z.string().min(1).max(512)).max(64),
-    // Optional until each adapter has published tested Agent Plugins evidence.
     agentPlugins: AgentPluginsCapabilityReportSchema.optional(),
     observedAt: TimestampSchema,
     capabilityEvaluation: CapabilityEvaluationSchema.optional(),
@@ -56,10 +55,6 @@ export const RuntimeExecutionHandleSchema = z
     startedAt: TimestampSchema,
 })
     .strict();
-/**
- * Reported runtime accounting provenance, not funding authorization. Consumers
- * must verify `sourceId` against a trusted authority before charging.
- */
 export const RuntimeUsageAccountingSchema = z
     .object({
     schemaVersion: z.literal(1),
@@ -183,20 +178,6 @@ export const RuntimeExecutionStateSchema = z.enum([
     'timed_out',
     'unknown',
 ]);
-/**
- * The runtime's own observed generation identity for the execution's current
- * turn.
- *
- * Observed by construction: the runtime reports the generation it authorized
- * for this attempt, never a generation a caller claimed. A control that names
- * a generation the runtime did not observe is not bound to it, so this shape
- * is an identity, not a counter the caller can advance.
- *
- * The identity is self-verifying: the inference key is the turn's key extended
- * by the inference id, exactly as the runtime retained it. A key that names a
- * different turn or inference is refused here rather than accepted as an
- * observation of something else.
- */
 export const RuntimeObservedGenerationSchema = z
     .object({
     schemaVersion: z.literal('runtime-observed-generation/v1'),
@@ -215,13 +196,8 @@ export const RuntimeExecutionStatusSchema = z
     handle: RuntimeExecutionHandleSchema,
     state: RuntimeExecutionStateSchema,
     observedAt: TimestampSchema,
-    // The generation the runtime observed for this attempt, when it has one.
-    // Additive in contract 3.1: a consumer that advertised an earlier version
-    // parses with the pre-3.1 strict status shape, so a producer publishes it
-    // only to a consumer whose negotiated version includes it.
     observedGeneration: RuntimeObservedGenerationSchema.optional(),
     result: RuntimeExecutionResultSchema.optional(),
-    // Observed usage survives unsuccessful termination without fabricating a result.
     terminalUsage: RuntimeUsageSchema.optional(),
     error: RuntimeErrorSchema.optional(),
 })
@@ -262,7 +238,6 @@ export const RuntimeExecutionPlanSnapshotSchema = z
     runtimeRequirements: CapabilityRequirementSetSchema,
 })
     .catchall(z.unknown());
-/** Allocation under an accepted allowance; not prepaid funds or charge authority. */
 export const RuntimeAttemptBudgetAuthoritySchema = z
     .object({
     schemaVersion: z.literal(1),

package/dist/agent-plugins.d.ts

@@ -1,9 +1,5 @@
 import { z } from 'zod';
 import type { RuntimeAdapterInspection } from './adapter.js';
-/**
- * Capability evidence reported by a tested runtime adapter. A harness name is
- * intentionally not enough to claim Agent Plugins support.
- */
 export declare const AgentPluginsCapabilityReportSchema: z.ZodObject<{
     versions: z.ZodArray<z.ZodString>;
     skills: z.ZodBoolean;

package/dist/agent-plugins.js

@@ -1,8 +1,4 @@
 import { z } from 'zod';
-/**
- * Capability evidence reported by a tested runtime adapter. A harness name is
- * intentionally not enough to claim Agent Plugins support.
- */
 export const AgentPluginsCapabilityReportSchema = z
     .object({
     versions: z.array(z.string().min(1).max(32)).max(16),

package/dist/channel-ownership.d.ts

@@ -35,11 +35,9 @@ export declare const RuntimeChannelSequenceRequestSchema: z.ZodObject<{
     minimum: z.ZodNumber;
 }, z.core.$strict>;
 export type RuntimeChannelSequenceRequest = z.output<typeof RuntimeChannelSequenceRequestSchema>;
-/** Reserve before sending; ambiguous/failed sends burn their range rather than reuse it. */
 export interface RuntimeChannelSequenceRepository {
     reserve(request: RuntimeChannelSequenceRequest): Promise<number>;
 }
-/** Durable fencing only; replacement notification is owned by the gateway coordinator. */
 export interface RuntimeChannelOwnershipRepository {
     claim(record: RuntimeChannelOwnership, credentialFence?: RuntimeChannelOwnershipCredentialFence): Promise<{
         accepted: boolean;

package/dist/inventory.d.ts

@@ -14,7 +14,6 @@ export declare const RuntimeInventoryScanSchema: z.ZodObject<{
     limit: z.ZodNumber;
 }, z.core.$strict>;
 export type RuntimeInventoryScan = z.output<typeof RuntimeInventoryScanSchema>;
-/** Internal worker scan across workspaces; not an end-user discovery operation. */
 export interface RuntimeInventoryCheckpointScanner {
     scan(input: RuntimeInventoryScan): Promise<readonly RuntimeInventoryCheckpoint[]>;
 }

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

@@ -43,51 +43,28 @@ export declare const PiDurableLeadReadEnvelopeSchema: z.ZodObject<{
     caller: typeof Caller;
     correlation: typeof Correlation;
 }, z.core.$strict>;
-/** Requested target reference: the session, task, and generation a caller
- *  asks to bind to an intent, echoed back on every receipt. UNTRUSTED by
- *  construction — the taskId is an opaque cross-system reference (Adea
- *  UUIDs and control-plane tsk_ ids share no namespace), and no lookup
- *  verifies the triple against session authority. Owners verify claimed
- *  vs retained vs independently observed bindings together; the shape
- *  alone proves nothing. */
 export declare const PiDurableLeadRequestedTargetSchema: z.ZodReadonly<z.ZodObject<{
     sessionId: z.ZodString;
     taskId: z.ZodString;
     generation: z.ZodNumber;
 }, z.core.$strict>>;
 export type PiDurableLeadRequestedTarget = z.output<typeof PiDurableLeadRequestedTargetSchema>;
-/** Server-owned execution observation: the session the runtime assigned
- *  this execution, the authority-resolved plan task, and the generation the
- *  runtime observed for the attempt that owns it. All three come from
- *  server-held records (adapter handle + admitted plan + the runtime's own
- *  observed generation), never from caller claims. A caller-claimed
- *  generation is retained on the request and echoed back as a claim; it can
- *  never appear here, because a claimed value laundered as an observation is
- *  not an observation. The generation is additive in contract 3.1: a consumer
- *  that advertised an earlier version parses with the strict pre-3.1 shape, so
- *  a producer publishes it only to a negotiated consumer. */
 export declare const PiDurableLeadObservedTargetSchema: z.ZodReadonly<z.ZodObject<{
     sessionId: z.ZodString;
     taskId: z.ZodString;
     generation: z.ZodOptional<typeof RuntimeObservedGenerationSchema>;
 }, z.core.$strict>>;
 export type PiDurableLeadObservedTarget = z.output<typeof PiDurableLeadObservedTargetSchema>;
-/** The contract version that introduced the runtime-observed generation on the
- *  lead receipt and on the runtime execution status. The field is optional and
- *  additive within the major, but the pre-3.1 target and runtime-status shapes
- *  are strict: a consumer that predates this version rejects an unknown key and
- *  reports an invalid response. */
 export declare const PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION: {
     readonly major: 3;
     readonly minor: 1;
 };
-/** Whether a consumer that advertised `consumerVersion` negotiated a contract
- *  that includes the runtime-observed generation. The producer and the consumer
- *  negotiate the highest common major and the lower of the two minors, so an
- *  earlier same-major consumer (or a consumer of another major) never receives
- *  the field it cannot parse. A consumer that advertised a newer minor already
- *  understands it. */
 export declare function supportsPiDurableObservedGeneration(consumerVersion: unknown): boolean;
+export declare const PI_DURABLE_REMOTE_SESSION_REFERENCE_CONTRACT_VERSION: {
+    readonly major: 3;
+    readonly minor: 2;
+};
+export declare function supportsPiDurableRemoteSessionReference(consumerVersion: unknown): boolean;
 export declare const PiDurableLeadPrepareRequestSchema: z.ZodObject<{
     contractVersion: z.ZodObject<{
         major: z.ZodNumber;
@@ -177,7 +154,6 @@ export declare const PiDurableLeadProgressRequestSchema: z.ZodObject<{
         afterSequence: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>;
 }, z.core.$strict>;
-/** Position after which the next page of children starts: the last returned child's sort key. */
 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>>;
@@ -202,6 +178,23 @@ export declare const PiDurableLeadChildrenRequestSchema: z.ZodObject<{
         limit: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>;
 }, z.core.$strict>;
+export declare const PiDurableLeadChildTargetRequestSchema: 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.child-target">;
+    parameters: z.ZodObject<{
+        dispatchId: typeof DispatchId;
+        delegationId: typeof IdentifierSchemas.delegationId;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export declare const PiDurableLeadCancelRequestSchema: z.ZodObject<{
     contractVersion: z.ZodObject<{
         major: z.ZodNumber;
@@ -232,9 +225,6 @@ export declare const PiDurableLeadReceiptResponseSchema: z.ZodObject<{
     observedTarget: z.ZodOptional<typeof PiDurableLeadObservedTargetSchema>;
 }, z.core.$strict>;
 declare const PlanDigest: z.ZodString;
-/** What the accepted lead plan holds back for child executions. Disclosure only: never a funding,
- *  admission or spending capability. `not_stated` means the plan holds nothing back, so only
- *  balance the lead releases can fund children; it is not an error and not a missing disclosure. */
 export declare const PiDurableLeadChildAllowanceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schemaVersion: z.ZodLiteral<"pi-lead-child-allowance/v1">;
     executionPlanDigest: typeof PlanDigest;
@@ -259,7 +249,6 @@ export declare const PiDurableLeadChildAllowanceSchema: z.ZodDiscriminatedUnion<
     }, z.core.$strict>>;
     state: z.ZodLiteral<"not_stated">;
 }, z.core.$strict>], "state">;
-/** Disclosure bound to a prepared canonical attempt; never a spending or runtime capability. */
 export declare const PiDurableLeadPreparationSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"pi-lead-preparation/v1">;
     preparationRef: typeof PiDurableLeadPreparationRefSchema;
@@ -321,7 +310,6 @@ export declare const PiDurableLeadPrepareResponseSchema: z.ZodObject<{
     }, z.core.$strict>;
     data: typeof PiDurableLeadPreparationSchema;
 }, z.core.$strict>;
-/** Stored dispatch metadata; lookup never creates an execution or runtime session. */
 export declare const PiDurableLeadLookupResponseSchema: z.ZodObject<{
     contractVersion: z.ZodObject<{
         major: z.ZodNumber;
@@ -449,7 +437,6 @@ export declare const PiDurableLeadCancelResponseSchema: z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strict>;
 declare const ChildReference: z.ZodString;
-/** Terminal child outcome as retained by the delegation record; identifiers and bounded codes only. */
 export declare const PiDurableLeadChildOutcomeSchema: z.ZodObject<{
     state: z.ZodEnum<{
         cancelled: "cancelled";
@@ -470,11 +457,6 @@ export declare const PiDurableLeadChildOutcomeSchema: z.ZodObject<{
         }>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
-/**
- * Canonical, authorized view of one child job of a lead dispatch. It is read from retained
- * delegation records only: no prompt, objective, plan, digest, credential or native payload.
- * `awaitingInput` is the child's own approval/input state; it is observation, never a grant.
- */
 export declare const PiDurableLeadChildSchema: z.ZodObject<{
     delegationId: typeof IdentifierSchemas.delegationId;
     childExecutionId: typeof IdentifierSchemas.executionId;
@@ -497,12 +479,6 @@ export declare const PiDurableLeadChildSchema: z.ZodObject<{
     revision: z.ZodNumber;
     outcome: z.ZodOptional<typeof PiDurableLeadChildOutcomeSchema>;
 }, z.core.$strict>;
-/**
- * One page of the dispatch's children, ordered by acceptance time then delegation ID.
- * `totalChildren` counts every child of this dispatch at the time of the read, so a consumer
- * can tell a complete set from a page. `complete` is true only when this page ends the set;
- * otherwise `next` is the cursor for the following page. A page is never silently cut short.
- */
 export declare const PiDurableLeadChildrenResponseSchema: z.ZodObject<{
     contractVersion: z.ZodObject<{
         major: z.ZodNumber;
@@ -529,7 +505,78 @@ export declare const PiDurableLeadChildrenResponseSchema: z.ZodObject<{
         next: z.ZodOptional<typeof PiDurableLeadChildrenCursorSchema>;
     }, z.core.$strict>;
 }, z.core.$strict>;
-/** Existing versioned authenticated envelopes; payloads contain opaque references only. */
+export declare const PiDurableLeadChildTargetSchema: z.ZodObject<{
+    source: z.ZodLiteral<"control_plane_reported">;
+    runtimeConnectionId: typeof IdentifierSchemas.runtimeConnectionId;
+    nativeSessionId: typeof IdentifierSchemas.externalSessionId;
+    nativeTaskId: typeof IdentifierSchemas.taskId;
+    nativeState: typeof RuntimeExecutionStateSchema;
+    observedAt: z.ZodISODateTime;
+    observedGeneration: z.ZodOptional<typeof RuntimeObservedGenerationSchema>;
+}, z.core.$strict>;
+export declare const PiDurableLeadRemoteSessionReferenceSchema: z.ZodReadonly<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"pi-child-remote-session-reference/v1">;
+    source: z.ZodLiteral<"control_plane_reported">;
+    basis: z.ZodLiteral<"retained_native_attribution">;
+    runtimeConnectionId: typeof IdentifierSchemas.runtimeConnectionId;
+    nativeSessionId: typeof IdentifierSchemas.externalSessionId;
+    permission: z.ZodLiteral<"none">;
+    history: z.ZodLiteral<"adapter_journal_only">;
+    attachment: z.ZodLiteral<"unavailable">;
+}, z.core.$strict>>;
+export type PiDurableLeadRemoteSessionReference = z.output<typeof PiDurableLeadRemoteSessionReferenceSchema>;
+export declare const PiDurableLeadChildTargetResponseSchema: 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>;
+        child: typeof PiDurableLeadChildSchema;
+        target: z.ZodNullable<z.ZodObject<{
+            source: z.ZodLiteral<"control_plane_reported">;
+            runtimeConnectionId: typeof IdentifierSchemas.runtimeConnectionId;
+            nativeSessionId: typeof IdentifierSchemas.externalSessionId;
+            nativeTaskId: typeof IdentifierSchemas.taskId;
+            nativeState: typeof RuntimeExecutionStateSchema;
+            observedAt: z.ZodISODateTime;
+            observedGeneration: z.ZodOptional<typeof RuntimeObservedGenerationSchema>;
+        }, z.core.$strict>>;
+        unavailableReason: z.ZodOptional<z.ZodEnum<{
+            NOT_CONFIGURED: "NOT_CONFIGURED";
+            NOT_STARTED: "NOT_STARTED";
+            UNAVAILABLE: "UNAVAILABLE";
+        }>>;
+        remoteSessionReference: z.ZodOptional<z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"pi-child-remote-session-reference/v1">;
+            source: z.ZodLiteral<"control_plane_reported">;
+            basis: z.ZodLiteral<"retained_native_attribution">;
+            runtimeConnectionId: typeof IdentifierSchemas.runtimeConnectionId;
+            nativeSessionId: typeof IdentifierSchemas.externalSessionId;
+            permission: z.ZodLiteral<"none">;
+            history: z.ZodLiteral<"adapter_journal_only">;
+            attachment: z.ZodLiteral<"unavailable">;
+        }, z.core.$strict>>>>;
+        remoteSessionReferenceUnavailableReason: z.ZodOptional<z.ZodEnum<{
+            NOT_CONFIGURED: "NOT_CONFIGURED";
+            NOT_STARTED: "NOT_STARTED";
+            UNAVAILABLE: "UNAVAILABLE";
+        }>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export declare const PiDurableLeadHttpContract: Readonly<{
     schemaVersion: "pi-lead-dispatch/v1";
     basePath: "/v3/pi-durable/lead-dispatches";
@@ -576,6 +623,13 @@ export declare const PiDurableLeadHttpContract: Readonly<{
         requestSchema: typeof PiDurableLeadChildrenRequestSchema;
         responseSchema: typeof PiDurableLeadChildrenResponseSchema;
     }>;
+    childTarget: Readonly<{
+        route: "child-target";
+        operation: "pi-durable.lead.child-target";
+        scope: "execution:read";
+        requestSchema: typeof PiDurableLeadChildTargetRequestSchema;
+        responseSchema: typeof PiDurableLeadChildTargetResponseSchema;
+    }>;
     cancel: Readonly<{
         route: "cancel";
         operation: "pi-durable.lead.cancel";
@@ -601,4 +655,7 @@ export type PiDurableLeadChildrenResponse = z.output<typeof PiDurableLeadChildre
 export type PiDurableLeadChild = z.output<typeof PiDurableLeadChildSchema>;
 export type PiDurableLeadCancelRequest = z.output<typeof PiDurableLeadCancelRequestSchema>;
 export type PiDurableLeadCancelResponse = z.output<typeof PiDurableLeadCancelResponseSchema>;
+export type PiDurableLeadChildTargetRequest = z.output<typeof PiDurableLeadChildTargetRequestSchema>;
+export type PiDurableLeadChildTargetResponse = z.output<typeof PiDurableLeadChildTargetResponseSchema>;
+export type PiDurableLeadChildTarget = z.output<typeof PiDurableLeadChildTargetSchema>;
 export {};

package/dist/pi-durable-lead.js

@@ -14,13 +14,6 @@ export const PiDurableLeadReadEnvelopeSchema = ReadRequestEnvelopeSchema.extend(
     caller: Caller,
     correlation: Correlation,
 }).strict();
-/** Requested target reference: the session, task, and generation a caller
- *  asks to bind to an intent, echoed back on every receipt. UNTRUSTED by
- *  construction — the taskId is an opaque cross-system reference (Adea
- *  UUIDs and control-plane tsk_ ids share no namespace), and no lookup
- *  verifies the triple against session authority. Owners verify claimed
- *  vs retained vs independently observed bindings together; the shape
- *  alone proves nothing. */
 export const PiDurableLeadRequestedTargetSchema = z
     .strictObject({
     sessionId: z.string().trim().min(1).max(256),
@@ -28,36 +21,14 @@ export const PiDurableLeadRequestedTargetSchema = z
     generation: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
 })
     .readonly();
-/** Server-owned execution observation: the session the runtime assigned
- *  this execution, the authority-resolved plan task, and the generation the
- *  runtime observed for the attempt that owns it. All three come from
- *  server-held records (adapter handle + admitted plan + the runtime's own
- *  observed generation), never from caller claims. A caller-claimed
- *  generation is retained on the request and echoed back as a claim; it can
- *  never appear here, because a claimed value laundered as an observation is
- *  not an observation. The generation is additive in contract 3.1: a consumer
- *  that advertised an earlier version parses with the strict pre-3.1 shape, so
- *  a producer publishes it only to a negotiated consumer. */
 export const PiDurableLeadObservedTargetSchema = z
     .strictObject({
     sessionId: z.string().trim().min(1).max(256),
     taskId: z.string().trim().min(1).max(256),
-    /** The runtime-observed generation, when the runtime has observed one. */
     generation: RuntimeObservedGenerationSchema.optional(),
 })
     .readonly();
-/** The contract version that introduced the runtime-observed generation on the
- *  lead receipt and on the runtime execution status. The field is optional and
- *  additive within the major, but the pre-3.1 target and runtime-status shapes
- *  are strict: a consumer that predates this version rejects an unknown key and
- *  reports an invalid response. */
 export const PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION = { major: 3, minor: 1 };
-/** Whether a consumer that advertised `consumerVersion` negotiated a contract
- *  that includes the runtime-observed generation. The producer and the consumer
- *  negotiate the highest common major and the lower of the two minors, so an
- *  earlier same-major consumer (or a consumer of another major) never receives
- *  the field it cannot parse. A consumer that advertised a newer minor already
- *  understands it. */
 export function supportsPiDurableObservedGeneration(consumerVersion) {
     const consumer = ContractVersionSchema.safeParse(consumerVersion);
     if (!consumer.success)
@@ -68,12 +39,15 @@ export function supportsPiDurableObservedGeneration(consumerVersion) {
     return (negotiated.major === PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION.major &&
         negotiated.minor >= PI_DURABLE_OBSERVED_GENERATION_CONTRACT_VERSION.minor);
 }
-/** Every published observed generation must belong to the attempt the receipt
- *  owns. A generation observed for another attempt is a late old-attempt
- *  event: publishing it would fence the wrong attempt, so it is refused
- *  instead. The fence covers both places a generation is published — the
- *  observed target and the embedded runtime status — so no publication path
- *  can carry a foreign generation. */
+export const PI_DURABLE_REMOTE_SESSION_REFERENCE_CONTRACT_VERSION = { major: 3, minor: 2 };
+export function supportsPiDurableRemoteSessionReference(consumerVersion) {
+    const consumer = ContractVersionSchema.safeParse(consumerVersion);
+    if (!consumer.success)
+        return false;
+    const negotiated = negotiateContractVersion([PublicContractManifest.current], [consumer.data]);
+    return (negotiated?.major === PI_DURABLE_REMOTE_SESSION_REFERENCE_CONTRACT_VERSION.major &&
+        negotiated.minor >= PI_DURABLE_REMOTE_SESSION_REFERENCE_CONTRACT_VERSION.minor);
+}
 function fenceForeignGeneration(receipt, context) {
     const foreign = (generation) => generation !== undefined && generation.attemptId !== receipt.attemptId;
     if (foreign(receipt.observedTarget?.generation))
@@ -120,7 +94,6 @@ export const PiDurableLeadProgressRequestSchema = PiDurableLeadReadEnvelopeSchem
     })
         .strict(),
 });
-/** Position after which the next page of children starts: the last returned child's sort key. */
 export const PiDurableLeadChildrenCursorSchema = z
     .object({ acceptedAt: z.iso.datetime(), delegationId: IdentifierSchemas.delegationId })
     .strict()
@@ -131,13 +104,20 @@ export const PiDurableLeadChildrenRequestSchema = PiDurableLeadReadEnvelopeSchem
     parameters: z
         .object({
         dispatchId: DispatchId,
-        /** Resume strictly after this child (acceptance time, then delegation ID). */
         after: PiDurableLeadChildrenCursorSchema.optional(),
-        /** Page size, 1..256; the default is the maximum. */
         limit: z.number().int().min(1).max(PI_DURABLE_LEAD_CHILDREN_MAX_PAGE).optional(),
     })
         .strict(),
 });
+export const PiDurableLeadChildTargetRequestSchema = PiDurableLeadReadEnvelopeSchema.extend({
+    operation: z.literal('pi-durable.lead.child-target'),
+    parameters: z
+        .object({
+        dispatchId: DispatchId,
+        delegationId: IdentifierSchemas.delegationId,
+    })
+        .strict(),
+});
 export const PiDurableLeadCancelRequestSchema = PiDurableLeadCommandEnvelopeSchema.extend({
     operation: z.literal('pi-durable.lead.cancel'),
     payload: z.object({ dispatchId: DispatchId }).strict(),
@@ -161,9 +141,7 @@ const response = SuccessResponseEnvelopeSchema.extend({ correlation: Correlation
 const PlanDigest = z.string().regex(/^sha256:[a-f0-9]{64}$/);
 const ChildAllowanceBinding = {
     schemaVersion: z.literal('pi-lead-child-allowance/v1'),
-    /** The accepted plan the statement is read from; the same plan the lead attempt runs under. */
     executionPlanDigest: PlanDigest,
-    /** Pinned profile version the plan was compiled from; matches a caller's opaque profile pin. */
     profile: z
         .strictObject({
         profileId: IdentifierSchemas.profileId,
@@ -173,9 +151,6 @@ const ChildAllowanceBinding = {
     })
         .readonly(),
 };
-/** What the accepted lead plan holds back for child executions. Disclosure only: never a funding,
- *  admission or spending capability. `not_stated` means the plan holds nothing back, so only
- *  balance the lead releases can fund children; it is not an error and not a missing disclosure. */
 export const PiDurableLeadChildAllowanceSchema = z.discriminatedUnion('state', [
     z.strictObject({
         ...ChildAllowanceBinding,
@@ -186,7 +161,6 @@ export const PiDurableLeadChildAllowanceSchema = z.discriminatedUnion('state', [
     }),
     z.strictObject({ ...ChildAllowanceBinding, state: z.literal('not_stated') }),
 ]);
-/** Disclosure bound to a prepared canonical attempt; never a spending or runtime capability. */
 export const PiDurableLeadPreparationSchema = z
     .object({
     schemaVersion: z.literal('pi-lead-preparation/v1'),
@@ -197,7 +171,6 @@ export const PiDurableLeadPreparationSchema = z
     selectionRef: ModelSelectionRefSchema,
     selectionRevision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
     funding: ModelSelectionFundingViewSchema.options[0],
-    /** Absent from a control plane that predates this disclosure; absence is not `not_stated`. */
     childAllowance: PiDurableLeadChildAllowanceSchema.optional(),
     expiresAt: z.iso.datetime(),
     replayed: z.boolean(),
@@ -222,7 +195,6 @@ export const PiDurableLeadPreparationSchema = z
 export const PiDurableLeadPrepareResponseSchema = response.extend({
     data: PiDurableLeadPreparationSchema,
 });
-/** Stored dispatch metadata; lookup never creates an execution or runtime session. */
 export const PiDurableLeadLookupResponseSchema = response.extend({
     data: z
         .object({
@@ -243,8 +215,6 @@ export const PiDurableLeadLookupResponseSchema = response.extend({
         })
             .strict()
             .superRefine((receipt, context) => {
-            // Same fence as the live receipt: an observed generation belongs to
-            // the attempt that owns it.
             fenceForeignGeneration(receipt, context);
         })
             .nullable(),
@@ -276,7 +246,6 @@ const ChildReference = z
     .min(1)
     .max(256)
     .regex(/^[A-Za-z0-9._:/-]+$/);
-/** Terminal child outcome as retained by the delegation record; identifiers and bounded codes only. */
 export const PiDurableLeadChildOutcomeSchema = z
     .object({
     state: z.enum(['completed', 'failed', 'cancelled']),
@@ -290,11 +259,6 @@ export const PiDurableLeadChildOutcomeSchema = z
         .strict(),
 })
     .strict();
-/**
- * Canonical, authorized view of one child job of a lead dispatch. It is read from retained
- * delegation records only: no prompt, objective, plan, digest, credential or native payload.
- * `awaitingInput` is the child's own approval/input state; it is observation, never a grant.
- */
 export const PiDurableLeadChildSchema = z
     .object({
     delegationId: IdentifierSchemas.delegationId,
@@ -319,12 +283,6 @@ export const PiDurableLeadChildSchema = z
     outcome: PiDurableLeadChildOutcomeSchema.optional(),
 })
     .strict();
-/**
- * One page of the dispatch's children, ordered by acceptance time then delegation ID.
- * `totalChildren` counts every child of this dispatch at the time of the read, so a consumer
- * can tell a complete set from a page. `complete` is true only when this page ends the set;
- * otherwise `next` is the cursor for the following page. A page is never silently cut short.
- */
 export const PiDurableLeadChildrenResponseSchema = response.extend({
     data: PiDurableLeadReceiptResponseSchema.extend({
         children: z
@@ -348,7 +306,64 @@ export const PiDurableLeadChildrenResponseSchema = response.extend({
             });
     }),
 });
-/** Existing versioned authenticated envelopes; payloads contain opaque references only. */
+export const PiDurableLeadChildTargetSchema = z.strictObject({
+    source: z.literal('control_plane_reported'),
+    runtimeConnectionId: IdentifierSchemas.runtimeConnectionId,
+    nativeSessionId: IdentifierSchemas.externalSessionId,
+    nativeTaskId: IdentifierSchemas.taskId,
+    nativeState: RuntimeExecutionStateSchema,
+    observedAt: z.iso.datetime(),
+    observedGeneration: RuntimeObservedGenerationSchema.optional(),
+});
+export const PiDurableLeadRemoteSessionReferenceSchema = z
+    .strictObject({
+    schemaVersion: z.literal('pi-child-remote-session-reference/v1'),
+    source: z.literal('control_plane_reported'),
+    basis: z.literal('retained_native_attribution'),
+    runtimeConnectionId: IdentifierSchemas.runtimeConnectionId,
+    nativeSessionId: IdentifierSchemas.externalSessionId,
+    permission: z.literal('none'),
+    history: z.literal('adapter_journal_only'),
+    attachment: z.literal('unavailable'),
+})
+    .readonly();
+export const PiDurableLeadChildTargetResponseSchema = response.extend({
+    data: PiDurableLeadReceiptResponseSchema.extend({
+        child: PiDurableLeadChildSchema,
+        target: PiDurableLeadChildTargetSchema.nullable(),
+        unavailableReason: z.enum(['NOT_STARTED', 'NOT_CONFIGURED', 'UNAVAILABLE']).optional(),
+        remoteSessionReference: PiDurableLeadRemoteSessionReferenceSchema.nullable().optional(),
+        remoteSessionReferenceUnavailableReason: z
+            .enum(['NOT_STARTED', 'NOT_CONFIGURED', 'UNAVAILABLE'])
+            .optional(),
+    }).superRefine((value, context) => {
+        const reference = value.remoteSessionReference;
+        if ((reference === null) !== (value.remoteSessionReferenceUnavailableReason !== undefined))
+            context.addIssue({
+                code: 'custom',
+                message: 'Unavailable remote reference requires a bounded reason',
+            });
+        if (reference &&
+            (value.child.childAttemptId === undefined ||
+                (value.target !== null &&
+                    (reference.runtimeConnectionId !== value.target.runtimeConnectionId ||
+                        reference.nativeSessionId !== value.target.nativeSessionId))))
+            context.addIssue({
+                code: 'custom',
+                message: 'Remote reference must bind the selected child target',
+            });
+        if ((value.target === null) !== (value.unavailableReason !== undefined))
+            context.addIssue({ code: 'custom', message: 'Unavailable target requires a bounded reason' });
+        if (value.target &&
+            (value.child.childAttemptId === undefined ||
+                (value.target.observedGeneration !== undefined &&
+                    value.target.observedGeneration.attemptId !== value.child.childAttemptId)))
+            context.addIssue({
+                code: 'custom',
+                message: 'Native target must bind the selected child attempt',
+            });
+    }),
+});
 export const PiDurableLeadHttpContract = Object.freeze({
     schemaVersion: 'pi-lead-dispatch/v1',
     basePath: '/v3/pi-durable/lead-dispatches',
@@ -395,6 +410,13 @@ export const PiDurableLeadHttpContract = Object.freeze({
         requestSchema: PiDurableLeadChildrenRequestSchema,
         responseSchema: PiDurableLeadChildrenResponseSchema,
     }),
+    childTarget: Object.freeze({
+        route: 'child-target',
+        operation: 'pi-durable.lead.child-target',
+        scope: 'execution:read',
+        requestSchema: PiDurableLeadChildTargetRequestSchema,
+        responseSchema: PiDurableLeadChildTargetResponseSchema,
+    }),
     cancel: Object.freeze({
         route: 'cancel',
         operation: 'pi-durable.lead.cancel',

package/dist/routing.js

@@ -306,12 +306,7 @@ function normalizeRoutingInput(input) {
             .toSorted((left, right) => compareCodePointOrder(left.runtimeConnectionId, right.runtimeConnectionId)),
     };
 }
-// The digest below serializes fixed-order literals, so verification recomputes
-// over the persisted array order and stored decisions remain verifiable across
-// this ordering change (#612 in-place disposition, same rationale as #618).
 function compareCoded(left, right) {
-    // Code-point ordering keeps decision serialization host-independent; stored
-    // decisions always verify against their own persisted array order (#612).
     return compareCodePointOrder(`${left.code}:${left.capability ?? ''}`, `${right.code}:${right.capability ?? ''}`);
 }
 function digest(value) {

package/dist/transport.d.ts

@@ -1,14 +1,6 @@
 import type { RuntimeAdapter, RuntimeAdapterInspection, RuntimeApprovalRequest, RuntimeCancelRequest, RuntimeExecutionHandle, RuntimeExecutionProgress, RuntimeExecutionStatus, RuntimeInputRequest, RuntimeProgressOptions, RuntimeSessionOperation, RuntimeSessionResult, RuntimeStartRequest } from './adapter.js';
 export type RuntimeTransportKind = 'direct-local' | 'remote-gateway';
-/**
- * Concrete runtime operations at the location where a harness executes.
- * Drivers do not decide whether their caller is co-located or remote.
- */
 export type RuntimeDriver = RuntimeAdapter;
-/**
- * Selects how normalized RuntimeAdapter operations reach a RuntimeDriver.
- * Transport choice is topology metadata and never changes semantic payloads.
- */
 export interface RuntimeTransport extends RuntimeAdapter {
     readonly kind: RuntimeTransportKind;
 }
@@ -32,7 +24,6 @@ declare abstract class DelegatingRuntimeAdapter implements RuntimeAdapter {
 declare abstract class DelegatingRuntimeTransport extends DelegatingRuntimeAdapter implements RuntimeTransport {
     abstract readonly kind: RuntimeTransportKind;
 }
-/** Adapter-side facade that records topology while preserving the driver's semantic surface. */
 export declare class TransportedRuntimeAdapter extends DelegatingRuntimeAdapter implements RuntimeAdapterWithTransport {
     protected readonly transport: RuntimeTransport;
     readonly expectedAdapterName: string;
@@ -40,14 +31,9 @@ export declare class TransportedRuntimeAdapter extends DelegatingRuntimeAdapter
     constructor(transport: RuntimeTransport, expectedAdapterName: string);
     inspect(requirements?: Parameters<RuntimeAdapter['inspect']>[0]): Promise<RuntimeAdapterInspection>;
 }
-/** In-process/IPC-free transport for a co-located Local or Hosted runtime driver. */
 export declare class DirectLocalRuntimeTransport extends DelegatingRuntimeTransport {
     readonly kind: 'direct-local';
 }
-/**
- * Semantic wrapper for a driver proxy backed by the authenticated Runtime Gateway.
- * Wire delivery, reconnect, and command-ledger behavior remain in the proxy driver.
- */
 export declare class RemoteRuntimeGatewayTransport extends DelegatingRuntimeTransport {
     readonly kind: 'remote-gateway';
 }

package/dist/transport.js

@@ -37,7 +37,6 @@ class DelegatingRuntimeAdapter {
 }
 class DelegatingRuntimeTransport extends DelegatingRuntimeAdapter {
 }
-/** Adapter-side facade that records topology while preserving the driver's semantic surface. */
 export class TransportedRuntimeAdapter extends DelegatingRuntimeAdapter {
     transport;
     expectedAdapterName;
@@ -59,14 +58,9 @@ export class TransportedRuntimeAdapter extends DelegatingRuntimeAdapter {
         });
     }
 }
-/** In-process/IPC-free transport for a co-located Local or Hosted runtime driver. */
 export class DirectLocalRuntimeTransport extends DelegatingRuntimeTransport {
     kind = 'direct-local';
 }
-/**
- * Semantic wrapper for a driver proxy backed by the authenticated Runtime Gateway.
- * Wire delivery, reconnect, and command-ledger behavior remain in the proxy driver.
- */
 export class RemoteRuntimeGatewayTransport extends DelegatingRuntimeTransport {
     kind = 'remote-gateway';
 }

package/package.json

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