@zq-silk/yui 0.13.4 → 0.13.6

package/dist/run/recoveryProjection.js

@@ -1,252 +0,0 @@
-import { createHash } from "node:crypto";
-import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
-import { actionableExecutionLaneRecoveries } from "../execution/executionHealth.js";
-import { runOwnsBlockingProviderContinuation } from "../runtime/runtimeContinuationProjection.js";
-import { runHasActiveRuntimeOperations } from "../runtime/runtimeObservation.js";
-export const RUN_RECOVERY_ACTIONS = [
-    "diagnose",
-    "retry",
-    "terminate"
-];
-/**
- * Reads every durable record the recovery projection needs. Returns null
- * only when the Run itself is absent.
- */
-export function readRunRecoveryFacts(store, taskId, runId) {
-    const run = store.getAgentRun(taskId, runId);
-    if (run === null || run.taskId !== taskId)
-        return null;
-    const task = store.getTask(taskId);
-    const sessionSet = store.getTaskRoleSessionSet(taskId, run.roleName);
-    const events = store.listEvents(taskId);
-    const roleMailbox = store.getWorkMailbox?.({
-        kind: "role",
-        taskId,
-        roleName: run.roleName
-    }) ?? null;
-    const progress = latestRunDurableProgressAt(store, taskId, run.roleName, runId);
-    return {
-        run,
-        task: task === null ? null : { id: task.id, status: task.status },
-        sessionSet,
-        inputDeliveryUnsettled: roleMailbox?.inputDelivery != null,
-        blockingProviderContinuation: runOwnsBlockingProviderContinuation(events, {
-            taskId,
-            roleName: run.roleName,
-            runId: run.id,
-            agentId: run.effective.agentId
-        }),
-        activeRuntimeOperation: runHasActiveRuntimeOperations(events, {
-            taskId,
-            roleName: run.roleName,
-            runId: run.id,
-            agentId: run.effective.agentId
-        }),
-        progress,
-        latestProviderObservation: latestRunProviderObservation(events, runId)
-    };
-}
-/**
- * Resolve the exact live-Run recovery plans referenced by Lane health. Failed
- * terminal Lanes use `task run retry` directly and therefore need no live-Run
- * recovery projection here.
- */
-export function projectExecutionLaneRunRecoveries(store, taskId, groups) {
-    const runIds = new Set(actionableExecutionLaneRecoveries(groups).flatMap((lane) => (lane.runId === undefined || lane.recovery === "retry-new-agent-run"
-        ? []
-        : [lane.runId])));
-    return [...runIds].flatMap((runId) => {
-        const facts = readRunRecoveryFacts(store, taskId, runId);
-        return facts === null ? [] : [projectRunRecovery(facts)];
-    });
-}
-/**
- * Latest Provider observation for a Run. Provider timestamps are evidence:
- * they explain why a stale fence was supplied but never authorize recovery.
- */
-function latestRunProviderObservation(events, runId) {
-    let latest = null;
-    for (const event of events) {
-        if (event.type !== "runtime.observation")
-            continue;
-        if (event.payload.runId !== runId)
-            continue;
-        const kind = typeof event.payload.kind === "string" ? event.payload.kind : "unknown";
-        const receivedAt = typeof event.payload.receivedAt === "string"
-            && Number.isFinite(Date.parse(event.payload.receivedAt))
-            ? event.payload.receivedAt
-            : event.createdAt;
-        const at = Date.parse(receivedAt);
-        if (latest === null || at > latest.at) {
-            latest = { kind, receivedAt, at };
-        }
-    }
-    return latest === null ? null : { kind: latest.kind, receivedAt: latest.receivedAt };
-}
-export function projectRunRecovery(facts) {
-    const { run, task, sessionSet, progress } = facts;
-    const session = activeSession(facts);
-    const canonicalProgressAt = progress?.progressAt ?? null;
-    const accepted = run.deliveredAt !== undefined;
-    const acceptanceOptions = accepted
-        ? ["accepted", "ambiguous"]
-        : ["rejected", "ambiguous"];
-    const blocked = recoveryBlocker(facts, session, canonicalProgressAt);
-    const sessionTerminal = session?.status === "stopped" || session?.status === "broken";
-    const providerTerminal = sessionSet?.providerBinding?.turn?.status === "failed"
-        || sessionSet?.providerBinding?.turn?.status === "cancelled"
-        || sessionSet?.providerBinding?.turn?.status === "rejected";
-    const supportedActions = RUN_RECOVERY_ACTIONS.filter((action) => ((action !== "retry" || !sessionTerminal)
-        && (action !== "terminate" || sessionTerminal || providerTerminal)));
-    const actions = blocked === null
-        ? supportedActions.map((action) => buildActionPlan(facts, action, session, canonicalProgressAt))
-        : [];
-    const judgmentRequired = blocked === null && actions.some((plan) => plan.argv.includes(PROVIDER_ACCEPTANCE_PLACEHOLDER))
-        ? "Provider acceptance is not durably determined for every action; pass --provider-acceptance explicitly."
-        : undefined;
-    return {
-        taskId: run.taskId,
-        runId: run.id,
-        roleName: run.roleName,
-        runStatus: run.status,
-        recoverable: blocked === null,
-        canonicalProgressAt,
-        ...(progress?.evidence === undefined ? {} : { canonicalProgressEvidence: progress.evidence }),
-        provider: {
-            acceptedAt: run.deliveredAt ?? null,
-            observedAt: facts.latestProviderObservation?.receivedAt ?? null,
-            observationKind: facts.latestProviderObservation?.kind ?? null
-        },
-        providerAcceptance: {
-            accepted,
-            options: acceptanceOptions
-        },
-        session: session === null ? null : {
-            status: session.status,
-            ...(session.nativeSessionId === undefined ? {} : { nativeSessionId: session.nativeSessionId }),
-            ...(session.launchId === undefined ? {} : { launchId: session.launchId })
-        },
-        actions,
-        ...(judgmentRequired === undefined ? {} : { judgmentRequired }),
-        ...(blocked === null ? {} : { reason: blocked })
-    };
-}
-const PROVIDER_ACCEPTANCE_PLACEHOLDER = "<accepted|rejected|ambiguous>";
-function activeSession(facts) {
-    const sessions = facts.sessionSet;
-    if (sessions === null)
-        return null;
-    const session = sessions.sessions[sessions.activeAgentId];
-    if (session === undefined)
-        return null;
-    if (session.agentId !== facts.run.effective.agentId)
-        return null;
-    if (session.adapterId !== facts.run.effective.adapterId)
-        return null;
-    return session;
-}
-/**
- * Mirrors the fail-closed checks of `recoverExactAgentRun` that are visible
- * from durable records. A non-null result means recovery cannot currently be
- * applied; the canonical fence is still projected for diagnosis.
- */
-function recoveryBlocker(facts, session, canonicalProgressAt) {
-    const { run, task } = facts;
-    if (task === null)
-        return "task-missing";
-    if (task.status !== "active")
-        return "task-terminal";
-    if (run.status !== "active")
-        return "run-terminal";
-    if (canonicalProgressAt === null)
-        return "progress-unavailable";
-    if (session === null)
-        return "session-missing";
-    if (facts.inputDeliveryUnsettled)
-        return "provider-input-delivery-unsettled";
-    if (facts.blockingProviderContinuation)
-        return "provider-continuation-writer-owned";
-    if (facts.activeRuntimeOperation)
-        return "provider-operation-active";
-    const binding = facts.sessionSet?.providerBinding;
-    if (run.deliveredAt !== undefined
-        && (binding === null || binding?.turn === null))
-        return "provider-turn-state-missing";
-    if (binding !== null && binding !== undefined) {
-        if (["submitting", "accepted", "running", "delivery-unknown"].includes(binding.turn?.status ?? ""))
-            return "provider-turn-unsettled";
-        if (binding.authority.owner === "human" || binding.authority.owner === "unknown") {
-            return "provider-writer-authority-unavailable";
-        }
-    }
-    return null;
-}
-function buildActionPlan(facts, action, session, canonicalProgressAt) {
-    const { run } = facts;
-    const acceptance = actionAcceptance(facts, action);
-    const argv = [
-        "task",
-        "run",
-        "recover",
-        `${run.taskId}/${run.id}`,
-        "--action",
-        action,
-        "--expected-progress-at",
-        canonicalProgressAt,
-        "--provider-acceptance",
-        acceptance,
-        "--reason",
-        "<text>",
-        "--agent-id",
-        run.effective.agentId,
-        "--adapter-id",
-        run.effective.adapterId,
-        ...(session.nativeSessionId === undefined
-            ? []
-            : ["--native-session-id", session.nativeSessionId]),
-        ...(session.launchId === undefined
-            ? []
-            : ["--launch-id", session.launchId])
-    ];
-    const command = `yui ${argv
-        .map((part) => (part === "<text>" ? '"<text>"' : part))
-        .join(" ")}`;
-    const fingerprintSource = [
-        run.id,
-        action,
-        canonicalProgressAt,
-        run.effective.agentId,
-        run.effective.adapterId,
-        session.nativeSessionId ?? "",
-        session.launchId ?? ""
-    ].join("|");
-    return {
-        action,
-        reason: ACTION_REASONS[action],
-        expectedProgressAt: canonicalProgressAt,
-        agentId: run.effective.agentId,
-        adapterId: run.effective.adapterId,
-        ...(session.nativeSessionId === undefined
-            ? {}
-            : { nativeSessionId: session.nativeSessionId }),
-        ...(session.launchId === undefined ? {} : { launchId: session.launchId }),
-        command,
-        argv,
-        fingerprint: createHash("sha256").update(fingerprintSource).digest("hex")
-    };
-}
-/**
- * The acceptance value for the copy-paste command. When exactly one value is
- * durably valid it is filled in (the durable record, not a guess); otherwise
- * the Leader must choose and the command carries an explicit placeholder.
- */
-function actionAcceptance(facts, action) {
-    if (action === "diagnose")
-        return PROVIDER_ACCEPTANCE_PLACEHOLDER;
-    return facts.run.deliveredAt === undefined ? "rejected" : "accepted";
-}
-const ACTION_REASONS = {
-    diagnose: "Collect bounded diagnostics before any state-changing recovery.",
-    retry: "Request another provider turn on the same native Session when the failure is transient.",
-    terminate: "Fail the Run explicitly when recovery is not viable."
-};

