@zq-silk/yui 0.16.2 → 1.0.0-alpha

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

@@ -13,91 +13,100 @@ 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 (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: 4, 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."
-                                        }) } }
-                            }
+            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;
+                    }
+                    let result;
+                    try {
+                        result = await reconcileKnownDetachedContinuations({
+                            port: this.metadata,
+                            continuations: group,
+                            ...(previous === undefined ? {} : { previous }),
+                            now
                         });
-                        if (this.sink.observeRuntimeObservation(observation, now) === "applied")
-                            changedTaskIds.add(task.id);
+                    }
+                    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);
                     }
                 }
-                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());
@@ -167,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/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/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,

package/dist/runtime/taskRuntimeIsolation.js

@@ -154,7 +154,7 @@ export function createTaskRuntimeIsolationDescriptor(input) {
     const portPreference = ports(input.policy?.portPreference ?? [], "Port preference");
     const portAllocations = allocations(input.policy?.portAllocations ?? []);
     return Object.freeze({
-        schemaVersion: 2,
+        schemaVersion: 1,
         kind: "yui-task-runtime-isolation",
         taskId,
         workspace: Object.freeze({ owner, root: canonicalPath(workspace.root, "Workspace root") }),
@@ -181,7 +181,7 @@ export function parseTaskRuntimeIsolationDescriptor(serialized) {
     if (!isRecord(value) || value.kind !== "yui-task-runtime-isolation") {
         throw new Error(`Expected yui-task-runtime-isolation descriptor; found ${isRecord(value) && typeof value.kind === "string" ? value.kind : "unknown"}.`);
     }
-    if (value.schemaVersion !== 2) {
+    if (value.schemaVersion !== 1) {
         throw new Error("Task runtime isolation descriptor schema version is invalid.");
     }
     const workspace = requireRecord(value.workspace, "Task runtime workspace");
@@ -189,7 +189,7 @@ export function parseTaskRuntimeIsolationDescriptor(serialized) {
     const external = requireRecord(value.externalCapabilities, "Task runtime external capabilities");
     const owner = taskRuntimeWorkspaceOwner(requireRecord(workspace.owner, "Task runtime workspace owner"));
     const descriptor = {
-        schemaVersion: 2,
+        schemaVersion: 1,
         kind: "yui-task-runtime-isolation",
         taskId: requireIdentity(value.taskId, "Task id"),
         workspace: {

package/dist/runtime/tmuxAdapters.js

@@ -249,8 +249,8 @@ export class TmuxSessionHost {
         const yuiHome = planned.launch.env.YUI_HOME;
         const childLifecycle = planned.launch.childLifecycle;
         // Global Codex retains the native TUI inside a thin Host that acknowledges
-        // its own App Server startup response. Existing live TUIs (including
-        // 0.15.0 Sessions) remain directly attachable without replacing them.
+        // its own App Server startup response. Current live TUIs remain directly
+        // attachable without replacing their native conversation.
         if (reuseInteractivePane
             || (!interactiveCodex && (yuiHome === undefined
                 || childLifecycle === undefined
@@ -310,7 +310,7 @@ export class TmuxSessionHost {
             throw new Error("Managed Task Agent Host launch is missing its Session Manifest.");
         }
         const reservation = broker.reserve(Object.freeze({
-            schemaVersion: 2,
+            schemaVersion: 1,
             ...(request.runId === undefined ? {} : { startupRunId: request.runId }),
             command: planned.launch.command,
             args: [...planned.launch.args],

package/dist/scheduler/taskWake.js

@@ -1,7 +1,7 @@
 import { requireIdentity, requirePositiveInteger, requireText, requireTimestamp } from "../domain/validation.js";
 import { TASK_RECORD_ID_PREFIXES } from "../task/taskRecordReference.js";
 import { copyRef } from "../coordination/workMailbox.js";
-export const CURRENT_TASK_WAKE_SCHEMA_VERSION = 2;
+export const CURRENT_TASK_WAKE_SCHEMA_VERSION = 1;
 export function createTaskWake(input) {
     if (Object.hasOwn(input, "runId"))
         throw new Error("A notification wake cannot dispatch an AgentRun.");