@flowdesk/opencode-plugin 0.1.14 → 0.1.16

package/dist/managed-dispatch-adapter.js

@@ -1,8 +1,10 @@
 import { createHash } from "node:crypto";
 import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { dirname, resolve, sep } from "node:path";
-import { applyFlowDeskSessionEvidenceWriteIntentsV1, evaluateFlowDeskDispatchAttemptDurablePrecallV1, evaluateManagedDispatchBetaGuardBoundaryV1, planFlowDeskFallbackRegateV1, prepareFlowDeskDispatchIdempotencyReservationV1, prepareFlowDeskDispatchIdempotencyStateUpdateV1, prepareFlowDeskSessionEvidenceWriteIntentV1, promoteFlowDeskExternalWriteAuthorityV1, promoteFlowDeskFallbackReselectionRegateV1, promoteFlowDeskManagedDispatchBetaAuthorityV1, promoteFlowDeskReviewerTypedVerdictsV1, recordFlowDeskExactModelAvailabilityCacheProviderAcquisitionResultV1, reloadFlowDeskSessionEvidenceV1, validateFlowDeskExactModelAvailabilityCacheAcquisitionPlanV1, validateFlowDeskFallbackRegatePlanV1, validateFlowDeskProductionApprovalSourceV1, validateFlowDeskPermissionAskDecisionV1, validateFlowDeskPromptNoReplyDecisionV1, validateFlowDeskRuntimeLaneLaunchPlanV1, validateFlowDeskSessionAbortDecisionV1, validateNoForbiddenRawPayloads, validateTopTierReviewVerdictV1, FLOWDESK_TOP_TIER_REVIEW_PERSPECTIVES, } from "@flowdesk/core";
+import { applyFlowDeskSessionEvidenceWriteIntentsV1, evaluateFlowDeskDispatchAttemptDurablePrecallV1, evaluateManagedDispatchBetaGuardBoundaryV1, planFlowDeskFallbackRegateV1, prepareFlowDeskDispatchIdempotencyReservationV1, prepareFlowDeskDispatchIdempotencyStateUpdateV1, prepareFlowDeskSessionEvidenceWriteIntentV1, promoteFlowDeskExternalWriteAuthorityV1, promoteFlowDeskFallbackReselectionRegateV1, promoteFlowDeskManagedDispatchBetaAuthorityV1, promoteFlowDeskReviewerTypedVerdictsV1, recordFlowDeskExactModelAvailabilityCacheProviderAcquisitionResultV1, reloadFlowDeskSessionEvidenceV1, validateFlowDeskExactModelAvailabilityCacheAcquisitionPlanV1, validateFlowDeskFallbackRegatePlanV1, validateFlowDeskProductionApprovalSourceV1, validateFlowDeskPermissionAskDecisionV1, validateFlowDeskPromptNoReplyDecisionV1, validateFlowDeskRuntimeLaneLaunchPlanV1, planFlowDeskRuntimeLaneLaunchV1, validateFlowDeskSessionAbortDecisionV1, validateNoForbiddenRawPayloads, validateTopTierReviewVerdictV1, FLOWDESK_TOP_TIER_REVIEW_PERSPECTIVES, } from "@flowdesk/core";
+import { observeFlowDeskAgentTaskOutputV1 } from "./agent-task-output.js";
 export const flowdeskManagedDispatchBetaAdapterProfile = "managed_dispatch_beta_real_opencode_dispatch_adapter";
+const MANAGED_DISPATCH_LANE_RESULT_MAX_TEXT = 32_768;
 function disabledAuthority() {
     return {
         realOpenCodeDispatch: false,
@@ -1933,6 +1935,53 @@ export function createFlowDeskManagedDispatchBetaDurableReservationStoreV1(optio
                     : { redactedFailureReason: materialized.redactedFailureReason }),
             };
         },