package/dist/runtime/conversationSwitch.js

@@ -1,277 +0,0 @@
-import { roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
-import { effectiveLaunchSnapshotsCompatibleForTaskSession } from "../executor/effectiveLaunch.js";
-import { currentProviderActivation, currentProviderConversation } from "./providerRuntimeIdentity.js";
-import { blockingProviderContinuations } from "./runtimeContinuationProjection.js";
-import { runtimeObservationFromTaskEvent } from "./runtimeObservation.js";
-export const CONVERSATION_SWITCH_REQUESTED_EVENT = "runtime.conversation-switch-requested";
-export const CONVERSATION_SWITCH_RESOLVED_EVENT = "runtime.conversation-switch-resolved";
-export const CONVERSATION_SWITCH_DETACHED_EVENT = "runtime.conversation-switch-detached";
-export function providerConversationGeneration(sessions) {
-    const binding = sessions?.providerBinding;
-    if (binding === null || binding === undefined)
-        return null;
-    const current = currentProviderConversation(binding);
-    return `${binding.providerNamespace}:${binding.accountScope}:${current.epoch}:${current.conversationId}`;
-}
-export function projectConversationSwitch(events, roleName, sessions) {
-    const requests = events.filter((event) => (event.type === CONVERSATION_SWITCH_REQUESTED_EVENT
-        && event.payload.roleName === roleName));
-    const request = requests.at(-1);
-    if (request === undefined)
-        return null;
-    const requestId = request.payload.requestId;
-    const generation = request.payload.generation;
-    const requestedBy = request.payload.requestedBy;
-    const reason = request.payload.reason;
-    if (requestId === undefined || generation === undefined || reason === undefined
-        || (requestedBy !== "user" && requestedBy !== "operator" && requestedBy !== "leader")) {
-        return null;
-    }
-    const resolution = [...events].reverse().find((event) => (event.type === CONVERSATION_SWITCH_RESOLVED_EVENT
-        && event.payload.requestId === requestId));
-    const explicitStatus = resolution?.payload.status;
-    const currentGeneration = providerConversationGeneration(sessions);
-    const status = explicitStatus === "applied" || explicitStatus === "obsolete"
-        ? explicitStatus
-        : currentGeneration !== null && currentGeneration !== generation
-            ? "obsolete"
-            : "pending";
-    return {
-        requestId,
-        roleName,
-        generation,
-        requestedBy,
-        reason,
-        requestedAt: request.createdAt,
-        status,
-        ...(resolution === undefined ? {} : { resolvedAt: resolution.createdAt })
-    };
-}
-export function pendingConversationSwitch(events, roleName, sessions) {
-    const projected = projectConversationSwitch(events, roleName, sessions);
-    return projected?.status === "pending" ? projected : null;
-}
-export function roleSessionDispatchModeWithConversationSwitch(sessions, events, mailbox, roleName, agentId, effective) {
-    const ordinary = roleAgentSessionResumeMode(sessions, agentId, effective);
-    if (ordinary !== "resume") {
-        if (sessions?.providerBinding !== null && sessions?.providerBinding !== undefined) {
-            if (freshConversationLaunchAllowed({ sessions, events, mailbox, roleName })) {
-                return "new";
-            }
-            const existing = sessions.sessions[agentId];
-            if (existing?.nativeSessionId !== undefined
-                && (existing.status === "stopped" || existing.status === "broken")
-                && effectiveLaunchSnapshotsCompatibleForTaskSession(existing.effective, effective)) {
-                // A terminal local Activation does not prove the Provider Conversation
-                // is gone. Reattach to the same native identity by default.
-                return "resume";
-            }
-            throw new Error(`Fresh Provider Conversation is not yet safe: ${sessions.owner.taskId}/${roleName}.`);
-        }
-        return ordinary;
-    }
-    if (sessions?.providerBinding !== null && sessions?.providerBinding !== undefined
-        && freshConversationLaunchAllowed({ sessions, events, mailbox, roleName })) {
-        return "new";
-    }
-    return "resume";
-}
-export function conversationDetachmentBasis(input) {
-    const { sessions, mailbox } = input;
-    const binding = sessions.providerBinding;
-    const activation = binding === null ? null : currentProviderActivation(binding);
-    if (input.runMode !== "new" || binding === null || activation === null
-        || sessions.inFlight?.runId !== input.runId
-        || mailbox?.processing?.batchId !== sessions.inFlight.receiptId
-        || mailbox.processing.owner !== "controller"
-        || mailbox.processing.executionRef?.type !== "run"
-        || mailbox.processing.executionRef.taskId !== sessions.owner.taskId
-        || mailbox.processing.executionRef.id !== input.runId
-        || !actorRequestedSwitchBoundaryReady(sessions, mailbox)
-        || currentConversationExecutionBlockers(sessions, input.events, input.roleName).length > 0
-        || pendingConversationSwitch(input.events, input.roleName, sessions) === null) {
-        return null;
-    }
-    return "actor-request";
-}
-export function conversationReplacementBasis(input) {
-    const { sessions, mailbox } = input;
-    const binding = sessions.providerBinding;
-    if (input.runMode !== "new" || binding === null
-        || sessions.inFlight?.runId !== input.runId
-        || mailbox?.processing?.batchId !== sessions.inFlight.receiptId
-        || mailbox.processing.owner !== "controller"
-        || mailbox?.processing?.executionRef?.type !== "run"
-        || mailbox.processing.executionRef.taskId !== sessions.owner.taskId
-        || mailbox.processing.executionRef.id !== input.runId
-        || mailbox.inputDelivery !== null
-        || !conversationIsQuiescent(sessions, mailbox)
-        || currentConversationExecutionBlockers(sessions, input.events, input.roleName).length > 0) {
-        return null;
-    }
-    if (currentConversationIsExactlyUnrecoverable(sessions, input.events, input.roleName))
-        return "exact-unrecoverable";
-    return pendingConversationSwitch(input.events, input.roleName, sessions) === null
-        ? null
-        : "actor-request";
-}
-export function freshConversationLaunchAllowed(input) {
-    return freshConversationLaunchBlockers(input).length === 0;
-}
-/** Exact reasons a fresh Conversation cannot currently be admitted. */
-export function freshConversationLaunchBlockers(input) {
-    const { sessions } = input;
-    if (sessions === null)
-        return [];
-    const session = sessions.sessions[sessions.activeAgentId];
-    if (sessions.providerBinding === null) {
-        return session === undefined
-            || session.status === "stopped"
-            || session.status === "broken"
-            ? []
-            : ["native-session-not-terminal"];
-    }
-    const request = pendingConversationSwitch(input.events, input.roleName, sessions);
-    const binding = sessions.providerBinding;
-    const blockers = [];
-    if (input.mailbox?.inputDelivery != null)
-        blockers.push("provider-input-delivery-unsettled");
-    if (binding.turn !== null
-        && ["submitting", "accepted", "running", "delivery-unknown"].includes(binding.turn.status))
-        blockers.push("provider-turn-unsettled");
-    blockers.push(...currentConversationExecutionBlockers(sessions, input.events, input.roleName));
-    if (blockers.length > 0)
-        return blockers;
-    if (request !== null && actorRequestedSwitchBoundaryReady(sessions, input.mailbox, input.candidateRunId))
-        return [];
-    if (currentProviderActivation(binding) !== null)
-        blockers.push("provider-activation-active");
-    if (binding.authority.owner !== "none")
-        blockers.push("provider-writer-authority-owned");
-    if (blockers.length > 0)
-        return blockers;
-    if (currentProviderConversation(binding).recoverability === "unrecoverable") {
-        return currentConversationIsExactlyUnrecoverable(sessions, input.events, input.roleName) ? [] : ["exact-unrecoverable-evidence-missing"];
-    }
-    if (request !== null)
-        return ["actor-switch-boundary-not-ready"];
-    return ["current-conversation-recoverable"];
-}
-function actorRequestedSwitchBoundaryReady(sessions, mailbox, candidateRunId) {
-    const binding = sessions?.providerBinding;
-    if (sessions === null || sessions === undefined
-        || binding === null || binding === undefined
-        || mailbox?.inputDelivery != null)
-        return false;
-    const turnSettled = binding.turn === null
-        || ["completed", "failed", "cancelled", "rejected"].includes(binding.turn.status);
-    if (!turnSettled)
-        return false;
-    const session = sessions.sessions[sessions.activeAgentId];
-    if (session?.status === "running")
-        return false;
-    const activation = currentProviderActivation(binding);
-    if (activation === null)
-        return binding.authority.owner === "none";
-    if (binding.authority.owner !== "controller"
-        || binding.authority.holderId !== activation.activationId)
-        return false;
-    if (session === undefined)
-        return false;
-    if (sessions.inFlight === null) {
-        if (mailbox?.processing === null)
-            return true;
-        return candidateRunId !== undefined
-            && mailbox?.processing?.owner === "controller"
-            && mailbox.processing.executionRef?.type === "run"
-            && mailbox.processing.executionRef.taskId === sessions.owner.taskId
-            && mailbox.processing.executionRef.id === candidateRunId;
-    }
-    return mailbox?.processing?.batchId === sessions.inFlight.receiptId
-        && mailbox.processing.owner === "controller"
-        && mailbox.processing.executionRef?.type === "run"
-        && mailbox.processing.executionRef.taskId === sessions.owner.taskId
-        && mailbox.processing.executionRef.id === sessions.inFlight.runId;
-}
-function conversationIsQuiescent(sessions, mailbox) {
-    const binding = sessions?.providerBinding;
-    if (binding === null || binding === undefined)
-        return false;
-    const turnSettled = binding.turn === null
-        || ["completed", "failed", "cancelled", "rejected"].includes(binding.turn.status);
-    return turnSettled
-        && currentProviderActivation(binding) === null
-        && binding.authority.owner === "none"
-        && mailbox?.inputDelivery == null;
-}
-/**
- * A projected recoverability flag is necessary but not sufficient to replace
- * a Conversation. Require the exact structured missing-Conversation fact for
- * the current Provider identity and latest Activation generation, so an old
- * observation cannot authorize a later fresh Conversation. The binding's Run
- * id is deliberately excluded: replacement work rebinds that fence before
- * launching, while the missing fact necessarily came from the preceding Run's
- * exact attempt to resume this same Activation.
- */
-function currentConversationIsExactlyUnrecoverable(sessions, events, roleName) {
-    const binding = sessions.providerBinding;
-    if (binding === null)
-        return false;
-    const conversation = currentProviderConversation(binding);
-    if (conversation.recoverability !== "unrecoverable")
-        return false;
-    const activation = [...binding.activations].reverse().find((entry) => (entry.conversationId === conversation.conversationId));
-    const generationStartedAt = activation?.startedAt ?? conversation.createdAt;
-    return events.some((event) => {
-        const observation = runtimeObservationFromTaskEvent(event);
-        if (observation === null
-            || observation.kind !== "conversation.observed"
-            || observation.payload.recoverability !== "unrecoverable"
-            || (observation.authority !== "provider-structured"
-                && observation.authority !== "controller"))
-            return false;
-        const fence = observation.fence;
-        if (fence.taskId !== sessions.owner.taskId
-            || fence.roleName !== roleName
-            || fence.agentId !== binding.accountScope
-            || fence.driverId !== binding.providerNamespace
-            || fence.conversationId !== conversation.conversationId
-            || (activation !== undefined && fence.activationId !== activation.activationId)) {
-            return false;
-        }
-        return Date.parse(observation.observedAt ?? observation.receivedAt)
-            >= Date.parse(generationStartedAt);
-    });
-}
-/** Current Provider-owned work that may outlive a foreground Turn. */
-function currentConversationExecutionBlockers(sessions, events, roleName) {
-    const binding = sessions.providerBinding;
-    if (binding === null)
-        return [];
-    const conversation = currentProviderConversation(binding);
-    const activation = [...binding.activations].reverse().find((entry) => (entry.conversationId === conversation.conversationId));
-    if (activation === undefined)
-        return ["provider-activation-identity-missing"];
-    const activeOperation = events.some((event) => {
-        const observation = runtimeObservationFromTaskEvent(event);
-        if (observation?.kind !== "operation.started")
-            return false;
-        const fence = observation.fence;
-        return fence.taskId === sessions.owner.taskId
-            && fence.roleName === roleName
-            && fence.agentId === binding.accountScope
-            && fence.driverId === binding.providerNamespace
-            && (fence.conversationId ?? fence.nativeSessionId) === conversation.conversationId
-            && (fence.activationId ?? fence.launchId) === activation.activationId;
-    });
-    const blockingContinuation = blockingProviderContinuations(events).some((entry) => (entry.taskId === sessions.owner.taskId
-        && entry.roleName === roleName
-        && entry.identity.providerNamespace === binding.providerNamespace
-        && entry.identity.accountScope === binding.accountScope
-        && entry.identity.conversationId === conversation.conversationId
-        && entry.identity.activationId === activation.activationId));
-    return [
-        ...(activeOperation ? ["provider-operation-active"] : []),
-        ...(blockingContinuation ? ["provider-continuation-writer-owned"] : [])
-    ];
-}