mixdog 1.0.12 → 1.1.0

package/src/tui/session/agent-job-feed/execution-delivery.mjs

@@ -22,7 +22,15 @@ function ackModelVisible(event) {
 
 // The `execution-ui` delivery: one transcript card per execution card key,
 // then the model-visible completion body enqueued once per execution.
-export function createExecutionDelivery({ dedup, pendingResume, enqueue, nextId, pushResponse, statusRefresh }) {
+export function createExecutionDelivery({
+  dedup,
+  pendingResume,
+  enqueue,
+  nextId,
+  pushResponse,
+  statusRefresh,
+  getAdmission = () => 'open',
+}) {
   function pushCard({ event, text, parsed, delivery, executionId, status, terminal }) {
     const cardKey = executionCardKey(event, text, parsed);
     const firstDelivery = !cardKey || !dedup.hasNotificationKey(cardKey);
@@ -65,6 +73,10 @@ export function createExecutionDelivery({ dedup, pendingResume, enqueue, nextId,
   function enqueueCompletion({ event, text, delivery, executionId, notificationKey }) {
     const resumeBody = String(delivery.modelContent || '').trim();
     if (!resumeBody) return;
+    // Validated at consumption (not only at the bus): a closing/closed owner
+    // keeps the card for UI/history but never queues a model-visible twin, and
+    // does not ack it as model-delivered.
+    if (getAdmission() !== 'open' || event?.meta?.owner_closed === true) return;
     const completionKey = executionResumeKey(resumeBody, executionId);
     if (pendingResume.isDiscarded(completionKey) || isDeliveredCompletion({ executionId, text: resumeBody })) {
       ackModelVisible(event);

package/src/tui/session/agent-job-feed/notification-router.mjs

@@ -13,6 +13,7 @@ export function createNotificationRouter({
   statusRefresh,
   executionDelivery,
   modelNotification,
+  getAdmission = () => 'open',
 }) {
   let uiOpenSeq = 0;
   let setupChangeSeq = 0;
@@ -68,6 +69,8 @@ export function createNotificationRouter({
       });
     }
     statusRefresh.refresh(parsed);
+    // A closing/closed owner enqueues no model work from a notification.
+    if (getAdmission() !== 'open' || event?.meta?.owner_closed === true) return false;
     return modelNotification.enqueueNotification({ event, text, delivery, notificationKey });
   };
 }

package/src/tui/session/agent-job-feed/pending-resume.mjs

@@ -25,6 +25,7 @@ export function createPendingResume({
   now,
   tombstoneTtlMs,
   tombstoneLimit,
+  getAdmission = () => 'open',
 }) {
   let deferred = false;
   // Completion keys explicitly abandoned by Esc. Tombstones are per-feed
@@ -88,8 +89,20 @@ export function createPendingResume({
   function kick(body = '', completionKey = '') {
     const key = executionResumeKey(body, completionKey);
     if (body && isDiscarded(key)) return;
+    // Admission fence: a closed session never resumes from a completion; a
+    // closing one defers (a failed close flushes the deferred kick).
+    const admission = getAdmission();
+    if (admission === 'terminal') {
+      bodies.length = 0;
+      deferred = false;
+      return;
+    }
     if (body) bodies.push({ body, key });
     if (getDisposed()) return;
+    if (admission === 'closing') {
+      deferred = true;
+      return;
+    }
     if (getState().busy) {
       deferred = true;
       return;
@@ -104,7 +117,7 @@ export function createPendingResume({
   }
 
   function flushDeferred() {
-    if (!deferred || getDisposed() || getState().busy) return;
+    if (!deferred || getDisposed() || getState().busy || getAdmission() !== 'open') return;
     kick();
   }
 

package/src/tui/session/agent-job-feed.mjs

@@ -40,6 +40,7 @@ export function createAgentJobFeed({
   now = () => Date.now(),
   executionResumeTombstoneTtlMs = 30_000,
   executionResumeTombstoneLimit = 128,
+  getAdmission = () => 'open',
 }) {
   const dedup = createExecutionDedup({ displayedNotificationKeys: displayedExecutionNotificationKeys });
   const pendingResume = createPendingResume({
@@ -51,6 +52,7 @@ export function createAgentJobFeed({
     now,
     tombstoneTtlMs: executionResumeTombstoneTtlMs,
     tombstoneLimit: executionResumeTombstoneLimit,
+    getAdmission,
   });
   const card = createAgentJobCard({ getState, itemIndexById, patchItem });
   const statusRefresh = createAgentStatusRefresh({ set, getDisposed, agentStatusState });
@@ -61,6 +63,7 @@ export function createAgentJobFeed({
     nextId,
     pushResponse: pushAsyncAgentResponse || pushUserOrSyntheticItem,
     statusRefresh,
+    getAdmission,
   });
   const modelNotification = createModelNotificationEnqueue({
     chain: createNotificationEnqueueChain({ pushNotice }),
@@ -76,6 +79,7 @@ export function createAgentJobFeed({
     statusRefresh,
     executionDelivery,
     modelNotification,
+    getAdmission,
   });
 
   function subscribeRuntimeNotifications() {

package/src/tui/session/context-state.mjs

@@ -8,7 +8,14 @@
 import { contextMeasurementStats } from '../../runtime/shared/context-measurement.mjs';
 import { goalStateSnapshot } from '../../runtime/agent/orchestrator/runtime-core/goal-state.mjs';
 
-export function createContextState({ runtime, getState, updateState, getPendingSessionReset, getVisibleGoal }) {
+export function createContextState({
+  runtime,
+  getState,
+  updateState,
+  getPendingSessionReset,
+  getVisibleGoal,
+  getQuotaResume = null,
+}) {
   const autoClearState = () =>
     runtime.getAutoClear?.() ||
     runtime.autoClear || {
@@ -46,6 +53,8 @@ export function createContextState({ runtime, getState, updateState, getPendingS
     clientHostPid: runtime.clientHostPid || null,
     model: runtime.model,
     provider: runtime.provider,
+    sessionProvider: runtime.sessionProvider ?? null,
+    sessionModel: runtime.sessionModel ?? null,
     effort: runtime.effort,
     effortOptions: runtime.effortOptions,
     fast: runtime.fast,
@@ -69,6 +78,9 @@ export function createContextState({ runtime, getState, updateState, getPendingS
     // 안 보이던 골이 생성되었다 바로 사라짐).
     // Clock-anchored, so an unchanged running Goal reads equal on every pulse.
     goal: goalStateSnapshot(typeof getVisibleGoal === 'function' ? getVisibleGoal() : runtime.goalStatus?.() || null),
+    // The daemon-queued quota resume of this session id (identity-stable while
+    // unchanged), so a resume or session switch republishes it with the route.
+    quotaResume: typeof getQuotaResume === 'function' ? getQuotaResume() : null,
   });
 
   const routeState = () => {

package/src/tui/session/initial-state.mjs

@@ -23,6 +23,12 @@ export function createInitialSessionState({ runtime, runtimeCwd, baseRouteState
     queued: [],
     thinking: null,
     toolApproval: null,
+    // How the last approval ended and from which device, so every device can
+    // say who answered ({ id, approved, device, at }).
+    toolApprovalResult: null,
+    // A prompt reclaimed by a DIFFERENT device than the one that sent it:
+    // { id, ids, text, device, at } — only the sender's composer applies it.
+    promptRestore: null,
     lastTurn: null,
     stats: createSessionStats(),
     // Incremental derivations published by the session runtime so App does not scan all

package/src/tui/session/quota-resume.mjs

@@ -0,0 +1,263 @@
+/**
+ * quota-resume.mjs — one Lead session's side of the quota auto-resume: it
+ * queues a resume when a turn stops on exhausted provider quota, cancels it on
+ * the inputs that supersede it, owns the one "retry failed turn" operation,
+ * and runs the resume when the daemon scheduler fires it.
+ *
+ * The durable queue itself lives in the daemon-wide store
+ * (runtime/shared/quota-resume-store.mjs); this lane never keeps a timer, so an
+ * evicted session waits exactly like a live one.
+ */
+import {
+  cancelQuotaResumeEntry,
+  forgetQuotaSuspendedGoal,
+  noteQuotaSuspendedGoal,
+  publicQuotaResume,
+  quotaAutoResumeEnabled,
+  quotaResumeEntry,
+  quotaSuspendedGoal,
+  scheduleQuotaResumeEntry,
+  subscribeQuotaResume,
+} from '../../runtime/shared/quota-resume-store.mjs';
+import { createSubmissionIntake } from './session-api/intake/submission.mjs';
+
+export const RETRY_CONTINUE_INSTRUCTION = 'Continue from where you left off.';
+
+// Rows that frame a turn rather than carry its output (desktop transcript-rows).
+const TURN_CHROME_KINDS = new Set(['user', 'turndone', 'statusdone', 'notice']);
+
+function stableItemKey(item, index) {
+  if (item?.id !== undefined && item?.id !== null) return String(item.id);
+  return `${item?.kind || 'item'}:${item?.text || item?.label || item?.status || ''}:${index}`;
+}
+
+/** Turn identity per transcript row — the same keys the desktop derives. */
+export function transcriptTurnKeys(items) {
+  const transcript = Array.isArray(items) ? items : [];
+  const keys = [];
+  let activeTurn = null;
+  for (let index = 0; index < transcript.length; index += 1) {
+    const item = transcript[index];
+    if (item?.kind === 'user') activeTurn = `turn:${stableItemKey(item, index)}`;
+    if (!activeTurn) activeTurn = `segment:${stableItemKey(item, index)}`;
+    keys.push(activeTurn);
+    if (item?.kind === 'turndone') activeTurn = null;
+  }
+  return keys;
+}
+
+/** The failed turndone that ended the transcript on exhausted provider quota,
+ *  when no later turn has begun: { turnKey, quota: { provider, model, resetAt|null } }. */
+export function latestQuotaFailure(items) {
+  const transcript = Array.isArray(items) ? items : [];
+  for (let index = transcript.length - 1; index >= 0; index -= 1) {
+    const item = transcript[index];
+    if (item?.kind === 'user') return null;
+    if (item?.kind !== 'turndone') continue;
+    const quota = item.quota;
+    if (String(item.status || '').toLowerCase() !== 'failed' || !quota || typeof quota.provider !== 'string') {
+      return null;
+    }
+    const turnKey = transcriptTurnKeys(transcript)[index] || '';
+    if (!turnKey) return null;
+    return {
+      turnKey,
+      quota: {
+        provider: quota.provider,
+        model: typeof quota.model === 'string' ? quota.model : '',
+        resetAt: typeof quota.resetAt === 'number' && Number.isFinite(quota.resetAt) ? quota.resetAt : null,
+      },
+    };
+  }
+  return null;
+}
+
+/** What retrying the turn submits: its prompt when it produced no output, the
+ *  continuation instruction when it did, null when the prompt carried no text
+ *  (a media/attachment-only prompt cannot be replayed). */
+export function failedTurnRetryPrompt(items, turnKey) {
+  const transcript = Array.isArray(items) ? items : [];
+  const keys = transcriptTurnKeys(transcript);
+  let prompt = '';
+  let sampled = false;
+  let hasAttachments = false;
+  for (let index = 0; index < transcript.length; index += 1) {
+    if (keys[index] !== turnKey) continue;
+    const item = transcript[index];
+    if (item?.kind === 'user' && !prompt) {
+      prompt = String(item.text ?? '').trim();
+      hasAttachments = Array.isArray(item.images) && item.images.length > 0;
+    }
+    if (!TURN_CHROME_KINDS.has(String(item?.kind || ''))) sampled = true;
+  }
+  if (!prompt) return null;
+  // Transcript rows keep only attachment metadata, so a text-only replay
+  // would drop the attachments and the rewind would delete the original row.
+  if (hasAttachments && !sampled) return null;
+  return sampled ? RETRY_CONTINUE_INSTRUCTION : prompt;
+}
+
+export function createQuotaResumeLane(bag) {
+  const { runtime, flags, getState, set, pending } = bag;
+  const currentId = () => String(getState().sessionId || '');
+  let intake = null;
+  const submitAsync = (...args) => {
+    intake ??= createSubmissionIntake(bag);
+    return intake.submitAsync(...args);
+  };
+
+  const publishQuotaResume = () => {
+    const next = publicQuotaResume(quotaResumeEntry(currentId()));
+    if ((getState().quotaResume ?? null) !== next) set({ quotaResume: next });
+  };
+  const unsubscribe = subscribeQuotaResume((sessionId) => {
+    if (flags.disposed) return;
+    if (sessionId === null || sessionId === currentId()) publishQuotaResume();
+  });
+
+  const requireAddressed = (sessionId) => {
+    if (!sessionId || currentId() !== sessionId) throw new Error('session is not the active session');
+  };
+
+  // The session's own route (the selected route only before it has one).
+  const sessionRoute = () => ({
+    routeProvider: String(runtime.sessionProvider ?? runtime.provider ?? ''),
+    routeModel: String(runtime.sessionModel ?? runtime.model ?? ''),
+  });
+  const queueResume = (sessionId, failure) =>
+    scheduleQuotaResumeEntry({ sessionId, turnKey: failure.turnKey, ...failure.quota, ...sessionRoute() });
+
+  // A failed turn is settling between its failed turndone (where the resume is
+  // queued) and its Goal settlement (where the suspended Goal is recorded).
+  // Every superseding cancel bumps the epoch, so a cancel that lands inside
+  // that window also keeps the settlement from recording the Goal.
+  let settlement = null;
+  let cancelEpoch = 0;
+
+  const cancelFor = (sessionId) => {
+    cancelEpoch += 1;
+    cancelQuotaResumeEntry(sessionId);
+    forgetQuotaSuspendedGoal(sessionId);
+  };
+
+  /** The one retry operation. `automatic` is the scheduler's resume: it
+   *  enqueues directly, because the hours it waited must not trigger the idle
+   *  auto-clear a user submission starts. */
+  function retryFailedTurn(turnKey, { automatic = false } = {}) {
+    const prompt = failedTurnRetryPrompt(getState().items, turnKey);
+    if (!prompt) return false;
+    if (automatic) {
+      return bag.enqueue(prompt, { mode: 'prompt', id: bag.nextId(), displayText: prompt, retryFailedTurn: true });
+    }
+    return submitAsync(prompt, { retryFailedTurn: true });
+  }
+
+  return {
+    publishQuotaResume,
+    disposeQuotaResume: unsubscribe,
+
+    /** Turn close, synchronously with the failed turndone: with a known reset
+     *  and the setting on, queues the resume, so the same publication that
+     *  shows the failure carries `quotaResume`. */
+    beginQuotaSettlement() {
+      const id = currentId();
+      const failure = latestQuotaFailure(getState().items);
+      settlement = null;
+      if (!id || !failure) return null;
+      settlement = { sessionId: id, turnKey: failure.turnKey, epoch: cancelEpoch };
+      if (failure.quota.resetAt === null || !quotaAutoResumeEnabled()) return null;
+      return queueResume(id, failure);
+    },
+
+    /** After the Goal settled: records the Goal this failure suspended, unless
+     *  a superseding cancel landed since the turn closed. */
+    finishQuotaSettlement({ suspendedGoalId = '' } = {}) {
+      const current = settlement;
+      settlement = null;
+      if (!current || current.epoch !== cancelEpoch || !suspendedGoalId) return false;
+      return noteQuotaSuspendedGoal(current.sessionId, current.turnKey, suspendedGoalId);
+    },
+
+    /** New user input supersedes the stopped turn. */
+    cancelQuotaResumeOnUserInput() {
+      const id = currentId();
+      if (id) cancelFor(id);
+    },
+
+    /** Explicit request to auto-resume the latest quota-failed turn. */
+    scheduleQuotaResume(sessionId) {
+      requireAddressed(sessionId);
+      const failure = latestQuotaFailure(getState().items);
+      if (!failure || failure.quota.resetAt === null) {
+        throw new Error('latest turn did not fail on exhausted provider quota with a known reset time');
+      }
+      queueResume(sessionId, failure);
+      return true;
+    },
+
+    cancelQuotaResume(sessionId) {
+      requireAddressed(sessionId);
+      cancelQuotaResumeEntry(sessionId);
+      return true;
+    },
+
+    /** A route change or a session clear/delete supersedes the wait. */
+    supersedeQuotaResume(sessionId) {
+      if (sessionId) cancelFor(String(sessionId));
+    },
+
+    async retryFailedTurn(sessionId, turnKey) {
+      requireAddressed(sessionId);
+      return (await retryFailedTurn(String(turnKey || ''))) === true;
+    },
+
+    /** Scheduler fire for the entry of `generation`, after a usable reading.
+     *  Synchronous from the generation check to the admitted retry, so no
+     *  cancellation can land between them. Returns the outcome. */
+    fireQuotaResume({ generation } = {}) {
+      const id = currentId();
+      const entry = quotaResumeEntry(id);
+      if (!id || !entry || entry.generation !== generation) return 'stale';
+      const state = getState();
+      if (
+        flags.disposed ||
+        settlement !== null ||
+        (flags.admission || 'open') !== 'open' ||
+        state.busy ||
+        state.commandBusy ||
+        flags.autoClearRunning ||
+        flags.draining ||
+        pending.length > 0
+      ) {
+        return 'busy';
+      }
+      const failure = latestQuotaFailure(state.items);
+      if (!failure || failure.turnKey !== entry.turnKey) {
+        cancelQuotaResumeEntry(id, { generation });
+        return 'superseded';
+      }
+      const route = sessionRoute();
+      if (route.routeProvider !== entry.routeProvider || route.routeModel !== entry.routeModel) {
+        cancelQuotaResumeEntry(id, { generation });
+        return 'route-changed';
+      }
+      const goalId = quotaSuspendedGoal(id, entry.turnKey);
+      // A user turn replays its prompt; an automatic Goal turn has no user row
+      // and resumes as its Goal's next continuation.
+      const userTurn = entry.turnKey.startsWith('turn:');
+      if (userTurn ? !failedTurnRetryPrompt(state.items, entry.turnKey) : !goalId) {
+        cancelQuotaResumeEntry(id, { generation });
+        return 'unreplayable';
+      }
+      if (!cancelQuotaResumeEntry(id, { generation })) return 'stale';
+      forgetQuotaSuspendedGoal(id);
+      // Queued on the Goal's mutation chain ahead of the retry turn's own
+      // start, so that turn opens on the revived Goal; the retry is busy
+      // before the revived Goal's continuation check runs, so it queues none.
+      // Without a retry the revived Goal's continuation is the one turn.
+      if (goalId) void Promise.resolve(runtime.reactivateUsageLimitedGoal?.(goalId)).catch(() => {});
+      if (!userTurn) return 'fired';
+      return retryFailedTurn(entry.turnKey, { automatic: true }) !== false ? 'fired' : 'rejected';
+    },
+  };
+}

package/src/tui/session/session-api/intake/abort.mjs

@@ -1,7 +1,6 @@
-// Abort: Esc while idle hands a queued or still-accepting submission back to
-// the draft; Esc during a turn cancels it and, unless a steering prompt is
-// already queued, reclaims the in-flight prompt, its history slot and its
-// requeue entries.
+// Abort: Esc while idle hands a queued submission back to the draft; Esc
+// during a turn cancels it and, unless a steering prompt is already queued,
+// reclaims the in-flight prompt, its history slot and its requeue entries.
 import { hydratePastedAttachments, hydrateRestorableFileParts } from '../../../../runtime/attachments/store.mjs';
 import { abortGoalTurn } from '../../goal-turn-state.mjs';
 import { promptHistoryWithout } from '../../prompt-history.mjs';
@@ -15,16 +14,15 @@ function hydrateTolerantly(pastedImages, pastedTexts, content = null) {
   };
   const hydrated = hydratePastedAttachments(pastedImages, pastedTexts, { onUnreadable });
   const files = hydrateRestorableFileParts(content, { onUnreadable });
+  const verb = unreadable === 1 ? ' was' : 's were';
   return {
     ...hydrated,
     ...(files.length ? { content: files } : {}),
-    notice: unreadable
-      ? `${unreadable} attachment${unreadable === 1 ? ' was' : 's were'} no longer available and dropped.`
-      : '',
+    notice: unreadable ? `${unreadable} attachment${verb} no longer available and dropped.` : '',
   };
 }
 
-export function createAbortAction(bag, { acceptingSubmissions }) {
+export function createAbortAction(bag) {
   const {
     runtime,
     flags,
@@ -39,31 +37,12 @@ export function createAbortAction(bag, { acceptingSubmissions }) {
     discardExecutionPendingResume,
   } = bag;
 
-  // Esc while idle: hand a queued (or still-accepting) submission back to the
-  // draft instead of interrupting anything.
+  // Esc while idle: hand a queued submission back to the draft instead of
+  // interrupting anything.
   const reclaimIdleSubmission = (submissionId) => {
     if (!submissionId) return false;
     const restored = restoreQueued('', submissionId);
-    if (!restored || Number(restored.count) < 1) {
-      const intake = acceptingSubmissions.get(submissionId);
-      if (!intake) return false;
-      // Hydrate before cancelling: nothing is lost if an attachment is gone.
-      const attachments = hydrateTolerantly(
-        intake.queueOptions.pastedImages,
-        intake.queueOptions.pastedTexts,
-        intake.text
-      );
-      intake.cancelled = true;
-      return {
-        aborted: false,
-        restoreText: String(intake.queueOptions.displayText || '').trim(),
-        pastedImages: attachments.pastedImages,
-        pastedTexts: attachments.pastedTexts,
-        ...(attachments.content ? { content: attachments.content } : {}),
-        ...(attachments.notice ? { notice: attachments.notice } : {}),
-        restoredSubmissionIds: [submissionId],
-      };
-    }
+    if (!restored || Number(restored.count) < 1) return false;
     return {
       aborted: false,
       restoreText: restored.text,
@@ -77,10 +56,21 @@ export function createAbortAction(bag, { acceptingSubmissions }) {
 
   // Pull the interrupted prompt back out of the transcript and history and
   // put its unsent requeue entries at the front of the queue.
-  const reclaimInFlightPrompt = (restoreState, { restoreText, requeueEntries }) => {
+  const reclaimInFlightPrompt = (restoreState, { restoreText, requeueEntries, handoff = false }) => {
     restoreState.reclaimed = true;
     const idSet = new Set((restoreState.submittedIds || []).filter((id) => id != null));
     const patch = { spinner: null, thinking: null, lastTurn: null };
+    // Another device cancelled this turn: the prompt travels to the device that
+    // sent it through the state, never through the canceller's reply.
+    if (handoff && restoreText) {
+      patch.promptRestore = {
+        id: `restore-${Date.now()}-${[...idSet].join(',')}`,
+        ids: [...idSet].map(String),
+        text: restoreText,
+        device: restoreState.device,
+        at: Date.now(),
+      };
+    }
     if (restoreText) patch.promptHistoryList = promptHistoryWithout(getState().promptHistoryList, restoreText);
     if (idSet.size > 0) {
       const items = getState().items.filter((item) => !idSet.has(item?.id));
@@ -127,7 +117,18 @@ export function createAbortAction(bag, { acceptingSubmissions }) {
     // interrupting should just cancel the running turn and let the steering
     // prompt run next, NOT resurrect the in-flight prompt back into the draft.
     const hasPendingSteering = pending.some((entry) => isQueuedEntryEditable(entry));
-    const canRestore = options?.restorePrompt !== false && restoreState?.restorable && !hasPendingSteering;
+    // A different device than the one that sent the prompt is cancelling. Only
+    // plain text can be handed over through the state; a prompt carrying
+    // attachments stays in the transcript instead of landing in the wrong
+    // composer.
+    const canceller = typeof options?.device === 'string' ? options.device : '';
+    const crossDevice = Boolean(canceller && restoreState?.device && canceller !== restoreState.device);
+    const hasAttachments = Boolean(restoreState?.pastedImages || restoreState?.pastedTexts || restoreState?.content);
+    const canRestore =
+      options?.restorePrompt !== false &&
+      restoreState?.restorable &&
+      !hasPendingSteering &&
+      !(crossDevice && hasAttachments);
     const restoreText = canRestore ? restoreState.text : '';
     const restorePastedImages = canRestore && restoreState?.pastedImages ? restoreState.pastedImages : null;
     const restorePastedTexts = canRestore && restoreState?.pastedTexts ? restoreState.pastedTexts : null;
@@ -151,7 +152,7 @@ export function createAbortAction(bag, { acceptingSubmissions }) {
         discardExecutionPendingResume?.(restoreState.discardExecutionPendingResumeKeys);
       }
       if ((restoreText || requeueEntries.length > 0) && aborted !== false) {
-        reclaimInFlightPrompt(restoreState, { restoreText, requeueEntries });
+        reclaimInFlightPrompt(restoreState, { restoreText, requeueEntries, handoff: crossDevice });
       }
       restoreState.restorable = false;
       restoreState.requeueEntries = [];
@@ -163,16 +164,19 @@ export function createAbortAction(bag, { acceptingSubmissions }) {
       restorePastedTexts,
       canRestore ? restoreState?.content : null
     );
+    // The canceller never receives another device's prompt.
+    const handedOver = crossDevice && Boolean(restoreText) && aborted !== false;
     return {
       aborted,
-      restoreText,
+      restoreText: handedOver ? '' : restoreText,
       ...(restored.content ? { content: restored.content } : {}),
       ...(restored.notice ? { notice: restored.notice } : {}),
       pastedImages: restored.pastedImages,
       discardPastedImages,
       pastedTexts: restored.pastedTexts,
       discardPastedTexts,
-      restoredSubmissionIds: restoreText ? (restoreState?.submittedIds || []).map(String).filter(Boolean) : [],
+      restoredSubmissionIds:
+        restoreText && !handedOver ? (restoreState?.submittedIds || []).map(String).filter(Boolean) : [],
     };
   };
 

package/src/tui/session/session-api/intake/submission.mjs

@@ -1,14 +1,10 @@
-// Prompt submission: mint the intake, decide between queueing now and queueing
-// after idle auto-clear, and keep every still-accepting submission addressable
-// so Esc can reclaim it before enqueue.
+// Prompt submission: mint the intake and queue it at once, starting idle
+// auto-clear first when the session is idle. Queued prompts are reclaimed by
+// Esc through restoreQueued.
 import { promptDisplayText } from '../../queue-helpers.mjs';
 
 export function createSubmissionIntake(bag) {
   const { runtime, nextId, flags, getState, enqueue, autoClearBeforeSubmit } = bag;
-  // submitAsync may be awaiting auto-clear while the renderer already owns an
-  // optimistic user row. Keep that intake addressable so Esc can reclaim it
-  // before enqueue()/busy publication without racing a delayed snapshot.
-  const acceptingSubmissions = new Map();
 
   const submission = (text, options = {}) => {
     const displayText = promptDisplayText(text, options);
@@ -25,20 +21,17 @@ export function createSubmissionIntake(bag) {
         displayText,
       },
     };
-    acceptingSubmissions.set(intake.queueOptions.id, intake);
     return intake;
   };
 
   const enqueueSubmission = (intake) => {
-    const submissionId = String(intake?.queueOptions?.id || '').trim();
-    if (submissionId) acceptingSubmissions.delete(submissionId);
-    if (intake?.cancelled === true) return false;
     const accepted = enqueue(intake.text, intake.queueOptions);
     // User input wakes a passive `task wait` without cancelling either the
     // turn or the background task. The returned running snapshot creates the
     // normal post-tool boundary, where this queued prompt is injected.
     if (accepted !== false) {
       if ((intake.queueOptions.mode || 'prompt') === 'prompt') {
+        bag.cancelQuotaResumeOnUserInput?.();
         bag.cancelQueuedGoalContinuations?.();
         bag.archiveCompletedGoalOnUserInput?.();
       }
@@ -58,18 +51,17 @@ export function createSubmissionIntake(bag) {
     if (flags.autoClearRunning || getState().commandBusy || getState().busy) {
       return enqueueSubmission(intake) !== false;
     }
-    // If autoClearBeforeSubmit rejects (e.g. compaction timeout throws), the
-    // prompt must still be queued — swallow the rejection so enqueue always
-    // runs and the submit is never silently lost.
-    // A synchronous throw is the same failure as a rejection.
-    let autoClear;
+    // Start idle auto-clear first so commandBusy is raised synchronously, then
+    // queue right away: drain stays blocked until the clear settles, so the
+    // prompt still runs against the cleared conversation, and a later submit
+    // can never be queued ahead of this one. A rejection or synchronous throw
+    // must never lose the prompt.
     try {
-      autoClear = Promise.resolve(autoClearBeforeSubmit());
+      void Promise.resolve(autoClearBeforeSubmit()).catch(() => {});
     } catch {
-      autoClear = Promise.resolve();
+      /* the prompt is queued below regardless */
     }
-    void autoClear.catch(() => {}).then(() => enqueueSubmission(intake));
-    return true;
+    return enqueueSubmission(intake) !== false;
   };
 
   const submitAsync = async (text, options = {}) => {
@@ -107,5 +99,5 @@ export function createSubmissionIntake(bag) {
     return await settled;
   };
 
-  return { acceptingSubmissions, submit, submitAsync, submitAndWait };
+  return { submit, submitAsync, submitAndWait };
 }

package/src/tui/session/session-api/intake.mjs

@@ -2,7 +2,7 @@
  * intake.mjs — the session object's prompt intake and interruption surface:
  * state access/subscription and the reserved-session handshake here, with
  * submit / submitAsync / submitAndWait, abort (which reclaims an in-flight or
- * still-accepting submission back into the draft) and message rewind composed
+ * queued submission back into the draft) and message rewind composed
  * from ./intake/.
  */
 import { createAbortAction } from './intake/abort.mjs';
@@ -24,7 +24,7 @@ export function createSessionIntakeApi(bag) {
     restoreQueued,
     prioritizeQueued,
   } = bag;
-  const { acceptingSubmissions, submit, submitAsync, submitAndWait } = createSubmissionIntake(bag);
+  const { submit, submitAsync, submitAndWait } = createSubmissionIntake(bag);
 
   return {
     getState: () => getPublishedState(),
@@ -49,6 +49,6 @@ export function createSessionIntakeApi(bag) {
     restoreQueued,
     prioritizeQueued,
     ...createRewindAction(bag),
-    ...createAbortAction(bag, { acceptingSubmissions }),
+    ...createAbortAction(bag),
   };
 }