fix(desktop): clarify delivery states and recover failed messages

apps/desktop/e2e-budget.json

@@ -42,8 +42,8 @@
       "electron": "needs a second real Session (Host round trip) to switch to; the focus and draft-restore halves alone would not earn a window"
     },
     "session-local-recovery.spec.ts": {
-      "tests": 3,
-      "electron": "SQLite admission crosses preload and main, survives both renderer reload and complete Electron restart, and cached history must render when the live IPC endpoint is unavailable"
+      "tests": 6,
+      "electron": "SQLite admission crosses preload and main, survives renderer reload and complete Electron restart, and cached history renders without live IPC. Failed-message recovery reads original bytes, fences drafts, and preserves one-shot slash intent through the real composer/Main path. Stop retractions remain retired across offline navigation and application restart. Failed-message alignment with transcript turns is covered by the FailedLocalMessage Storybook play function."
     },
     "session-workbar.spec.ts": {
       "tests": 5,

apps/desktop/e2e/fixtures.ts

@@ -446,7 +446,7 @@ export async function withE2eWindow(
     /** Attaches captured main/renderer console output when the test fails. */
     testInfo?: TestInfo;
   },
-  use: (page: Page, context: { userDataDir: string; app: ElectronApplication; restart(): Promise<Page> }) => Promise<void>,
+  use: (page: Page, context: { userDataDir: string; app: ElectronApplication; restart(beforeReady?: (app: ElectronApplication) => Promise<void>): Promise<Page> }) => Promise<void>,
 ): Promise<void> {
   const userDataDir = await mkdtemp(path.join(tmpdir(), 'maka-e2e-'));
   // Lives inside the throwaway userData dir so the existing teardown removes
@@ -532,7 +532,7 @@ export async function withE2eWindow(
       throw new Error(`${detail}${mainDetail}${rendererDetail}`, { cause: error });
     }
     try {
-      await use(page, { userDataDir, app, restart: async () => {
+      await use(page, { userDataDir, app, restart: async (beforeReady) => {
       await closeElectronApplication(app!, 5_000);
       app = await electron.launch({
         args: ['.', ...(visibleWindow ? inactiveWindowPlatformArgs() : [])],
@@ -545,6 +545,7 @@ export async function withE2eWindow(
         if (rendererLogs.length > 30) rendererLogs.shift();
       });
       app.context().on('page', watchCrash);
+      await beforeReady?.(app);
       await restored.waitForSelector(readinessSelector, { timeout: readinessTimeoutMs });
       return restored;
     } });
@@ -579,7 +580,7 @@ export async function withE2eWindow(
 }
 
 type E2eTestFixtures = {
-  sessionLocalWindow: { page: Page; app: ElectronApplication; restart(): Promise<Page> };
+  sessionLocalWindow: { page: Page; app: ElectronApplication; restart(beforeReady?: (app: ElectronApplication) => Promise<void>): Promise<Page> };
   window: Page;
   gitReviewWindow: { page: Page; projectRoot: string };
   invocableSkillsWindow: Page;

apps/desktop/src/main/__tests__/app-shell-revision-resend.test.ts

@@ -102,6 +102,7 @@ function userMessage(turnId: string, text: string): StoredMessage {
 }
 
 interface RevisionWorld {
+  ports: RevisionSendPorts<TurnRevisionDraft>;
   revisionActions: {
     beginEditUserMessage: (turnId: string) => void;
   };
@@ -259,6 +260,7 @@ async function mountRevisionWorld(): Promise<RevisionWorld> {
     retractedWorkspaceReferencesRef: { current: {} },
     captureStaging: () => ({
       draftKey: 'draft',
+      retainAttachments: () => () => {},
       hasPendingContext: false,
       hasStagedQuotes: false,
       submittableAttachments: undefined,
@@ -355,6 +357,7 @@ async function mountRevisionWorld(): Promise<RevisionWorld> {
   });
 
   return {
+    ports,
     revisionActions,
     composer,
     document,
@@ -413,3 +416,64 @@ test('resending an unchanged revision goes through reviseBeforeTurn and the norm
     world.restoreWindow();
   }
 });
+
+for (const text of ['edited message', '/swarm task edited message', '/graph task edited message']) {
+  test(`submit preserves replacement and attachment ownership: ${text}`, async () => {
+    const world = await mountRevisionWorld();
+    try {
+      const staging = { ...world.ports.captureStaging(), submittableAttachments: [{
+        stagingKey: 'restored-file', displayName: 'notes.txt', kind: 'doc', size: 4,
+        source: { type: 'approval', approvalId: 'restored-approval', name: 'notes.txt' },
+      }] as NonNullable<ReturnType<typeof world.ports.captureStaging>['submittableAttachments']> };
+      const events: string[] = [];
+      let finish!: (ok: boolean) => void;
+      const result = new Promise<boolean>((resolve) => { finish = resolve; });
+      const onSend = createRevisionAwareOnSend({
+        ...world.ports,
+        captureStaging: () => ({
+          ...staging,
+          clearSubmittedContext: () => { assert.fail('refused send must retain context'); },
+          retainAttachments: (pending) => {
+            assert.equal(pending, staging.submittableAttachments);
+            events.push('retain');
+            return () => { events.push('release'); };
+          },
+        }),
+        setNewTaskSendPending: (pending) => { events.push(`pending:${pending}`); },
+        send: async (_text, _pending, options) => {
+          assert.equal(_pending, staging.submittableAttachments);
+          assert.equal(options?.replacesLocalMessageId, 'paused-original');
+          events.push('send');
+          return result;
+        },
+      });
+      const sent = onSend(text, { replacesLocalMessageId: 'paused-original' });
+      assert.deepEqual(events, ['retain', 'pending:true', 'send']);
+      finish(false);
+      assert.equal(await sent, false);
+      assert.deepEqual(events, ['retain', 'pending:true', 'send', 'release', 'pending:false']);
+    } finally {
+      world.restoreWindow();
+    }
+  });
+}
+
+test('submit releases attachment ownership when sending throws', async () => {
+  const world = await mountRevisionWorld();
+  try {
+    const events: string[] = [];
+    const onSend = createRevisionAwareOnSend({
+      ...world.ports,
+      captureStaging: () => ({ ...world.ports.captureStaging(), retainAttachments: () => {
+        events.push('retain');
+        return () => { events.push('release'); };
+      } }),
+      setNewTaskSendPending: (pending) => { events.push(`pending:${pending}`); },
+      send: async () => { throw new Error('send failed'); },
+    });
+    await assert.rejects(onSend('edited message'), /send failed/);
+    assert.deepEqual(events, ['retain', 'pending:true', 'release', 'pending:false']);
+  } finally {
+    world.restoreWindow();
+  }
+});

apps/desktop/src/main/__tests__/chat-view-optimistic-render.test.ts

@@ -72,6 +72,12 @@ const OPTIMISTIC_BUBBLE: TransientUserMessageProjection = {
   transientPlacement: 'transcript',
 };
 
+const ACTIVE_SESSION: NonNullable<ComponentProps<typeof ChatView>['activeSession']> = {
+  id: 'session-1', name: 'pending', status: 'active', backend: 'ai-sdk',
+  labels: [], isFlagged: false, isArchived: false, hasUnread: false,
+  llmConnectionSlug: 'conn', connectionLocked: false, model: 'model', permissionMode: 'ask',
+};
+
 test('ChatView renders the optimistic bubble and running status before a session exists', () => {
   const markup = renderChatView({
     transientMessages: [{ ...OPTIMISTIC_BUBBLE, hostTurnId: 'turn-1' }],
@@ -111,11 +117,7 @@ test('a prompt on its way to the Host holds its Turn place beside a copy that di
 
 test('ordinary sends stay in ChatView while queued prompts stay in the composer', () => {
   const render = (message: TransientUserMessageProjection) => parseHTML(renderChatView({
-    activeSession: {
-      id: 'session-1', name: 'pending', status: 'active', backend: 'ai-sdk',
-      labels: [], isFlagged: false, isArchived: false, hasUnread: false,
-      llmConnectionSlug: 'conn', connectionLocked: false, model: 'model', permissionMode: 'ask',
-    },
+    activeSession: ACTIVE_SESSION,
     transientMessages: [message],
   }, createElement(Composer, {
     pendingMessages: [message], onSend() {}, onStop() {},
@@ -138,3 +140,27 @@ test('ordinary sends stay in ChatView while queued prompts stay in the composer'
   assert.ok(followUp.querySelector('.maka-composer-queue')?.textContent?.includes(OPTIMISTIC_BUBBLE.text));
   assert.equal(followUp.querySelector('.maka-user-message'), null, 'a follow-up stays out of the transcript');
 });
+
+test('failed local feedback remains outside a Host Turn while ordinary prompts group by its identity', () => {
+  for (const failed of [false, true]) {
+    const message: TransientUserMessageProjection = {
+      ...OPTIMISTIC_BUBBLE, hostTurnId: 'host-turn',
+      ...(failed ? {
+        deliveryStatus: 'Message not sent', deliveryTone: 'danger',
+        deliveryActions: [{ label: 'Edit and resend', onClick() {} }],
+      } as const : {}),
+    };
+    const { document } = parseHTML(renderChatView({
+      activeSession: ACTIVE_SESSION,
+      messages: [{ type: 'turn_state', id: 'started', turnId: 'host-turn', ts: 2, status: 'running' }],
+      activeTurn: { turnId: 'host-turn' },
+      transientMessages: [message],
+    }));
+    const prompt = document.querySelector('[data-transient-message-id="turn-1"]')!;
+    assert.ok(prompt, 'the local prompt remains visible exactly once');
+    assert.equal(document.querySelectorAll('[data-transient-message-id="turn-1"]').length, 1);
+    assert.equal(Boolean(prompt.closest('[data-transcript-turn-id="host-turn"]')), !failed);
+    assert.equal(Boolean(prompt.querySelector('.maka-message-delivery')), failed);
+    if (failed) assert.match(prompt.textContent!, /Edit and resend/);
+  }
+});

apps/desktop/src/main/__tests__/composer-directories.test.ts

@@ -17,13 +17,14 @@
  * under the License.
  */
 
-import { useComposerAttachments } from '../../renderer/features/conversation/testing.js';
+import { stubConversationServices, useComposerAttachments } from '../../renderer/features/conversation/testing.js';
 import assert from 'node:assert/strict';
 import { afterEach, test } from 'node:test';
 import { act, createElement } from 'react';
 import { LocaleProvider } from '@maka/ui';
 import { normalizeSessionSendCommand } from '../permission-response-guard.js';
 import {
+  ConversationServicesProvider,
   type ComposerAttachmentService,
 } from '../../renderer/features/conversation/index.js';
 import { cleanupFakeDom, installReactRenderer } from './fake-dom.js';
@@ -34,6 +35,22 @@ type Picker = NonNullable<ComposerAttachmentService['pickDirectory']>;
 type Options = { draftKey: string; hostId?: string; pick: Picker };
 type State = ReturnType<typeof useComposerAttachments>;
 const reference = { hostId: 'host-a', path: '/workspace/source' };
+const services = stubConversationServices({
+  listMessages: async () => [],
+  readFailedMessage: async () => { throw new Error('unused'); },
+  releaseRecoveryAttachments: async () => {},
+  cancelMessage: async () => {}, reconcileMessage: async () => {}, subscribeChanges: () => () => {},
+  sessions: {
+    readSnapshot: async () => { throw new Error('unused'); },
+    readExecutionBoundary: async () => { throw new Error('unused'); },
+  },
+  runtimeHosts: { subscribeChanges: () => () => {} },
+  skills: { listInvocable: async () => [] },
+  workspace: { searchFiles: async () => ({ ok: false, reason: 'no_project' }) },
+  newTasks: { subscribeChanges: () => () => {}, listInvocableSkills: async () => [],
+    searchFiles: async () => ({ ok: false, reason: 'no_project' }) },
+  mcp: { subscribeChanges: () => () => {} },
+});
 
 async function mount(initial: Partial<Options> = {}) {
   const { root } = installReactRenderer();
@@ -60,7 +77,9 @@ async function mount(initial: Partial<Options> = {}) {
   }
   const render = async (patch: Partial<Options> = {}) => {
     options = { ...options, ...patch };
-    await act(() => root.render(createElement(LocaleProvider, { locale: 'en', children: createElement(Probe) })));
+    await act(() => root.render(createElement(LocaleProvider, { locale: 'en',
+      children: createElement(ConversationServicesProvider, { services, children: createElement(Probe) }),
+    })));
   };
   await render();
   return { state: () => state, render, errors };
@@ -126,6 +145,26 @@ test('caps concurrent picker results and clearing a submitted draft keeps newer
   assert.equal(probe.state().pendingDirectories.length, 1, 'must not clear a reference added after send');
 });
 
+test('live directory context is Host-scoped and submitted cleanup preserves newer references', async () => {
+  const probe = await mount();
+  await act(() => probe.state().directoryComposerProps.onPickDirectory!());
+  const submitted = probe.state();
+  assert.equal(submitted.hasPendingContextNow(), true);
+  await probe.render({ hostId: 'host-b' });
+  assert.equal(probe.state().hasPendingContextNow(), false);
+  await probe.render({ hostId: 'host-a', pick: async () => ({
+    ok: true, reference: { ...reference, path: '/workspace/new' },
+  }) });
+  await act(async () => {
+    await probe.state().directoryComposerProps.onPickDirectory!();
+    submitted.clearSubmittedContext();
+    assert.equal(probe.state().hasPendingContextNow(), true);
+    probe.state().directoryComposerProps.onRemoveDirectory(0);
+    assert.equal(probe.state().hasPendingContextNow(), false);
+  });
+  assert.deepEqual(probe.state().pendingDirectories, []);
+});
+
 test('IPC validates directory references without turning them into attachments or permissions', () => {
   const normalized = normalizeSessionSendCommand({
     type: 'send', text: 'inspect', directoryReferences: [reference],

apps/desktop/src/main/__tests__/composer-mentions.test.ts

@@ -135,6 +135,7 @@ function installCatalogRenderer(t: TestContext) {
             value: sessionCatalog,
             children: createElement(ComposerStagingFixture, {
               draftKey: sessionId,
+              conversationServices: services,
               children: createElement(ComposerMentionsProvider, {
               sessionId,
               projectPath,

apps/desktop/src/main/__tests__/composer-staging-fixture.ts

@@ -20,10 +20,12 @@
 import { createElement, useMemo, type ReactNode } from 'react';
 import { AstryxLocaleProvider, ToastProvider } from '@maka/ui';
 import {
-  ComposerStagingProvider, ComposerStagingServicesProvider, createComposerStagingCommands,
-  type ComposerStagingCommands, type ComposerStagingServices,
+  ComposerStagingProvider, ComposerStagingServicesProvider, createComposerStagingCommands, ConversationServicesProvider,
+  type ComposerStagingCommands, type ComposerStagingServices, type ConversationServices,
 } from '../../renderer/features/conversation/index.js';
 
+import { stubConversationServices } from '../../renderer/features/conversation/testing.js';
+
 const emptyServices: ComposerStagingServices = {
   pickFiles: async () => ({ ok: false, reason: 'cancelled' }),
   previewApproval: async () => ({ ok: false, reason: 'unavailable' }),
@@ -36,10 +38,12 @@ export function ComposerStagingFixture(props: {
   readonly directoryHostId?: string;
   readonly commands?: ComposerStagingCommands;
   readonly services?: ComposerStagingServices;
+  readonly conversationServices?: ConversationServices;
   readonly children?: ReactNode;
 }) {
   const fallbackCommands = useMemo(createComposerStagingCommands, []);
-  return createElement(AstryxLocaleProvider, {
+  const fallbackServices = useMemo(() => stubConversationServices(), []);
+  return createElement(ConversationServicesProvider, { services: props.conversationServices ?? fallbackServices, children: createElement(AstryxLocaleProvider, {
     children: createElement(ToastProvider, {
       children: createElement(ComposerStagingServicesProvider, {
         services: props.services ?? emptyServices,
@@ -51,5 +55,5 @@ export function ComposerStagingFixture(props: {
         }),
       }),
     }),
-  });
+  }) });
 }