@nylorun/runtime 0.9.0-beta → 0.10.0-beta

package/dist/core/flow-host.js

@@ -0,0 +1,783 @@
+import { createHash } from "node:crypto";
+import { mayDispatchMore } from "./limits.js";
+/** Deterministic agent session id: derive(workflowSessionId, path, …parts). */
+export function deriveSessionId(workflowSessionId, path, ...parts) {
+    const digest = createHash("sha256")
+        .update([workflowSessionId, path, ...parts].join("\0"))
+        .digest("hex")
+        .slice(0, 24);
+    return `wf_${digest}`;
+}
+/**
+ * Linked agent session id for a flow agent effect.
+ * Verifier agents (`context.role === "verify-agent"`) get a unique session per
+ * (path, turnId, iterations) so prior verdicts cannot leak across Loop iterations.
+ */
+export function deriveAgentEffectSessionId(workflowSessionId, path, request) {
+    if (request.context?.role === "verify-agent") {
+        const iterations = request.iterations ?? "-";
+        const iterParts = iterations !== "-" && iterations.length > 0 ? iterations.split(".") : [];
+        return deriveSessionId(workflowSessionId, path, "verify", request.turnId, ...iterParts);
+    }
+    return deriveSessionId(workflowSessionId, path);
+}
+export function isWorkflowManifest(manifest) {
+    return (!!manifest &&
+        typeof manifest === "object" &&
+        manifest.kind === "workflow");
+}
+/** Flow tool-node effect: `tool` with path/key and no agent capabilityId. */
+export function isFlowToolEffect(request) {
+    return (request.kind === "tool" &&
+        typeof request.path === "string" &&
+        request.path.length > 0 &&
+        typeof request.key === "string" &&
+        request.key.length > 0 &&
+        request.capabilityId === undefined);
+}
+export function isFlowEffect(request) {
+    return (request.kind === "agent" ||
+        request.kind === "fn" ||
+        request.kind === "verify" ||
+        isFlowToolEffect(request));
+}
+/**
+ * Resolve flow effects: agent (via session contract), tool nodes, fn, verify.
+ * Runtime never writes agent session state — only issues commands.
+ */
+export function resolveFlowEffect(input) {
+    const { request, store, session } = input;
+    if (!isFlowEffect(request))
+        throw new Error(`Not a flow effect: ${request.kind}`);
+    const existing = store.get("effects", request.effectId);
+    if (existing) {
+        if (existing.status === "completed")
+            return { status: "completed", outcome: existing.outcome };
+        if (existing.status === "queued") {
+            if (input.limits &&
+                !mayDispatchMore(countActiveFlowWork(store, session.id, request.turnId), input.limits))
+                return { status: "pending" };
+            return dispatchQueuedEffect(input, existing);
+        }
+        if (request.kind === "agent")
+            return settleAgentEffect(input, existing) ?? { status: "pending" };
+        return {
+            status: existing.status === "uncertain" || existing.status === "invoking"
+                ? "uncertain"
+                : "pending",
+        };
+    }
+    if (input.limits &&
+        !mayDispatchMore(countActiveFlowWork(store, session.id, request.turnId), input.limits)) {
+        store.put("effects", request.effectId, {
+            request,
+            status: "queued",
+        });
+        return { status: "pending" };
+    }
+    if (request.kind === "agent")
+        return startAgentEffect(input);
+    if (isFlowToolEffect(request))
+        return startToolNode(input);
+    return startFnOrVerify(input);
+}
+/** Active agent turns + pending/claimed actions for one workflow turn. */
+export function countActiveFlowWork(store, workflowSessionId, turnId) {
+    let n = 0;
+    for (const effect of store.all("effects")) {
+        if (effect.request?.sessionId !== workflowSessionId)
+            continue;
+        if (effect.request?.turnId !== turnId)
+            continue;
+        if (effect.status === "queued")
+            continue;
+        if (effect.status === "completed" || effect.status === "cancelled")
+            continue;
+        if (effect.request?.kind === "agent" && effect.status === "pending") {
+            n += 1;
+            continue;
+        }
+        if (effect.request?.kind === "fn" ||
+            effect.request?.kind === "verify" ||
+            isFlowToolEffect(effect.request)) {
+            const action = store.get("actions", effect.request.effectId);
+            if (action &&
+                (action.status === "pending" || action.status === "claimed"))
+                n += 1;
+        }
+    }
+    return n;
+}
+function dispatchQueuedEffect(input, existing) {
+    const { request, store } = input;
+    store.put("effects", request.effectId, {
+        ...existing,
+        status: "pending",
+    });
+    if (request.kind === "agent")
+        return startAgentEffect(input);
+    if (isFlowToolEffect(request))
+        return startToolNode(input);
+    return startFnOrVerify(input);
+}
+function startFnOrVerify(input) {
+    const { request, store, session } = input;
+    store.put("effects", request.effectId, {
+        request,
+        status: "pending",
+    });
+    const kind = request.kind;
+    const action = {
+        actionId: request.effectId,
+        sessionId: request.sessionId,
+        turnId: request.turnId,
+        agentId: request.agentId,
+        manifestHash: request.manifestHash,
+        implementationVersion: session.implementationVersion,
+        input: request.input,
+        context: request.context,
+        status: "pending",
+        generation: 0,
+        claimId: null,
+        leaseExpiresAt: null,
+        kind,
+        path: request.path,
+        key: request.key,
+    };
+    store.put("actions", action.actionId, action);
+    const event = store.event(session.id, session.activeTurnId, "action.pending", {
+        actionId: action.actionId,
+        kind: action.kind,
+        path: action.path,
+        key: action.key,
+        input: action.input,
+    });
+    input.publish(event);
+    input.notify();
+    return { status: "pending" };
+}
+function startToolNode(input) {
+    const { request, store, session } = input;
+    store.put("effects", request.effectId, {
+        request,
+        status: "pending",
+    });
+    const action = {
+        actionId: request.effectId,
+        sessionId: request.sessionId,
+        turnId: request.turnId,
+        agentId: request.agentId,
+        manifestHash: request.manifestHash,
+        implementationVersion: session.implementationVersion,
+        input: request.input,
+        context: request.context,
+        status: "pending",
+        generation: 0,
+        claimId: null,
+        leaseExpiresAt: null,
+        kind: "tool",
+        path: request.path,
+        key: request.key,
+    };
+    store.put("actions", action.actionId, action);
+    emitNodeStarted(input, {
+        path: request.path,
+        kind: "tool",
+        key: request.key,
+        iterations: request.iterations,
+    });
+    const event = store.event(session.id, session.activeTurnId, "action.pending", {
+        actionId: action.actionId,
+        kind: action.kind,
+        path: action.path,
+        key: action.key,
+        input: action.input,
+    });
+    input.publish(event);
+    input.notify();
+    return { status: "pending" };
+}
+function startAgentEffect(input) {
+    const { request, store, session } = input;
+    const body = request.input;
+    const path = body.path ?? request.path;
+    const agentSessionId = deriveAgentEffectSessionId(session.id, path, request);
+    const iterations = request.iterations ?? "-";
+    const n = Number(request.context.n ?? iterations.split(".")[0] ?? 1);
+    store.put("effects", request.effectId, {
+        request,
+        status: "pending",
+        agentSessionId,
+    });
+    store.put("links", agentSessionId, {
+        workflowSessionId: session.id,
+        path,
+        effectId: request.effectId,
+        turnId: request.turnId,
+    });
+    const existingAgent = input.readSession(agentSessionId);
+    if (!existingAgent) {
+        input.putLinkedSession({
+            id: agentSessionId,
+            agentId: body.agentId,
+            ownerUserId: session.ownerUserId,
+            vaultIds: session.vaultIds,
+            credentialSelections: session.credentialSelections,
+        });
+    }
+    const idempotencyKey = `${request.turnId}:${path}:${iterations}`;
+    const messageInput = body.input;
+    const accepted = input.sendMessage({
+        sessionId: agentSessionId,
+        ...(typeof messageInput === "string"
+            ? { content: messageInput }
+            : { data: messageInput }),
+        idempotencyKey,
+        requestId: `flow-${request.effectId}`,
+    });
+    const iterationEvent = store.event(session.id, session.activeTurnId, "loop.iteration", {
+        path: String(request.context.loopPath ?? path.split("/")[0]),
+        n,
+        sessionId: agentSessionId,
+        turnId: accepted.turnId ?? undefined,
+    });
+    input.publish(iterationEvent);
+    const nodeAgent = store.event(session.id, session.activeTurnId, "node.agent", {
+        path,
+        iterations,
+        sessionId: agentSessionId,
+        turnId: accepted.turnId,
+    });
+    input.publish(nodeAgent);
+    return (settleAgentEffect(input, store.get("effects", request.effectId)) ?? {
+        status: "pending",
+    });
+}
+function settleAgentEffect(input, effect) {
+    if (effect.status === "completed" && effect.outcome)
+        return { status: "completed", outcome: effect.outcome };
+    const agentSessionId = effect.agentSessionId ??
+        deriveAgentEffectSessionId(input.session.id, input.request.input.path ?? input.request.path, input.request);
+    const agent = input.readSession(agentSessionId);
+    if (!agent)
+        return undefined;
+    if (agent.status === "completed" && agent.activeTurnId === null) {
+        const output = agent.lastOutput ?? null;
+        const outcome = { value: output };
+        input.store.put("effects", input.request.effectId, {
+            request: input.request,
+            status: "completed",
+            outcome,
+            agentSessionId,
+        });
+        return { status: "completed", outcome };
+    }
+    if (agent.status === "failed") {
+        const outcome = {
+            value: {
+                kind: "failed",
+                code: "agent.failed",
+                message: agent.error ?? "Agent turn failed",
+            },
+        };
+        input.store.put("effects", input.request.effectId, {
+            request: input.request,
+            status: "completed",
+            outcome,
+            agentSessionId,
+        });
+        return { status: "completed", outcome };
+    }
+    if (agent.status === "cancelled") {
+        const outcome = {
+            value: {
+                kind: "failed",
+                code: "agent.cancelled",
+                message: agent.error ?? "Agent turn was cancelled",
+            },
+        };
+        input.store.put("effects", input.request.effectId, {
+            request: input.request,
+            status: "completed",
+            outcome,
+            agentSessionId,
+        });
+        return { status: "completed", outcome };
+    }
+    return undefined;
+}
+/** After an agent turn settles, wake the owning workflow if linked. */
+export function wakeLinkedWorkflow(input) {
+    const link = input.store.get("links", input.agentSessionId);
+    if (!link)
+        return;
+    const effect = input.store.get("effects", link.effectId);
+    if (!effect || effect.status === "completed")
+        return;
+    const workflow = input.store.get("sessions", link.workflowSessionId);
+    if (!workflow)
+        return;
+    if (workflow.activeTurnId !== link.turnId)
+        return;
+    const outcome = input.cancelled
+        ? {
+            value: {
+                kind: "failed",
+                code: "agent.cancelled",
+                message: input.error ?? "Agent turn was cancelled",
+            },
+        }
+        : input.failed
+            ? {
+                value: {
+                    kind: "failed",
+                    code: "agent.failed",
+                    message: input.error ?? "Agent turn failed",
+                },
+            }
+            : { value: input.output ?? null };
+    input.store.put("effects", link.effectId, {
+        ...effect,
+        status: "completed",
+        outcome,
+    });
+    workflow.status = "runnable";
+    input.store.put("sessions", workflow.id, workflow);
+    input.schedule(workflow.id);
+}
+/** On Runtime start: settle pending agent effects whose linked turns already finished. */
+export function reconcilePendingAgentEffects(input) {
+    for (const effect of input.store.all("effects")) {
+        if (effect.request?.kind !== "agent" || effect.status !== "pending")
+            continue;
+        const id = typeof effect.agentSessionId === "string"
+            ? effect.agentSessionId
+            : undefined;
+        if (!id)
+            continue;
+        const agent = input.store.get("sessions", id);
+        const workflow = input.store.get("sessions", effect.request.sessionId);
+        if (workflow && workflow.status === "waiting") {
+            workflow.status = "runnable";
+            input.store.put("sessions", workflow.id, workflow);
+            input.schedule(workflow.id);
+        }
+        if (!agent)
+            continue;
+        if (agent.status === "completed") {
+            wakeLinkedWorkflow({
+                agentSessionId: id,
+                store: input.store,
+                output: agent.lastOutput ?? null,
+                schedule: input.schedule,
+                publish: input.publish,
+            });
+        }
+        else if (agent.status === "failed") {
+            wakeLinkedWorkflow({
+                agentSessionId: id,
+                store: input.store,
+                failed: true,
+                error: agent.error,
+                schedule: input.schedule,
+                publish: input.publish,
+            });
+        }
+        else if (agent.status === "cancelled") {
+            wakeLinkedWorkflow({
+                agentSessionId: id,
+                store: input.store,
+                cancelled: true,
+                error: agent.error,
+                schedule: input.schedule,
+                publish: input.publish,
+            });
+        }
+        else if (agent.status === "running" || agent.status === "runnable") {
+            input.schedule(id);
+        }
+        else if (agent.status === "paused") {
+            // Linked pause surfaces on the workflow waits list; keep waiting.
+            if (workflow && workflow.status !== "paused") {
+                const waits = aggregateWaits({
+                    store: input.store,
+                    workflowSessionId: workflow.id,
+                });
+                if (waits.length > 0) {
+                    workflow.status = "paused";
+                    workflow.waits = waits;
+                    input.store.put("sessions", workflow.id, workflow);
+                }
+            }
+        }
+    }
+}
+/** Re-offer orphaned fn/verify claims after a process restart (SD-P7 / WF-C9). */
+export function reofferOrphanedFnVerifyClaims(store) {
+    let n = 0;
+    for (const action of store.all("actions")) {
+        if (action.status === "claimed" &&
+            (action.kind === "fn" || action.kind === "verify")) {
+            action.status = "pending";
+            action.claimId = null;
+            action.leaseExpiresAt = null;
+            store.put("actions", action.actionId, action);
+            const s = store.get("sessions", action.sessionId);
+            if (s && (s.status === "waiting" || s.status === "running")) {
+                s.status = "runnable";
+                store.put("sessions", s.id, s);
+            }
+            n += 1;
+        }
+    }
+    return n;
+}
+/**
+ * On lease expiry: fn/verify → pending again; tool nodes → uncertain (WF-R35, WF-R38).
+ * Returns whether any fn/verify was redelivered.
+ */
+export function applyFlowLeaseExpiry(input) {
+    if (input.action.status !== "claimed" || !input.action.leaseExpiresAt)
+        return "skip";
+    const now = input.now ?? Date.now();
+    if (Date.parse(input.action.leaseExpiresAt) > now)
+        return "skip";
+    if (input.action.kind === "fn" || input.action.kind === "verify") {
+        input.action.status = "pending";
+        input.action.claimId = null;
+        input.action.leaseExpiresAt = null;
+        input.store.put("actions", input.action.actionId, input.action);
+        return "reoffer";
+    }
+    if (input.action.kind === "tool" &&
+        "path" in input.action &&
+        !("capabilityId" in input.action)) {
+        input.action.status = "uncertain";
+        input.store.put("actions", input.action.actionId, input.action);
+        const effect = input.store.get("effects", input.action.actionId);
+        if (effect) {
+            effect.status = "uncertain";
+            input.store.put("effects", input.action.actionId, effect);
+        }
+        return "uncertain";
+    }
+    return "skip";
+}
+/** Emit loop.verified / loop.decided after fn/verify actions complete. */
+export function emitLoopActionEvents(input) {
+    const { action, store, session } = input;
+    if (action.kind !== "fn" && action.kind !== "verify")
+        return;
+    const n = Number(action.context?.n ?? 1);
+    const path = String(action.context?.loopPath ?? action.path ?? "");
+    if (action.kind === "verify") {
+        const verdict = input.value;
+        if (verdict?.kind === "failed")
+            return;
+        const event = store.event(session.id, session.activeTurnId, "loop.verified", {
+            path,
+            n,
+            pass: Boolean(verdict?.pass),
+            ...(verdict?.feedback !== undefined
+                ? { feedback: verdict.feedback }
+                : {}),
+            ...(verdict?.data !== undefined ? { data: verdict.data } : {}),
+        });
+        input.publish(event);
+        return;
+    }
+    if (action.context?.role !== "decide")
+        return;
+    const decision = input.value;
+    const event = store.event(session.id, session.activeTurnId, "loop.decided", {
+        path,
+        n,
+        next: "output" in decision && !("input" in decision) ? "output" : "input",
+        patched: Boolean(decision.agent),
+    });
+    input.publish(event);
+}
+export function emitNodeStarted(input, payload) {
+    const event = input.store.event(input.session.id, input.session.activeTurnId, "node.started", payload);
+    input.publish(event);
+    return event;
+}
+export function emitNodeCompleted(input, payload) {
+    const event = input.store.event(input.session.id, input.session.activeTurnId, "node.completed", payload);
+    input.publish(event);
+    return event;
+}
+export function emitNodeFailed(input, payload) {
+    const event = input.store.event(input.session.id, input.session.activeTurnId, "node.failed", payload);
+    input.publish(event);
+    return event;
+}
+export function emitSwitchSelected(input, payload) {
+    const event = input.store.event(input.session.id, input.session.activeTurnId, "switch.selected", payload);
+    input.publish(event);
+    return event;
+}
+export function emitMapItems(input, payload) {
+    const event = input.store.event(input.session.id, input.session.activeTurnId, "map.items", payload);
+    input.publish(event);
+    return event;
+}
+/** Path depth for deepest-first cancel ordering. */
+export function pathDepth(path) {
+    if (!path)
+        return 0;
+    return path.split("/").filter(Boolean).length;
+}
+/**
+ * Plan a cancel cascade for a workflow session: linked agents deepest first,
+ * then pending → cancelled and claimed → uncertain actions (SD-P11 / WF-R53).
+ */
+export function planCancelCascade(input) {
+    // links table is keyed by agentSessionId — discover via sessions + get(links, id).
+    const agentEntries = [];
+    for (const sess of input.store.all("sessions")) {
+        const link = input.store.get("links", sess.id);
+        if (!link || link.workflowSessionId !== input.workflowSessionId)
+            continue;
+        agentEntries.push({ sessionId: sess.id, path: link.path });
+    }
+    agentEntries.sort((a, b) => pathDepth(b.path) - pathDepth(a.path));
+    const pendingActionIds = [];
+    const claimedActionIds = [];
+    for (const action of input.store.all("actions")) {
+        if (action.sessionId !== input.workflowSessionId)
+            continue;
+        if (input.turnId !== null && action.turnId !== input.turnId)
+            continue;
+        if (action.status === "pending")
+            pendingActionIds.push(action.actionId);
+        else if (action.status === "claimed")
+            claimedActionIds.push(action.actionId);
+    }
+    return {
+        agentSessionIds: agentEntries.map((e) => e.sessionId),
+        pendingActionIds,
+        claimedActionIds,
+    };
+}
+/**
+ * Cancel sibling work under a Parallel/Map parent when one branch fails (PAR-R6).
+ * Agent turns listed in `agentSessionIds` are returned for the caller to cancel;
+ * pending actions → cancelled, claimed tool actions → uncertain.
+ * When `cancelEffectIds` is provided, those effects are marked cancelled and their
+ * paths are included in the sibling path set.
+ */
+export function cancelSiblingWork(input) {
+    const cancelledActions = [];
+    const uncertainActions = [];
+    const agentSessionIds = [];
+    const siblingPaths = new Set(input.siblingPaths ?? []);
+    for (const effectId of input.cancelEffectIds ?? []) {
+        const effect = input.store.get("effects", effectId);
+        if (!effect)
+            continue;
+        const path = typeof effect.request?.path === "string"
+            ? effect.request.path
+            : undefined;
+        if (path)
+            siblingPaths.add(path);
+        if (effect.status === "pending" ||
+            effect.status === "queued" ||
+            effect.status === "uncertain") {
+            effect.status = "cancelled";
+            input.store.put("effects", effectId, effect);
+        }
+    }
+    const matchesSibling = (path) => {
+        if (!path)
+            return false;
+        return [...siblingPaths].some((sib) => path === sib || path.startsWith(`${sib}/`));
+    };
+    for (const sess of input.store.all("sessions")) {
+        const link = input.store.get("links", sess.id);
+        if (!link || link.workflowSessionId !== input.workflowSessionId)
+            continue;
+        if (!matchesSibling(link.path))
+            continue;
+        if (sess.activeTurnId &&
+            ["running", "runnable", "paused", "waiting"].includes(sess.status))
+            agentSessionIds.push(sess.id);
+    }
+    for (const action of input.store.all("actions")) {
+        if (action.sessionId !== input.workflowSessionId)
+            continue;
+        if (action.turnId !== input.turnId)
+            continue;
+        if (!matchesSibling(action.path))
+            continue;
+        if (action.status === "pending") {
+            action.status = "cancelled";
+            input.store.put("actions", action.actionId, action);
+            const effect = input.store.get("effects", action.actionId);
+            if (effect) {
+                effect.status = "cancelled";
+                input.store.put("effects", action.actionId, effect);
+            }
+            cancelledActions.push(action.actionId);
+        }
+        else if (action.status === "claimed") {
+            action.status = "uncertain";
+            input.store.put("actions", action.actionId, action);
+            const effect = input.store.get("effects", action.actionId);
+            if (effect) {
+                effect.status = "uncertain";
+                input.store.put("effects", action.actionId, effect);
+            }
+            uncertainActions.push(action.actionId);
+        }
+    }
+    return { cancelledActions, uncertainActions, agentSessionIds };
+}
+/**
+ * Apply cancel fencing to workflow-session actions (pending→cancelled, claimed→uncertain).
+ */
+export function fenceWorkflowActions(input) {
+    const cancelled = [];
+    const uncertain = [];
+    for (const action of input.store.all("actions")) {
+        if (action.sessionId !== input.workflowSessionId)
+            continue;
+        if (input.turnId !== null && action.turnId !== input.turnId)
+            continue;
+        if (!["pending", "claimed"].includes(action.status))
+            continue;
+        const next = action.status === "claimed" ? "uncertain" : "cancelled";
+        action.status = next;
+        input.store.put("actions", action.actionId, action);
+        const effect = input.store.get("effects", action.actionId);
+        if (effect) {
+            effect.status = next;
+            input.store.put("effects", action.actionId, effect);
+        }
+        if (next === "cancelled")
+            cancelled.push(action.actionId);
+        else
+            uncertain.push(action.actionId);
+    }
+    // Drop queued effects that never started.
+    for (const effect of input.store.all("effects")) {
+        if (effect.request?.sessionId !== input.workflowSessionId)
+            continue;
+        if (input.turnId !== null && effect.request?.turnId !== input.turnId)
+            continue;
+        if (effect.status === "queued") {
+            effect.status = "cancelled";
+            input.store.put("effects", effect.request.effectId, effect);
+            cancelled.push(effect.request.effectId);
+        }
+    }
+    return { cancelled, uncertain };
+}
+/**
+ * Aggregate human waits across the workflow session and linked agent sessions (WF-R51).
+ */
+export function aggregateWaits(input) {
+    const waits = [];
+    const workflow = input.store.get("sessions", input.workflowSessionId);
+    if (!workflow)
+        return waits;
+    const pushFromSession = (session, path, raw) => {
+        if (!Array.isArray(raw))
+            return;
+        for (const call of raw) {
+            const interaction = call.interaction ?? call;
+            const interactionId = String(interaction?.id ?? call.interactionId ?? "");
+            if (!interactionId)
+                continue;
+            waits.push({
+                sessionId: session.id,
+                path,
+                interactionId,
+                kind: String(interaction?.kind ?? call.kind ?? "approval"),
+                ...(call.invocationId !== undefined
+                    ? { invocationId: String(call.invocationId) }
+                    : {}),
+                ...(call.wait !== undefined ? { wait: call.wait } : {}),
+                ...(call.status !== undefined ? { status: String(call.status) } : {}),
+            });
+        }
+    };
+    // Workflow-owned interactions (tool-node / verify approvals) live on the workflow session.
+    if (Array.isArray(workflow.waits))
+        pushFromSession(workflow, "", workflow.waits);
+    else if (workflow.waits &&
+        typeof workflow.waits === "object" &&
+        Array.isArray(workflow.waits.interactions))
+        pushFromSession(workflow, "", workflow.waits.interactions);
+    for (const sess of input.store.all("sessions")) {
+        const link = input.store.get("links", sess.id);
+        if (!link || link.workflowSessionId !== input.workflowSessionId)
+            continue;
+        if (sess.status !== "paused")
+            continue;
+        pushFromSession(sess, link.path, sess.waits);
+    }
+    return waits;
+}
+/**
+ * Look up which session owns an interaction id. Used for 409 foreign approvals (WF-R52).
+ */
+export function findInteractionOwner(input) {
+    const waits = aggregateWaits(input);
+    const hit = waits.find((w) => w.interactionId === input.interactionId);
+    if (hit)
+        return { sessionId: hit.sessionId, path: hit.path };
+    // Also scan linked paused sessions' plan-shaped waits that aggregateWaits may have missed.
+    for (const sess of input.store.all("sessions")) {
+        const link = input.store.get("links", sess.id);
+        if (!link || link.workflowSessionId !== input.workflowSessionId)
+            continue;
+        const raw = sess.waits;
+        if (!Array.isArray(raw))
+            continue;
+        for (const call of raw) {
+            const id = String(call.interaction?.id ?? call.interactionId ?? "");
+            if (id === input.interactionId)
+                return { sessionId: sess.id, path: link.path };
+        }
+    }
+    return undefined;
+}
+/**
+ * If approve/respond targets an interaction owned by a linked agent session,
+ * return a 409 message naming that session (WF-R52 / LOOP-A4).
+ */
+export function foreignInteractionConflict(input) {
+    const owner = findInteractionOwner(input);
+    if (!owner)
+        return undefined;
+    if (owner.sessionId === input.workflowSessionId)
+        return undefined;
+    return {
+        status: 409,
+        message: `Interaction belongs to session ${owner.sessionId}`,
+        ownerSessionId: owner.sessionId,
+    };
+}
+/**
+ * When concurrency slots free, re-enter the workflow so queued effects can start
+ * (status stays `queued` until `resolveFlowEffect` dispatches them).
+ */
+export function wakeForQueuedEffects(input) {
+    if (!mayDispatchMore(countActiveFlowWork(input.store, input.workflowSessionId, input.turnId), input.limits))
+        return false;
+    const hasQueued = input.store
+        .all("effects")
+        .some((e) => e.status === "queued" &&
+        e.request?.sessionId === input.workflowSessionId &&
+        e.request?.turnId === input.turnId);
+    if (!hasQueued)
+        return false;
+    const workflow = input.store.get("sessions", input.workflowSessionId);
+    if (workflow && workflow.status === "waiting") {
+        workflow.status = "runnable";
+        input.store.put("sessions", workflow.id, workflow);
+    }
+    input.schedule(input.workflowSessionId);
+    return true;
+}