fix(web): keep report-only Design runs off the ARTIFACT_NOT_FOUND path (#5724)

A successful Design turn with zero produced files is only a missing
deliverable when the run actually attempted to mutate project files.
Image-analysis and report-only audit turns answer in prose without ever
calling a write tool; classify them as report_only and let them finish
as normal text results instead of appending ARTIFACT_NOT_FOUND.

Author: lefarcen

apps/web/src/runtime/design-delivery.ts

@@ -1,11 +1,13 @@
 import type { ChatSessionMode } from '@open-design/contracts';
 import type { AgentEvent, ChatMessage } from '../types';
+import { hasFileMutationToolUse } from './file-ops';
 import { unfinishedTodosFromEvents } from './todos';
 
 export type DesignDeliveryOutcome =
   | 'not_required'
   | 'awaiting_input'
   | 'delivered'
+  | 'report_only'
   | 'no_result'
   | 'delivery_failed';
 
@@ -60,6 +62,14 @@ function hasLiveArtifactDelivery(events: AgentEvent[] | undefined): boolean {
  * Design mode is artifact-first, but clarification and explicitly unfinished
  * turns are valid intermediate outcomes. Chat and Plan remain text-first and
  * must never be failed merely because they did not write a project file.
+ *
+ * A zero-file success is only a missing deliverable when the turn attempted
+ * to mutate project files (or an artifact save failed). A turn that never
+ * tried to write and answered with substantive text is a report-only result —
+ * image analysis and report-only audits end exactly this way — and must not
+ * be downgraded to ARTIFACT_NOT_FOUND. The known cost: an agent that merely
+ * claims completion without ever calling a write tool now passes as text; the
+ * text itself makes that visible to the user.
  */
 export function resolveDesignDeliveryOutcome(
   input: DesignDeliveryInput,
@@ -78,7 +88,11 @@ export function resolveDesignDeliveryOutcome(
   ) {
     return 'delivered';
   }
-  return input.persistenceFailed ? 'delivery_failed' : 'no_result';
+  if (input.persistenceFailed) return 'delivery_failed';
+  if (!hasFileMutationToolUse(input.events) && input.content.trim().length > 0) {
+    return 'report_only';
+  }
+  return 'no_result';
 }
 
 /**

apps/web/src/runtime/file-ops.ts

@@ -129,6 +129,25 @@ export function deriveFileOps(events: AgentEvent[] | undefined): FileOpEntry[] {
   return Array.from(byPath.values());
 }
 
+/**
+ * True when the run attempted any file mutation (write/edit/delete tool call,
+ * or a simple Bash rm/unlink), regardless of whether the attempt succeeded.
+ * Tool names must stay aligned with the daemon's cross-runtime
+ * `WRITE_OR_EDIT_TOOL_NAMES` set in `apps/daemon/src/runtimes/run-artifacts.ts`.
+ */
+export function hasFileMutationToolUse(events: AgentEvent[] | undefined): boolean {
+  for (const ev of events ?? []) {
+    if (ev.kind !== 'tool_use') continue;
+    if (ev.name === 'Bash') {
+      if (extractSimpleBashDeletes(ev.input).length > 0) return true;
+      continue;
+    }
+    const kind = classify(ev.name);
+    if (kind === 'write' || kind === 'edit' || kind === 'delete') return true;
+  }
+  return false;
+}
+
 export type FileOpCounts = Record<FileOpKind, number>;
 
 /** Total tool_use count per op family across `entries`. */

apps/web/tests/components/ProjectView.api-empty-response.test.tsx

@@ -403,7 +403,10 @@ describe('ProjectView API empty response handling', () => {
     });
   });
 
