@zq-silk/yui 0.16.1 → 1.0.0-alpha

package/dist/runtime/structuredProviderHost.js

@@ -7,7 +7,7 @@ import WebSocket from "ws";
 import { YUI_VERSION } from "../version.js";
 import { AcpStructuredProviderSession } from "./acpSession.js";
 import { acpDesiredSessionConfiguration } from "./acpSessionConfiguration.js";
-import { serializeAgentErrorRaw } from "./agentError.js";
+import { providerDeliveryFailureFrom, serializeAgentErrorRaw } from "./agentError.js";
 import { unsupportedAgentRunConfiguration } from "./agentRunConfiguration.js";
 import { codexAppServerErrorIsMissing, CodexAppServerRequestError, CodexAppServerRuntime, codexClientInitialization, codexGoalNotification, codexTurnInput, codexTurnOutput } from "./codexAppServerRuntime.js";
 import { JsonLineChannel, PROVIDER_MESSAGE_MAX_BYTES, terminateProcessGroup } from "./jsonLineChannel.js";
@@ -65,6 +65,7 @@ export async function startStructuredProviderSession(payload, input = {}) {
                     ? {}
                     : { nativeSessionId: control.nativeSessionId }),
                 ...(input.onTerminal === undefined ? {} : { onTerminal: input.onTerminal }),
+                ...(input.onDiagnostic === undefined ? {} : { onDiagnostic: input.onDiagnostic }),
                 mirror
             });
             return Object.freeze({ session });
@@ -79,7 +80,7 @@ export async function startStructuredProviderSession(payload, input = {}) {
                 goal: opened.goal
             });
         }
