@zq-silk/yui 0.16.1 → 1.0.0-alpha

package/dist/runtime/codexAppServerRuntime.js

@@ -70,8 +70,12 @@ export class CodexAppServerRuntime {
     async readGoal(conversationId) {
         const id = text(conversationId, "Codex thread id");
         const result = await this.transport.request("thread/goal/get", { threadId: id });
+        if (result.goal === null)
+            return null;
         const goal = objectMember(result, "goal");
-        return goal === null ? null : codexThreadGoal(goal, id);
+        if (goal === null)
+            throw new Error("Codex thread/goal/get returned no Goal state.");
+        return codexThreadGoal(goal, id);
     }
     async inspectConversation(conversationId) {
         const id = text(conversationId, "Codex thread id");
@@ -162,8 +166,7 @@ export class CodexAppServerRuntime {
                         text_elements: []
                     }]
             });
-            const turnId = optionalId(result.turnId)
-                ?? optionalId(objectMember(result, "turn")?.id);
+            const turnId = optionalId(objectMember(result, "turn")?.id);
             return turnId === undefined
                 ? { status: "unknown", reason: "turn/start returned no durable turn id" }
                 : { status: "accepted", turnId };
@@ -244,7 +247,7 @@ export class CodexAppServerRuntime {
         const result = await this.transport.request("thread/list", {
             ancestorThreadId: threadId
         });
-        const candidates = arrayMember(result, "threads")
+        const candidates = arrayMember(result, "data")
             .flatMap((entry) => optionalId(object(entry)?.id) === undefined
             ? []
             : [optionalId(object(entry)?.id)]);
@@ -276,7 +279,7 @@ export class CodexAppServerRuntime {
             return {
                 quality: "unavailable",
                 continuations: [],
-                detail: error instanceof Error ? error.message : String(error)
+                detail: serializeAgentErrorRaw(error)
             };
         }
         return { quality: "exact", continuations: Object.freeze(observed) };
@@ -284,10 +287,12 @@ export class CodexAppServerRuntime {
 }
 /** thread/closed unloads the client attachment; the durable thread remains resumable. */
 export function codexNotificationBoundary(input) {
-    const conversationId = optionalId(input.params.threadId)
-        ?? optionalId(objectMember(input.params, "thread")?.id);
-    const turnId = optionalId(input.params.turnId)
-        ?? optionalId(objectMember(input.params, "turn")?.id);
+    const conversationId = input.method === "thread/started"
+        ? optionalId(objectMember(input.params, "thread")?.id)
+        : optionalId(input.params.threadId);
+    const turnId = input.method === "turn/started" || input.method === "turn/completed"
+        ? optionalId(objectMember(input.params, "turn")?.id)
+        : optionalId(input.params.turnId);
     if (input.method === "thread/closed")
         return { kind: "attachment-closed", conversationId };
     if (input.method === "thread/goal/updated")
@@ -310,45 +315,53 @@ export function codexGoalNotification(input) {
         return undefined;
     const goal = objectMember(input.params, "goal");
     if (goal === null)
-        return undefined;
+        throw new Error("Codex Goal notification has no Goal state.");
     return codexThreadGoal(goal, conversationId);
 }
 function parseThreadSnapshot(result, expectedThreadId, loaded) {
-    const thread = objectMember(result, "thread") ?? result;
-    const id = optionalId(thread.id) ?? expectedThreadId;
+    const thread = objectMember(result, "thread");
+    if (thread === null)
+        throw new Error("Codex App Server returned no thread.");
+    const id = text(optionalId(thread.id), "Codex response thread id");
     if (id !== expectedThreadId)
         throw new Error("Codex App Server returned a different thread.");
-    const turns = arrayMember(thread, "turns").map(object).filter((entry) => (entry !== null));
-    const active = [...turns].reverse().find((turn) => (["inProgress", "in_progress", "running", "active"].includes(String(turn.status))));
-    const latestStatus = optionalTurnStatus(turns.at(-1)?.status);
-    const turnSnapshots = turns.flatMap((turn) => {
-        const turnId = optionalId(turn.id);
-        if (turnId === undefined)
-            return [];
+    const status = threadStatus(thread.status);
+    if (status === "unknown")
+        throw new Error("Codex thread status is missing or unsupported.");
+    if (!Array.isArray(thread.turns))
+        throw new Error("Codex thread turns are missing or invalid.");
+    const turnSnapshots = thread.turns.map((value) => {
+        const turn = object(value);
+        if (turn === null)
+            throw new Error("Codex thread contains an invalid Turn.");
+        const turnId = text(optionalId(turn.id), "Codex response Turn id");
         const status = optionalTurnStatus(turn.status);
+        if (status === undefined)
+            throw new Error("Codex Turn status is missing or unsupported.");
         const output = codexTurnOutput(turn);
         const error = providerError(turn.error);
-        return [{
-                turnId,
-                ...(status === undefined ? {} : { status }),
-                ...(output === undefined ? {} : { output }),
-                ...(error === undefined ? {} : { error }),
-                ...(turn.error === undefined || turn.error === null ? {} : {
-                    rawError: serializeAgentErrorRaw(turn.error)
-                })
-            }];
+        return {
+            turnId,
+            status,
+            ...(output === undefined ? {} : { output }),
+            ...(error === undefined ? {} : { error }),
+            ...(turn.error === undefined || turn.error === null ? {} : {
+                rawError: serializeAgentErrorRaw(turn.error)
+            })
+        };
     });
+    const active = [...turnSnapshots].reverse().find((turn) => turn.status === "inProgress");
+    const latestStatus = turnSnapshots.at(-1)?.status;
     return {
         threadId: id,
         loaded,
-        status: threadStatus(thread.status),
-        ...(optionalId(active?.id) === undefined ? {} : { activeTurnId: optionalId(active?.id) }),
+        status,
+        ...(active === undefined ? {} : { activeTurnId: active.turnId }),
         ...(latestStatus === undefined ? {} : { latestTurnStatus: latestStatus }),
         turns: Object.freeze(turnSnapshots),
         ...(optionalId(thread.parentThreadId) === undefined
             ? {}
             : { parentThreadId: optionalId(thread.parentThreadId) }),
-        ancestorThreadIds: Object.freeze(arrayMember(thread, "ancestorThreadIds").flatMap((entry) => (optionalId(entry) === undefined ? [] : [optionalId(entry)]))),
         raw: result
     };
 }
@@ -356,36 +369,9 @@ function parseThreadSnapshot(result, expectedThreadId, loaded) {
 export function codexTurnOutput(turn) {
     for (const value of [...arrayMember(turn, "items")].reverse()) {
         const item = object(value);
-        if (item === null)
-            continue;
-        const type = item.type;
-        const message = object(item.message);
-        const agentMessage = type === "agentMessage"
-            || type === "agent_message"
-            || (type === "message" && (item.role === "assistant" || message?.role === "assistant"));
-        if (!agentMessage)
-            continue;
-        const text = messageOutput(item) ?? (message === null ? undefined : messageOutput(message));
-        if (text !== undefined)
-            return text;
-    }
-    return undefined;
-}
-function messageOutput(message) {
-    for (const value of [message.text, message.content]) {
-        if (typeof value === "string" && value.trim().length > 0)
-            return value;
-        if (!Array.isArray(value))
-            continue;
-        const parts = value.flatMap((part) => {
-            if (typeof part === "string" && part.trim().length > 0)
-                return [part];
-            const record = object(part);
-            const text = record?.text ?? record?.content;
-            return typeof text === "string" && text.trim().length > 0 ? [text] : [];
-        });
-        if (parts.length > 0)
-            return parts.join("\n");
+        if (item?.type === "agentMessage"
+            && typeof item.text === "string" && item.text.trim().length > 0)
+            return item.text;
     }
     return undefined;
 }
@@ -393,33 +379,12 @@ function messageOutput(message) {
 export function codexTurnInput(turn) {
     for (const value of arrayMember(turn, "items")) {
         const item = object(value);
-        if (item === null)
-            continue;
-        const type = item.type;
-        const message = object(item.message);
-        const userMessage = type === "userMessage"
-            || type === "user_message"
-            || (type === "message" && (item.role === "user" || message?.role === "user"));
-        if (!userMessage)
-            continue;
-        const text = messageText(item) ?? (message === null ? undefined : messageText(message));
-        if (text !== undefined)
-            return text;
-    }
-    return undefined;
-}
-function messageText(message) {
-    for (const value of [message.text, message.content]) {
-        if (typeof value === "string" && value.trim().length > 0)
-            return value.trim();
-        if (!Array.isArray(value))
+        if (item?.type !== "userMessage")
             continue;
-        const parts = value.flatMap((part) => {
-            if (typeof part === "string" && part.trim().length > 0)
-                return [part];
+        const parts = arrayMember(item, "content").flatMap((part) => {
             const record = object(part);
-            const text = record?.text ?? record?.content;
-            return typeof text === "string" && text.trim().length > 0 ? [text] : [];
+            return record?.type === "text" && typeof record.text === "string"
+                && record.text.trim().length > 0 ? [record.text] : [];
         });
         if (parts.length > 0)
             return parts.join("\n").trim();
@@ -438,7 +403,7 @@ function providerError(value) {
     return JSON.stringify(record);
 }
 function codexThreadGoal(goal, expectedThreadId) {
-    const conversationId = text(goal.threadId, "Codex Goal thread id");
+    const conversationId = text(optionalId(goal.threadId), "Codex Goal thread id");
     if (conversationId !== expectedThreadId) {
         throw new Error("Codex Goal belongs to a different thread.");
     }
@@ -554,7 +519,7 @@ export function codexAppServerErrorIsMissing(error) {
         || /\b(not found|missing|does not exist)\b.*\b(thread|conversation)\b/u.test(message);
 }
 function threadId(result) {
-    return text(optionalId(result.threadId) ?? optionalId(objectMember(result, "thread")?.id), "Codex thread id");
+    return text(optionalId(objectMember(result, "thread")?.id), "Codex response thread id");
 }
 function object(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -568,7 +533,8 @@ function arrayMember(value, key) {
     return Array.isArray(value[key]) ? value[key] : [];
 }
 function optionalId(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+    return typeof value === "string" && !value.includes("\0") && value.length > 0
+        && value.trim() === value ? value : undefined;
 }
 function text(value, label) {
     if (typeof value !== "string" || value.includes("\0") || value.trim().length === 0) {

package/dist/runtime/codexInteractiveHost.js

@@ -29,7 +29,7 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
     }
     const expectedId = environment.YUI_NATIVE_SESSION_ID;
     let snapshot = {
-        schemaVersion: 2, state: "starting", adapterId: "codex", updatedAt: new Date().toISOString()
+        schemaVersion: 1, state: "starting", adapterId: "codex", updatedAt: new Date().toISOString()
     };
     const control = await openAgentHostControl(home, payload, () => snapshot, async (request) => {
         if (request.type !== "status") {

package/dist/runtime/jsonLineChannel.js

@@ -1,3 +1,4 @@
+import { serializeAgentErrorRaw } from "./agentError.js";
 export const PROVIDER_MESSAGE_MAX_BYTES = 16 * 1024 * 1024;
 /**
  * Newline-delimited JSON over a child process's stdio. This is a plain shared
@@ -7,13 +8,15 @@ export const PROVIDER_MESSAGE_MAX_BYTES = 16 * 1024 * 1024;
 export class JsonLineChannel {
     child;
     mirror;
+    onFailure;
     #listeners = new Set();
     #closeListeners = new Set();
     #buffer = "";
     #closedError;
-    constructor(child, mirror) {
+    constructor(child, mirror, onFailure) {
         this.child = child;
         this.mirror = mirror;
+        this.onFailure = onFailure;
         child.stdout.setEncoding("utf8");
         child.stdout.on("data", (chunk) => this.#receive(chunk));
         child.once("error", (error) => this.#close(error));
@@ -57,10 +60,12 @@ export class JsonLineChannel {
         });
     }
     #receive(chunk) {
+        if (this.#closedError !== undefined)
+            return;
         this.mirror("stdout", chunk);
         this.#buffer += chunk;
         if (Buffer.byteLength(this.#buffer, "utf8") > PROVIDER_MESSAGE_MAX_BYTES) {
-            this.#close(new Error("Provider response line exceeds its message bound."));
+            this.#fail(new Error("Provider response line exceeds its message bound."));
             terminateProcessGroup(this.child, "SIGTERM");
             return;
         }
@@ -72,18 +77,41 @@ export class JsonLineChannel {
             this.#buffer = this.#buffer.slice(newline + 1);
             if (line.length === 0)
                 continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch (cause) {
+                this.#fail(new Error("Provider response is not valid JSON.", { cause }));
+                return;
+            }
+            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+                this.#fail(new Error("Provider response must be a JSON object."));
+                return;
+            }
+            // Unknown protocol objects belong to the protocol listener. A listener
+            // throwing is not an unrelated notification or a parse error.
             try {
-                const parsed = JSON.parse(line);
-                if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
-                    continue;
                 for (const listener of this.#listeners)
                     listener(parsed);
             }
-            catch {
-                continue;
+            catch (cause) {
+                this.#fail(new Error("Provider message listener failed.", { cause }));
+                return;
             }
         }
     }
+    #fail(error) {
+        // Failing this pipe neither proves a native terminal nor permits replay.
+        // Keep the original cause for pending callers and the Host's durable sink.
+        try {
+            this.mirror("stderr", `${serializeAgentErrorRaw(error)}\n`);
+            this.onFailure?.(error);
+        }
+        finally {
+            this.#close(error);
+        }
+    }
     #close(error) {
         if (this.#closedError !== undefined)
             return;

package/dist/runtime/launchBroker.js

@@ -56,7 +56,7 @@ export function validateAgentHostLaunchPayload(value) {
     return validatePayload(value);
 }
 function validatePayload(payload) {
-    if (payload.schemaVersion !== 2)
+    if (payload.schemaVersion !== 1)
         throw new Error("Agent Host launch payload version is invalid.");
     text(payload.command, "command");
     text(payload.cwd, "cwd");

package/dist/runtime/processExitObservation.js

@@ -1,4 +1,4 @@
-export const RUNTIME_PROCESS_EXIT_SCHEMA_VERSION = 2;
+export const RUNTIME_PROCESS_EXIT_SCHEMA_VERSION = 1;
 export const RUNTIME_PROCESS_EXIT_TASK_EVENT = "runtime.process-exit-observed";
 export function validateRuntimeProcessExitObservation(observation) {
     if (observation.schemaVersion !== RUNTIME_PROCESS_EXIT_SCHEMA_VERSION) {

package/dist/runtime/providerContinuationReconciliationService.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { serializeAgentErrorRaw, standardAgentError } from "./agentError.js";
 import { providerContinuationKey } from "./providerContinuation.js";
 import { projectProviderContinuations } from "./runtimeContinuationProjection.js";
 import { reconcileKnownDetachedContinuations } from "./providerRuntimeReconciler.js";
@@ -12,54 +13,101 @@ export class ProviderContinuationReconciliationService {
     store;
     sink;
     metadata;
+    onError;
     #schedules = new Map();
-    constructor(store, sink, metadata) {
+    constructor(store, sink, metadata, onError = error => { throw error; }) {
         this.store = store;
         this.sink = sink;
         this.metadata = metadata;
+        this.onError = onError;
     }
     async reconcile(now) {
         const changedTaskIds = new Set();
         for (const task of this.store.listTasks().filter((entry) => (entry.status === "active" && entry.executionGate.state === "enabled"))) {
-            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))
+            try {
+                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;
-                    const disposition = this.sink.observeRuntimeObservation(reconciliationObservation(after, candidates[index].fence, now), now);
-                    if (disposition === "applied")
-                        changedTaskIds.add(after.taskId);
+                    }
+                    let result;
+                    try {
+                        result = await reconcileKnownDetachedContinuations({
+                            port: this.metadata,
+                            continuations: group,
+                            ...(previous === undefined ? {} : { previous }),
+                            now
+                        });
+                    }
+                    catch (error) {
+                        // One malformed identity group must not restart or block the
+                        // Controller. Keep it writer-owned and retry through the same
+                        // bounded, metadata-only schedule.
+                        result = {
+                            continuations: group, quality: "unavailable", changed: false,
+                            schedule: failureSchedule(groupKey, previous, now),
+                            failure: standardAgentError({
+                                source: "yui", phase: "turn-reconcile",
+                                message: error instanceof Error ? error.message : String(error),
+                                raw: serializeAgentErrorRaw(error)
+                            })
+                        };
+                    }
+                    if (result.schedule === null)
+                        this.#schedules.delete(groupKey);
+                    else
+                        this.#schedules.set(groupKey, result.schedule);
+                    if (result.failure !== undefined) {
+                        const failure = result.failure;
+                        // One original failure and one circuit-limit notice, not one wake per
+                        // poll. Existing observations deduplicate across Controller restarts.
+                        const digest = createHash("sha256").update(JSON.stringify([
+                            task.id, candidates.map(entry => entry.fence), failure.raw,
+                            result.schedule?.circuitOpenUntil === undefined ? "unavailable" : "circuit-open"
+                        ])).digest("hex");
+                        const eventId = `continuation-reconcile-error:${digest}`;
+                        if (!events.some(event => event.payload.eventId === eventId
+                            || event.type === "runtime.agent-error" && event.payload.sourceEventId === eventId)) {
+                            const observation = createRuntimeObservation({
+                                schemaVersion: 1, eventId, semanticKey: eventId,
+                                kind: "observer.health", authority: "controller",
+                                receivedAt: now.toISOString(), observedAt: now.toISOString(),
+                                fence: candidates[0].fence,
+                                payload: {
+                                    sourceId: "continuation-metadata", observerStatus: "unavailable",
+                                    observerDetail: failure.message,
+                                    failure: { error: { ...failure, raw: serializeAgentErrorRaw({
+                                                failure, targets: group.map(entry => entry.identity),
+                                                schedule: result.schedule,
+                                                confirmed: "Metadata query did not prove quiescence; existing writer ownership is preserved.",
+                                                unknown: "Continuation execution, result and external effects."
+                                            }) } }
+                                }
+                            });
+                            if (this.sink.observeRuntimeObservation(observation, now) === "applied")
+                                changedTaskIds.add(task.id);
+                        }
+                    }
+                    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);
+                    }
                 }
             }
+            catch (error) {
+                this.onError(new Error(`Continuation reconciliation failed for ${task.id}: `
+                    + `${error instanceof Error ? error.message : String(error)}. `
+                    + "Unconfirmed continuation state and writer ownership are retained.", { cause: error }));
+            }
         }
         return Object.freeze([...changedTaskIds].sort());
     }
@@ -128,7 +176,7 @@ function reconciliationObservation(continuation, sourceFence, now) {
     const settled = continuation.execution === "quiescent"
         && continuation.observation === "exact";
     return createRuntimeObservation({
-        schemaVersion: 4,
+        schemaVersion: 1,
         eventId: `continuation-reconcile:${digest}`,
         semanticKey: `continuation-reconcile:${digest}`,
         kind: settled ? "continuation.settled" : "continuation.started",

package/dist/runtime/providerRetry.js

@@ -152,6 +152,21 @@ export function providerRetryProjection(binding) {
         category: retry.error.category, preservesWork: true, nativeSessionId: retry.nativeSessionId,
         ...(retry.reason === undefined ? {} : { reason: retry.reason }),
         failureRef: retry.failureRef,
+        error: retry.error,
+        inputRef: retry.input.kind === "text" ? { kind: "text" } : retry.input,
+        failedAttemptId: retry.failedAttemptId,
+        failureAttemptId: retry.failureAttemptId,
+        ...(retry.failedNativeTurnId === undefined ? {} : { failedNativeTurnId: retry.failedNativeTurnId }),
+        ...(retry.currentAttemptId === undefined ? {} : { currentAttemptId: retry.currentAttemptId }),
+        currentTurn: binding?.run == null ? null : {
+            attemptId: binding.run.attemptId, status: binding.run.status,
+            ...(binding.run.nativeTurnId === undefined ? {} : { nativeTurnId: binding.run.nativeTurnId }),
+            ...(binding.run.failure === undefined ? {} : { failure: binding.run.failure })
+        },
+        history: (binding?.retryHistory ?? []).map(entry => ({
+            chainId: entry.chainId, status: entry.status, attempts: entry.attempts,
+            failureRef: entry.failureRef, failedAttemptId: entry.failedAttemptId
+        })),
         ...(retry.previousRunId === undefined ? {} : { previousRunId: retry.previousRunId }),
         ...(retry.successorRunId === undefined ? {} : { successorRunId: retry.successorRunId })
     };

package/dist/runtime/providerRuntimeIdentity.js

@@ -3,7 +3,7 @@ import { isStandardAgentError } from "./agentError.js";
 export function createProviderRuntimeBinding(input) {
     const startedAt = timestamp(input.startedAt, "Provider Conversation startedAt");
     return validateProviderRuntimeBinding({
-        schemaVersion: 5,
+        schemaVersion: 1,
         providerNamespace: identity(input.providerNamespace, "Provider namespace"),
         accountScope: identity(input.accountScope, "Provider account scope"),
         currentConversationEpoch: 1,
@@ -308,8 +308,8 @@ export function supersedeProviderConversation(raw, input) {
     });
 }
 export function validateProviderRuntimeBinding(value) {
-    if (value.schemaVersion !== 5)
-        throw new Error("Provider Runtime Binding schemaVersion must be 5.");
+    if (value.schemaVersion !== 1)
+        throw new Error("Provider Runtime Binding schemaVersion must be 1.");
     identity(value.providerNamespace, "Provider namespace");
     identity(value.accountScope, "Provider account scope");
     integer(value.currentConversationEpoch, 1, "Current Provider Conversation epoch");

package/dist/runtime/providerRuntimeReconciler.js

@@ -1,4 +1,5 @@
 import { continuationOwnsWriterUmbrella, observeProviderContinuation, providerContinuationKey } from "./providerContinuation.js";
+import { serializeAgentErrorRaw, standardAgentError } from "./agentError.js";
 const BASE_RECONCILE_MS = 2_000;
 const MAX_RECONCILE_MS = 5 * 60_000;
 const CIRCUIT_ERROR_LIMIT = 5;
@@ -47,8 +48,11 @@ export async function reconcileKnownDetachedContinuations(input) {
             })))
         }), QUERY_TIMEOUT_MS);
         result = validateQueryResult(raw, new Set(candidates.map((entry) => (providerContinuationKey(entry.identity)))));
+        if (result.quality === "unavailable") {
+            throw new Error(result.detail ?? "Provider continuation metadata is unavailable.");
+        }
     }
-    catch {
+    catch (error) {
         const errors = (input.previous?.consecutiveErrors ?? 0) + 1;
         const delay = backoff(input.previous?.attempts ?? 0);
         const circuitOpenUntil = errors >= CIRCUIT_ERROR_LIMIT
@@ -64,7 +68,13 @@ export async function reconcileKnownDetachedContinuations(input) {
                 ...(circuitOpenUntil === undefined ? {} : { circuitOpenUntil })
             },
             quality: "unavailable",
-            changed: false
+            changed: false,
+            failure: standardAgentError({
+                source: "driver", phase: "turn-reconcile",
+                message: error instanceof Error ? error.message : String(error),
+                raw: serializeAgentErrorRaw(error),
+                inputDisposition: "unknown", sessionDisposition: "unknown"
+            })
         };
     }
     const observations = new Map(result.continuations.map((entry) => [entry.key, entry]));

package/dist/runtime/runtimeCoherence.js

@@ -1,4 +1,5 @@
 import { resolve } from "node:path";
+import { isStorageVersion, compareStorageVersions } from "../storage/storageVersions.js";
 import { callController as defaultCallController } from "../core/controllerClient.js";
 import { inspectStorageSchema } from "../storage/storageSchema.js";
 import { yuiVersionIdentity } from "../version.js";
@@ -41,9 +42,12 @@ function validateVersionIdentity(value) {
         throw new Error("Yui version identity is invalid.");
     const version = requireText(value.version, "Yui version");
     const controllerProtocolVersion = requireVersion(value.controllerProtocolVersion, "Controller protocol version");
-    const storageVersion = requireVersion(value.storageVersion, "Storage version");
-    const minimumStorageVersion = requireVersion(value.minimumStorageVersion, "Minimum storage migration version");
-    if (minimumStorageVersion > storageVersion) {
+    const storageVersion = value.storageVersion;
+    const minimumStorageVersion = value.minimumStorageVersion;
+    if (!isStorageVersion(storageVersion) || !isStorageVersion(minimumStorageVersion)) {
+        throw new Error("Storage version must be a major.minor identity.");
+    }
+    if (compareStorageVersions(minimumStorageVersion, storageVersion) > 0) {
         throw new Error("Minimum storage migration version cannot exceed the current storage version.");
     }
     return {

package/dist/runtime/runtimeObservation.js

@@ -84,8 +84,8 @@ const PROVIDER_STATE = new Set([
     "operation.failed"
 ]);
 export function createRuntimeObservation(input) {
-    if (input.schemaVersion !== 4)
-        throw new Error("Runtime observation schemaVersion must be 4.");
+    if (input.schemaVersion !== 1)
+        throw new Error("Runtime observation schemaVersion must be 1.");
     if (!KINDS.includes(input.kind))
         throw new Error("Runtime observation kind is invalid.");
     if (!AUTHORITIES.includes(input.authority))
@@ -126,7 +126,7 @@ export function createRuntimeObservation(input) {
         throw new Error("Runtime observation ordinal must be a non-negative safe integer.");
     }
     return Object.freeze({
-        schemaVersion: 4,
+        schemaVersion: 1,
         eventId: requireIdentity(input.eventId, "Runtime observation event id"),
         semanticKey: requireIdentity(input.semanticKey, "Runtime observation semantic key"),
         kind: input.kind,

package/dist/runtime/sessionOwnerIdentity.js

@@ -36,7 +36,7 @@ export function createSessionOwnerIdentity(input) {
     }
     const tmux = input.tmux;
     return Object.freeze({
-        schemaVersion: 2,
+        schemaVersion: 1,
         kind: "yui-session-owner",
         owner: Object.freeze({
             scope: owner.scope,