fix(desktop,runtime): interrupt and bound empty assistant loops

apps/desktop/e2e/streaming-remount.spec.ts

@@ -56,7 +56,7 @@ async function submitSteeringDraft(
   await composer.press("ControlOrMeta+Enter");
 }
 
-test("ordinary Enter queues on an already-running Session before observation recovers", async ({
+test("ordinary Enter interrupts an already-running Session before observation recovers", async ({
   window: page,
 }) => {
   const nextPrompt = "do this only after the current answer";
@@ -107,39 +107,34 @@ test("ordinary Enter queues on an already-running Session before observation rec
   const sidebar = page.getByRole("navigation", { name: "任务列表" });
   await ensureSidebarExpanded(page);
   await sessionRow(sidebar, sessionId).click();
-  // No execution snapshot has reached this surface. Sending must still express next-turn intent.
+  // No execution snapshot has reached this surface. Sending must still interrupt
+  // via Host-known running turns rather than queue a follow-up (#4083).
   await expect(
     page.getByRole("button", { name: "停止", exact: true }),
   ).toHaveCount(0);
   const composer = page.locator(COMPOSER_INPUT);
   await composer.fill(nextPrompt);
   await awaitSendReady(page);
   await composer.press("Enter");
-  await expect
-    .poll(() =>
-      page.evaluate(
-        () =>
-          (
-            window as typeof window & {
-              admissionEvidence?: { queued: boolean; steered: boolean };
-            }
-          ).admissionEvidence,
-      ),
-    )
-    .toEqual({ queued: true, steered: false });
+  // After interrupt, the typed draft is admitted as a new root turn — not queued.
+  await expect(page.getByRole("log")).toContainText(nextPrompt, {
+    timeout: 20_000,
+  });
+  expect(
+    await page.evaluate(
+      () =>
+        (
+          window as typeof window & {
+            admissionEvidence?: { queued: boolean; steered: boolean };
+          }
+        ).admissionEvidence,
+    ),
+  ).toEqual({ queued: false, steered: false });
   await page.evaluate(() =>
     (window as SessionObservationLatchWindow).makaE2eLatch!.release(
       "sessions.observe",
     ),
   );
-  await expect(page.locator(".maka-bubble-streaming")).toContainText(
-    "Fake backend waiting",
-    { timeout: 20_000 },
-  );
-  await page.getByRole("button", { name: "停止", exact: true }).click();
-  await expect(
-    page.getByRole("button", { name: "停止", exact: true }),
-  ).toHaveCount(0, { timeout: 20_000 });
 });
 
 test("a failed transcript open recovers when its Session observation becomes ready", async ({

apps/desktop/src/main/__tests__/app-shell-stop-action.test.ts

@@ -46,8 +46,7 @@ test('removes exactly the transient messages the Host retracts while stopping',
       toastApi: { error() {} },
     });
 
-    await stop();
-
+    assert.equal(await stop(), 'interrupted');
     assert.deepEqual(removed, [
       { sessionId: 'session-1', messageId: 'message-1' },
       { sessionId: 'session-1', messageId: 'message-2' },
@@ -56,3 +55,172 @@ test('removes exactly the transient messages the Host retracts while stopping',
     target.window = previousWindow;
   }
 });
+
+test('reports a thrown stop as failed after toasting it', async () => {
+  const target = globalThis as unknown as { window?: unknown };
+  const previousWindow = target.window;
+  const errors: string[] = [];
+  target.window = {
+    maka: {
+      sessions: {
+        stop: async () => {
+          throw new Error('stop failed');
+        },
+      },
+    },
+  };
+  try {
+    const stop = createStopAction({
+      services: windowSubmissionServices(),
+      uiLocale: 'en',
+      activeIdRef: { current: 'session-1' },
+      stopPending: { claim: () => true, release: () => undefined },
+      removeTransientMessage: () => undefined,
+      toastApi: {
+        error(title) {
+          errors.push(title);
+        },
+      },
+    });
+
+    assert.equal(await stop(), 'failed');
+    assert.equal(errors.length, 1);
+  } finally {
+    target.window = previousWindow;
+  }
+});
+
+test('reports a Host no-op stop as not_running when expectedTurnId is pinned', async () => {
+  const target = globalThis as unknown as { window?: unknown };
+  const previousWindow = target.window;
+  const stopped: Array<{ sessionId: string; options: unknown }> = [];
+  target.window = {
+    maka: {
+      sessions: {
+        stop: async (sessionId: string, options?: unknown) => {
+          stopped.push({ sessionId, options });
+          // Host returns undefined when expectedTurnId no longer matches the
+          // live root (settled or replaced by a newer turn).
+          return undefined;
+        },
+      },
+    },
+  };
+  try {
+    const stop = createStopAction({
+      services: windowSubmissionServices(),
+      uiLocale: 'en',
+      activeIdRef: { current: 'session-1' },
+      stopPending: { claim: () => true, release: () => undefined },
+      removeTransientMessage: () => undefined,
+      toastApi: { error() {} },
+    });
+
+    assert.equal(await stop('session-1', 'turn-a'), 'not_running');
+    assert.deepEqual(stopped, [
+      {
+        sessionId: 'session-1',
+        options: { source: 'stop_button', expectedTurnId: 'turn-a' },
+      },
+    ]);
+  } finally {
+    target.window = previousWindow;
+  }
+});
+
+test('stops the captured Session when the active id changes during the await', async () => {
+  const target = globalThis as unknown as { window?: unknown };
+  const previousWindow = target.window;
+  const stopped: Array<{ sessionId: string; options: unknown }> = [];
+  const activeIdRef = { current: 'session-a' as string | undefined };
+  let release!: () => void;
+  const gate = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  target.window = {
+    maka: {
+      sessions: {
+        stop: async (sessionId: string, options?: unknown) => {
+          stopped.push({ sessionId, options });
+          await gate;
+          return { kind: 'interrupted', retractedMessageIds: [] };
+        },
+      },
+    },
+  };
+  try {
+    const stop = createStopAction({
+      services: windowSubmissionServices(),
+      uiLocale: 'en',
+      activeIdRef,
+      stopPending: { claim: () => true, release: () => undefined },
+      removeTransientMessage: () => undefined,
+      toastApi: { error() {} },
+    });
+
+    const pending = stop('session-a', 'turn-1');
+    activeIdRef.current = 'session-b';
+    release();
+    assert.equal(await pending, 'interrupted');
+    assert.deepEqual(stopped, [
+      { sessionId: 'session-a', options: { source: 'stop_button', expectedTurnId: 'turn-1' } },
+    ]);
+  } finally {
+    target.window = previousWindow;
+  }
+});
+
+test('a second stop for the same Session awaits the one in flight', async () => {
+  let release!: () => void;
+  const gate = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  let hostCalls = 0;
+  let held = false;
+  const stop = createStopAction({
+    services: {
+      stop: async () => {
+        hostCalls += 1;
+        await gate;
+        return { kind: 'interrupted', retractedMessageIds: [] };
+      },
+    },
+    uiLocale: 'en',
+    activeIdRef: { current: 'session-1' },
+    stopPending: {
+      claim: () => (held ? false : (held = true)),
+      release: () => {
+        held = false;
+      },
+    },
+    removeTransientMessage: () => undefined,
+    toastApi: { error() {} },
+    inFlight: new Map(),
+  });
+
+  const first = stop('session-1');
+  const second = stop('session-1', 'turn-1');
+  release();
+  assert.deepEqual(await Promise.all([first, second]), ['interrupted', 'interrupted']);
+  assert.equal(hostCalls, 1);
+});
+
+test('reports busy when another owner holds the stop claim', async () => {
+  let hostCalls = 0;
+  const stop = createStopAction({
+    services: {
+      stop: async () => {
+        hostCalls += 1;
+        return undefined;
+      },
+    },
+    uiLocale: 'en',
+    activeIdRef: { current: 'session-1' },
+    stopPending: { claim: () => false, release: () => undefined },
+    removeTransientMessage: () => undefined,
+    toastApi: { error() {} },
+  });
+
+  assert.equal(await stop('session-1'), 'busy');
+  assert.equal(hostCalls, 0);
+});