@zq-silk/yui 0.15.7 → 0.15.8

package/dist/scheduler/activeRoleTurnDelivery.js

@@ -1,315 +0,0 @@
-import { serializeTurnInputEnvelope } from "../context/turnInputContract.js";
-import { roleSessionMayContinue, sameEffectiveLaunch } from "../executor/effectiveLaunch.js";
-import { RuntimeLifecycleBusyError } from "../runtime/lifecycleReservation.js";
-import { managedProviderTurnId } from "../runtime/providerRuntimeIdentity.js";
-import { formatProviderDeliveryFailure, providerDeliveryFailureFacts, innermostCauseName, serializeAgentErrorRaw } from "../runtime/agentError.js";
-import { RuntimeLaunchFailure } from "../runtime/launchDiagnostics.js";
-import { RuntimeGenerationMismatchError, RuntimeLaunchError } from "../runtime/ports.js";
-import { formatTurnReceiptId } from "../task/taskRecordReference.js";
-import { turnInputEnvelope } from "../turn/turn.js";
-import { captureRoleTurnDispatch } from "../coordination/workMailboxQueue.js";
-import { isSchedulerTaskWorkspaceReady, selectedActiveSchedulerTasks, selectedSchedulerRoles } from "./ports.js";
-/**
- * Sole managed Provider write path. A Turn is durable workflow intent;
- * each invocation here is an ordinary Provider-native Turn on the Role's
- * shared conversation. Stable request ids make a repeated submit idempotent
- * without copying Provider delivery state into Turn or WorkMailbox.
- */
-export async function processActiveRoleTurnDeliveries(store, delivery, now, selection) {
-    const results = [];
-    for (const task of selectedActiveSchedulerTasks(store, selection)) {
-        for (const role of selectedSchedulerRoles(store, task.id, selection)) {
-            const turn = store.getActiveTurn(task.id, role.name);
-            if (turn === null)
-                continue;
-            results.push(await deliverActiveTurn(store, delivery, task, role, turn, now));
-        }
-    }
-    return results;
-}
-async function deliverActiveTurn(store, delivery, task, role, turn, now) {
-    const base = { taskId: task.id, roleName: role.name, turnId: turn.id };
-    if (!isSchedulerTaskWorkspaceReady(task, store.getTaskWorkspace(task.id))) {
-        return { ...base, status: "skipped", reason: "workspace-not-ready" };
-    }
-    const dispatchToken = captureRoleTurnDispatch(store.getWorkMailbox({
-        kind: "role",
-        taskId: task.id,
-        roleName: role.name
-    }), {
-        taskId: task.id,
-        roleName: role.name,
-        turnId: turn.id
-    });
-    const sessionSet = store.getTaskRoleSessionSet?.(task.id, role.name) ?? null;
-    const binding = sessionSet?.providerBinding ?? null;
-    const observedTurn = binding?.turn ?? null;
-    const initialAttemptId = formatTurnReceiptId(task.id, turn.id);
-    const currentProviderTurn = managedProviderTurnId(observedTurn) === turn.id ? observedTurn : null;
-    if (binding?.authority.owner === "human"
-        || binding?.authority.owner === "unknown") {
-        return { ...base, status: "skipped", reason: "writer-attached" };
-    }
-    if (currentProviderTurn?.status === "accepted") {
-        settleAcceptedRoleTurnDispatch(store, turn, dispatchToken);
-        return { ...base, status: "skipped", reason: "not-ready" };
-    }
-    if (currentProviderTurn?.status === "submitting") {
-        return { ...base, status: "skipped", reason: "not-ready" };
-    }
-    if (currentProviderTurn?.status === "delivery-unknown") {
-        return failTurnDelivery(store, turn, now, "delivery-unknown", currentProviderTurn.terminalReason ?? "Provider could not determine whether the Turn was accepted.");
-    }
-    if (currentProviderTurn !== null) {
-        const reason = currentProviderTurn.terminalReason
-            ?? `Provider Turn ended with status ${currentProviderTurn.status} without recording its Turn result.`;
-        // A terminal Provider projection without an application result is a
-        // framework consistency failure, not evidence that the Agent omitted its
-        // report. Keep the exact input fenced; never submit it again.
-        return { ...base, status: "skipped", reason: "delivery-uncertain", error: reason };
-    }
-    const attemptId = initialAttemptId;
-    const mode = turn.mode;
-    const existingSession = store.getRoleSession(task.id, role.name, turn.effective.agentId);
-    let prepared;
-    let submitted = false;
-    try {
-        const nativeSessionId = mode === "resume"
-            ? requireResumeSession(role, turn, existingSession)
-            : undefined;
-        prepared = await delivery.prepareRoleSession({
-            taskId: task.id,
-            roleName: role.name,
-            agentId: turn.effective.agentId,
-            adapterId: turn.effective.adapterId,
-            effective: turn.effective,
-            workspace: turn.effective.workspace.root,
-            ...(turn.workspace === undefined ? {} : { managedWorkspace: turn.workspace }),
-            mode,
-            turnId: turn.id,
-            ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
-            ...(mode !== "resume" || existingSession?.runtimeGenerationId === undefined
-                ? {}
-                : { hostActivationId: existingSession.runtimeGenerationId }),
-            beforeHostStart: (preflight) => persistPreStartSession(store, task, role, turn, existingSession, mode, preflight, now)
-        });
-        const preparedSession = prepared.session === undefined
-            ? existingSession
-            : validateRoleSession(role, turn, existingSession, mode, prepared.session);
-        store.saveRoleTurnPrepared({
-            task,
-            role,
-            turn,
-            session: preparedSession,
-            ...(prepared.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: prepared.runtimeGenerationId }),
-            now
-        });
-        const ready = await delivery.waitUntilReady(prepared);
-        const readySession = validateRoleSession(role, turn, existingSession, mode, ready.session);
-        store.saveRoleTurnPrepared({
-            task,
-            role,
-            turn,
-            session: readySession,
-            ...(ready.prepared.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: ready.prepared.runtimeGenerationId }),
-            now
-        });
-        submitted = true;
-        const outcome = await delivery.sendOnce({
-            delivery: ready,
-            receiptId: attemptId,
-            text: serializeTurnInputEnvelope(turnInputEnvelope(turn))
-        });
-        if (outcome.status === "busy" || outcome.status === "unavailable") {
-            forget(delivery, task.id, role.name, turn.id, ready.prepared.runtimeGenerationId);
-            return {
-                ...base,
-                status: "skipped",
-                reason: outcome.status === "busy" ? "not-ready" : "runtime-unavailable"
-            };
-        }
-        if (outcome.status === "rejected" || outcome.status === "delivery-unknown") {
-            forget(delivery, task.id, role.name, turn.id, ready.prepared.runtimeGenerationId);
-            const unknown = outcome.status === "delivery-unknown";
-            const failure = outcome.failure;
-            // The Host's own account of the failure. Without it the only honest
-            // statement is that delivery did not complete — never that the Provider
-            // rejected the input, which is one specific cause among many.
-            const cause = failure === undefined
-                ? `The Agent Host did not deliver the managed Turn (${outcome.status}) and reported no cause.`
-                : formatProviderDeliveryFailure(failure);
-            // This path is the common Provider write failure and previously left no
-            // durable fact at all, so the cause was unrecoverable after the fact.
-            store.recordAgentError?.({
-                taskId: task.id,
-                roleName: role.name,
-                turnId: turn.id,
-                source: "host",
-                phase: failure?.phase ?? "turn-submit",
-                message: cause,
-                // The Host already serialized the complete redacted chain. Re-serializing
-                // the failure object here would persist this layer's wrapper instead of
-                // the original cause, which is the detail an authorized reader needs.
-                raw: failure?.raw ?? serializeAgentErrorRaw(failure ?? cause),
-                inputDisposition: failure?.inputDisposition ?? (unknown ? "unknown" : "not-accepted"),
-                ...providerDeliveryFailureFacts(failure)
-            }, now);
-            return failTurnDelivery(store, turn, now, unknown ? "delivery-unknown" : "runtime-failed", unknown
-                ? `Provider Turn delivery is ambiguous; Yui will not replay it automatically. ${cause}`
-                : cause);
-        }
-        forget(delivery, task.id, role.name, turn.id, ready.prepared.runtimeGenerationId);
-        settleAcceptedRoleTurnDispatch(store, turn, dispatchToken);
-        return {
-            ...base,
-            status: outcome.status === "sent" ? "delivered" : "already-delivered"
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        // A launch failure carries its own structure — the class that threw, the
-        // innermost cause, and for a generation mismatch both generations. Recording
-        // only `message` flattened all of it into prose that no reader could
-        // reliably parse back.
-        const causeName = innermostCauseName(error);
-        const mismatch = error instanceof RuntimeGenerationMismatchError ? error : undefined;
-        store.recordAgentError?.({
-            taskId: task.id,
-            roleName: role.name,
-            turnId: turn.id,
-            source: error instanceof RuntimeLaunchError || error instanceof RuntimeLaunchFailure ? "host" : "yui",
-            phase: submitted ? "turn-submit" : mode === "new" ? "session-start" : "session-restore",
-            message,
-            raw: serializeAgentErrorRaw(error),
-            inputDisposition: submitted ? "unknown" : "not-accepted",
-            // Nothing was submitted, so the Provider provably holds no registration
-            // for this attempt; after a submit the Host owns that fact, not this layer.
-            ...(submitted ? {} : { registrationDisposition: "not-committed" }),
-            ...(error instanceof Error ? { errorName: error.name } : {}),
-            ...(causeName === undefined ? {} : { causeName }),
-            ...(mismatch === undefined ? {} : {
-                expectedRuntimeGenerationId: mismatch.expectedRuntimeGenerationId,
-                ...(mismatch.observedRuntimeGenerationId === undefined
-                    ? {}
-                    : { observedRuntimeGenerationId: mismatch.observedRuntimeGenerationId })
-            }),
-            ...(error instanceof RuntimeLaunchError
-                ? { expectedRuntimeGenerationId: error.runtimeGenerationId }
-                : {}),
-            attemptId
-        }, now);
-        if (error instanceof RuntimeLifecycleBusyError
-            || (error instanceof RuntimeLaunchError && error.retryable)) {
-            return {
-                ...base,
-                status: "skipped",
-                reason: error instanceof RuntimeLaunchError && error.reason === "writable-client"
-                    ? "writer-attached"
-                    : "runtime-unavailable",
-                error: message
-            };
-        }
-        forget(delivery, task.id, role.name, turn.id, prepared?.runtimeGenerationId);
-        return failTurnDelivery(store, turn, now, submitted ? "delivery-unknown" : "startup-failed", message);
-    }
-}
-function failTurnDelivery(store, turn, now, failureReason, summary) {
-    const disposition = store.saveRoleTurnDeliveryFailure({
-        taskId: turn.taskId,
-        roleName: turn.roleName,
-        agentId: turn.effective.agentId,
-        adapterId: turn.effective.adapterId,
-        turnId: turn.id,
-        failureReason,
-        summary,
-        now
-    });
-    return {
-        taskId: turn.taskId,
-        roleName: turn.roleName,
-        turnId: turn.id,
-        status: disposition === "failed" ? "failed" : "skipped",
-        reason: failureReason === "delivery-unknown" ? "delivery-uncertain" : "launch-failed",
-        error: summary,
-        ...(disposition === "failed" ? { terminalized: true } : {})
-    };
-}
-function settleAcceptedRoleTurnDispatch(store, turn, expected) {
-    store.settleRoleTurnDispatch({
-        taskId: turn.taskId,
-        roleName: turn.roleName,
-        turnId: turn.id,
-        ...(expected === undefined ? {} : { expected })
-    });
-}
-function persistPreStartSession(store, task, role, turn, existing, mode, preflight, now) {
-    if (preflight.owner.scope !== "task"
-        || preflight.owner.taskId !== task.id
-        || preflight.owner.roleName !== role.name
-        || preflight.turnId !== turn.id
-        || preflight.runtimeGenerationId.trim().length === 0) {
-        throw new Error(`Pre-start launch fence changed the active Role Turn: ${task.id}/${role.name}.`);
-    }
-    const session = preflight.nativeSessionId === undefined ? null : {
-        agentId: preflight.agentId,
-        adapterId: preflight.adapterId,
-        nativeSessionId: preflight.nativeSessionId,
-        runtimeGenerationId: preflight.runtimeGenerationId,
-        ...(preflight.sessionTitle === undefined ? {} : { title: preflight.sessionTitle }),
-        status: "active",
-        effective: preflight.effective
-    };
-    store.saveRoleTurnPrepared({
-        task,
-        role,
-        turn,
-        session: validateRoleSession(role, turn, existing, mode, session),
-        runtimeGenerationId: preflight.runtimeGenerationId,
-        now
-    });
-}
-function validateRoleSession(role, turn, existing, mode, session) {
-    if (mode === "new" && session === null)
-        return null;
-    if (session === null || !hasText(session.nativeSessionId)) {
-        throw new Error(`Ready Role session has no native session id: ${role.taskId}/${role.name}.`);
-    }
-    if (session.agentId !== turn.effective.agentId
-        || session.adapterId !== turn.effective.adapterId) {
-        throw new Error(`Ready Role session identity changed: ${role.taskId}/${role.name}.`);
-    }
-    const compatible = mode === "resume"
-        ? roleSessionMayContinue(session.effective, turn.effective)
-        : sameEffectiveLaunch(session.effective, turn.effective);
-    if (!compatible) {
-        throw new Error(`Ready Role session effective snapshot changed: ${role.taskId}/${role.name}.`);
-    }
-    if (mode === "resume" && session.nativeSessionId !== existing?.nativeSessionId) {
-        throw new Error(`Role resume changed the fixed native session id: ${role.taskId}/${role.name}.`);
-    }
-    return {
-        ...session,
-        status: "active",
-        ...(mode === "resume" && existing !== null ? { effective: existing.effective } : {})
-    };
-}
-function requireResumeSession(role, turn, session) {
-    if (session === null || !hasText(session.nativeSessionId)) {
-        throw new Error(`Role resume has no fixed native session: ${role.taskId}/${role.name}.`);
-    }
-    if (!roleSessionMayContinue(session.effective, turn.effective)) {
-        throw new Error(`Role resume effective snapshot drifted: ${role.taskId}/${role.name}.`);
-    }
-    return session.nativeSessionId;
-}
-function forget(delivery, taskId, roleName, turnId, runtimeGenerationId) {
-    delivery.forgetPrepared?.({
-        taskId,
-        roleName,
-        turnId,
-        ...(runtimeGenerationId === undefined ? {} : { runtimeGenerationId })
-    });
-}
-function hasText(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}