@zq-silk/yui 0.6.8 → 0.6.10

package/dist/runtime/continuationManager.js

@@ -0,0 +1,117 @@
+import { createProviderContinuation, observeProviderContinuation, providerContinuationKey, recordProviderReport } from "./providerContinuation.js";
+import { createRuntimeObservation } from "./runtimeObservation.js";
+export function foldContinuationObservation(existing, raw) {
+    const observation = createRuntimeObservation(raw);
+    if (!observation.kind.startsWith("continuation.")) {
+        throw new Error("ContinuationManager requires a continuation observation.");
+    }
+    const identity = continuationIdentity(observation);
+    const payload = observation.payload;
+    const base = existing ?? createProviderContinuation({
+        taskId: observation.fence.taskId,
+        roleName: observation.fence.roleName,
+        runId: observation.fence.runId,
+        identity,
+        ...(observation.fence.parentContinuationId === undefined
+            ? {}
+            : { parentContinuationId: observation.fence.parentContinuationId }),
+        attachment: payload.attachment,
+        observation: payload.observationQuality,
+        // A report is model-visible information, not settlement evidence. When
+        // it arrives before start, keep a conservative writer umbrella until an
+        // exact continuation.settled or complete native-work snapshot releases it.
+        mayWriteWorkspace: observation.kind === "continuation.reported"
+            ? true
+            : payload.mayWriteWorkspace,
+        observedAt: observation.observedAt ?? observation.receivedAt,
+        ...(observation.sequence === undefined ? {} : { providerSequence: observation.sequence })
+    });
+    if (existing !== null && providerContinuationKey(existing.identity) !== providerContinuationKey(identity)) {
+        throw new Error("Continuation observation identity does not match the existing projection.");
+    }
+    if (observation.kind === "continuation.reported") {
+        const next = recordProviderReport(base, {
+            reportId: payload.reportId,
+            ...(payload.resultRef === undefined ? {} : { resultRef: payload.resultRef }),
+            ...(payload.providerDeliveryRef === undefined
+                ? {}
+                : { providerDeliveryRef: payload.providerDeliveryRef }),
+            observedAt: observation.observedAt ?? observation.receivedAt
+        }, observation.sequence);
+        return {
+            disposition: next === base ? "duplicate" : "reported",
+            continuation: next
+        };
+    }
+    const next = observeProviderContinuation(base, {
+        execution: payload.execution,
+        outcome: payload.outcome,
+        attachment: payload.attachment,
+        observation: payload.observationQuality,
+        mayWriteWorkspace: payload.mayWriteWorkspace,
+        observedAt: observation.observedAt ?? observation.receivedAt,
+        ...(payload.resultRef === undefined ? {} : { resultRef: payload.resultRef }),
+        ...(observation.sequence === undefined ? {} : { providerSequence: observation.sequence })
+    });
+    return {
+        disposition: next === base
+            ? existing === null ? "created" : "duplicate"
+            : next.identityConflict ? "conflict"
+                : observation.kind === "continuation.settled" ? "settled"
+                    : existing === null ? "created" : "updated",
+        continuation: next
+    };
+}
+/**
+ * Commits the semantic continuation fact and its Leader notification before
+ * releasing child ownership. The surrounding TaskStore transaction is the
+ * crash boundary; a replay with the same semanticKey becomes a no-op.
+ */
+export function applyContinuationObservationAtomically(store, raw, factRef) {
+    const observation = createRuntimeObservation(raw);
+    const identity = continuationIdentity(observation);
+    return store.transaction((tx) => {
+        const result = foldContinuationObservation(tx.getProviderContinuation(providerContinuationKey(identity)), observation);
+        if (!tx.appendContinuationFactOnce(observation.semanticKey, observation, result.continuation)) {
+            return { disposition: "duplicate", continuation: result.continuation };
+        }
+        tx.saveProviderContinuation(result.continuation);
+        if (result.disposition === "reported" || result.disposition === "settled"
+            || result.disposition === "conflict") {
+            tx.enqueueContinuationSignal({
+                taskId: result.continuation.taskId,
+                roleName: "leader",
+                signal: {
+                    reason: result.disposition === "reported"
+                        ? "provider-continuation-report"
+                        : result.disposition === "settled"
+                            ? "provider-continuation-settled"
+                            : "provider-continuation-identity-conflict",
+                    refs: [factRef],
+                    occurredAt: observation.observedAt ?? observation.receivedAt,
+                    source: "continuation-manager",
+                    dedupeKey: observation.semanticKey,
+                    deliveryMode: "followup",
+                    lane: "normal"
+                }
+            });
+        }
+        return result;
+    });
+}
+function continuationIdentity(observation) {
+    const fence = observation.fence;
+    if (fence.taskId === undefined || fence.runId === undefined
+        || fence.conversationId === undefined || fence.activationId === undefined
+        || fence.continuationId === undefined) {
+        throw new Error("Continuation observation fence is incomplete.");
+    }
+    return {
+        providerNamespace: fence.driverId,
+        accountScope: fence.agentId,
+        conversationId: fence.conversationId,
+        activationId: fence.activationId,
+        continuationId: fence.continuationId,
+        generation: fence.continuationGeneration
+    };
+}

