@scotthuang/agent-knock-knock 0.12.11 → 0.12.13

package/dist/src/deferred-foreground-application-service.js

@@ -0,0 +1,742 @@
+import { isExactNativeThreadId, managedSessionRevision, managedSessionBindingToken, terminalBindingFrom } from "./managed-session.js";
+import { exactRolloutMatches } from "./terminal-binding-authority.js";
+import { isCompleteNativeRollout, terminalControlsShareIncarnation } from "./terminal-authority-policy.js";
+export function deferredForegroundTransferRevision(transfer) {
+    const revision = Number(transfer.revision);
+    if (!Number.isSafeInteger(revision) || revision < 1) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} has no valid revision`);
+    }
+    return revision;
+}
+export class DeferredForegroundApplicationService {
+    #ports;
+    constructor(ports) {
+        this.#ports = ports;
+    }
+    assertTransferAuthority(scope, transfer, boundary) {
+        scope.assertBoundary(boundary);
+        const same = transfer.transfer_id === boundary.transferId &&
+            transfer.source_session_id === boundary.sourceSessionId &&
+            transfer.target_session_id === boundary.targetSessionId &&
+            transfer.source_expected_revision === boundary.sourceBoundRevision &&
+            transfer.source_binding_token === boundary.sourceBoundBindingToken &&
+            transfer.previous_dispatch_status ===
+                boundary.previousDispatchSnapshot.status &&
+            transfer.previous_dispatch_fingerprint ===
+                boundary.previousDispatchSnapshot.fingerprint &&
+            (transfer.version === 1 ? "status_card_only" : transfer.source_kind) ===
+                boundary.sourceKind &&
+            (transfer.source_rollout_authority ?? "present") ===
+                boundary.sourceRolloutAuthority &&
+            transfer.source_abandonment_fingerprint ===
+                boundary.sourceAbandonmentFingerprint &&
+            this.#ports.authority.valuesMatch(transfer.source_turn_history, boundary.sourceTurnHistory) &&
+            transfer.source_previous_last_transition_id ===
+                boundary.sourcePreviousLastTransitionId &&
+            transfer.process_uuid === boundary.processUuid &&
+            transfer.process_birth === boundary.processBirth &&
+            scope.terminalMatches(transfer, boundary) &&
+            scope.transferBelongsToTurn(transfer);
+        if (!same) {
+            throw new Error(`deferred foreground transfer ${boundary.transferId} authority changed`);
+        }
+    }
+    abortBeforeInput(options) {
+        let transfer = options.scope.loadTransfer(options.boundary.transferId);
+        this.assertTransferAuthority(options.scope, transfer, options.boundary);
+        if (transfer.status === "abort_resolved")
+            return;
+        const zeroInput = provedDispatchDidNotStart(transfer, options.terminalInputNotStartedAt);
+        assertCanAbort(transfer, zeroInput);
+        if (transfer.status !== "aborted") {
+            transfer = options.scope.saveTransfer({
+                ...transfer,
+                status: "aborted",
+                aborted_at: this.#ports.clock.now().toISOString(),
+                ...(zeroInput
+                    ? { terminal_input_not_started_at: options.terminalInputNotStartedAt }
+                    : {}),
+                error: this.#ports.runtime.errorReceipt(options.reason)
+            }, deferredForegroundTransferRevision(transfer));
+        }
+        transfer = this.finalizeAbort(options.scope, transfer);
+        this.#ports.runtime.log("info", "deferred_codex_foreground_transfer_aborted", {
+            transfer_id: transfer.transfer_id,
+            source_session_id: transfer.source_session_id,
+            target_session_id: transfer.target_session_id,
+            terminal_input_sent: false,
+            reason: this.#ports.runtime.summary(options.reason)
+        });
+    }
+    finalizeAbort(scope, transfer) {
+        let current = scope.loadTransfer(transfer.transfer_id);
+        if (current.status === "abort_resolved")
+            return current;
+        assertZeroInputAbortIntent(current);
+        const target = this.#finalizeAbortedTarget(scope, current);
+        const source = this.#finalizeAbortedSource(scope, current);
+        const completedAt = this.#ports.clock.now().toISOString();
+        current = scope.saveTransfer({
+            ...current,
+            status: "abort_resolved",
+            abort_cleanup_completed_at: completedAt,
+            abort_source_after_revision: managedSessionRevision(source),
+            abort_source_after_status: "bound",
+            abort_source_after_binding_token: managedSessionBindingToken(source),
+            abort_source_after_binding: source.binding,
+            abort_target_after_status: target ? "detached" : "absent",
+            ...(target ? abortTargetReceipt(target) : {})
+        }, deferredForegroundTransferRevision(current));
+        return current;
+    }
+    async reserve(request) {
+        let transfer = request.scope.loadTransfer(request.boundary.transferId);
+        this.assertTransferAuthority(request.scope, transfer, request.boundary);
+        if (transfer.status !== "prepared" || transfer.input_stage !== "none") {
+            throw new Error(`deferred foreground transfer ${transfer.transfer_id} is already ` +
+                transfer.status);
+        }
+        const source = await this.#ports.authority.verifyReservedSource(request.scope, request.boundary);
+        try {
+            return this.#reserveAfterVerification(request, transfer, source);
+        }
+        catch (error) {
+            this.#abortFailedReservation(request, error);
+            throw error;
+        }
+    }
+    begin(options) {
+        let transfer = options.scope.loadTransfer(options.boundary.transferId);
+        this.assertTransferAuthority(options.scope, transfer, options.boundary);
+        this.#assertPreparedTarget(options.scope, transfer);
+        if (transfer.status !== "target_prepared" || transfer.input_stage !== "none") {
+            throw new Error(`deferred foreground transfer ${transfer.transfer_id} cannot begin ` +
+                `dispatch from ${transfer.status}/${transfer.input_stage}`);
+        }
+        transfer = options.scope.saveTransfer({
+            ...transfer,
+            status: "dispatch_started",
+            input_stage: "dispatch_started",
+            dispatch_started_at: options.at
+        }, deferredForegroundTransferRevision(transfer));
+        return transfer;
+    }
+    advance(options) {
+        let transfer = options.scope.loadTransfer(options.boundary.transferId);
+        this.assertTransferAuthority(options.scope, transfer, options.boundary);
+        this.#assertPreparedTarget(options.scope, transfer);
+        this.#assertReservedSource(options.scope, transfer, options.boundary);
+        assertStageTransition(transfer, options.stage);
+        transfer = options.scope.saveTransfer({
+            ...transfer,
+            status: "dispatch_started",
+            input_stage: options.stage,
+            dispatch_started_at: transfer.dispatch_started_at ?? options.at,
+            ...(options.stage === "text_injected"
+                ? { text_injected_at: options.at }
+                : { enter_dispatched_at: options.at })
+        }, deferredForegroundTransferRevision(transfer));
+        return transfer;
+    }
+    async commit(request) {
+        let transfer = request.scope.loadTransfer(request.boundary.transferId);
+        this.assertTransferAuthority(request.scope, transfer, request.boundary);
+        this.#ports.authority.assertFrozenPredecessor(request.scope, request.boundary, transfer);
+        assertAcceptedIdentityAuthority(transfer, request.identity);
+        let source = request.scope.loadSession(transfer.source_session_id);
+        const sameNativeThread = request.identity.sessionId.toLowerCase() ===
+            transfer.source_before_binding.native_thread_id?.toLowerCase();
+        const sourceAlreadyScrubbed = sameNativeThread &&
+            this.#isExactScrubbedSource(source, transfer);
+        this.#assertCommittableSource(source, transfer, request.boundary, sourceAlreadyScrubbed);
+        let target = request.scope.loadSession(transfer.target_session_id);
+        const targetAlreadyAccepted = this.#isExactAcceptedTarget(target, transfer, request.identity);
+        if (!targetAlreadyAccepted) {
+            target = this.#assertPreparedTarget(request.scope, transfer);
+        }
+        await this.#assertCommitOwnership(request, transfer, sameNativeThread, targetAlreadyAccepted);
+        if (sameNativeThread && !sourceAlreadyScrubbed) {
+            source = this.#scrubSource(request.scope, transfer, source);
+        }
+        if (!targetAlreadyAccepted) {
+            target = this.#acceptTarget(request, target);
+        }
+        transfer = this.#persistCommit(request, transfer, source, target, sameNativeThread);
+        this.#ports.runtime.crashAt("committed");
+        return this.resolve({
+            scope: request.scope,
+            boundary: request.boundary
+        });
+    }
+    async resolve(options) {
+        let transfer = options.scope.loadTransfer(options.boundary.transferId);
+        this.assertTransferAuthority(options.scope, transfer, options.boundary);
+        if (transfer.status === "resolved") {
+            return this.#resolvedTarget(options.scope, transfer);
+        }
+        assertCommittedReceipt(transfer);
+        const source = this.#retireSource(options.scope, transfer);
+        const target = this.#bindTarget(options.scope, transfer);
+        await this.#ports.authority.assertExclusive(options.scope, options.boundary, {
+            processPid: transfer.process_pid,
+            nativeThreadId: transfer.target_native_thread_id,
+            excludedManagedSessionId: target.session_id,
+            allowedManagedSessionIds: abandonedSourceAllowance(transfer)
+        });
+        transfer = options.scope.saveTransfer({
+            ...transfer,
+            status: "resolved",
+            target_after_revision: managedSessionRevision(target),
+            target_after_status: "bound",
+            target_after_binding_token: managedSessionBindingToken(target),
+            source_after_revision: managedSessionRevision(source),
+            source_after_status: "detached",
+            source_after_binding: source.binding,
+            source_after_binding_token: managedSessionBindingToken(source),
+            resolved_at: this.#ports.clock.now().toISOString()
+        }, deferredForegroundTransferRevision(transfer));
+        this.#logResolved(transfer, source, target);
+        return target;
+    }
+    markUncertain(options) {
+        let transfer = options.scope.loadTransfer(options.boundary.transferId);
+        this.assertTransferAuthority(options.scope, transfer, options.boundary);
+        if (["committed", "resolved", "uncertain"].includes(transfer.status)) {
+            return transfer;
+        }
+        if (!["target_prepared", "dispatch_started"].includes(transfer.status)) {
+            throw new Error(`deferred foreground transfer ${transfer.transfer_id} has no durable ` +
+                "dispatch-start fence");
+        }
+        const dispatchStartedAt = transfer.dispatch_started_at ??
+            this.#ports.clock.now().toISOString();
+        const uncertainAt = this.#ports.clock.now().toISOString();
+        transfer = options.scope.saveTransfer({
+            ...transfer,
+            status: "uncertain",
+            input_stage: transfer.input_stage === "none"
+                ? "dispatch_started"
+                : transfer.input_stage,
+            dispatch_started_at: dispatchStartedAt,
+            uncertain_at: uncertainAt,
+            error: options.reason.slice(0, 2000),
+            do_not_retry: true
+        }, deferredForegroundTransferRevision(transfer));
+        return transfer;
+    }
+    #finalizeAbortedTarget(scope, transfer) {
+        let target = scope.tryLoadSession(transfer.target_session_id);
+        if (!target)
+            return undefined;
+        assertAbortTargetShape(target, transfer, this.#ports.authority.valuesMatch);
+        if (target.status === "transitioning") {
+            assertAbortTargetRevision(target, transfer);
+            const detachedAt = this.#ports.clock.now().toISOString();
+            target = scope.saveSession({
+                ...target,
+                status: "detached",
+                detached_at: detachedAt,
+                updated_at: detachedAt
+            }, managedSessionRevision(target));
+        }
+        else {
+            assertResolvedAbortTarget(target, transfer);
+        }
+        return target;
+    }
+    #finalizeAbortedSource(scope, transfer) {
+        let source = scope.loadSession(transfer.source_session_id);
+        if (isRestorableAbortSource(source, transfer, this.#ports.authority.valuesMatch)) {
+            const restoredAt = this.#ports.clock.now().toISOString();
+            source = scope.saveSession({
+                ...source,
+                status: "bound",
+                last_transition_id: transfer.source_previous_last_transition_id,
+                updated_at: restoredAt
+            }, managedSessionRevision(source));
+        }
+        assertResolvedAbortSource(source, transfer, this.#ports.authority.valuesMatch);
+        return source;
+    }
+    #reserveAfterVerification(request, transfer, source) {
+        const reservedAt = this.#ports.clock.now().toISOString();
+        const reserved = request.scope.saveSession({
+            ...source,
+            status: "transitioning",
+            last_transition_id: transfer.transfer_id,
+            updated_at: reservedAt
+        }, managedSessionRevision(source));
+        this.#ports.runtime.crashAt("source_session_reserved");
+        request.boundary.sourceReservedRevision = managedSessionRevision(reserved);
+        request.boundary.sourceReservedBindingToken =
+            managedSessionBindingToken(reserved);
+        transfer = request.scope.saveTransfer({
+            ...transfer,
+            status: "source_reserved",
+            source_reserved_at: reservedAt
+        }, deferredForegroundTransferRevision(transfer));
+        this.#ports.runtime.crashAt("source_reserved");
+        const target = this.#prepareTarget(request, transfer);
+        transfer = target.transfer;
+        this.#ports.runtime.crashAt("target_prepared");
+        const createdSession = request.scope.saveSession(target.provisional, null);
+        assertCreatedTarget(createdSession, request.boundary);
+        this.#logReserved(request.boundary, transfer, source);
+        return {
+            createdSession,
+            rollback: (scope) => {
+                if (!request.scope.sameInvocation(scope)) {
+                    throw new Error("deferred foreground rollback escaped its exact mutation resources");
+                }
+                this.abortBeforeInput({
+                    scope,
+                    boundary: request.boundary,
+                    reason: "terminal input was proved not to have started"
+                });
+            }
+        };
+    }
+    #prepareTarget(request, transfer) {
+        const provisional = {
+            ...request.targetSession,
+            status: "transitioning",
+            last_transition_id: transfer.transfer_id
+        };
+        request.boundary.targetPreparedRevision = 1;
+        request.boundary.targetPreparedBindingToken =
+            managedSessionBindingToken(provisional);
+        const prepared = request.scope.withTurnStatePath({
+            ...transfer,
+            status: "target_prepared",
+            target_prepared_at: this.#ports.clock.now().toISOString(),
+            target_prepared_revision: 1,
+            target_prepared_status: "transitioning",
+            target_prepared_last_transition_id: transfer.transfer_id,
+            target_prepared_binding_token: managedSessionBindingToken(provisional),
+            target_before_binding: provisional.binding,
+            message_id: request.messageId,
+            turn_id: request.turnId
+        });
+        return {
+            provisional,
+            transfer: request.scope.saveTransfer(prepared, deferredForegroundTransferRevision(transfer))
+        };
+    }
+    #abortFailedReservation(request, error) {
+        try {
+            this.abortBeforeInput({
+                scope: request.scope,
+                boundary: request.boundary,
+                reason: error instanceof Error ? error.message : String(error)
+            });
+        }
+        catch (abortError) {
+            throw new Error(`deferred foreground reservation failed and could not be aborted: ${abortError instanceof Error ? abortError.message : String(abortError)}`, { cause: error });
+        }
+    }
+    #assertPreparedTarget(scope, transfer) {
+        const target = scope.loadSession(transfer.target_session_id);
+        const matches = target.status === "transitioning" &&
+            target.last_transition_id === transfer.transfer_id &&
+            managedSessionRevision(target) === transfer.target_prepared_revision &&
+            managedSessionBindingToken(target) ===
+                transfer.target_prepared_binding_token &&
+            this.#ports.authority.valuesMatch(target.binding, transfer.target_before_binding) &&
+            target.lineage.transition_id === transfer.transfer_id &&
+            target.lineage.previous_session_id === transfer.source_session_id;
+        if (!matches) {
+            throw new Error(`deferred foreground target ${transfer.target_session_id} changed ` +
+                "before terminal dispatch");
+        }
+        return target;
+    }
+    #assertReservedSource(scope, transfer, boundary) {
+        const source = scope.loadSession(transfer.source_session_id);
+        const matches = source.status === "transitioning" &&
+            source.last_transition_id === transfer.transfer_id &&
+            managedSessionRevision(source) === transfer.source_expected_revision + 1 &&
+            managedSessionBindingToken(source) === boundary.sourceReservedBindingToken &&
+            this.#ports.authority.valuesMatch(source.binding, transfer.source_before_binding);
+        if (!matches) {
+            throw new Error(`deferred foreground source ${transfer.source_session_id} changed ` +
+                "during terminal dispatch");
+        }
+    }
+    #isExactScrubbedSource(source, transfer) {
+        const before = transfer.source_before_binding;
+        const after = source.binding;
+        return Boolean(source.status === "transitioning" &&
+            source.last_transition_id === transfer.transfer_id &&
+            managedSessionRevision(source) === transfer.source_expected_revision + 2 &&
+            after &&
+            after.binding_id !== before.binding_id &&
+            after.generation === before.generation + 1 &&
+            after.terminal_id === before.terminal_id &&
+            terminalControlsShareIncarnation(after.terminal_control, before.terminal_control) &&
+            after.native_thread_id === undefined &&
+            after.native_process.rollout === undefined &&
+            after.native_process.pid === transfer.process_pid &&
+            after.native_process.process_uuid === transfer.process_uuid &&
+            after.native_process.process_birth === transfer.process_birth &&
+            after.native_process.evidence ===
+                "deferred_predecessor_binding_scrubbed");
+    }
+    #isExactAcceptedTarget(target, transfer, identity) {
+        const before = transfer.target_before_binding;
+        const after = target.binding;
+        return Boolean(before && after && target.status === "transitioning" &&
+            target.last_transition_id === transfer.transfer_id &&
+            managedSessionRevision(target) ===
+                Number(transfer.target_prepared_revision) + 1 &&
+            after.binding_id === before.binding_id &&
+            after.generation === before.generation &&
+            after.native_thread_id === identity.sessionId &&
+            after.native_process.pid === transfer.process_pid &&
+            after.native_process.process_uuid === identity.processUuid &&
+            after.native_process.process_birth === identity.processBirth &&
+            exactRolloutMatches(after.native_process.rollout, identity.rollout));
+    }
+    #assertCommittableSource(source, transfer, boundary, alreadyScrubbed) {
+        const reserved = source.status === "transitioning" &&
+            source.last_transition_id === transfer.transfer_id &&
+            managedSessionRevision(source) === transfer.source_expected_revision + 1 &&
+            managedSessionBindingToken(source) === boundary.sourceReservedBindingToken &&
+            this.#ports.authority.valuesMatch(source.binding, transfer.source_before_binding);
+        if (!reserved && !alreadyScrubbed) {
+            throw new Error(`deferred foreground source ${source.session_id} changed before commit`);
+        }
+    }
+    async #assertCommitOwnership(request, transfer, sameNativeThread, targetAlreadyAccepted) {
+        await this.#ports.authority.assertExclusive(request.scope, request.boundary, {
+            processPid: transfer.process_pid,
+            nativeThreadId: request.identity.sessionId,
+            excludedManagedSessionId: targetAlreadyAccepted
+                ? transfer.target_session_id
+                : sameNativeThread
+                    ? transfer.source_session_id
+                    : transfer.target_session_id,
+            allowedManagedSessionIds: abandonedSourceAllowance(transfer)
+        });
+    }
+    #scrubSource(scope, transfer, source) {
+        const scrubbedAt = this.#ports.clock.now();
+        const scrubbedBinding = terminalBindingFrom({
+            terminalId: transfer.source_before_binding.terminal_id,
+            terminalControl: transfer.source_before_binding.terminal_control,
+            pid: transfer.process_pid,
+            processUuid: transfer.process_uuid,
+            processBirth: transfer.process_birth,
+            evidence: "deferred_predecessor_binding_scrubbed",
+            generation: transfer.source_before_binding.generation + 1,
+            now: scrubbedAt
+        });
+        const saved = scope.saveSession({
+            ...source,
+            binding: scrubbedBinding,
+            updated_at: scrubbedAt.toISOString()
+        }, managedSessionRevision(source));
+        this.#ports.runtime.crashAt("source_scrubbed");
+        return saved;
+    }
+    #acceptTarget(request, target) {
+        const acceptedBinding = {
+            ...target.binding,
+            native_thread_id: request.identity.sessionId,
+            native_process: {
+                ...target.binding.native_process,
+                process_uuid: request.identity.processUuid,
+                process_birth: request.identity.processBirth,
+                rollout: request.identity.rollout,
+                evidence: request.identity.evidence
+            },
+            last_verified_at: request.acceptedAt
+        };
+        const saved = request.scope.saveSession({
+            ...target,
+            binding: acceptedBinding,
+            updated_at: request.acceptedAt
+        }, managedSessionRevision(target));
+        this.#ports.runtime.crashAt("target_accepted");
+        return saved;
+    }
+    #persistCommit(request, transfer, source, target, sameNativeThread) {
+        const transportProofAt = transfer.dispatch_started_at ?? request.acceptedAt;
+        return request.scope.saveTransfer({
+            ...transfer,
+            status: "committed",
+            input_stage: "agent_accepted",
+            dispatch_started_at: transfer.dispatch_started_at ?? transportProofAt,
+            text_injected_at: transfer.text_injected_at ?? transportProofAt,
+            enter_dispatched_at: transfer.enter_dispatched_at ?? transportProofAt,
+            agent_accepted_at: request.acceptedAt,
+            target_native_thread_id: request.identity.sessionId,
+            target_accepted_revision: managedSessionRevision(target),
+            target_accepted_status: "transitioning",
+            target_accepted_binding_token: managedSessionBindingToken(target),
+            target_accepted_binding: target.binding,
+            source_pre_retirement_revision: managedSessionRevision(source),
+            source_pre_retirement_status: "transitioning",
+            source_pre_retirement_binding_token: managedSessionBindingToken(source),
+            source_pre_retirement_binding: source.binding,
+            source_retirement: sameNativeThread
+                ? "binding_scrubbed_same_native_thread"
+                : "binding_retained",
+            committed_at: request.acceptedAt,
+            ...(transfer.status === "uncertain"
+                ? { recovered_at: request.acceptedAt }
+                : {})
+        }, deferredForegroundTransferRevision(transfer));
+    }
+    #resolvedTarget(scope, transfer) {
+        const target = scope.loadSession(transfer.target_session_id);
+        if (target.status !== "bound" ||
+            managedSessionRevision(target) !== transfer.target_after_revision ||
+            managedSessionBindingToken(target) !== transfer.target_after_binding_token) {
+            throw new Error(`resolved deferred target ${target.session_id} changed`);
+        }
+        return target;
+    }
+    #retireSource(scope, transfer) {
+        let source = scope.loadSession(transfer.source_session_id);
+        if (source.status === "transitioning") {
+            assertSourceCommitReceipt(source, transfer, this.#ports.authority.valuesMatch);
+            const detachedAt = this.#ports.clock.now().toISOString();
+            source = scope.saveSession({
+                ...source,
+                status: "detached",
+                last_transition_id: transfer.source_previous_last_transition_id,
+                detached_at: detachedAt,
+                updated_at: detachedAt
+            }, managedSessionRevision(source));
+            this.#ports.runtime.crashAt("source_detached");
+        }
+        else {
+            assertRetiredSource(source, transfer, this.#ports.authority.valuesMatch);
+        }
+        return source;
+    }
+    #bindTarget(scope, transfer) {
+        let target = scope.loadSession(transfer.target_session_id);
+        if (target.status === "transitioning") {
+            assertTargetCommitReceipt(target, transfer, this.#ports.authority.valuesMatch);
+            const boundAt = this.#ports.clock.now().toISOString();
+            target = scope.saveSession({
+                ...target,
+                status: "bound",
+                last_transition_id: undefined,
+                updated_at: boundAt
+            }, managedSessionRevision(target));
+            this.#ports.runtime.crashAt("target_bound");
+        }
+        else {
+            assertBoundTarget(target, transfer, this.#ports.authority.valuesMatch);
+        }
+        return target;
+    }
+    #logReserved(boundary, transfer, source) {
+        this.#ports.runtime.log("info", "deferred_codex_foreground_source_reserved", {
+            transfer_id: transfer.transfer_id,
+            terminal_id: boundary.terminal.conversationId,
+            source_session_id: source.session_id,
+            native_thread_id: source.binding?.native_thread_id,
+            process_uuid: boundary.processUuid,
+            process_birth: boundary.processBirth,
+            terminal_input_sent: false
+        });
+    }
+    #logResolved(transfer, source, target) {
+        this.#ports.runtime.log("info", "deferred_codex_foreground_transfer_resolved", {
+            transfer_id: transfer.transfer_id,
+            source_session_id: source.session_id,
+            target_session_id: target.session_id,
+            native_thread_id: transfer.target_native_thread_id,
+            source_retirement: transfer.source_retirement
+        });
+    }
+}
+function provedDispatchDidNotStart(transfer, terminalInputNotStartedAt) {
+    return transfer.status === "dispatch_started" &&
+        transfer.input_stage === "dispatch_started" &&
+        terminalInputNotStartedAt !== undefined &&
+        Number.isFinite(Date.parse(terminalInputNotStartedAt));
+}
+function assertCanAbort(transfer, provedZeroInput) {
+    if (transfer.input_stage !== "none" && !provedZeroInput) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} may have started ` +
+            "terminal input and cannot restore its source");
+    }
+    const statusAllowed = [
+        "prepared",
+        "source_reserved",
+        "target_prepared",
+        "dispatch_started",
+        "aborted"
+    ].includes(transfer.status);
+    if (!statusAllowed) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} cannot abort from ` +
+            transfer.status);
+    }
+}
+function assertZeroInputAbortIntent(transfer) {
+    const provedZeroInput = transfer.input_stage === "dispatch_started" &&
+        transfer.terminal_input_not_started_at !== undefined &&
+        Number.isFinite(Date.parse(transfer.terminal_input_not_started_at));
+    if (transfer.status !== "aborted" ||
+        (transfer.input_stage !== "none" && !provedZeroInput)) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} does not carry a ` +
+            "zero-input abort intent");
+    }
+}
+function assertAbortTargetShape(target, transfer, valuesMatch) {
+    if (target.lineage.transition_id !== transfer.transfer_id ||
+        target.lineage.previous_session_id !== transfer.source_session_id ||
+        target.binding?.native_thread_id ||
+        target.binding?.native_process.rollout ||
+        target.last_transition_id !== transfer.transfer_id ||
+        !transfer.target_before_binding ||
+        !valuesMatch(target.binding, transfer.target_before_binding)) {
+        throw new Error(`deferred foreground target ${target.session_id} changed before abort cleanup`);
+    }
+}
+function assertAbortTargetRevision(target, transfer) {
+    if (managedSessionRevision(target) !== transfer.target_prepared_revision ||
+        managedSessionBindingToken(target) !== transfer.target_prepared_binding_token) {
+        throw new Error(`deferred foreground target ${target.session_id} changed before abort cleanup`);
+    }
+}
+function assertResolvedAbortTarget(target, transfer) {
+    const expectedToken = managedSessionBindingToken({
+        session_id: transfer.target_session_id,
+        status: "detached",
+        binding: transfer.target_before_binding
+    });
+    if (target.status !== "detached" ||
+        managedSessionRevision(target) !== Number(transfer.target_prepared_revision) + 1 ||
+        managedSessionBindingToken(target) !== expectedToken) {
+        throw new Error(`deferred foreground target ${target.session_id} cannot finish abort ` +
+            `cleanup from ${target.status}`);
+    }
+}
+function isRestorableAbortSource(source, transfer, valuesMatch) {
+    return source.status === "transitioning" &&
+        source.last_transition_id === transfer.transfer_id &&
+        managedSessionRevision(source) === transfer.source_expected_revision + 1 &&
+        managedSessionBindingToken(source) === managedSessionBindingToken({
+            session_id: transfer.source_session_id,
+            status: "transitioning",
+            binding: transfer.source_before_binding
+        }) &&
+        valuesMatch(source.binding, transfer.source_before_binding);
+}
+function assertResolvedAbortSource(source, transfer, valuesMatch) {
+    const allowedRevisions = transfer.source_reserved_at
+        ? [transfer.source_expected_revision + 2]
+        : [transfer.source_expected_revision, transfer.source_expected_revision + 2];
+    if (source.status !== "bound" ||
+        source.last_transition_id !== transfer.source_previous_last_transition_id ||
+        !allowedRevisions.includes(managedSessionRevision(source)) ||
+        managedSessionBindingToken(source) !== transfer.source_binding_token ||
+        !valuesMatch(source.binding, transfer.source_before_binding)) {
+        throw new Error(`deferred foreground source ${source.session_id} changed before abort cleanup`);
+    }
+}
+function abortTargetReceipt(target) {
+    return {
+        abort_target_after_revision: managedSessionRevision(target),
+        abort_target_after_binding_token: managedSessionBindingToken(target),
+        abort_target_after_binding: target.binding
+    };
+}
+function assertCreatedTarget(created, boundary) {
+    if (managedSessionRevision(created) !== 1 ||
+        managedSessionBindingToken(created) !== boundary.targetPreparedBindingToken) {
+        throw new Error(`deferred foreground target ${created.session_id} did not materialize ` +
+            "at its prepared CAS authority");
+    }
+}
+function assertStageTransition(transfer, stage) {
+    const expected = stage ===
+        "text_injected"
+        ? "dispatch_started"
+        : "text_injected";
+    if (transfer.status !== "dispatch_started" || transfer.input_stage !== expected) {
+        const action = stage === "text_injected" ? "record text" : "record Enter";
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} cannot ${action} ` +
+            `from ${transfer.status}/${transfer.input_stage}`);
+    }
+}
+function assertAcceptedIdentityAuthority(transfer, identity) {
+    if (!["dispatch_started", "uncertain"].includes(transfer.status) ||
+        transfer.input_stage === "none" ||
+        identity.processUuid !== transfer.process_uuid ||
+        identity.processBirth !== transfer.process_birth ||
+        !isExactNativeThreadId(identity.sessionId) ||
+        !isCompleteNativeRollout(identity.rollout)) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} lacks exact ` +
+            "accepted identity authority");
+    }
+}
+function abandonedSourceAllowance(transfer) {
+    return transfer.source_rollout_authority ===
+        "explicitly_abandoned_predecessor"
+        ? [transfer.source_session_id]
+        : [];
+}
+function assertCommittedReceipt(transfer) {
+    if (transfer.status !== "committed" ||
+        !transfer.source_pre_retirement_binding ||
+        !transfer.source_pre_retirement_revision ||
+        !transfer.source_pre_retirement_binding_token ||
+        !transfer.target_accepted_binding ||
+        !transfer.target_accepted_revision ||
+        !transfer.target_accepted_binding_token ||
+        !transfer.target_native_thread_id) {
+        throw new Error(`deferred foreground transfer ${transfer.transfer_id} is not committed`);
+    }
+}
+function assertSourceCommitReceipt(source, transfer, valuesMatch) {
+    if (source.last_transition_id !== transfer.transfer_id ||
+        managedSessionRevision(source) !== transfer.source_pre_retirement_revision ||
+        managedSessionBindingToken(source) !==
+            transfer.source_pre_retirement_binding_token ||
+        !valuesMatch(source.binding, transfer.source_pre_retirement_binding)) {
+        throw new Error(`deferred foreground source ${source.session_id} changed during commit recovery`);
+    }
+}
+function assertRetiredSource(source, transfer, valuesMatch) {
+    const token = managedSessionBindingToken({
+        session_id: source.session_id,
+        status: "detached",
+        binding: transfer.source_pre_retirement_binding
+    });
+    if (source.status !== "detached" ||
+        managedSessionRevision(source) !==
+            Number(transfer.source_pre_retirement_revision) + 1 ||
+        managedSessionBindingToken(source) !== token ||
+        !valuesMatch(source.binding, transfer.source_pre_retirement_binding)) {
+        throw new Error(`deferred foreground source ${source.session_id} has no exact retired receipt`);
+    }
+}
+function assertTargetCommitReceipt(target, transfer, valuesMatch) {
+    if (target.last_transition_id !== transfer.transfer_id ||
+        managedSessionRevision(target) !== transfer.target_accepted_revision ||
+        managedSessionBindingToken(target) !== transfer.target_accepted_binding_token ||
+        !valuesMatch(target.binding, transfer.target_accepted_binding)) {
+        throw new Error(`deferred foreground target ${target.session_id} changed during commit recovery`);
+    }
+}
+function assertBoundTarget(target, transfer, valuesMatch) {
+    const token = managedSessionBindingToken({
+        session_id: target.session_id,
+        status: "bound",
+        binding: transfer.target_accepted_binding
+    });
+    if (target.status !== "bound" ||
+        managedSessionRevision(target) !==
+            Number(transfer.target_accepted_revision) + 1 ||
+        managedSessionBindingToken(target) !== token ||
+        !valuesMatch(target.binding, transfer.target_accepted_binding)) {
+        throw new Error(`deferred foreground target ${target.session_id} has no exact bound receipt`);
+    }
+}
+//# sourceMappingURL=deferred-foreground-application-service.js.map