-  it('records no_result without downgrading a successful Design run', async () => {
+  it('keeps a text-only successful Design run as a report-only success', async () => {
+    // Report-only turns (image analysis, audits) legitimately end with prose
+    // and zero produced files (#5714, #5718). They must not be downgraded to
+    // ARTIFACT_NOT_FOUND.
     mockedStreamViaDaemon.mockImplementation(async (options: DaemonStreamOptions) => {
       const { handlers } = options;
       handlers.onDelta('hello');
@@ -413,6 +416,39 @@ describe('ProjectView API empty response handling', () => {
 
     await sendTestPrompt();
 
+    await waitFor(() => expect(screen.getAllByText('hello').length).toBeGreaterThan(0));
+    await waitFor(() => {
+      expect(
+        hasSavedAssistantMessage(
+          (message) =>
+            message.runStatus === 'succeeded' &&
+            message.resultDeliveryState === undefined &&
+            message.producedFiles !== undefined &&
+            message.events?.some(
+              (event) => event.kind === 'status' && event.code === 'ARTIFACT_NOT_FOUND',
+            ) !== true,
+        ),
+      ).toBe(true);
+    });
+    expect(screen.queryByText(/without producing a deliverable project file/i)).toBeNull();
+  });
+
+  it('records no_result when a Design run attempted file writes that never landed', async () => {
+    mockedStreamViaDaemon.mockImplementation(async (options: DaemonStreamOptions) => {
+      const { handlers } = options;
+      handlers.onAgentEvent({
+        kind: 'tool_use',
+        id: 'write-1',
+        name: 'Write',
+        input: { file_path: 'index.html', content: '<!doctype html>' },
+      });
+      handlers.onDelta('hello');
+      handlers.onDone('hello');
+    });
+    renderProjectView();
+
+    await sendTestPrompt();
+
     await waitFor(() => expect(screen.getAllByText('hello').length).toBeGreaterThan(0));
     await waitFor(() => {
       expect(
@@ -548,6 +584,12 @@ describe('ProjectView API empty response handling', () => {
   it('waits for delivery verification before playing the failure sound for a missing result', async () => {
     mockedStreamViaDaemon.mockImplementation(async (options: DaemonStreamOptions) => {
       const { handlers } = options;
+      handlers.onAgentEvent({
+        kind: 'tool_use',
+        id: 'write-1',
+        name: 'Write',
+        input: { file_path: 'index.html', content: '<!doctype html>' },
+      });
       handlers.onDelta('hello');
       handlers.onDone('hello');
     });

apps/web/tests/components/ProjectView.run-isolation.test.tsx

@@ -932,13 +932,21 @@ describe('ProjectView conversation run isolation', () => {
     expect(showCompletionNotification).not.toHaveBeenCalled();
   });
 
-  it('downgrades a reloaded terminal Design run with prose but no delivered file', async () => {
+  it('downgrades a reloaded terminal Design run whose file writes never landed', async () => {
     conversationAMessages = [
       {
         ...succeededAssistant,
         content: '',
         sessionMode: 'design',
-        events: [{ kind: 'text', text: 'I finished the design.' }],
+        events: [
+          { kind: 'text', text: 'I finished the design.' },
+          {
+            kind: 'tool_use',
+            id: 'write-1',
+            name: 'Write',
+            input: { file_path: 'index.html', content: '<!doctype html>' },
+          },
+        ],
         preTurnFileNames: [],
         producedFiles: undefined,
         traceObjectFiles: undefined,
@@ -981,6 +989,54 @@ describe('ProjectView conversation run isolation', () => {
     expect(reattachDaemonRun).not.toHaveBeenCalled();
   });
 
+  it('keeps a reloaded report-only Design run without file writes on the success path', async () => {
+    // Prose-only turns (image analysis, audits) are legitimate zero-file
+    // Design results (#5714, #5718); reload must not downgrade them.
+    conversationAMessages = [
+      {
+        ...succeededAssistant,
+        content: '',
+        sessionMode: 'design',
+        events: [{ kind: 'text', text: 'The hero image contrast is too low.' }],
+        preTurnFileNames: [],
+        producedFiles: undefined,
+        traceObjectFiles: undefined,
+      },
+    ];
+    fetchChatRunStatus.mockResolvedValue({
+      id: 'run-a',
+      status: 'succeeded',
+      createdAt: 1,
+      updatedAt: 2,
+      exitCode: 0,
+      signal: null,
+    });
+
+    renderProjectView();
+
+    await waitFor(() => {
+      const recoveredMessage = saveMessage.mock.calls
+        .map((call) => call[2] as ChatMessage)
+        .find(
+          (message) =>
+            message.id === succeededAssistant.id && message.producedFiles !== undefined,
+        );
+      expect(recoveredMessage).toMatchObject({
+        runStatus: 'succeeded',
+        producedFiles: [],
+        traceObjectFiles: [],
+      });
+      expect(recoveredMessage?.resultDeliveryState).toBeUndefined();
+      expect(recoveredMessage?.events).not.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ code: 'ARTIFACT_NOT_FOUND' }),
+        ]),
+      );
+    });
+    expect(screen.getByTestId('chat-error').textContent).toBe('');
+    expect(reattachDaemonRun).not.toHaveBeenCalled();
+  });
+
   it('does not reload or reattach when selecting the active streaming conversation', async () => {
     renderProjectView();
 

apps/web/tests/runtime/design-delivery.test.ts

@@ -5,7 +5,24 @@ import {
 } from '../../src/runtime/design-delivery';
 
 describe('resolveDesignDeliveryOutcome', () => {
-  it('requires file delivery for a successfully completed Design-mode turn', () => {
+  it('treats a text answer without any file-write attempt as a report-only result', () => {
+    // Image analysis / report-only audits legitimately end with prose and no
+    // new project file (#5714, #5718). Only fail delivery when the agent
+    // actually attempted to write files and nothing landed.
+    expect(
+      resolveDesignDeliveryOutcome({
+        sessionMode: 'design',
+        runStatus: 'succeeded',
+        content: 'The hero image uses low contrast; increase it for readability.',
+        events: [
+          { kind: 'tool_use', id: 'read-1', name: 'Read', input: { file_path: 'hero.png' } },
+        ],
+        producedFileCount: 0,
+        traceObjectFileCount: 0,
+      }),
+    ).toBe('report_only');
+    // BYOK API runs have no tool events at all; a substantive text answer is
+    // still a report-only result, not a missing artifact.
     expect(
       resolveDesignDeliveryOutcome({
         sessionMode: 'design',
@@ -15,6 +32,38 @@ describe('resolveDesignDeliveryOutcome', () => {
         producedFileCount: 0,
         traceObjectFileCount: 0,
       }),
+    ).toBe('report_only');
+  });
+
+  it('requires file delivery once the turn attempted to write project files', () => {
+    for (const attempt of [
+      { kind: 'tool_use' as const, id: 'w-1', name: 'Write', input: { file_path: 'index.html' } },
+      { kind: 'tool_use' as const, id: 'e-1', name: 'Edit', input: { file_path: 'index.html' } },
+      { kind: 'tool_use' as const, id: 'b-1', name: 'Bash', input: { command: 'rm stale.html' } },
+    ]) {
+      expect(
+        resolveDesignDeliveryOutcome({
+          sessionMode: 'design',
+          runStatus: 'succeeded',
+          content: 'I finished the design.',
+          events: [attempt],
+          producedFileCount: 0,
+          traceObjectFileCount: 0,
+        }),
+      ).toBe('no_result');
+    }
+  });
+
+  it('does not accept an empty answer as a report-only result', () => {
+    expect(
+      resolveDesignDeliveryOutcome({
+        sessionMode: 'design',
+        runStatus: 'succeeded',
+        content: '   ',
+        events: [],
+        producedFileCount: 0,
+        traceObjectFileCount: 0,
+      }),
     ).toBe('no_result');
   });
 
@@ -84,6 +133,22 @@ describe('resolveDesignDeliveryOutcome', () => {
     ).toBe('delivery_failed');
   });
 
+  it('keeps a failed artifact save a failure even without file-write tool calls', () => {
+    // A BYOK <artifact> block that failed to persist is a delivery failure;
+    // the report-only escape must never mask it.
+    expect(
+      resolveDesignDeliveryOutcome({
+        sessionMode: 'design',
+        runStatus: 'succeeded',
+        content: 'Here is the landing page you asked for.',
+        events: [],
+        producedFileCount: 0,
+        traceObjectFileCount: 0,
+        persistenceFailed: true,
+      }),
+    ).toBe('delivery_failed');
+  });
+
   it('does not fail clarification turns or turns with explicitly unfinished work', () => {
     expect(
       resolveDesignDeliveryOutcome({