-        const session = await ClaudeStructuredProviderSession.open(child, exit, processInstanceId, control, input.onAccepted, input.onTerminal, input.onGoal, input.onActivity, mirror);
+        const session = await ClaudeStructuredProviderSession.open(child, exit, processInstanceId, control, input.onAccepted, input.onTerminal, input.onGoal, input.onActivity, input.onDiagnostic, mirror);
         return Object.freeze({ session });
     }
     catch (error) {
@@ -325,6 +326,7 @@ class CodexStructuredProviderSession {
     onGoal;
     onInput;
     onActivity;
+    mirror;
     nativeAccountHome;
     #turnAttempts = new Map();
     adapterId = "codex";
@@ -335,7 +337,7 @@ class CodexStructuredProviderSession {
     #bufferedStarts = [];
     #bufferedTerminals = [];
     #bufferedActivities = [];
-    constructor(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, nativeAccountHome) {
+    constructor(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, mirror, nativeAccountHome) {
         this.child = child;
         this.exit = exit;
         this.processInstanceId = processInstanceId;
@@ -346,6 +348,7 @@ class CodexStructuredProviderSession {
         this.onGoal = onGoal;
         this.onInput = onInput;
         this.onActivity = onActivity;
+        this.mirror = mirror;
         this.nativeAccountHome = nativeAccountHome;
     }
     static async open(child, exit, processInstanceId, payload, control, onStarted, onTerminal, onGoal, onInput, onActivity, mirror) {
@@ -387,7 +390,7 @@ class CodexStructuredProviderSession {
                 name: control.sessionTitle
             });
         }
-        const session = new CodexStructuredProviderSession(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, optionalId(initialized.codexHome));
+        const session = new CodexStructuredProviderSession(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, mirror, optionalId(initialized.codexHome));
         session.#activeTurnId = resumedActiveTurnId;
         const ownedTurn = control.kind === "restore" ? control.ownedTurn : undefined;
         session.#clientOwnedTurnId = ownedTurn?.turnId;
@@ -445,9 +448,21 @@ class CodexStructuredProviderSession {
     #observeMessage(message, emit) {
         const method = typeof message.method === "string" ? message.method : "";
         const params = object(message.params) ?? {};
-        if (optionalId(params.threadId) !== this.conversationId)
+        const threadId = optionalId(params.threadId);
+        if (threadId !== this.conversationId) {
+            if (threadId === undefined && (method === "turn/started" || method === "turn/completed")) {
+                this.mirror("stderr", `Codex protocol: ${method} has no thread identity; ignored.\n`);
+            }
             return undefined;
-        const goal = codexGoalNotification({ method, params });
+        }
+        let goal;
+        try {
+            goal = codexGoalNotification({ method, params });
+        }
+        catch {
+            this.mirror("stderr", "Codex protocol: invalid Goal notification; ignored.\n");
+            return undefined;
+        }
         if (goal !== undefined) {
             if (emit)
                 this.onGoal?.(goal);
@@ -456,17 +471,20 @@ class CodexStructuredProviderSession {
         if (emit && (method === "item/started" || method === "item/completed"
             || method === "item/agentMessage/delta" || method === "item/reasoning/summaryTextDelta")) {
             const item = object(params.item);
-            const id = optionalId(item?.id) ?? optionalId(params.itemId);
+            const delta = method === "item/agentMessage/delta" || method === "item/reasoning/summaryTextDelta";
+            const id = optionalId(delta ? params.itemId : item?.id);
             const nativeTurnId = optionalId(params.turnId);
-            const tool = ["commandExecution", "mcpToolCall", "dynamicToolCall", "fileChange"].includes(String(item?.type));
-            const model = ["agentMessage", "reasoning"].includes(String(item?.type)) || method.endsWith("Delta") || method.endsWith("/delta");
-            if (id !== undefined && nativeTurnId !== undefined && (tool || model)) {
+            const tool = typeof item?.type === "string"
+                && ["commandExecution", "mcpToolCall", "dynamicToolCall", "fileChange"].includes(item.type);
+            const model = delta || item?.type === "agentMessage" || item?.type === "reasoning";
+            const phase = model ? "model" : tool ? codexToolPhase(item, method === "item/started") : undefined;
+            if (tool && phase === undefined) {
+                this.mirror("stderr", "Codex protocol: tool item has no valid lifecycle status; ignored.\n");
+            }
+            if (id !== undefined && nativeTurnId !== undefined && phase !== undefined) {
                 const activity = {
                     conversationId: this.conversationId, nativeSessionId: this.conversationId,
-                    nativeTurnId, id, observedAt: new Date().toISOString(),
-                    phase: model ? "model" : method === "item/started" ? "started"
-                        : item?.status === "failed" || (typeof item?.exitCode === "number" && item.exitCode !== 0)
-                            ? "failed" : "completed"
+                    nativeTurnId, id, observedAt: new Date().toISOString(), phase
                 };
                 if (this.#submissionPending)
                     this.#bufferedActivities.push(activity);
@@ -486,10 +504,10 @@ class CodexStructuredProviderSession {
             return undefined;
         }
         if (method === "turn/started") {
-            const turnId = nestedId(params, "turn") ?? optionalId(params.turnId);
-            if (turnId !== undefined) {
+            const turn = object(params.turn);
+            const turnId = optionalId(turn?.id);
+            if (turnId !== undefined && turn?.status === "inProgress") {
                 this.#activeTurnId = turnId;
-                const turn = object(params.turn) ?? {};
                 const input = codexTurnInput(turn);
                 const started = {
                     conversationId: this.conversationId,
@@ -503,14 +521,20 @@ class CodexStructuredProviderSession {
                 else if (emit)
                     this.#emitStarted(started);
             }
+            else {
+                this.mirror("stderr", "Codex protocol: turn/started has no valid Turn identity/status; ignored.\n");
+            }
             return undefined;
         }
         if (method !== "turn/completed")
             return undefined;
-        const turn = object(params.turn) ?? {};
-        const nativeTurnId = optionalId(turn.id) ?? optionalId(params.turnId);
-        if (nativeTurnId === undefined)
+        const turn = object(params.turn);
+        const nativeTurnId = optionalId(turn?.id);
+        if (nativeTurnId === undefined || turn === null
+            || (turn.status !== "completed" && turn.status !== "failed" && turn.status !== "interrupted")) {
+            this.mirror("stderr", "Codex protocol: turn/completed has no valid terminal Turn identity/status; ignored.\n");
             return undefined;
+        }
         const status = turn.status === "failed"
             ? "failed"
             : turn.status === "interrupted" ? "cancelled" : "completed";
@@ -680,6 +704,7 @@ class ClaudeStructuredProviderSession {
     conversationId;
     channel;
     onGoal;
+    mirror;
     adapterId = "claude";
     get ownedProcessId() { return this.child.pid; }
     #activeAttemptId;
@@ -689,22 +714,33 @@ class ClaudeStructuredProviderSession {
     #openToolIds = new Set();
     #resultAttempts = new Map();
     #lastGoalKey;
-    constructor(child, exit, processInstanceId, conversationId, channel, onGoal) {
+    constructor(child, exit, processInstanceId, conversationId, channel, onGoal, mirror) {
         this.child = child;
         this.exit = exit;
         this.processInstanceId = processInstanceId;
         this.conversationId = conversationId;
         this.channel = channel;
         this.onGoal = onGoal;
+        this.mirror = mirror;
     }
-    static async open(child, exit, processInstanceId, control, onAccepted, onTerminal, onGoal, onActivity, mirror) {
-        const channel = new JsonLineChannel(child, mirror);
+    static async open(child, exit, processInstanceId, control, onAccepted, onTerminal, onGoal, onActivity, onDiagnostic, mirror) {
         const nativeSessionId = control.nativeSessionId;
         if (nativeSessionId === undefined) {
             throw new Error("Managed Claude launch requires a preallocated native Session id.");
         }
-        const session = new ClaudeStructuredProviderSession(child, exit, processInstanceId, nativeSessionId, channel, onGoal);
-        channel.onMessage((message) => session.#receive(message, onTerminal, onAccepted, onActivity));
+        let receivingAttemptId;
+        const channel = new JsonLineChannel(child, mirror, error => onDiagnostic?.({
+            nativeSessionId,
+            ...((receivingAttemptId ?? session.#activeAttemptId) === undefined
+                ? {} : { attemptId: receivingAttemptId ?? session.#activeAttemptId }),
+            failure: providerDeliveryFailureFrom(error, { phase: "turn-reconcile", inputDisposition: "unknown" })
+        }));
+        const session = new ClaudeStructuredProviderSession(child, exit, processInstanceId, nativeSessionId, channel, onGoal, mirror);
+        channel.onMessage((message) => {
+            receivingAttemptId = session.#activeAttemptId;
+            session.#receive(message, onTerminal, onAccepted, onActivity);
+            receivingAttemptId = undefined;
+        });
         // This client owns the whole Claude execution process, unlike a Codex
         // proxy. An exit without a result ends the exact local input as failure,
         // not as continuing work merely because the supervising Host is alive.
@@ -855,24 +891,35 @@ class ClaudeStructuredProviderSession {
             }
             return;
         }
-        if (message.type !== "result"
-            || optionalId(message.session_id) !== this.conversationId)
+        if (message.type !== "result")
             return;
+        const sessionId = optionalId(message.session_id);
+        if (sessionId !== this.conversationId) {
+            if (sessionId === undefined)
+                this.mirror("stderr", "Claude protocol: result has no Session identity; ignored.\n");
+            return;
+        }
         // A result UUID identifies this message, not the Provider execution.
         // Retain its local association so a delayed duplicate cannot be assigned
         // to a successor request on the same long-lived process.
         const resultId = optionalId(message.uuid);
-        const priorAttempt = resultId === undefined ? undefined : this.#resultAttempts.get(resultId);
+        const subtype = message.subtype;
+        const failed = subtype === "success" ? message.is_error
+            : ["error_during_execution", "error_max_turns", "error_max_budget_usd",
+                "error_max_structured_output_retries"].includes(String(subtype)) ? true : undefined;
+        if (resultId === undefined || typeof message.is_error !== "boolean" || failed === undefined) {
+            this.mirror("stderr", "Claude protocol: result has no valid identity/status; ignored.\n");
+            return;
+        }
+        const priorAttempt = this.#resultAttempts.get(resultId);
         const attemptId = priorAttempt ?? this.#activeAttemptId;
         if (attemptId === undefined)
             return;
-        if (resultId !== undefined)
-            this.#resultAttempts.set(resultId, attemptId);
+        this.#resultAttempts.set(resultId, attemptId);
         if (attemptId === this.#activeAttemptId) {
             this.#activeAttemptId = undefined;
             this.#openToolIds.clear();
         }
-        const failed = message.is_error === true || message.subtype === "error_during_execution";
         const result = typeof message.result === "string" && message.result.length > 0
             ? message.result
             : providerErrorEvidence(message).error;
@@ -891,64 +938,44 @@ class ClaudeStructuredProviderSession {
         });
     }
 }
+function codexToolPhase(item, started) {
+    if (started)
+        return item.status === "inProgress" ? "started" : undefined;
+    if (item.status === "failed")
+        return "failed";
+    if (item.status === "declined"
+        && (item.type === "commandExecution" || item.type === "fileChange"))
+        return "failed";
+    if (item.status !== "completed")
+        return undefined;
+    if (item.type === "commandExecution" && typeof item.exitCode === "number" && item.exitCode !== 0) {
+        return "failed";
+    }
+    if (item.type === "dynamicToolCall" && item.success === false)
+        return "failed";
+    return "completed";
+}
 function claudeActiveGoal(message, conversationId) {
-    if (!Object.hasOwn(message, "active_goal"))
+    if (message.type !== "active_goal" || optionalId(message.session_id) !== conversationId)
         return undefined;
-    if (message.active_goal === null)
+    if (message.value === null)
         return null;
-    const raw = object(message.active_goal);
+    const raw = object(message.value);
     if (raw === null)
         return undefined;
-    const objective = typeof raw.objective === "string" ? raw.objective.trim() : "";
+    const objective = typeof raw.condition === "string" ? raw.condition.trim() : "";
     if (objective.length === 0)
         return undefined;
-    const status = providerGoalStatus(raw.status);
-    if (status === undefined)
-        return undefined;
-    const tokenBudget = positiveOptionalInteger(raw.token_budget ?? raw.tokenBudget);
     return Object.freeze({
         conversationId,
-        status,
+        // Claude emits a live goal or clears it. There is no Codex-style Goal
+        // status/budget/Turn field on this event, and clearing is not success.
+        status: "active",
         objective,
-        updatedAt: providerTimestamp(raw.updated_at ?? raw.updatedAt),
-        ...(optionalId(raw.turn_id ?? raw.turnId) === undefined
-            ? {}
-            : { nativeTurnId: optionalId(raw.turn_id ?? raw.turnId) }),
-        ...(tokenBudget === undefined ? {} : { tokenBudget })
+        // set_at is creation time, not a last-update timestamp.
+        updatedAt: new Date().toISOString()
     });
 }
-function providerGoalStatus(value) {
-    switch (value) {
-        case "active":
-        case "paused":
-        case "blocked":
-        case "complete":
-            return value;
-        case "usageLimited":
-        case "usage_limited":
-        case "usage-limited":
-            return "usage-limited";
-        case "budgetLimited":
-        case "budget_limited":
-        case "budget-limited":
-            return "budget-limited";
-        default:
-            return undefined;
-    }
-}
-function providerTimestamp(value) {
-    if (typeof value === "string" && Number.isFinite(Date.parse(value))) {
-        return new Date(value).toISOString();
-    }
-    if (Number.isSafeInteger(value) && value >= 0) {
-        const epoch = value;
-        return new Date(epoch < 1_000_000_000_000 ? epoch * 1_000 : epoch).toISOString();
-    }
-    return new Date().toISOString();
-}
-function positiveOptionalInteger(value) {
-    return Number.isSafeInteger(value) && value > 0 ? value : undefined;
-}
 function childExit(child, processInstanceId) {
     return new Promise((resolvePromise, reject) => {
         child.once("error", reject);
@@ -971,10 +998,8 @@ function object(value) {
         : null;
 }
 function optionalId(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function nestedId(value, key) {
-    return optionalId(object(value[key])?.id);
+    return typeof value === "string" && !value.includes("\0") && value.length > 0
+        && value.trim() === value ? value : undefined;
 }
 function providerErrorEvidence(value) {
     const error = object(value);

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/activeRoleRunDelivery.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { serializeRunInputEnvelope } from "../context/runInputContract.js";
+import { readRunContextSnapshot } from "../context/runContextPack.js";
 import { roleSessionMayContinue, sameEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { RuntimeLifecycleBusyError } from "../runtime/lifecycleReservation.js";
 import { managedProviderTurnId } from "../runtime/providerRuntimeIdentity.js";
@@ -121,6 +122,9 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
     let prepared;
     let submitted = false;
     try {
+        // Validate the dispatch contract before starting any Provider resources.
+        readRunContextSnapshot(store, run);
+        const text = serializeRunInputEnvelope(runInputEnvelope(run));
         const nativeSessionId = mode === "resume"
             ? requireResumeSession(role, run, existingSession)
             : undefined;
@@ -172,7 +176,7 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
         const outcome = await delivery.sendOnce({
             delivery: ready,
             receiptId: attemptId,
-            text: serializeRunInputEnvelope(runInputEnvelope(run))
+            text
         });
         if (outcome.status === "pending") {
             // The original Host request is still in flight. Its durable submitting

package/dist/scheduler/operatorInputNotificationProcessor.js

@@ -1,6 +1,6 @@
 import { createOperatorBatchPresentation } from "../interaction/operatorPresentation.js";
 import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
-export async function processOperatorInputNotifications(store, delivery, selection, now = new Date()) {
+export async function processOperatorInputNotifications(store, selection, now = new Date()) {
     if (selection !== undefined && !selection.full && !selection.operator)
         return [];
     const targetMailbox = { kind: "operator" };
@@ -35,30 +35,20 @@ export async function processOperatorInputNotifications(store, delivery, selecti
         store.completeWorkMailbox(targetMailbox, processing.batchId);
         return [];
     }
-    const target = store.getOperatorDeliveryTarget();
-    if (target === null || delivery.notifyOperatorInputOnce === undefined) {
-        const reason = target === null ? "operator-unavailable" : "delivery-unsupported";
-        store.releaseWorkMailbox(targetMailbox, processing.batchId);
-        return attentions.map((attention) => skipped(attention, reason));
-    }
     try {
         const presentation = createOperatorBatchPresentation(processing.batchId, attentions.map(toPresentationItem));
-        const outcome = await delivery.notifyOperatorInputOnce({
-            ...target,
+        const outcome = store.queueOperatorNotification({
+            batchId: processing.batchId,
             receiptId: presentation.receiptId,
             text: presentation.text
-        });
-        if (outcome === "unavailable" || outcome === "not-ready") {
+        }, now);
+        if (outcome.status === "unavailable") {
             store.releaseWorkMailbox(targetMailbox, processing.batchId);
-            const reason = outcome === "unavailable" ? "operator-unavailable" : "operator-not-ready";
-            return attentions.map((attention) => skipped(attention, reason));
+            return attentions.map((attention) => skipped(attention, "operator-unavailable"));
         }
-        if (outcome === "sent")
-            store.markOperatorRunStarted(now);
-        store.completeWorkMailbox(targetMailbox, processing.batchId);
         return attentions.map((attention) => ({
             ...attentionIdentity(attention),
-            status: outcome
+            ...outcome
         }));
     }
     catch (error) {

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.");