@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/worker/console/static-src/operator-chat/turn-stream-controller.js

@@ -0,0 +1,690 @@
+/**
+ * Executable Turn stream ownership / notice / abort controller.
+ *
+ * Production path for useChatStream: tests drive this same module rather than a
+ * parallel state machine or source-regex-only contracts.
+ *
+ * Constraints preserved here:
+ * - transport uncertainty is never accepted:false / rejected
+ * - same clientRequestId is never reminted during ambiguous retry/reconcile
+ * - Stop never disposes Session (no dispose call site in this module)
+ * - notice paths (adopt / 正在停止… / abort-pending) never escalate via setError
+ * - default request paths target real Operator Chat API (no Mock activation)
+ */
+import { createPendingSubmission, isRuntimeBusyUnion, isSubmissionCurrent, isTerminalTurnState, } from "./turn-submission.js";
+/** Real Operator Chat API path templates (production defaults; Mock off). */
+export const OPERATOR_CHAT_REAL_PATHS = {
+    turns: "/api/operator/v1/chat/sessions/:sessionId/turns",
+    state: "/api/operator/v1/chat/sessions/:sessionId/state",
+    events: "/api/operator/v1/chat/sessions/:sessionId/events",
+    abort: "/api/operator/v1/chat/sessions/:sessionId/turns/:turnId/abort",
+};
+export function operatorChatTurnsUrl(origin, sessionId) {
+    return `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/turns`;
+}
+export function operatorChatStateUrl(origin, sessionId) {
+    return `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/state`;
+}
+export function operatorChatEventsUrl(origin, sessionId) {
+    return `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/events`;
+}
+export function operatorChatAbortUrl(origin, sessionId, turnId) {
+    return `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/turns/${encodeURIComponent(turnId)}/abort`;
+}
+export function createTurnOwnershipBag(seed) {
+    return {
+        submitInFlight: false,
+        pendingSubmission: null,
+        activeTurnId: null,
+        streaming: false,
+        assistantId: null,
+        stoppingTurnId: null,
+        settledTurnIds: new Set(),
+        turnAssistantIds: new Map(),
+        sessionId: null,
+        sessionGeneration: 0,
+        submitGeneration: 0,
+        stopInFlight: false,
+        stopRequested: false,
+        abortPostedTurnIds: new Set(),
+        releasedClientRequestIds: new Set(),
+        ...seed,
+    };
+}
+/** Whether a second concurrent send is blocked by ownership / busy. */
+export function isSubmitOwnershipBusy(bag) {
+    return bag.streaming || bag.submitInFlight || Boolean(bag.pendingSubmission);
+}
+/**
+ * Release submit ownership. Optionally scoped to a clientRequestId so a stale
+ * release cannot clear a newer pending submission.
+ * Independent of React streaming projection — terminal evidence always clears
+ * pendingSubmission/submitInFlight for the matching clientRequestId.
+ */
+export function releaseSubmitOwnership(bag, pendingClientRequestId) {
+    const pending = bag.pendingSubmission;
+    if (pendingClientRequestId &&
+        pending &&
+        pending.clientRequestId !== pendingClientRequestId) {
+        return;
+    }
+    bag.submitInFlight = false;
+    if (!pendingClientRequestId ||
+        pending?.clientRequestId === pendingClientRequestId) {
+        if (pending?.clientRequestId) {
+            bag.releasedClientRequestIds.add(pending.clientRequestId);
+        }
+        else if (pendingClientRequestId) {
+            bag.releasedClientRequestIds.add(pendingClientRequestId);
+        }
+        bag.pendingSubmission = null;
+    }
+    // Ownership release clears durable stop intent for this submission.
+    if (!bag.pendingSubmission) {
+        bag.stopRequested = false;
+    }
+}
+/** Mark durable client Stop intent (survives ambiguous create-turn). */
+export function markStopRequested(bag) {
+    bag.stopRequested = true;
+}
+/** Clear durable Stop intent (terminal / no-active / rejected / after abort). */
+export function clearStopRequested(bag) {
+    bag.stopRequested = false;
+}
+/**
+ * Decide whether a real POST /abort should run for a newly known turnId.
+ * Coalesces to one abort per turnId. Never remints clientRequestId.
+ */
+export function shouldPostAbortForTurn(bag, turnId) {
+    if (!turnId)
+        return false;
+    if (bag.abortPostedTurnIds.has(turnId))
+        return false;
+    return true;
+}
+/** Record that a real POST /abort was issued for turnId (idempotent coalesce). */
+export function noteAbortPosted(bag, turnId) {
+    if (turnId)
+        bag.abortPostedTurnIds.add(turnId);
+}
+/**
+ * After accepted / adopt-active / bind-active yields a turnId, if stopRequested
+ * is still set, schedule exactly one abort for that turn (caller issues POST).
+ * Returns the turnId to abort, or null when no abort is needed.
+ */
+export function consumeStopIntentForAbort(bag, turnId) {
+    if (!bag.stopRequested)
+        return null;
+    if (!shouldPostAbortForTurn(bag, turnId))
+        return null;
+    noteAbortPosted(bag, turnId);
+    bag.stoppingTurnId = turnId;
+    bag.activeTurnId = turnId;
+    // Intent stays until terminal/no-active/rejected clears it; abort in-flight
+    // still represents the same durable client Stop.
+    return turnId;
+}
+/**
+ * Release ownership lease from terminal evidence even when React streaming is
+ * already false (SSE may have projected idle before /state bind). Scoped by
+ * clientRequestId so a newer pending submission is never cleared.
+ */
+export function releaseOwnershipOnTerminalEvidence(bag, input) {
+    const pending = bag.pendingSubmission;
+    if (pending && pending.clientRequestId !== input.clientRequestId) {
+        return false;
+    }
+    if (input.turnId) {
+        bag.settledTurnIds.add(input.turnId);
+    }
+    releaseSubmitOwnership(bag, input.clientRequestId);
+    clearStopRequested(bag);
+    if (input.markIdle !== false) {
+        // Streaming may already be false; still clear ownership-related fields.
+        bag.streaming = false;
+        bag.activeTurnId = null;
+        bag.assistantId = null;
+        bag.stoppingTurnId = null;
+    }
+    return true;
+}
+/** Acquire synchronous submit ownership before the first await (AC-001). */
+export function beginSubmitOwnership(bag, input) {
+    bag.submitInFlight = true;
+    const submitGeneration = ++bag.submitGeneration;
+    const pending = createPendingSubmission({
+        clientRequestId: input.clientRequestId,
+        submitGeneration,
+        sessionId: input.sessionId,
+        sessionGeneration: input.sessionGeneration,
+        text: input.text,
+        images: input.images,
+        assistantId: input.assistantId,
+        userMessageId: input.userMessageId,
+    });
+    bag.pendingSubmission = pending;
+    bag.sessionId = input.sessionId;
+    bag.sessionGeneration = input.sessionGeneration;
+    return pending;
+}
+export function applyAcceptedOwnership(bag, input) {
+    if (!isSubmissionCurrent({
+        pending: input.pending,
+        sessionId: bag.sessionId,
+        sessionGeneration: bag.sessionGeneration,
+        submitGeneration: bag.submitGeneration,
+    })) {
+        input.pending.resolveOutcome({ kind: "stale" });
+        return false;
+    }
+    input.pending.acceptedTurnId = input.turnId;
+    bag.activeTurnId = input.turnId;
+    bag.turnAssistantIds.set(input.turnId, input.assistantId);
+    bag.streaming = true;
+    // Keep pendingSubmission until terminal/idle so Stop-before-202 can observe it.
+    // Drop only the in-flight gate for new sends after acceptance.
+    bag.submitInFlight = false;
+    input.pending.resolveOutcome({
+        kind: "accepted",
+        turnId: input.turnId,
+    });
+    input.ui?.setStreaming(true);
+    input.ui?.setStreamingAssistantId(input.assistantId);
+    input.ui?.setPendingImages([]);
+    input.ui?.watchSessionTitle?.(input.sessionId);
+    return true;
+}
+/**
+ * TURN_ACTIVE adopt: non-fatal notice only. Never escalates via setError(message).
+ * Preserves local draft and binds the active turn.
+ */
+export function applyAdoptActiveOwnership(bag, input) {
+    input.pending.resolveOutcome({
+        kind: "adopt-active",
+        activeTurn: { turnId: input.activeTurnId },
+        message: input.message,
+    });
+    releaseSubmitOwnership(bag, input.pending.clientRequestId);
+    if (!input.current)
+        return;
+    input.ui?.clearEmptyAssistant(input.assistantId);
+    input.ui?.setInput(input.text);
+    input.ui?.setPendingImages(input.images);
+    bag.activeTurnId = input.activeTurnId;
+    bag.assistantId = null;
+    bag.streaming = true;
+    input.ui?.setStreaming(true);
+    input.ui?.setStreamingAssistantId(null);
+    // Clear any prior fatal error; adopt is non-fatal.
+    input.notice.setError(null);
+    input.notice.showNotice(input.message);
+}
+export function applyRejectedOwnership(bag, input) {
+    input.pending.resolveOutcome({
+        kind: "rejected",
+        message: input.message,
+    });
+    releaseSubmitOwnership(bag, input.pending.clientRequestId);
+    if (!input.current)
+        return;
+    const formatted = input.ui?.formatError
+        ? input.ui.formatError(input.message)
+        : input.message;
+    input.ui?.setError(formatted);
+    bag.streaming = false;
+    bag.assistantId = null;
+    input.ui?.setStreaming(false);
+    input.ui?.setStreamingAssistantId(null);
+    input.ui?.clearEmptyAssistant(input.assistantId);
+    input.ui?.setInput(input.text);
+    input.ui?.setPendingImages(input.images);
+}
+/**
+ * Settle a create-turn outcome onto ownership.
+ * Ambiguous leaves pending/busy for reconcile — never applyRejected / release.
+ */
+export function settleCreateTurnOutcome(bag, outcome, ctx) {
+    const current = isSubmissionCurrent({
+        pending: ctx.pending,
+        sessionId: bag.sessionId,
+        sessionGeneration: bag.sessionGeneration,
+        submitGeneration: bag.submitGeneration,
+    });
+    if (outcome.kind === "accepted") {
+        const applied = applyAcceptedOwnership(bag, {
+            turnId: outcome.turnId,
+            assistantId: ctx.assistantId,
+            pending: ctx.pending,
+            sessionId: ctx.sessionId,
+            ui: ctx.acceptedUi,
+        });
+        // AC-R5-001: Stop during create → exactly one abort once turnId is known.
+        if (applied) {
+            const abortTurnId = consumeStopIntentForAbort(bag, outcome.turnId);
+            if (abortTurnId)
+                ctx.onAutoAbort?.(abortTurnId);
+        }
+        return;
+    }
+    if (outcome.kind === "adopt-active") {
+        // AC-FINAL-001: for a still-current submission, consume durable stop
+        // intent before applyAdoptActiveOwnership → releaseSubmitOwnership
+        // clears stopRequested.
+        // Stale late adopt-active (newer submit already advanced generation)
+        // must not write old turnId into abortPostedTurnIds or fire onAutoAbort.
+        const abortTurnId = current
+            ? consumeStopIntentForAbort(bag, outcome.activeTurn.turnId)
+            : null;
+        applyAdoptActiveOwnership(bag, {
+            activeTurnId: outcome.activeTurn.turnId,
+            message: outcome.message,
+            assistantId: ctx.assistantId,
+            text: ctx.text,
+            images: ctx.images,
+            pending: ctx.pending,
+            current,
+            notice: ctx.notice,
+            ui: ctx.adoptUi,
+        });
+        if (abortTurnId)
+            ctx.onAutoAbort?.(abortTurnId);
+        return;
+    }
+    if (outcome.kind === "rejected") {
+        applyRejectedOwnership(bag, {
+            message: outcome.message,
+            assistantId: ctx.assistantId,
+            text: ctx.text,
+            images: ctx.images,
+            pending: ctx.pending,
+            current,
+            ui: ctx.rejectedUi,
+        });
+        clearStopRequested(bag);
+        return;
+    }
+    if (outcome.kind === "stale") {
+        ctx.pending.resolveOutcome(outcome);
+        releaseSubmitOwnership(bag, ctx.pending.clientRequestId);
+        clearStopRequested(bag);
+        return;
+    }
+    // ambiguous — leave pending/busy for reconcile; do not release ownership
+    // or forge idle. clientRequestId stays on pendingSubmission.
+    // Durable stopRequested (if set) survives until bind/accept/terminal.
+    ctx.pending.resolveOutcome(outcome);
+}
+/**
+ * Apply continuous /state reconcile decision for a still-owned pending submission.
+ * Same clientRequestId only — never mints a new id or re-POSTs Prompt.
+ */
+export function applyPendingReconcileDecision(bag, decision, state, opts) {
+    const pending = bag.pendingSubmission;
+    if (!pending)
+        return "held";
+    if (decision.action === "bind-active") {
+        const alreadyBound = Boolean(pending.acceptedTurnId);
+        if (!alreadyBound) {
+            // US-BUSY-ACTIVE-BOUND: keep streaming/busy with same id.
+            pending.acceptedTurnId = decision.turnId;
+            bag.activeTurnId = decision.turnId;
+            bag.turnAssistantIds.set(decision.turnId, pending.assistantId);
+            bag.streaming = true;
+            bag.submitInFlight = false;
+            // Retain pendingSubmission until terminal/non-acceptance release.
+        }
+        // AC-R5-001: durable stopRequested survives ambiguous create; bind-active
+        // must fire exactly one real abort for the bound turnId.
+        const abortTurnId = consumeStopIntentForAbort(bag, decision.turnId);
+        if (abortTurnId)
+            opts?.onAutoAbort?.(abortTurnId);
+        return alreadyBound ? "held" : "bound";
+    }
+    if (decision.action === "release-terminal" ||
+        decision.action === "release-not-accepted") {
+        // Terminal / not-accepted release clears ownership even after bind-active
+        // set acceptedTurnId (pendingSubmission held until this release).
+        // Independent of React streaming projection (AC-R5-002).
+        if (decision.action === "release-terminal") {
+            bag.settledTurnIds.add(decision.turnId);
+        }
+        releaseSubmitOwnership(bag, pending.clientRequestId);
+        clearStopRequested(bag);
+        const stillBusy = isRuntimeBusyUnion(state);
+        if (!stillBusy) {
+            bag.streaming = false;
+            bag.activeTurnId = null;
+            bag.assistantId = null;
+            bag.stoppingTurnId = null;
+            opts?.markIdle?.();
+        }
+        return "released";
+    }
+    // hold: keep pending clientRequestId + busy; no applyRejected.
+    const activeTurnId = state?.activeTurn?.turnId ?? state?.activeTurnId ?? null;
+    if (activeTurnId)
+        bag.activeTurnId = activeTurnId;
+    return "held";
+}
+export const STOPPING_NOTICE = "正在停止…";
+export const ABORT_PENDING_NOTICE = "正在停止…";
+export const ABORT_INCOMPLETE_NOTICE = "停止请求未完成，正在与服务端对账…";
+export const ABORT_FAILED_NOTICE = "停止请求失败，正在与服务端对账…";
+/**
+ * Emit non-fatal stop-before-turnId notice. Never calls setError.
+ * Stop never disposes Session (no dispose in this module).
+ */
+export function emitStoppingNotice(notice) {
+    notice.showNotice(STOPPING_NOTICE);
+}
+export function classifyAbortResponse(input) {
+    if (input.networkError) {
+        return { action: "keep-busy-notice", message: ABORT_FAILED_NOTICE };
+    }
+    const terminalState = input.body.turn?.state;
+    if (input.body.accepted === true &&
+        isTerminalTurnState(terminalState)) {
+        return { action: "terminal-idle", turnId: input.turnId };
+    }
+    if (input.body.error?.code === "TURN_ABORT_PENDING") {
+        return { action: "abort-pending-notice" };
+    }
+    if (input.body.error?.code === "CHAT_TURN_OWNER_LOST" ||
+        input.body.error?.code === "OWNER_LOST") {
+        return { action: "owner-lost-reconcile" };
+    }
+    if (!input.httpOk) {
+        return { action: "keep-busy-notice", message: ABORT_INCOMPLETE_NOTICE };
+    }
+    return { action: "noop" };
+}
+/**
+ * Apply abort decision. Notice paths use showNotice only — never setError.
+ * Session dispose is intentionally absent.
+ */
+export function applyAbortDecision(bag, decision, notice, opts) {
+    const current = opts?.sessionStillCurrent !== false;
+    if (decision.action === "terminal-idle") {
+        if (!current)
+            return;
+        bag.settledTurnIds.add(decision.turnId);
+        bag.streaming = false;
+        bag.activeTurnId = null;
+        bag.assistantId = null;
+        bag.stoppingTurnId = null;
+        opts?.markIdle?.();
+        return;
+    }
+    if (decision.action === "abort-pending-notice") {
+        // Non-fatal; keep busy.
+        notice.showNotice(ABORT_PENDING_NOTICE);
+        return;
+    }
+    if (decision.action === "owner-lost-reconcile") {
+        if (!current)
+            return;
+        if (!opts?.runtimeBusy) {
+            if (bag.stoppingTurnId) {
+                bag.settledTurnIds.add(bag.stoppingTurnId);
+            }
+            bag.streaming = false;
+            bag.activeTurnId = null;
+            bag.assistantId = null;
+            bag.stoppingTurnId = null;
+            opts?.markIdle?.();
+        }
+        return;
+    }
+    if (decision.action === "keep-busy-notice") {
+        notice.showNotice(decision.message);
+        return;
+    }
+}
+/**
+ * Simulate the double-POST ambiguous → /state bind → terminal release path
+ * for executable ownership tests. Reuses one clientRequestId throughout.
+ */
+export function simulateAmbiguousBindRelease(input) {
+    const assistantId = input.assistantId ?? "a-test";
+    const bag = createTurnOwnershipBag({
+        sessionId: input.sessionId,
+        sessionGeneration: 1,
+    });
+    const phases = [];
+    const pending = beginSubmitOwnership(bag, {
+        clientRequestId: input.clientRequestId,
+        sessionId: input.sessionId,
+        sessionGeneration: 1,
+        text: "hello",
+        images: [],
+        assistantId,
+        userMessageId: "u-test",
+    });
+    bag.streaming = true;
+    // After double-POST ambiguous: settle without release.
+    settleCreateTurnOutcome(bag, { kind: "ambiguous", message: "transport unclear" }, {
+        assistantId,
+        text: "hello",
+        images: [],
+        pending,
+        sessionId: input.sessionId,
+        notice: { showNotice: () => { }, setError: () => { } },
+    });
+    phases.push("pending-ambiguous");
+    // /state active bind with same clientRequestId.
+    const bound = applyPendingReconcileDecision(bag, { action: "bind-active", turnId: input.turnId }, {
+        activeTurn: {
+            turnId: input.turnId,
+            clientRequestId: input.clientRequestId,
+            state: "running",
+        },
+    });
+    if (bound !== "bound") {
+        throw new Error("expected bind-active");
+    }
+    phases.push("bound-active");
+    // Terminal release frees both ownership refs.
+    const released = applyPendingReconcileDecision(bag, {
+        action: "release-terminal",
+        turnId: input.turnId,
+        state: "settled",
+    }, {
+        latestTurn: {
+            turnId: input.turnId,
+            clientRequestId: input.clientRequestId,
+            state: "settled",
+        },
+        runtime: {
+            isStreaming: false,
+            isPromptRunning: false,
+            isCompacting: false,
+            isBashRunning: false,
+        },
+    });
+    if (released !== "released") {
+        throw new Error("expected release-terminal");
+    }
+    phases.push("released-terminal");
+    return { bag, clientRequestId: input.clientRequestId, phases };
+}
+/** True when production defaults do not activate a Mock handler. */
+export function isMockActivationOffByDefault() {
+    // No production Mock switch exists in this controller; real paths only.
+    return true;
+}
+/**
+ * Production-path Stop: set durable stopRequested synchronously before any
+ * await. If turnId is already known, coalesce to one POST /abort. If not,
+ * intent survives until accepted/adopt/bind-active yields a turnId.
+ * Never remints clientRequestId; never disposes Session.
+ */
+export function requestStopOnOwnership(bag, hooks) {
+    markStopRequested(bag);
+    const turnId = bag.activeTurnId ??
+        bag.pendingSubmission?.acceptedTurnId ??
+        null;
+    if (turnId) {
+        const abortTurnId = consumeStopIntentForAbort(bag, turnId);
+        if (abortTurnId) {
+            hooks.notice && emitStoppingNotice(hooks.notice);
+            void hooks.postAbort(abortTurnId);
+            return { abortedTurnId: abortTurnId, stopRequested: true };
+        }
+        return { abortedTurnId: null, stopRequested: true };
+    }
+    // No turnId yet (create in flight / ambiguous) — durable intent only.
+    hooks.notice && emitStoppingNotice(hooks.notice);
+    return { abortedTurnId: null, stopRequested: true };
+}
+/**
+ * After create settles or /state bind, honor durable stopRequested with at
+ * most one abort per turnId. Same clientRequestId; no second create-turn POST.
+ */
+export function honorStopIntentAfterBind(bag, turnId, hooks) {
+    const abortTurnId = consumeStopIntentForAbort(bag, turnId);
+    if (!abortTurnId)
+        return null;
+    void hooks.postAbort(abortTurnId);
+    return abortTurnId;
+}
+/**
+ * Drive bind-active then terminal (or reverse order) against the production
+ * ownership helpers. Proves lease release is independent of React streaming.
+ */
+export function runBindAndTerminalReleaseOrders(input) {
+    const bag = createTurnOwnershipBag({
+        sessionId: input.sessionId,
+        sessionGeneration: 1,
+    });
+    const pending = beginSubmitOwnership(bag, {
+        clientRequestId: input.clientRequestId,
+        sessionId: input.sessionId,
+        sessionGeneration: 1,
+        text: "hello",
+        images: [],
+        assistantId: "a-orch",
+        userMessageId: "u-orch",
+    });
+    bag.streaming = true;
+    settleCreateTurnOutcome(bag, { kind: "ambiguous", message: "transport unclear" }, {
+        assistantId: "a-orch",
+        text: "hello",
+        images: [],
+        pending,
+        sessionId: input.sessionId,
+        notice: { showNotice: () => { }, setError: () => { } },
+    });
+    const bindState = {
+        activeTurn: {
+            turnId: input.turnId,
+            clientRequestId: input.clientRequestId,
+            state: "running",
+        },
+    };
+    const terminalState = {
+        latestTurn: {
+            turnId: input.turnId,
+            clientRequestId: input.clientRequestId,
+            state: "settled",
+        },
+        runtime: {
+            isStreaming: false,
+            isPromptRunning: false,
+            isCompacting: false,
+            isBashRunning: false,
+        },
+    };
+    if (input.order === "bind-first") {
+        applyPendingReconcileDecision(bag, { action: "bind-active", turnId: input.turnId }, bindState);
+        applyPendingReconcileDecision(bag, {
+            action: "release-terminal",
+            turnId: input.turnId,
+            state: "settled",
+        }, terminalState);
+    }
+    else if (input.order === "terminal-first") {
+        // Terminal SSE evidence before /state bind: release by clientRequestId.
+        releaseOwnershipOnTerminalEvidence(bag, {
+            clientRequestId: input.clientRequestId,
+            turnId: input.turnId,
+        });
+    }
+    else {
+        // React streaming already false (SSE projected idle) must not skip lease.
+        bag.streaming = false;
+        releaseOwnershipOnTerminalEvidence(bag, {
+            clientRequestId: input.clientRequestId,
+            turnId: input.turnId,
+        });
+    }
+    return {
+        bag,
+        clientRequestId: input.clientRequestId,
+        busyAfter: isSubmitOwnershipBusy(bag),
+    };
+}
+/**
+ * Production orchestration: Stop during ambiguous create → bind-active → one abort.
+ * Reuses original clientRequestId; no second create-turn POST; no Session dispose.
+ */
+export function runStopDuringAmbiguousThenBind(input) {
+    const abortCalls = [];
+    const bag = createTurnOwnershipBag({
+        sessionId: input.sessionId,
+        sessionGeneration: 1,
+    });
+    const pending = beginSubmitOwnership(bag, {
+        clientRequestId: input.clientRequestId,
+        sessionId: input.sessionId,
+        sessionGeneration: 1,
+        text: "stop-race",
+        images: [],
+        assistantId: "a-stop",
+        userMessageId: "u-stop",
+    });
+    bag.streaming = true;
+    // create-turn still ambiguous / unresolved — Stop sets durable intent.
+    const hooks = {
+        postAbort: (turnId) => {
+            abortCalls.push(turnId);
+            input.postAbort(turnId);
+        },
+        notice: { showNotice: () => { }, setError: () => { } },
+    };
+    requestStopOnOwnership(bag, hooks);
+    // Ambiguous settle leaves pending + stopRequested.
+    settleCreateTurnOutcome(bag, { kind: "ambiguous", message: "unclear" }, {
+        assistantId: "a-stop",
+        text: "stop-race",
+        images: [],
+        pending,
+        sessionId: input.sessionId,
+        notice: hooks.notice,
+        onAutoAbort: (turnId) => void hooks.postAbort(turnId),
+    });
+    const stopRequestedAfterAmbiguous = bag.stopRequested;
+    const abortCallsAfterAmbiguous = abortCalls.length;
+    // /state bind-active → exactly one abort; same clientRequestId; no remint.
+    applyPendingReconcileDecision(bag, { action: "bind-active", turnId: input.turnId }, {
+        activeTurn: {
+            turnId: input.turnId,
+            clientRequestId: input.clientRequestId,
+            state: "running",
+        },
+    }, {
+        onAutoAbort: (turnId) => void hooks.postAbort(turnId),
+    });
+    // Repeated Stop / bind-time auto-abort coalesce to one.
+    requestStopOnOwnership(bag, hooks);
+    honorStopIntentAfterBind(bag, input.turnId, hooks);
+    return {
+        bag,
+        clientRequestId: input.clientRequestId,
+        abortCalls,
+        // Orchestration never issues a second create-turn POST.
+        createTurnPosts: 0,
+        stopRequestedAfterAmbiguous,
+        abortCallsAfterAmbiguous,
+    };
+}