@abot-ai/runtime 1.7.0 → 1.8.1

package/dist/src/web-ui/app/controllers/composer-queue-controller.js

@@ -1,286 +1,220 @@
+import { ComposerSubmissionRefused, isDefiniteSubmissionRefusal } from "./composer-submission-lifecycle.js";
+
+const scopeKey = (scope) => JSON.stringify([scope.environmentId, scope.sessionId]);
+
+function hasConversationQueueScope(scope) {
+  if (!scope.environmentId) return false;
+  return Boolean(scope.sessionId);
+}
+
+/** Sole owner of queue ordering. Drafts and submissions own their respective payloads. */
 export function createComposerQueueController({
-  state,
-  dom,
-  queue,
-  selectedEnvironmentId,
-  getToolPermissionMode,
-  getModelPreference,
-  rememberModelSelection,
-  attachments,
-  updateSendState,
-  postChatMessage,
-  appendLocalUserMessage,
-  activateRequestForScope,
-  renderMessages,
-  setMessageStatus,
-  recordControlEvent,
-  resizeComposer,
+  queue, drafts, lifecycle, getDraft, requests, getSettings,
+  isCurrentScope, reportFailure, reportRecovery = () => {}, onChange = () => {},
+  confirmTakeover = (message) => globalThis.confirm?.(message) === true,
 }) {
-  const scopeKey = (scope) =>
-    JSON.stringify([scope.environmentId, scope.sessionId]);
-  const currentScope = () => ({
-    environmentId: selectedEnvironmentId(),
-    sessionId: state.currentSessionId,
-  });
-  const isCurrentScope = (scope) =>
-    selectedEnvironmentId() === scope.environmentId &&
-    state.currentSessionId === scope.sessionId;
-  const isCurrentDraining = () =>
-    state.composerQueueDrainingScopes.has(scopeKey(currentScope()));
-  const queuedCount = () => {
-    const scope = currentScope();
-    if (!scope.environmentId || !scope.sessionId) return 0;
-    return queue.list(scope).length;
-  };
+  const processing = new Map();
+  const bindings = new Map();
+  const terminals = new Map();
 
-  async function enqueue(text) {
-    const scope = currentScope();
-    const waitForRequestId = state.activeRequestId;
-    if (!scope.sessionId || !waitForRequestId) {
-      throw new Error("Send next requires an active request.");
-    }
-    const queuedAttachments = [...state.pendingAttachments];
-    rememberModelSelection();
-    queue.enqueue(scope, {
-      waitForRequestId,
-      text,
-      attachments: queuedAttachments,
-      agentMode: state.agentMode,
-      toolPermissionMode: getToolPermissionMode(),
-      modelPreference: getModelPreference(),
-    });
-    attachments.invalidateCompletions();
-    state.pendingAttachments = [];
-    attachments.render();
+  function queuedCount() {
+    const scope = getDraft().scope;
+    if (!hasConversationQueueScope(scope)) return 0;
+    return queue.list(scope).length;
   }
+  function isCurrentDraining() { return processing.has(scopeKey(getDraft().scope)); }
 
-  function reportFailure(scope, summary, tone = "failed") {
-    if (!isCurrentScope(scope)) return;
-    state.messages.push({
-      id: `queue-error-${Date.now()}`,
-      role: "assistant",
-      text: summary,
-      createdAt: Date.now(),
-      requestId: "",
-      streaming: false,
-    });
-    renderMessages();
-    setMessageStatus("Send next queue is paused.");
-    recordControlEvent({
-      type: "control",
-      name: "Send next queue paused",
-      tone,
-      summary,
-    });
+  function queueItem(payload, settings, requestId) {
+    return { text: payload.text, attachments: [...payload.attachments], ...settings, waitForRequestId: requestId };
   }
 
-  function restoreText(text, scope) {
-    if (!isCurrentScope(scope)) return;
-    const current = dom.composerInput.value.trim();
-    dom.composerInput.value = current ? `${text}\n${current}` : text;
-    resizeComposer();
+  async function prepareManualSend(attempt) {
+    const { payload, settings } = attempt;
+    if (!payload.release) return;
+    const { scope, release } = payload;
+    const item = queueItem(payload, settings, release.item.waitForRequestId);
+    const updated = await queue.updateBlockedRelease(scope, release.releaseToken, item);
+    if (!updated) throw new ComposerSubmissionRefused("This queued message changed in another window. Reload before sending it.");
+    const begun = await queue.beginBlockedSend(scope, release.releaseToken);
+    if (!begun) throw new ComposerSubmissionRefused("This window no longer owns the queued message. Reload before sending it.");
   }
 
-  function restoreItem(item, scope) {
-    if (!isCurrentScope(scope)) return false;
-    restoreText(item.text, scope);
-    state.pendingAttachments = [
-      ...item.attachments,
-      ...state.pendingAttachments,
-    ];
-    attachments.render();
-    return true;
+  async function send(attempt) {
+    try { return await requests.send(attempt); }
+    catch (error) {
+      if (attempt.payload.release && !isDefiniteSubmissionRefusal(error)) {
+        try { await queue.markBlockedUncertain(attempt.payload.scope, attempt.payload.release.releaseToken); }
+        catch (markError) { reportFailure(attempt.payload.scope, `The queued message remains paused: ${markError.message}`); }
+      }
+      throw error;
+    }
   }
 
-  function clearRecovery(scope) {
-    const active = state.activeComposerQueueRecovery;
-    if (!active || scopeKey(active.scope) !== scopeKey(scope)) return;
-    state.composerQueueRecoveredReleaseTokens.delete(active.releaseToken);
-    state.activeComposerQueueRecovery = null;
+  async function prepareRestore(attempt) {
+    const { payload } = attempt;
+    // Only a confirmed request rejection can return a sending lease to editing.
+    // A failed preparation has not submitted anything and retains its existing lease.
+    if (!payload.release || attempt.phase !== "sending") return payload;
+    const claimed = await queue.claimBlockedRelease(payload.scope, payload.release.releaseToken, { takeover: true });
+    if (!claimed) throw new Error("The rejected message remains paused because its queue ownership changed.");
+    return { ...payload, release: claimed };
   }
 
-  async function drain({ environmentId, sessionId, terminalRequestId, cancelled = false }) {
-    const scope = { environmentId, sessionId };
+  async function bindAccepted(attempt, requestId) {
+    const { scope, release } = attempt.payload;
+    if (!release) { requests.activate(attempt, requestId); return; }
     const key = scopeKey(scope);
-    if (state.composerQueueDrainingScopes.has(key)) return;
-    state.composerQueueDrainingScopes.add(key);
-    if (isCurrentScope(scope)) updateSendState();
-    let released;
-    try {
-      released = queue.releaseForTerminal(scope, terminalRequestId);
-    } catch (error) {
-      reportFailure(
-        scope,
-        `The queued message was not released: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-      );
-      state.composerQueueDrainingScopes.delete(key);
-      if (isCurrentScope(scope)) updateSendState();
-      return;
-    }
-    if (!released) {
-      state.composerQueueDrainingScopes.delete(key);
-      if (isCurrentScope(scope)) updateSendState();
-      return;
-    }
-    if (cancelled) {
-      state.composerQueueDrainingScopes.delete(key);
-      recoverForManualSend(scope, "Response stopped. The next queued message is back in the composer; send it when you are ready to continue.", "neutral");
-      if (isCurrentScope(scope)) updateSendState();
-      return;
-    }
-    updateSendState();
-    const { item, releaseToken } = released;
-    let requestId;
-    try {
-      requestId = await postChatMessage({
-        text: item.text,
-        attachments: item.attachments,
-        environmentId,
-        sessionId,
-        agentMode: item.agentMode,
-        toolPermissionMode: item.toolPermissionMode,
-        modelPreference: item.modelPreference,
-      });
-    } catch (error) {
-      const restored = restoreItem(item, scope);
-      if (restored) {
-        state.composerQueueRecoveredReleaseTokens.add(releaseToken);
-        state.activeComposerQueueRecovery = {
-          scope: { ...scope },
-          releaseToken,
-        };
-      }
-      reportFailure(
-        scope,
-        `The queued message could not be confirmed and will not be retried automatically: ${
-          error instanceof Error ? error.message : String(error)
-        }.${restored ? " It was restored to the composer for a manual send." : ""}`,
-      );
-      state.composerQueueDrainingScopes.delete(key);
-      if (isCurrentScope(scope)) updateSendState();
-      return;
+    const binding = Promise.resolve().then(async () => {
+      const bound = await queue.bindReleasedSuccess(scope, release.releaseToken, requestId);
+      if (!bound) throw new Error("The remaining queue could not be bound to the accepted request.");
+      return true;
+    }).catch((error) => {
+      reportFailure(scope, `The request started, but the remaining Send next queue is paused: ${error.message}`);
+      return false;
+    });
+    bindings.set(key, binding);
+    onChange();
+    requests.activate(attempt, requestId);
+    try { await binding; }
+    finally {
+      if (bindings.get(key) === binding) bindings.delete(key);
+      onChange();
     }
-    let queueBound = false;
-    try {
-      queueBound = queue.bindReleasedSuccess(scope, releaseToken, requestId);
-    } catch (error) {
-      queueBound = null;
-      reportFailure(
-        scope,
-        `The queued message started, but the remaining queue is paused: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-      );
+  }
+
+  async function enqueue(attempt, waitForRequestId) {
+    if (!waitForRequestId) throw new ComposerSubmissionRefused("Send next requires an active request.");
+    try { return await queue.enqueue(attempt.payload.scope, queueItem(attempt.payload, attempt.settings, waitForRequestId)); }
+    catch (error) {
+      if (error?.workspaceMutationMayHaveCommitted !== true)
+        throw new ComposerSubmissionRefused(error.message, { cause: error });
+      throw error;
     }
-    if (queueBound === false) {
-      reportFailure(
-        scope,
-        "The queued message started, but the remaining queue could not be rebound and is paused.",
-      );
+  }
+
+  function hasManualRecovery(scope) {
+    if (!hasConversationQueueScope(scope)) return false;
+    if (bindings.has(scopeKey(scope))) return false;
+    if (lifecycle.hasPendingScope(scope)) return false;
+    const release = queue.getBlockedRelease(scope);
+    if (!release) return false;
+    if (drafts.open(scope).release?.releaseToken === release.releaseToken) return false;
+    return !lifecycle.paused(scope).some((attempt) => attempt.payload.release?.releaseToken === release.releaseToken);
+  }
+
+  async function recoverForManualSend(scope) {
+    const draft = drafts.open(scope);
+    const release = queue.getBlockedRelease(scope);
+    if (!release || draft.release?.releaseToken === release.releaseToken) return false;
+    if (!draft.isEmpty()) {
+      reportFailure(scope, "Send next is paused. Finish or clear your current draft before reviewing the queued message.");
+      return false;
     }
-    if (isCurrentScope(scope)) {
-      appendLocalUserMessage({
-        text: item.text,
-        attachments: item.attachments,
-        requestId,
-      });
+    let claimed = await queue.claimBlockedRelease(scope, release.releaseToken);
+    if (!claimed) {
+      const approved = confirmTakeover("This queued message may have been sent or may belong to another window. Close that window and check the conversation before taking ownership for manual review. Sending it again may repeat its actions. Continue?");
+      if (!approved) return false;
+      claimed = await queue.claimBlockedRelease(scope, release.releaseToken, { takeover: true });
     }
-    state.composerQueueDrainingScopes.delete(key);
-    activateRequestForScope(scope, requestId);
+    if (!claimed) throw new Error("This queued message changed before it could be recovered.");
+    // Ownership can be acknowledged after navigation. Restore only to its own draft,
+    // and never merge a second recovery over input typed during that acknowledgement.
+    if (!draft.isEmpty()) return false;
+    draft.restore({ scope, text: claimed.item.text, attachments: claimed.item.attachments, release: claimed });
+    onChange();
+    reportRecovery(scope, "Send next is paused. Review the recovered message and send it manually when ready.");
+    return true;
   }
 
   function prepareRecoveryForNavigation() {
-    const active = state.activeComposerQueueRecovery;
-    if (!active) return () => {};
+    const draft = getDraft();
+    if (!draft.release) return () => {};
+    return persistRecoveryDraft(draft);
+  }
+
+  async function persistRecoveryDraft(draft) {
+    const snapshot = draft.snapshot();
+    const revision = draft.revision;
     try {
-      const blockedRelease = queue.getBlockedRelease(active.scope);
-      const hasMatchingRecoveryRelease = blockedRelease?.releaseToken === active.releaseToken;
-      if (!hasMatchingRecoveryRelease) {
-        return () => clearRecovery(active.scope);
-      }
-      const updated = queue.updateBlockedRelease(
-        active.scope,
-        active.releaseToken,
-        {
-          ...blockedRelease.item,
-          text: dom.composerInput.value,
-          attachments: [...state.pendingAttachments],
-        },
-      );
-      if (!updated)
-        throw new Error("blocked release changed before it was saved");
+      const updated = await queue.updateBlockedRelease(snapshot.scope, snapshot.release.releaseToken,
+        queueItem(snapshot, getSettings(), snapshot.release.item.waitForRequestId));
+      if (!updated) throw new Error("The queued message changed in another window.");
+      const commit = () => {};
+      commit.canCommit = () => draft.revision === revision;
+      return commit;
     } catch (error) {
-      reportFailure(
-        active.scope,
-        `The recovered Send next draft could not be saved before navigation: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-      );
+      reportFailure(snapshot.scope, `The recovered draft could not be saved: ${error.message}`);
       return false;
     }
-    return () => {
-      dom.composerInput.value = "";
-      resizeComposer();
-      attachments.clear({ cleanup: false });
-      clearRecovery(active.scope);
+  }
+
+  function suspendRecoveryForNavigation(canNavigate = () => true) {
+    const prepared = prepareRecoveryForNavigation();
+    const commit = (action) => {
+      if (!action || !canNavigate() || action.canCommit?.() === false) return false;
+      action();
+      return true;
     };
+    return typeof prepared?.then === "function" ? prepared.then(commit) : commit(prepared);
   }
 
-  function suspendRecoveryForNavigation() {
-    const commit = prepareRecoveryForNavigation();
-    if (!commit) return false;
-    commit();
-    return true;
+  async function processTerminal(input) {
+    const scope = { environmentId: input.environmentId, sessionId: input.sessionId };
+    const binding = bindings.get(scopeKey(scope));
+    if (binding && await binding !== true) return;
+    const released = await queue.releaseForTerminal(scope, input.terminalRequestId);
+    if (!released) return;
+    if (input.cancelled) { await recoverForManualSend(scope); return; }
+    const item = released.item;
+    const attempt = await lifecycle.submitCaptured({
+      action: "send", payload: { scope, text: item.text, attachments: item.attachments, release: released },
+      settings: { agentMode: item.agentMode, toolPermissionMode: item.toolPermissionMode, modelPreference: item.modelPreference },
+      prepare: async (submission) => { await prepareManualSend(submission); requests.prepareView(submission); },
+      execute: send, accepted: bindAccepted, prepareRestore,
+    });
+    if (attempt.status !== "accepted")
+      reportFailure(scope, "The queued message could not be confirmed. It is paused and will not be retried automatically.");
   }
 
-  function recoverForManualSend(scope, message = "Send next is paused. The queued message was restored to the composer for review and will not be sent automatically.", tone = "neutral") {
-    let blockedRelease;
-    try {
-      blockedRelease = queue.getBlockedRelease(scope);
-    } catch (error) {
-      reportFailure(
-        scope,
-        `The paused Send next message could not be recovered: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-      );
-      return false;
-    }
-    if (
-      !blockedRelease ||
-      state.composerQueueRecoveredReleaseTokens.has(blockedRelease.releaseToken)
-    ) {
-      return false;
-    }
-    if (!restoreItem(blockedRelease.item, scope)) return false;
-    state.composerQueueRecoveredReleaseTokens.add(blockedRelease.releaseToken);
-    state.activeComposerQueueRecovery = {
-      scope: { ...scope },
-      releaseToken: blockedRelease.releaseToken,
-    };
-    reportFailure(
-      scope,
-      message,
-      tone,
-    );
-    return true;
+  function drain(input) {
+    const key = scopeKey(input);
+    let pending = terminals.get(key);
+    if (!pending) { pending = new Map(); terminals.set(key, pending); }
+    pending.set(input.terminalRequestId, input);
+    if (processing.has(key)) return processing.get(key);
+    const operation = Promise.resolve().then(async () => {
+      while (pending.size) {
+        const [requestId, terminal] = pending.entries().next().value;
+        pending.delete(requestId);
+        try { await processTerminal(terminal); }
+        catch (error) { reportFailure(input, `Send next remains paused: ${error.message}`); }
+      }
+    }).finally(() => {
+      processing.delete(key);
+      terminals.delete(key);
+      onChange();
+    });
+    processing.set(key, operation);
+    onChange();
+    return operation;
   }
 
   return {
-    clearRecovery,
-    currentScope,
-    drain,
-    enqueue,
-    isCurrentDraining,
-    isCurrentScope,
-    prepareRecoveryForNavigation,
-    queuedCount,
-    recoverForManualSend,
-    reportFailure,
-    restoreText,
-    scopeKey,
-    suspendRecoveryForNavigation,
+    queuedCount, isCurrentDraining, enqueue, prepareManualSend, send, bindAccepted, drain, prepareRestore,
+    recoverForManualSend, hasManualRecovery, prepareRecoveryForNavigation, suspendRecoveryForNavigation,
+    isCurrentScope, scopeKey, currentScope: () => getDraft().scope, reportFailure,
+    async authorizeReview(attempt) {
+      if (!attempt.payload.release) return true;
+      const { scope, release } = attempt.payload;
+      const claimed = await queue.claimBlockedRelease(scope, release.releaseToken, { takeover: true });
+      return claimed ? { release: claimed } : false;
+    },
+    ownsAttachment(attachment) {
+      const scope = { environmentId: attachment.environment, sessionId: attachment.sessionId };
+      if (!scope.environmentId || !scope.sessionId) return false;
+      const release = queue.getBlockedRelease(scope);
+      const items = [...queue.list(scope), ...(release ? [release.item] : [])];
+      return items.some((item) => item.attachments.some((file) => file.id === attachment.id && file.storageRef === attachment.storageRef));
+    },
   };
 }

package/dist/src/web-ui/app/controllers/composer-submission-lifecycle.d.ts

@@ -0,0 +1,48 @@
+import type { SessionComposerQueueItem, ReleasedSessionComposerQueueItem } from "../lib/session-composer-queue.js";
+import type { ComposerAttachment, ComposerDraft, ComposerDraftSnapshot, ComposerDrafts, ComposerScope } from "./composer-drafts.js";
+
+export type ComposerSubmissionAction = "send" | "send_next" | "steer";
+export type ComposerSubmissionSettings = Pick<SessionComposerQueueItem, "agentMode" | "toolPermissionMode" | "modelPreference">;
+export type ComposerSubmissionPhase = "preparing" | "sending" | "accepted" | "refused" | "uncertain" | "restored";
+
+export interface ComposerSubmissionAttempt<Settings = unknown, Result = unknown> {
+  readonly id: number;
+  readonly action: ComposerSubmissionAction;
+  readonly settings: Settings;
+  readonly payload: ComposerDraftSnapshot;
+  phase: ComposerSubmissionPhase;
+  error: unknown;
+  result?: Result;
+}
+
+export type ComposerSubmissionResult<Settings = unknown, Result = unknown> =
+  | { status: "accepted"; attempt: ComposerSubmissionAttempt<Settings, Result>; result: Result; bookkeepingError?: unknown }
+  | { status: "refused" | "uncertain"; attempt: ComposerSubmissionAttempt<Settings, Result>; error: unknown };
+
+export type ComposerReviewAuthorization = boolean | { release: ReleasedSessionComposerQueueItem };
+export interface ComposerSubmissionOptions<Settings = unknown, Result = unknown> {
+  action: ComposerSubmissionAction;
+  settings?: Settings;
+  prepare?(attempt: ComposerSubmissionAttempt<Settings, Result>): void | Promise<void>;
+  execute(attempt: ComposerSubmissionAttempt<Settings, Result>): Result | Promise<Result>;
+  accepted?(attempt: ComposerSubmissionAttempt<Settings, Result>, result: Result): void | Promise<void>;
+  prepareRestore?(attempt: ComposerSubmissionAttempt<Settings, Result>): ComposerDraftSnapshot | Promise<ComposerDraftSnapshot>;
+}
+
+export interface ComposerSubmissionLifecycle {
+  submit<Settings = unknown, Result = unknown>(options: ComposerSubmissionOptions<Settings, Result> & { draft: ComposerDraft }): Promise<ComposerSubmissionResult<Settings, Result>>;
+  submitCaptured<Settings = unknown, Result = unknown>(options: ComposerSubmissionOptions<Settings, Result> & { payload: ComposerDraftSnapshot }): Promise<ComposerSubmissionResult<Settings, Result>>;
+  hasPendingScope(scope: ComposerScope): boolean;
+  restoreForManualReview(id: number, authorize: (attempt: ComposerSubmissionAttempt) => ComposerReviewAuthorization | Promise<ComposerReviewAuthorization>): Promise<boolean>;
+  paused(scope: ComposerScope): ComposerSubmissionAttempt[];
+  ownsAttachment(attachment: ComposerAttachment): boolean;
+}
+
+export declare class ComposerSubmissionRefused extends Error {
+  constructor(message: string, options?: ErrorOptions);
+}
+export declare function isDefiniteSubmissionRefusal(error: unknown): error is ComposerSubmissionRefused;
+export declare function createComposerSubmissionLifecycle(options: {
+  drafts: ComposerDrafts;
+  onChange?(attempt: ComposerSubmissionAttempt): void;
+}): ComposerSubmissionLifecycle;

package/dist/src/web-ui/app/controllers/composer-submission-lifecycle.js

@@ -0,0 +1,97 @@
+function scopeKey(scope) {
+  return JSON.stringify([scope.environmentId, scope.sessionId]);
+}
+
+/** Explicit refusal is distinct from a missing acknowledgement after an effect. */
+export class ComposerSubmissionRefused extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ComposerSubmissionRefused";
+  }
+}
+
+export function isDefiniteSubmissionRefusal(error) {
+  return error instanceof ComposerSubmissionRefused;
+}
+
+/** Owns captured payloads from take() until acceptance, restoration or manual review. */
+export function createComposerSubmissionLifecycle({ drafts, onChange = () => {} }) {
+  const attempts = new Map();
+  let sequence = 0;
+
+  function hasPendingScope(scope) {
+    const key = scopeKey(scope);
+    return [...attempts.values()].some((attempt) =>
+      scopeKey(attempt.payload.scope) === key && ["preparing", "sending"].includes(attempt.phase));
+  }
+
+  function publish(attempt, phase) {
+    attempt.phase = phase;
+    onChange(attempt);
+  }
+
+  async function submitCaptured({ payload, action, settings, prepare = async () => {}, execute, accepted = async () => {}, prepareRestore = async (attempt) => attempt.payload }) {
+    const attempt = { id: ++sequence, action, settings, payload, phase: "preparing", error: null };
+    attempts.set(attempt.id, attempt);
+    publish(attempt, "preparing");
+    let result;
+    try {
+      await prepare(attempt);
+      publish(attempt, "sending");
+      result = await execute(attempt);
+    } catch (error) {
+      attempt.error = error;
+      if (canRestoreRejectedSubmission(attempt, error)) {
+        try {
+          const restored = await prepareRestore(attempt);
+          drafts.restore(restored);
+          attempts.delete(attempt.id);
+          publish(attempt, "refused");
+          return { status: "refused", attempt, error };
+        } catch (restoreError) { attempt.error = restoreError; }
+      }
+      publish(attempt, "uncertain");
+      return { status: "uncertain", attempt, error };
+    }
+    attempt.result = result;
+    attempts.delete(attempt.id);
+    publish(attempt, "accepted");
+    // Acceptance cannot turn into a rejected send because post-send bookkeeping fails.
+    try { await accepted(attempt, result); }
+    catch (error) { return { status: "accepted", attempt, result, bookkeepingError: error }; }
+    return { status: "accepted", attempt, result };
+  }
+
+  async function restoreForManualReview(id, authorize) {
+    const attempt = attempts.get(id);
+    if (!attempt || attempt.phase !== "uncertain") return false;
+    const approval = await authorize(attempt);
+    if (approval !== true && !approval?.release) return false;
+    if (attempts.get(id) !== attempt || attempt.phase !== "uncertain") return false;
+    drafts.restore(approval?.release ? { ...attempt.payload, release: approval.release } : attempt.payload);
+    attempts.delete(id);
+    publish(attempt, "restored");
+    return true;
+  }
+
+  return {
+    submit(options) {
+      if (hasPendingScope(options.draft.scope))
+        return Promise.reject(new ComposerSubmissionRefused("A message is already being submitted for this conversation."));
+      return submitCaptured({ ...options, payload: options.draft.take() });
+    },
+    submitCaptured,
+    hasPendingScope,
+    restoreForManualReview,
+    paused: (scope) => [...attempts.values()].filter((attempt) =>
+      attempt.phase === "uncertain" && scopeKey(attempt.payload.scope) === scopeKey(scope)),
+    ownsAttachment: (attachment) => [...attempts.values()].some((attempt) =>
+      attempt.payload.attachments.some((file) => file.id === attachment.id && file.storageRef === attachment.storageRef)),
+  };
+}
+
+function canRestoreRejectedSubmission(attempt, error) {
+  if (error?.workspaceMutationMayHaveCommitted === true) return false;
+  if (isDefiniteSubmissionRefusal(error)) return true;
+  return attempt.phase === "preparing";
+}