package/dist/runtime/index.js

@@ -9,4 +9,6 @@ export { FileTaskRuntimeIsolation, YUI_TASK_RUNTIME_ISOLATION_DESCRIPTOR, YUI_TA
 export { createSessionOwnerIdentity, discoverProviderRootByLaunchEnv, isLinuxProcessLive, listLaunchFencedProcesses, listOwnedProcessTree, readLinuxProcessIdentity } from "./sessionOwnerIdentity.js";
 export { FileSessionOwnerRegistry } from "./sessionOwnerRegistry.js";
 export { DEFAULT_FORCED_GRACE_MS, DEFAULT_GRACEFUL_GRACE_MS, terminateSessionOwners } from "./sessionTerminationGuard.js";
+export { ProviderContinuationReconciliationService } from "./providerContinuationReconciliationService.js";
+export { codexNotificationBoundary, CodexAppServerRequestError, CodexAppServerRuntime } from "./codexAppServerRuntime.js";
 export { reconcileSessionOwners } from "./sessionReconciliation.js";

package/dist/runtime/lifecycleReservation.js

@@ -1,3 +1,4 @@
+import { mailboxHasWork } from "../coordination/workMailbox.js";
 export const RUNTIME_LIFECYCLE_OWNER = "runtime-lifecycle";
 export const RUNTIME_LAUNCH_RESERVED_REASON = "runtime-launch-reserved";
 export const RUNTIME_CLEANUP_REQUIRED_REASON = "runtime-cleanup-required";
@@ -28,11 +29,11 @@ export function hasRuntimeLaunchReservation(mailbox) {
     return isRuntimeLaunchReservation(mailbox?.processing);
 }
 export function hasRuntimeCleanupObligation(mailbox) {
-    return mailbox?.pending?.reasons.includes(RUNTIME_CLEANUP_REQUIRED_REASON) === true
+    const pending = mailbox?.pending.normal;
+    return pending?.reasons.includes(RUNTIME_CLEANUP_REQUIRED_REASON) === true
         || (!isRuntimeLaunchReservation(mailbox?.processing)
             && mailbox?.processing?.batch.reasons.includes(RUNTIME_CLEANUP_REQUIRED_REASON) === true);
 }
 export function hasRuntimeLifecycleWork(mailbox) {
-    return mailbox !== null
-        && (mailbox.processing !== null || mailbox.pending !== null);
+    return mailbox !== null && mailboxHasWork(mailbox);
 }

package/dist/runtime/promptEnvelope.js

@@ -1,13 +1,15 @@
 import { requireText, requireTimestamp } from "./validation.js";
 import { formatAgentRunReceiptId, formatInputRequestReceiptId, validateTaskRecordReference } from "../task/taskRecordReference.js";
 export function createPromptEnvelope(input) {
-    if (input.source.kind !== "agent-run" && input.source.kind !== "input-request") {
+    if (input.source.kind !== "agent-run"
+        && input.source.kind !== "run-input"
+        && input.source.kind !== "input-request") {
         throw new Error("Prompt source kind is invalid.");
     }
     const source = validateTaskRecordReference({
         taskId: input.source.taskId,
         localId: input.source.localId
-    }, input.source.kind === "agent-run" ? "agentRun" : "inputRequest");
+    }, input.source.kind === "input-request" ? "inputRequest" : "agentRun");
     const id = requireQualifiedReceiptId(input.id, input.source.kind, source.taskId, source.localId);
     return {
         id,
@@ -23,7 +25,16 @@ export function createPromptEnvelope(input) {
 function requireQualifiedReceiptId(value, kind, taskId, localId) {
     const expected = kind === "agent-run"
         ? formatAgentRunReceiptId(taskId, localId)
-        : formatInputRequestReceiptId(taskId, localId);
+        : kind === "input-request"
+            ? formatInputRequestReceiptId(taskId, localId)
+            : `agent-input:${taskId}/${localId}/`;
+    if (kind === "run-input") {
+        if (!value.startsWith(expected)
+            || !/^(normal|user-correction):[1-9]\d*-[1-9]\d*$/.test(value.slice(expected.length))) {
+            throw new Error("Prompt envelope id does not match its source.");
+        }
+        return value;
+    }
     if (value !== expected)
         throw new Error("Prompt envelope id does not match its source.");
     return expected;

package/dist/runtime/providerContinuation.js

@@ -0,0 +1,225 @@
+export function providerContinuationKey(identity) {
+    const normalized = validateProviderContinuationIdentity(identity);
+    return [
+        normalized.providerNamespace,
+        normalized.accountScope,
+        normalized.conversationId,
+        normalized.activationId,
+        normalized.continuationId,
+        normalized.generation
+    ].join("\u0000");
+}
+export function createProviderContinuation(input) {
+    return validateProviderContinuation({
+        schemaVersion: 1,
+        taskId: text(input.taskId, "Task id"),
+        roleName: text(input.roleName, "Role name"),
+        runId: text(input.runId, "Run id"),
+        identity: validateProviderContinuationIdentity(input.identity),
+        ...(input.parentContinuationId === undefined
+            ? {}
+            : { parentContinuationId: text(input.parentContinuationId, "Parent Continuation id") }),
+        execution: "active",
+        outcome: "pending",
+        attachment: input.attachment,
+        observation: input.observation,
+        mayWriteWorkspace: input.mayWriteWorkspace,
+        reports: [],
+        ...(input.providerSequence === undefined ? {} : { lastProviderSequence: input.providerSequence }),
+        identityConflict: false,
+        createdAt: timestamp(input.observedAt, "Continuation observedAt"),
+        updatedAt: input.observedAt
+    });
+}
+export function recordProviderReport(raw, report, providerSequence) {
+    const current = validateProviderContinuation(raw);
+    if (current.identityConflict)
+        return current;
+    if (providerSequenceRegresses(current, providerSequence))
+        return current;
+    const normalized = validateProviderReport(report);
+    if (current.reports.some((entry) => entry.reportId === normalized.reportId))
+        return current;
+    return validateProviderContinuation({
+        ...current,
+        reports: [...current.reports, normalized],
+        ...(providerSequence === undefined ? {} : { lastProviderSequence: providerSequence }),
+        updatedAt: normalized.observedAt
+    });
+}
+export function observeProviderContinuation(raw, input) {
+    const current = validateProviderContinuation(raw);
+    if (current.identityConflict || providerSequenceRegresses(current, input.providerSequence)) {
+        return current;
+    }
+    const observedAt = timestamp(input.observedAt, "Continuation observedAt");
+    if (current.settledAt !== undefined) {
+        if (input.execution === "quiescent"
+            && input.outcome === current.outcome
+            && (input.resultRef === undefined || input.resultRef === current.resultRef))
+            return current;
+        // Exact terminal evidence may fill a result reference that was indexed
+        // after settlement, but it can never replace an existing reference.
+        if (input.execution === "quiescent"
+            && input.observation === "exact"
+            && input.outcome === current.outcome
+            && current.resultRef === undefined
+            && input.resultRef !== undefined) {
+            return validateProviderContinuation({
+                ...current,
+                resultRef: text(input.resultRef, "Result ref"),
+                ...(input.providerSequence === undefined
+                    ? {}
+                    : { lastProviderSequence: input.providerSequence }),
+                updatedAt: observedAt
+            });
+        }
+        // Exact absence/completeness can close writer ownership before the
+        // provider's terminal result record arrives. A later exact terminal fact
+        // may refine only the unknown outcome; it cannot reopen execution.
+        if (current.outcome === "unknown"
+            && input.execution === "quiescent"
+            && input.observation === "exact"
+            && input.outcome !== "pending") {
+            return validateProviderContinuation({
+                ...current,
+                outcome: input.outcome,
+                ...(input.resultRef === undefined ? {} : { resultRef: text(input.resultRef, "Result ref") }),
+                ...(input.providerSequence === undefined
+                    ? {}
+                    : { lastProviderSequence: input.providerSequence }),
+                updatedAt: observedAt
+            });
+        }
+        return validateProviderContinuation({ ...current, identityConflict: true, updatedAt: observedAt });
+    }
+    if (input.execution === "quiescent" && input.observation !== "exact") {
+        return validateProviderContinuation({
+            ...current,
+            execution: "unknown",
+            observation: input.observation,
+            attachment: input.attachment,
+            // Partial/unavailable evidence cannot release an already-established
+            // writer umbrella. Only exact quiescence may prove workspace ownership
+            // ended; otherwise cleanup could race a detached provider process.
+            mayWriteWorkspace: current.mayWriteWorkspace || input.mayWriteWorkspace,
+            ...(input.providerSequence === undefined ? {} : { lastProviderSequence: input.providerSequence }),
+            updatedAt: observedAt
+        });
+    }
+    return validateProviderContinuation({
+        ...current,
+        execution: input.execution,
+        outcome: input.outcome,
+        attachment: input.attachment,
+        observation: input.observation,
+        mayWriteWorkspace: input.mayWriteWorkspace,
+        ...(input.resultRef === undefined ? {} : { resultRef: text(input.resultRef, "Result ref") }),
+        ...(input.execution === "quiescent" && input.observation === "exact"
+            ? { settledAt: observedAt }
+            : {}),
+        ...(input.providerSequence === undefined ? {} : { lastProviderSequence: input.providerSequence }),
+        updatedAt: observedAt
+    });
+}
+export function detachProviderContinuation(raw, observedAt) {
+    const current = validateProviderContinuation(raw);
+    if (current.attachment === "detached")
+        return current;
+    return validateProviderContinuation({
+        ...current,
+        attachment: "detached",
+        updatedAt: timestamp(observedAt, "Continuation detachedAt")
+    });
+}
+export function continuationOwnsWriterUmbrella(value) {
+    const continuation = validateProviderContinuation(value);
+    return continuation.mayWriteWorkspace
+        && continuation.identityConflict === false
+        && (continuation.execution === "active" || continuation.execution === "unknown");
+}
+export function validateProviderContinuation(value) {
+    if (value.schemaVersion !== 1)
+        throw new Error("Provider Continuation schemaVersion must be 1.");
+    text(value.taskId, "Task id");
+    text(value.roleName, "Role name");
+    text(value.runId, "Run id");
+    validateProviderContinuationIdentity(value.identity);
+    if (!["active", "quiescent", "unknown"].includes(value.execution)) {
+        throw new Error("Provider Continuation execution is invalid.");
+    }
+    if (!["pending", "succeeded", "failed", "cancelled", "unknown"].includes(value.outcome)) {
+        throw new Error("Provider Continuation outcome is invalid.");
+    }
+    if (value.attachment !== "attached" && value.attachment !== "detached") {
+        throw new Error("Provider Continuation attachment is invalid.");
+    }
+    if (!["exact", "partial", "unavailable"].includes(value.observation)) {
+        throw new Error("Provider Continuation observation quality is invalid.");
+    }
+    if (typeof value.mayWriteWorkspace !== "boolean" || typeof value.identityConflict !== "boolean") {
+        throw new Error("Provider Continuation flags are invalid.");
+    }
+    const reports = value.reports.map(validateProviderReport);
+    if (new Set(reports.map((entry) => entry.reportId)).size !== reports.length) {
+        throw new Error("Provider Continuation reports contain duplicate identity.");
+    }
+    timestamp(value.createdAt, "Provider Continuation createdAt");
+    timestamp(value.updatedAt, "Provider Continuation updatedAt");
+    if (value.settledAt !== undefined) {
+        timestamp(value.settledAt, "Provider Continuation settledAt");
+        if (value.execution !== "quiescent" || value.observation !== "exact") {
+            throw new Error("Settled Provider Continuation requires exact quiescence.");
+        }
+    }
+    if (value.execution === "active" && value.outcome !== "pending") {
+        throw new Error("Active Provider Continuation outcome must remain pending.");
+    }
+    if (value.lastProviderSequence !== undefined)
+        sequence(value.lastProviderSequence);
+    return value;
+}
+export function validateProviderContinuationIdentity(value) {
+    text(value.providerNamespace, "Provider namespace");
+    text(value.accountScope, "Provider account scope");
+    text(value.conversationId, "Provider Conversation id");
+    text(value.activationId, "Provider Activation id");
+    text(value.continuationId, "Provider Continuation id");
+    if (!Number.isSafeInteger(value.generation) || value.generation < 1) {
+        throw new Error("Provider Continuation generation is invalid.");
+    }
+    return value;
+}
+function validateProviderReport(value) {
+    return {
+        reportId: text(value.reportId, "Provider report id"),
+        ...(value.resultRef === undefined ? {} : { resultRef: text(value.resultRef, "Result ref") }),
+        ...(value.providerDeliveryRef === undefined
+            ? {}
+            : { providerDeliveryRef: text(value.providerDeliveryRef, "Provider delivery ref") }),
+        observedAt: timestamp(value.observedAt, "Provider report observedAt")
+    };
+}
+function providerSequenceRegresses(current, incoming) {
+    if (incoming === undefined)
+        return false;
+    sequence(incoming);
+    return current.lastProviderSequence !== undefined && incoming < current.lastProviderSequence;
+}
+function sequence(value) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new Error("Provider sequence is invalid.");
+    return value;
+}
+function text(value, label) {
+    if (typeof value !== "string" || value.includes("\0") || value.trim().length === 0) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return value.trim();
+}
+function timestamp(value, label) {
+    const normalized = text(value, label);
+    if (!Number.isFinite(Date.parse(normalized)))
+        throw new Error(`${label} must be a timestamp.`);
+    return normalized;
+}

package/dist/runtime/providerContinuationReconciliationService.js

@@ -0,0 +1,172 @@
+import { createHash } from "node:crypto";
+import { providerContinuationKey } from "./providerContinuation.js";
+import { projectProviderContinuations } from "./runtimeContinuationProjection.js";
+import { reconcileKnownDetachedContinuations } from "./providerRuntimeReconciler.js";
+import { createRuntimeObservation, runtimeObservationFromTaskEvent } from "./runtimeObservation.js";
+/**
+ * Low-frequency, metadata-only recovery for already-known detached children.
+ * No launch/model method is reachable through this object. The backoff is an
+ * advisory cache; committed observations remain the only durable authority.
+ */
+export class ProviderContinuationReconciliationService {
+    store;
+    sink;
+    metadata;
+    #schedules = new Map();
+    constructor(store, sink, metadata) {
+        this.store = store;
+        this.sink = sink;
+        this.metadata = metadata;
+    }
+    async reconcile(now) {
+        const changedTaskIds = new Set();
+        for (const task of this.store.listTasks().filter((entry) => entry.status === "active")) {
+            const events = this.store.listEvents(task.id);
+            const groups = groupDetachedContinuations(projectProviderContinuations(events), events.map(runtimeObservationFromTaskEvent)
+                .filter((entry) => entry !== null));
+            for (const [groupKey, candidates] of groups) {
+                const group = candidates.map(({ continuation }) => continuation);
+                const previous = this.#schedules.get(groupKey);
+                if (previous !== undefined && Date.parse(previous.nextReconcileAt) > now.getTime()) {
+                    continue;
+                }
+                let result;
+                try {
+                    result = await reconcileKnownDetachedContinuations({
+                        port: this.metadata,
+                        continuations: group,
+                        ...(previous === undefined ? {} : { previous }),
+                        now
+                    });
+                }
+                catch {
+                    // One malformed identity group must not restart or block the
+                    // Controller. Keep it writer-owned and retry through the same
+                    // bounded, metadata-only schedule.
+                    this.#schedules.set(groupKey, failureSchedule(groupKey, previous, now));
+                    continue;
+                }
+                if (result.schedule === null)
+                    this.#schedules.delete(groupKey);
+                else
+                    this.#schedules.set(groupKey, result.schedule);
+                for (let index = 0; index < group.length; index += 1) {
+                    const before = group[index];
+                    const after = result.continuations[index];
+                    if (sameContinuationState(before, after))
+                        continue;
+                    const disposition = this.sink.observeRuntimeObservation(reconciliationObservation(after, candidates[index].fence, now), now);
+                    if (disposition === "applied")
+                        changedTaskIds.add(after.taskId);
+                }
+            }
+        }
+        return Object.freeze([...changedTaskIds].sort());
+    }
+}
+function failureSchedule(key, previous, now) {
+    const attempts = (previous?.attempts ?? 0) + 1;
+    const errors = (previous?.consecutiveErrors ?? 0) + 1;
+    const delay = Math.min(5 * 60_000, 2_000 * (2 ** Math.min(attempts - 1, 8)));
+    return Object.freeze({
+        key,
+        attempts,
+        consecutiveErrors: errors,
+        nextReconcileAt: new Date(now.getTime() + delay).toISOString(),
+        ...(errors < 5
+            ? {}
+            : { circuitOpenUntil: new Date(now.getTime() + 5 * 60_000).toISOString() })
+    });
+}
+function groupDetachedContinuations(continuations, observations) {
+    const groups = new Map();
+    for (const continuation of continuations) {
+        if (continuation.attachment !== "detached"
+            || continuation.identityConflict
+            || (continuation.execution !== "active" && continuation.execution !== "unknown")) {
+            continue;
+        }
+        const key = [
+            continuation.identity.providerNamespace,
+            continuation.identity.accountScope,
+            continuation.identity.conversationId,
+            continuation.identity.activationId
+        ].join("\u0000");
+        const source = [...observations].reverse().find((observation) => (observation.kind.startsWith("continuation.")
+            && observation.fence.driverId === continuation.identity.providerNamespace
+            && observation.fence.agentId === continuation.identity.accountScope
+            && observation.fence.conversationId === continuation.identity.conversationId
+            && observation.fence.activationId === continuation.identity.activationId
+            && observation.fence.continuationId === continuation.identity.continuationId
+            && observation.fence.continuationGeneration === continuation.identity.generation));
+        // A projected continuation without its original durable fence cannot be
+        // safely attached to a live Run. Keep ownership conservative and let the
+        // malformed identity remain visible instead of synthesizing a receipt.
+        if (source === undefined)
+            continue;
+        const group = groups.get(key) ?? [];
+        group.push({ continuation, fence: source.fence });
+        groups.set(key, group);
+    }
+    return groups;
+}
+function sameContinuationState(left, right) {
+    return left.execution === right.execution
+        && left.outcome === right.outcome
+        && left.attachment === right.attachment
+        && left.observation === right.observation
+        && left.mayWriteWorkspace === right.mayWriteWorkspace
+        && left.resultRef === right.resultRef
+        && left.lastProviderSequence === right.lastProviderSequence
+        && left.identityConflict === right.identityConflict;
+}
+function reconciliationObservation(continuation, sourceFence, now) {
+    const key = providerContinuationKey(continuation.identity);
+    const state = [
+        continuation.execution,
+        continuation.outcome,
+        continuation.observation,
+        continuation.mayWriteWorkspace ? "writer" : "read-only",
+        continuation.resultRef ?? "none",
+        continuation.lastProviderSequence ?? "none"
+    ].join(":");
+    const digest = createHash("sha256").update(`${key}\u0000${state}`).digest("hex");
+    const settled = continuation.execution === "quiescent"
+        && continuation.observation === "exact";
+    return createRuntimeObservation({
+        schemaVersion: 2,
+        eventId: `continuation-reconcile:${digest}`,
+        semanticKey: `continuation-reconcile:${digest}`,
+        kind: settled ? "continuation.settled" : "continuation.started",
+        authority: "provider-structured",
+        receivedAt: now.toISOString(),
+        observedAt: now.toISOString(),
+        ...(continuation.lastProviderSequence === undefined
+            ? {}
+            : { sequence: continuation.lastProviderSequence }),
+        fence: {
+            ...sourceFence,
+            taskId: continuation.taskId,
+            roleName: continuation.roleName,
+            runId: continuation.runId,
+            agentId: continuation.identity.accountScope,
+            driverId: continuation.identity.providerNamespace,
+            conversationId: continuation.identity.conversationId,
+            activationId: continuation.identity.activationId,
+            nativeSessionId: continuation.identity.conversationId,
+            continuationId: continuation.identity.continuationId,
+            continuationGeneration: continuation.identity.generation,
+            ...(continuation.parentContinuationId === undefined
+                ? {}
+                : { parentContinuationId: continuation.parentContinuationId })
+        },
+        payload: {
+            execution: continuation.execution,
+            outcome: continuation.outcome,
+            attachment: "detached",
+            observationQuality: continuation.observation,
+            mayWriteWorkspace: continuation.mayWriteWorkspace,
+            ...(continuation.resultRef === undefined ? {} : { resultRef: continuation.resultRef })
+        }
+    });
+}