+        recordDispatchCompleted(input) {
+            const recordedAt = now().toISOString();
+            const evidenceId = snapshotRefFor(input.manifest, "dispatch-completed");
+            const current = currentIdempotencySnapshot(options.rootDir, input.manifest.workflow_id);
+            if (!current.ok) {
+                return {
+                    ok: false,
+                    reservationEvidenceReloaded: false,
+                    redactedFailureReason: current.redactedFailureReason,
+                };
+            }
+            const stateUpdate = prepareFlowDeskDispatchIdempotencyStateUpdateV1({
+                workflowId: input.manifest.workflow_id,
+                attemptId: input.manifest.attempt_id,
+                idempotencyKey: input.manifest.idempotency_key,
+                snapshotRef: evidenceId,
+                recordedAt,
+                nextState: "dispatch_completed",
+                existingSnapshot: reservedSnapshots.get(reservationKey(input.manifest)) ??
+                    current.snapshot ??
+                    existingIdempotencySnapshot(input.reloadedEvidence),
+            });
+            if (!stateUpdate.state_update_prepared ||
+                stateUpdate.snapshot === undefined) {
+                return {
+                    ok: false,
+                    reservationEvidenceReloaded: false,
+                    redactedFailureReason: "completed state preparation blocked",
+                };
+            }
+            const materialized = materializeSnapshot({
+                rootDir: options.rootDir,
+                manifest: input.manifest,
+                evidenceId,
+                snapshot: stateUpdate.snapshot,
+                expectedState: "dispatch_completed",
+            });
+            if (materialized.ok && materialized.snapshot !== undefined)
+                reservedSnapshots.set(reservationKey(input.manifest), materialized.snapshot);
+            return {
+                ok: materialized.ok,
+                reservationEvidenceReloaded: materialized.reservationEvidenceReloaded,
+                ...(materialized.redactedFailureReason === undefined
+                    ? {}
+                    : { redactedFailureReason: materialized.redactedFailureReason }),
+            };
+        },
         recordDispatchFailure(input) {
             const recordedAt = now().toISOString();
             const evidenceId = snapshotRefFor(input.manifest, "dispatch-failed");
@@ -2023,6 +2072,47 @@ function parseProviderQualifiedModelId(value) {
         return undefined;
     return { providerID, modelID };
 }
+function workingModelCacheAllowsDispatch(input) {
+    if (input.durableStateRootDir === undefined || input.durableStateRootDir.trim().length === 0) {
+        return {
+            ok: false,
+            reason: "Working-model durable state root is required before managed dispatch.",
+        };
+    }
+    try {
+        const root = resolve(input.durableStateRootDir);
+        const snapshotPath = resolve(root, "model-availability", "working-models.json");
+        if (snapshotPath !== root && !snapshotPath.startsWith(`${root}${sep}`)) {
+            return {
+                ok: false,
+                reason: "Working-model evidence path validation failed; refresh working-model evidence before managed dispatch.",
+            };
+        }
+        if (!existsSync(snapshotPath)) {
+            return {
+                ok: false,
+                reason: "Working-model snapshot is missing; refresh working-model evidence before managed dispatch.",
+            };
+        }
+        const raw = JSON.parse(readFileSync(snapshotPath, "utf8"));
+        const availableModelIds = Array.isArray(raw.available_model_ids)
+            ? raw.available_model_ids.filter((value) => typeof value === "string")
+            : [];
+        if (!availableModelIds.includes(input.providerQualifiedModelId)) {
+            return {
+                ok: false,
+                reason: "Requested provider-qualified model is not present in cached working-model snapshot; refresh working-model evidence before managed dispatch.",
+            };
+        }
+        return { ok: true };
+    }
+    catch {
+        return {
+            ok: false,
+            reason: "Working-model snapshot is missing or unreadable; refresh working-model evidence before managed dispatch.",
+        };
+    }
+}
 function opencodeRuntimeProviderIDForFlowDeskProviderFamily(providerFamily) {
     switch (providerFamily) {
         case "claude":
@@ -2666,6 +2756,201 @@ export function materializeFlowDeskRuntimeLaneLaunchLifecycleEvidenceV1(input) {
         authority: runtimeLaneLaunchLifecycleAuthority(true),
     };
 }
+function managedDispatchLaneFinalizeAuthority() {
+    return {
+        realOpenCodeDispatch: false,
+        providerCall: false,
+        runtimeExecution: false,
+        actualLaneLaunch: false,
+        fallbackAuthority: false,
+        hardCancelOrNoReplyAuthority: false,
+        toolAuthority: false,
+        nudgeOrAbortPerformed: false,
+    };
+}
+function managedDispatchLaneHasTerminalTaskEvidence(input) {
+    const reloaded = reloadFlowDeskSessionEvidenceV1({
+        workflowId: input.workflowId,
+        rootDir: input.rootDir,
+    });
+    if (!reloaded.ok)
+        return false;
+    return reloaded.entries.some((entry) => {
+        if (entry.evidenceClass !== "task_result" && entry.evidenceClass !== "task_failed")
+            return false;
+        return entry.record.lane_id === input.laneId;
+    });
+}
+/**
+ * Observe a launched managed-dispatch lane's child session once and record
+ * terminal evidence (task_result + terminal lane_lifecycle, or a no_output
+ * lifecycle). Observation-only: no nudge, no abort, no dispatch authority.
+ */
+export async function observeAndFinalizeManagedDispatchLaneV1(input) {
+    const baseAuthority = managedDispatchLaneFinalizeAuthority();
+    const blocked = (reason) => ({
+        adapterProfile: "managed_dispatch_lane_finalize_observer",
+        status: "blocked_before_finalize",
+        workflowId: input.workflowId,
+        laneId: input.laneId,
+        redactedBlockReason: reason,
+        authority: baseAuthority,
+    });
+    if (typeof input.rootDir !== "string" || input.rootDir.trim().length === 0)
+        return blocked("durable state root is required");
+    if (typeof input.laneId !== "string" || input.laneId.trim().length === 0)
+        return blocked("laneId is required");
+    if (typeof input.childSessionId !== "string" || input.childSessionId.trim().length === 0)
+        return blocked("childSessionId is required");
+    if (managedDispatchLaneHasTerminalTaskEvidence({ rootDir: input.rootDir, workflowId: input.workflowId, laneId: input.laneId })) {
+        return {
+            adapterProfile: "managed_dispatch_lane_finalize_observer",
+            status: "lane_already_terminal",
+            workflowId: input.workflowId,
+            laneId: input.laneId,
+            authority: baseAuthority,
+        };
+    }
+    const observedAt = (input.now ? input.now() : new Date()).toISOString();
+    const messagesTimeoutMs = input.messagesTimeoutMs ?? 3_000;
+    const parentSessionRef = input.parentSessionRef ?? "ses-managed-dispatch";
+    const taskId = input.laneId.startsWith("task-") ? input.laneId : `task-${input.laneId}`;
+    // Read the child session once (no nudge/abort). Handle both legacy sessionID
+    // and current { path: { id } } SDK message shapes plus a timeout.
+    let raw = null;
+    const messages = input.client.session.messages;
+    if (typeof messages === "function") {
+        try {
+            const readMessages = async () => {
+                const current = await messages.call(input.client.session, { sessionID: input.childSessionId });
+                const currentRecord = asRecord(current);
+                const currentData = asRecord(responseData(current));
+                if (currentRecord?.error === undefined && currentData?.error === undefined)
+                    return current;
+                return messages.call(input.client.session, { path: { id: input.childSessionId } });
+            };
+            raw = await Promise.race([
+                readMessages(),
+                new Promise((resolve) => setTimeout(() => resolve(null), messagesTimeoutMs)),
+            ]);
+        }
+        catch {
+            raw = null;
+        }
+    }
+    const observed = raw === null ? undefined : observeFlowDeskAgentTaskOutputV1(raw);
+    const latestText = observed?.latestText;
+    const writeLifecycle = (state, outputRef, evidenceId) => {
+        const record = {
+            schema_version: "flowdesk.lane_lifecycle_record.v1",
+            lane_id: input.laneId,
+            workflow_id: input.workflowId,
+            attempt_id: input.attemptId,
+            parent_session_ref: parentSessionRef,
+            child_session_ref: input.childSessionId.startsWith("ses-") ? input.childSessionId : `ses-${input.childSessionId}`,
+            agent_ref: input.agentRef,
+            provider_qualified_model_id: input.providerQualifiedModelId,
+            state,
+            ...(outputRef === undefined ? {} : { output_ref: outputRef }),
+            timeout_ms: 0,
+            orphan_max_age_ms: 0,
+            retry_count: 0,
+            created_at: observedAt,
+            updated_at: observedAt,
+            dispatch_authority_enabled: false,
+            providerCall: false,
+            actualLaneLaunch: false,
+            runtimeExecution: false,
+        };
+        const prepared = prepareFlowDeskSessionEvidenceWriteIntentV1({
+            workflowId: input.workflowId,
+            evidenceId,
+            record: record,
+        });
+        if (!prepared.ok || prepared.writeIntent === undefined)
+            return false;
+        const applied = applyFlowDeskSessionEvidenceWriteIntentsV1(input.rootDir, [prepared.writeIntent]);
+        return applied.ok && applied.writtenPaths.length > 0;
+    };
+    const reloadHas = (predicate) => {
+        const reloaded = reloadFlowDeskSessionEvidenceV1({
+            workflowId: input.workflowId,
+            rootDir: input.rootDir,
+        });
+        return reloaded.ok && reloaded.blocked.length === 0 && reloaded.entries.some(predicate);
+    };
+    if (typeof latestText === "string" && latestText.trim().length > 0) {
+        const truncated = latestText.length > MANAGED_DISPATCH_LANE_RESULT_MAX_TEXT;
+        const storedText = truncated ? latestText.slice(0, MANAGED_DISPATCH_LANE_RESULT_MAX_TEXT) : latestText;
+        const completionStatus = observed?.terminalObserved === true ? "final" : "partial";
+        const finalizationReason = observed?.terminalObserved === true ? "terminal_marker" : "timeout_partial";
+        const taskResultEvidenceId = `task-result-managed-dispatch-${input.laneId}`;
+        const taskResultRecord = {
+            schema_version: "flowdesk.task_result.v1",
+            workflow_id: input.workflowId,
+            lane_id: input.laneId,
+            task_id: taskId,
+            agent_ref: input.agentRef,
+            provider_qualified_model_id: input.providerQualifiedModelId,
+            task_prompt_sha256: createHash("sha256").update("managed-dispatch-lane-finalize").digest("hex"),
+            result_text: storedText,
+            result_text_truncated: truncated,
+            result_text_sha256: createHash("sha256").update(latestText).digest("hex"),
+            completion_status: completionStatus,
+            output_kind: observed?.outputKind ?? "final_answer",
+            usable_for_synthesis: observed?.usableForSynthesis ?? true,
+            missing_contract: false,
+            finalization_reason: finalizationReason,
+            looks_like_refusal_or_error: observed?.looksLikeRefusalOrError ?? false,
+            created_at: observedAt,
+            dispatch_authority_enabled: false,
+        };
+        const prepared = prepareFlowDeskSessionEvidenceWriteIntentV1({
+            workflowId: input.workflowId,
+            evidenceId: taskResultEvidenceId,
+            record: taskResultRecord,
+        });
+        if (!prepared.ok || prepared.writeIntent === undefined)
+            return blocked(prepared.errors.join(", ") || "task_result evidence intent invalid");
+        const applied = applyFlowDeskSessionEvidenceWriteIntentsV1(input.rootDir, [prepared.writeIntent]);
+        if (!applied.ok || applied.writtenPaths.length === 0)
+            return blocked("task_result evidence write failed");
+        if (!reloadHas((entry) => entry.evidenceClass === "task_result" && entry.evidenceId === taskResultEvidenceId && entry.record.lane_id === input.laneId))
+            return blocked("task_result evidence reload verification failed");
+        const terminalLifecycleEvidenceId = `lifecycle-managed-dispatch-terminal-${input.laneId}`;
+        if (!writeLifecycle("incomplete", `output-${taskResultEvidenceId}`, terminalLifecycleEvidenceId))
+            return blocked("terminal lane_lifecycle evidence write failed");
+        if (!reloadHas((entry) => entry.evidenceClass === "lane_lifecycle" && entry.evidenceId === terminalLifecycleEvidenceId && entry.record.lane_id === input.laneId && entry.record.state === "incomplete"))
+            return blocked("terminal lane_lifecycle evidence reload verification failed");
+        return {
+            adapterProfile: "managed_dispatch_lane_finalize_observer",
+            status: "lane_finalized",
+            workflowId: input.workflowId,
+            laneId: input.laneId,
+            taskResultEvidenceId,
+            terminalLifecycleEvidenceId,
+            finalizationReason,
+            completionStatus,
+            looksLikeRefusalOrError: observed?.looksLikeRefusalOrError ?? false,
+            authority: baseAuthority,
+        };
+    }
+    // No usable text observed — record a terminal no_output lifecycle so the lane
+    // stops projecting as running/stalled. No task_failed authority is implied.
+    const terminalLifecycleEvidenceId = `lifecycle-managed-dispatch-terminal-${input.laneId}`;
+    if (!writeLifecycle("no_output", undefined, terminalLifecycleEvidenceId))
+        return blocked("terminal no_output lane_lifecycle evidence write failed");
+    if (!reloadHas((entry) => entry.evidenceClass === "lane_lifecycle" && entry.evidenceId === terminalLifecycleEvidenceId && entry.record.lane_id === input.laneId && entry.record.state === "no_output"))
+        return blocked("terminal no_output lane_lifecycle evidence reload verification failed");
+    return {
+        adapterProfile: "managed_dispatch_lane_finalize_observer",
+        status: "lane_no_output",
+        workflowId: input.workflowId,
+        laneId: input.laneId,
+        terminalLifecycleEvidenceId,
+        authority: baseAuthority,
+    };
+}
 export function materializeFlowDeskRuntimeLaneCompleteLifecycleEvidenceV1(input) {
     if (typeof input.rootDir !== "string" || input.rootDir.trim().length === 0)
         return blockRuntimeLaneLaunchLifecycle({
@@ -2840,6 +3125,35 @@ function dispatchOptions(request, model, text) {
         },
     };
 }
+function managedDispatchLaneLaunchPlan(input) {
+    const laneId = input.request.laneId ?? `lane-${input.manifest.attempt_id}`;
+    return planFlowDeskRuntimeLaneLaunchV1({
+        request: {
+            schema_version: "flowdesk.runtime_lane_launch_request.v1",
+            launch_request_id: input.request.launchRequestId ??
+                `launch-request-${input.manifest.attempt_id}`,
+            workflow_id: input.manifest.workflow_id,
+            attempt_id: input.manifest.attempt_id,
+            lane_id: laneId,
+            parent_session_ref: refFrom("ses", input.request.sessionId),
+            agent_ref: refFrom("agent", input.request.agent),
+            provider_qualified_model_id: input.request.provider_qualified_model_id,
+            launch_reason: "managed_dispatch",
+            pre_launch_audit_ref: input.manifest.pre_dispatch_audit_ref,
+            lane_launch_approval_ref: input.manifest.consumed_approval_ref,
+            requested_at: input.manifest.created_at,
+            timeout_ms: 60_000,
+            orphan_max_age_ms: 180_000,
+            retry_budget: 0,
+            dispatch_authority_enabled: false,
+            providerCall: false,
+            actualLaneLaunch: false,
+            runtimeExecution: false,
+        },
+        sdkClientAvailable: input.sdkClientAvailable,
+        durableEvidenceRootRef: `evidence-root-${input.manifest.workflow_id}`,
+    });
+}
 export async function dispatchManagedDispatchBetaPromptV1(input) {
     const guardDecision = evaluateManagedDispatchBetaGuardBoundaryV1(input.boundaryInput);
     if (guardDecision.status !== "eligible")
@@ -2911,6 +3225,132 @@ export async function dispatchManagedDispatchBetaPromptV1(input) {
     if (!reservation.ok || reservation.reservationEvidenceReloaded !== true) {
         return blocked(input.boundaryInput, guardDecision, `Dispatch idempotency reservation materialization blocked: ${reservation.redactedFailureReason ?? "reload not proven"}.`);
     }
+    const workingModelGate = workingModelCacheAllowsDispatch({
+        durableStateRootDir: input.durableStateRootDir,
+        providerQualifiedModelId: approvedProviderQualifiedModelId,
+    });
+    if (!workingModelGate.ok) {
+        return blocked(input.boundaryInput, guardDecision, workingModelGate.reason);
+    }
+    const dispatchMode = input.request.dispatchMode ?? "prompt";
+    if (dispatchMode === "lane_launch") {
+        const launchPlan = managedDispatchLaneLaunchPlan({
+            boundaryInput: input.boundaryInput,
+            request: input.request,
+            manifest: input.dispatchManifest,
+            sdkClientAvailable: input.client.session.create !== undefined,
+        });
+        const launchResult = await launchFlowDeskInjectedSdkRuntimeLaneFromPlanV1({
+            client: input.client,
+            launchPlan,
+            request: {
+                allowActualLaneLaunch: input.request.allowActualLaneLaunch === true,
+                parentSessionId: input.request.sessionId,
+                promptText: text,
+                ...(input.request.directory === undefined
+                    ? {}
+                    : { directory: input.request.directory }),
+                dispatchMethod,
+                ...(input.request.laneTitle === undefined
+                    ? {}
+                    : { title: input.request.laneTitle }),
+            },
+        });
+        if (launchResult.status !== "lane_launch_started") {
+            return {
+                adapterProfile: flowdeskManagedDispatchBetaAdapterProfile,
+                status: "dispatch_failed",
+                dispatchAttempted: true,
+                dispatchMethod,
+                guardDecision,
+                sessionId: input.request.sessionId,
+                agent: input.request.agent,
+                model: runtimeModel,
+                ...(input.request.directory === undefined
+                    ? {}
+                    : { directory: input.request.directory }),
+                redactedErrorCategory: "runtime",
+                authority: { ...enabledDispatchAuthority(), runtimeExecution: false },
+                verification: verificationFor(input.boundaryInput),
+            };
+        }
+        if (input.durableStateRootDir !== undefined) {
+            const lifecycle = materializeFlowDeskRuntimeLaneLaunchLifecycleEvidenceV1({
+                rootDir: input.durableStateRootDir,
+                launchPlan,
+                launchResult,
+                evidenceId: `lifecycle-managed-dispatch-${launchPlan.lane_id}`,
+                observedAt: new Date().toISOString(),
+                timeoutMs: 60_000,
+                orphanMaxAgeMs: 180_000,
+                retryCount: 0,
+            });
+            if (lifecycle.status !== "lane_lifecycle_recorded") {
+                return {
+                    adapterProfile: flowdeskManagedDispatchBetaAdapterProfile,
+                    status: "dispatch_failed",
+                    dispatchAttempted: true,
+                    dispatchMethod,
+                    guardDecision,
+                    sessionId: input.request.sessionId,
+                    agent: input.request.agent,
+                    model: runtimeModel,
+                    ...(input.request.directory === undefined
+                        ? {}
+                        : { directory: input.request.directory }),
+                    redactedErrorCategory: "runtime",
+                    authority: { ...enabledDispatchAuthority(), runtimeExecution: false },
+                    verification: verificationFor(input.boundaryInput),
+                };
+            }
+        }
+        const completedRecord = input.reservationStore.recordDispatchCompleted === undefined
+            ? { ok: true, reservationEvidenceReloaded: true }
+            : await input.reservationStore.recordDispatchCompleted({
+                manifest: input.dispatchManifest,
+                reloadedEvidence: input.reloadedEvidence,
+            });
+        if (!completedRecord.ok || completedRecord.reservationEvidenceReloaded !== true) {
+            return {
+                adapterProfile: flowdeskManagedDispatchBetaAdapterProfile,
+                status: "dispatch_failed",
+                dispatchAttempted: true,
+                dispatchMethod,
+                guardDecision,
+                sessionId: input.request.sessionId,
+                agent: input.request.agent,
+                model: runtimeModel,
+                ...(input.request.directory === undefined
+                    ? {}
+                    : { directory: input.request.directory }),
+                redactedErrorCategory: "runtime",
+                authority: { ...enabledDispatchAuthority(), runtimeExecution: false },
+                verification: verificationFor(input.boundaryInput),
+            };
+        }
+        return {
+            adapterProfile: flowdeskManagedDispatchBetaAdapterProfile,
+            status: "dispatch_accepted",
+            dispatchAttempted: true,
+            dispatchMethod,
+            guardDecision,
+            sessionId: input.request.sessionId,
+            agent: input.request.agent,
+            model: runtimeModel,
+            ...(input.request.directory === undefined
+                ? {}
+                : { directory: input.request.directory }),
+            ...(launchResult.laneId === undefined ? {} : { laneId: launchResult.laneId }),
+            ...(launchResult.childSessionRef === undefined
+                ? {}
+                : { childSessionRef: launchResult.childSessionRef }),
+            ...(launchResult.messageRef === undefined
+                ? {}
+                : { messageRef: launchResult.messageRef }),
+            authority: { ...enabledDispatchAuthority(), actualLaneLaunch: true },
+            verification: verificationFor(input.boundaryInput),
+        };
+    }
     const options = dispatchOptions(input.request, runtimeModel, text);
     let response;
     try {
@@ -2940,6 +3380,30 @@ export async function dispatchManagedDispatchBetaPromptV1(input) {
             verification: verificationFor(input.boundaryInput),
         };
     }
+    const completedRecord = input.reservationStore.recordDispatchCompleted === undefined
+        ? { ok: true, reservationEvidenceReloaded: true }
+        : await input.reservationStore.recordDispatchCompleted({
+            manifest: input.dispatchManifest,
+            reloadedEvidence: input.reloadedEvidence,
+        });
+    if (!completedRecord.ok || completedRecord.reservationEvidenceReloaded !== true) {
+        return {
+            adapterProfile: flowdeskManagedDispatchBetaAdapterProfile,
+            status: "dispatch_failed",
+            dispatchAttempted: true,
+            dispatchMethod,
+            guardDecision,
+            sessionId: input.request.sessionId,
+            agent: input.request.agent,
+            model: runtimeModel,
+            ...(input.request.directory === undefined
+                ? {}
+                : { directory: input.request.directory }),
+            redactedErrorCategory: "runtime",
+            authority: { ...enabledDispatchAuthority(), runtimeExecution: false },
+            verification: verificationFor(input.boundaryInput),
+        };
+    }
     return {
         adapterProfile: flowdeskManagedDispatchBetaAdapterProfile,
         status: dispatchMethod === "promptAsync"