@taskforcehq/taskforce 0.3.169 → 0.3.300

package/dist/components/features/DocumentWorkspace.test.js

@@ -0,0 +1,1202 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { buildPrintDocumentHtml, DocumentViewer, schedulePrintCleanup } from './DocumentViewer';
+import { DocumentGenerateModal } from './DocumentGenerateModal';
+import { DocumentWorkspace, DocumentWorkspaceShell } from './DocumentWorkspace';
+const { fetchTaskforceApi } = vi.hoisted(() => ({
+    fetchTaskforceApi: vi.fn(),
+}));
+vi.mock('../../utils/taskforceApiClient', () => ({
+    fetchTaskforceApi,
+    resolveTaskforceApiUrl: (path) => path,
+}));
+vi.mock('../../utils/documentManagerApi', async () => {
+    const actual = await vi.importActual('../../utils/documentManagerApi');
+    return {
+        ...actual,
+        logDocumentManagerDebug: vi.fn(),
+    };
+});
+function createDoc(overrides = {}) {
+    return {
+        id: 'doc-1',
+        assetId: 'asset-doc-1',
+        fsPath: 'workspaces/default/assets/documents/technical-notes.md',
+        apiUrl: '/api/taskforce/documents/asset-doc-1/content',
+        taskId: null,
+        displayName: 'Technical Notes',
+        title: 'Technical Notes',
+        docType: 'other',
+        sizeBytes: 64,
+        updatedAt: '2026-03-19T11:00:00.000Z',
+        editable: true,
+        attachmentCount: 0,
+        attachmentState: 'unattached',
+        ...overrides,
+    };
+}
+function createEmptyReviewSessionsResponse() {
+    return {
+        ok: true,
+        json: async () => ({ sessions: [] }),
+    };
+}
+describe('Document workspace management', () => {
+    beforeEach(() => {
+        fetchTaskforceApi.mockReset();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+        vi.restoreAllMocks();
+    });
+    it('filters documents by unattached status and shows a badge in the index', async () => {
+        const docs = [
+            {
+                id: 'doc-attached',
+                assetId: 'doc-attached',
+                fsPath: 'workspaces/default/assets/documents/doc-attached.md',
+                apiUrl: '/api/taskforce/documents/doc-attached/content',
+                taskId: 'task-1',
+                displayName: 'Attached notes',
+                title: 'Attached notes',
+                docType: 'other',
+                sizeBytes: 128,
+                updatedAt: '2026-03-19T10:00:00.000Z',
+                editable: true,
+                attachmentCount: 1,
+                attachmentState: 'attached',
+            },
+            {
+                id: 'doc-unattached',
+                assetId: 'doc-unattached',
+                fsPath: 'workspaces/default/assets/documents/doc-unattached.md',
+                apiUrl: '/api/taskforce/documents/doc-unattached/content',
+                taskId: null,
+                displayName: 'Orphan notes',
+                title: 'Orphan notes',
+                docType: 'other',
+                sizeBytes: 64,
+                updatedAt: '2026-03-19T11:00:00.000Z',
+                editable: true,
+                attachmentCount: 0,
+                attachmentState: 'unattached',
+            },
+        ];
+        function Harness() {
+            const [selectedDoc, setSelectedDoc] = useState(null);
+            return (_jsx(DocumentWorkspace, { tasks: [{ id: 'task-1', title: 'Parent task' }], documents: docs, loading: false, error: null, selectedDoc: selectedDoc, searchQuery: "", typeFilters: [], attachmentFilters: ['unattached'], onSearchChange: () => { }, onSelectDoc: setSelectedDoc, onRefresh: () => { } }));
+        }
+        render(_jsx(Harness, {}));
+        expect(screen.getByRole('button', { name: /Orphan notes/i })).toBeInTheDocument();
+        expect(screen.queryByRole('button', { name: /Attached notes/i })).not.toBeInTheDocument();
+        expect(screen.getByText('Unattached')).toBeInTheDocument();
+    });
+    it('keeps document search in the index without duplicate filter controls', () => {
+        render(_jsx(DocumentWorkspace, { tasks: [], documents: [createDoc()], loading: false, error: null, selectedDoc: null, searchQuery: "", typeFilters: [], attachmentFilters: [], onSearchChange: () => { }, onSelectDoc: () => { }, onRefresh: () => { } }));
+        expect(screen.getByPlaceholderText('Search documents…')).toBeInTheDocument();
+        expect(screen.queryByRole('button', { name: 'Attached' })).not.toBeInTheDocument();
+        expect(screen.queryByRole('button', { name: 'Plans' })).not.toBeInTheDocument();
+    });
+    it('shows the document reference badge in the bottom metadata row of index cards', () => {
+        render(_jsx(DocumentWorkspace, { tasks: [], documents: [createDoc({ referenceLabel: 'D-42' })], loading: false, error: null, selectedDoc: null, searchQuery: "", typeFilters: [], attachmentFilters: [], onSearchChange: () => { }, onSelectDoc: () => { }, onRefresh: () => { } }));
+        expect(screen.getByText('D-42')).toBeInTheDocument();
+        expect(screen.getByText(/64B/)).toBeInTheDocument();
+    });
+    it('shows permanent delete only for unattached docs and deletes after confirmation', async () => {
+        const user = userEvent.setup();
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Example\n',
+        })
+            .mockResolvedValueOnce(createEmptyReviewSessionsResponse())
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ success: true, softDeleted: true }),
+        });
+        const confirmSpy = vi.spyOn(window, 'confirm').mockReturnValue(true);
+        const alertSpy = vi.spyOn(window, 'alert').mockImplementation(() => { });
+        const onDeleted = vi.fn();
+        render(_jsx(DocumentViewer, { doc: {
+                id: 'doc-unattached',
+                assetId: 'asset-doc-unattached',
+                fsPath: 'workspaces/default/assets/documents/doc-unattached.md',
+                apiUrl: '/api/taskforce/documents/asset-doc-unattached/content',
+                taskId: null,
+                displayName: 'Unattached spec',
+                title: 'Unattached spec',
+                docType: 'other',
+                sizeBytes: 64,
+                updatedAt: '2026-03-19T11:00:00.000Z',
+                editable: true,
+                attachmentCount: 0,
+                attachmentState: 'unattached',
+            }, taskTitle: null, onDeleted: onDeleted }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenCalledWith('/api/taskforce/documents/asset-doc-unattached/content', { credentials: 'same-origin' }, ''));
+        await user.click(screen.getByRole('button', { name: /Delete Permanently/i }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenLastCalledWith('/api/taskforce/documents/asset-doc-unattached', expect.objectContaining({ method: 'DELETE', credentials: 'include' }), ''));
+        expect(onDeleted).toHaveBeenCalled();
+        confirmSpy.mockRestore();
+        alertSpy.mockRestore();
+    });
+    it('uses same-origin document routes in local runtime even when an api base is configured', async () => {
+        const user = userEvent.setup();
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ documents: [createDoc()] }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Example\n',
+        })
+            .mockResolvedValueOnce(createEmptyReviewSessionsResponse())
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ updatedAt: '2026-03-19T12:00:00.000Z' }),
+        });
+        render(_jsx(DocumentWorkspaceShell, { tasks: [], runtimeMode: "local", apiBaseUrl: "http://127.0.0.1:4280", cloudAuthBaseUrl: "https://cloud.example.com" }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(1, '/api/taskforce/documents', expect.objectContaining({ credentials: 'include' }), ''));
+        await screen.findByText('Technical Notes');
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(2, '/api/taskforce/documents/asset-doc-1/content', expect.objectContaining({ credentials: 'same-origin' }), ''));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(3, '/api/taskforce/document-reviews/sessions?assetId=asset-doc-1', expect.objectContaining({ credentials: 'include' }), ''));
+        await user.click(screen.getByRole('button', { name: /Edit/i }));
+        const editor = await screen.findByPlaceholderText('Write markdown here…');
+        await user.clear(editor);
+        await user.type(editor, '# Updated\n');
+        await user.click(screen.getByRole('button', { name: /^Save$/i }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(4, '/api/taskforce/documents/save', expect.objectContaining({
+            method: 'POST',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+        }), ''));
+    });
+    it('renders document review comments from the document review session API', async () => {
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Example\n',
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                sessions: [{
+                        id: 'review-1',
+                        tenantId: 'default',
+                        workspaceId: 'default',
+                        assetId: 'asset-doc-1',
+                        documentId: 'doc-1',
+                        documentVersion: 1,
+                        title: 'Review 1',
+                        status: 'open',
+                        createdByActorId: 'user',
+                        updatedByActorId: 'user',
+                        createdAt: '2026-03-19T12:00:00.000Z',
+                        updatedAt: '2026-03-19T12:10:00.000Z',
+                        deletedAt: null,
+                        createdByActor: null,
+                        updatedByActor: null,
+                        comments: [{
+                                id: 'comment-1',
+                                order: 0,
+                                body: 'Please tighten the rollout section.',
+                                anchor: { kind: 'line-range', startLine: 18, endLine: 24 },
+                                authorActorId: 'user',
+                                authorActor: {
+                                    id: 'user',
+                                    kind: 'human',
+                                    label: 'You',
+                                    username: 'you',
+                                    icon: 'User',
+                                    color: '#5b8def',
+                                    isNamed: true,
+                                },
+                                createdAt: '2026-03-19T12:05:00.000Z',
+                                updatedAt: '2026-03-19T12:05:00.000Z',
+                                deletedAt: null,
+                            }],
+                    }],
+            }),
+        });
+        render(_jsx(DocumentViewer, { doc: createDoc(), taskTitle: null }));
+        expect(await screen.findByText('Review & Comments')).toBeInTheDocument();
+        expect(await screen.findByText('Please tighten the rollout section.')).toBeInTheDocument();
+        expect(screen.getByText('Lines 18-24')).toBeInTheDocument();
+    });
+    it('creates a review session and posts comments from the document viewer', async () => {
+        const user = userEvent.setup();
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Example\n',
+        })
+            .mockResolvedValueOnce(createEmptyReviewSessionsResponse())
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                session: {
+                    id: 'review-1',
+                    tenantId: 'default',
+                    workspaceId: 'default',
+                    assetId: 'asset-doc-1',
+                    documentId: 'doc-1',
+                    documentVersion: 1,
+                    title: 'Review 1',
+                    status: 'open',
+                    createdByActorId: 'user',
+                    updatedByActorId: 'user',
+                    createdAt: '2026-03-19T12:00:00.000Z',
+                    updatedAt: '2026-03-19T12:00:00.000Z',
+                    deletedAt: null,
+                    createdByActor: null,
+                    updatedByActor: null,
+                    comments: [],
+                },
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                session: {
+                    id: 'review-1',
+                    tenantId: 'default',
+                    workspaceId: 'default',
+                    assetId: 'asset-doc-1',
+                    documentId: 'doc-1',
+                    documentVersion: 1,
+                    title: 'Review 1',
+                    status: 'open',
+                    createdByActorId: 'user',
+                    updatedByActorId: 'user',
+                    createdAt: '2026-03-19T12:00:00.000Z',
+                    updatedAt: '2026-03-19T12:04:00.000Z',
+                    deletedAt: null,
+                    createdByActor: null,
+                    updatedByActor: null,
+                    comments: [{
+                            id: 'comment-1',
+                            order: 0,
+                            body: 'Needs a stronger summary.',
+                            anchor: { kind: 'document' },
+                            authorActorId: 'user',
+                            authorActor: null,
+                            createdAt: '2026-03-19T12:04:00.000Z',
+                            updatedAt: '2026-03-19T12:04:00.000Z',
+                            deletedAt: null,
+                        }],
+                },
+            }),
+        });
+        render(_jsx(DocumentViewer, { doc: createDoc(), taskTitle: null }));
+        await screen.findByText('Review & Comments');
+        await user.type(screen.getByPlaceholderText('Add a comment for this document review…'), 'Needs a stronger summary.');
+        await user.click(screen.getByRole('button', { name: /Send review comment/i }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(3, '/api/taskforce/document-reviews/sessions', expect.objectContaining({
+            method: 'POST',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+        }), ''));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(4, '/api/taskforce/document-reviews/sessions/review-1/comments', expect.objectContaining({
+            method: 'POST',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+        }), ''));
+        expect(await screen.findByText('Needs a stronger summary.')).toBeInTheDocument();
+    });
+    it('anchors a review comment to selected document text', async () => {
+        const user = userEvent.setup();
+        const getSelectionSpy = vi.spyOn(window, 'getSelection');
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Example\n\nSelected rollout sentence for review.\n',
+        })
+            .mockResolvedValueOnce(createEmptyReviewSessionsResponse())
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                session: {
+                    id: 'review-1',
+                    tenantId: 'default',
+                    workspaceId: 'default',
+                    assetId: 'asset-doc-1',
+                    documentId: 'doc-1',
+                    documentVersion: 1,
+                    title: 'Review 1',
+                    status: 'open',
+                    createdByActorId: 'user',
+                    updatedByActorId: 'user',
+                    createdAt: '2026-03-19T12:00:00.000Z',
+                    updatedAt: '2026-03-19T12:00:00.000Z',
+                    deletedAt: null,
+                    createdByActor: null,
+                    updatedByActor: null,
+                    comments: [],
+                },
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                session: {
+                    id: 'review-1',
+                    tenantId: 'default',
+                    workspaceId: 'default',
+                    assetId: 'asset-doc-1',
+                    documentId: 'doc-1',
+                    documentVersion: 1,
+                    title: 'Review 1',
+                    status: 'open',
+                    createdByActorId: 'user',
+                    updatedByActorId: 'user',
+                    createdAt: '2026-03-19T12:00:00.000Z',
+                    updatedAt: '2026-03-19T12:04:00.000Z',
+                    deletedAt: null,
+                    createdByActor: null,
+                    updatedByActor: null,
+                    comments: [{
+                            id: 'comment-1',
+                            order: 0,
+                            body: 'This sentence needs stronger ownership.',
+                            anchor: { kind: 'quote', quote: 'Selected rollout sentence for review.' },
+                            authorActorId: 'user',
+                            authorActor: null,
+                            createdAt: '2026-03-19T12:04:00.000Z',
+                            updatedAt: '2026-03-19T12:04:00.000Z',
+                            deletedAt: null,
+                        }],
+                },
+            }),
+        });
+        render(_jsx(DocumentViewer, { doc: createDoc(), taskTitle: null }));
+        const selectedText = await screen.findByText('Selected rollout sentence for review.');
+        const selectionNode = selectedText.firstChild || selectedText;
+        getSelectionSpy.mockReturnValue({
+            toString: () => 'Selected rollout sentence for review.',
+            rangeCount: 1,
+            getRangeAt: () => ({
+                commonAncestorContainer: selectionNode,
+                startContainer: selectionNode,
+                startOffset: 0,
+                endContainer: selectionNode,
+                endOffset: 'Selected rollout sentence for review.'.length,
+            }),
+        });
+        fireEvent.mouseUp(selectedText);
+        expect(await screen.findByText('"Selected rollout sentence for review."')).toBeInTheDocument();
+        await user.type(screen.getByPlaceholderText('Add a comment for the selected text…'), 'This sentence needs stronger ownership.');
+        await user.click(screen.getByRole('button', { name: /Send review comment/i }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(4, '/api/taskforce/document-reviews/sessions/review-1/comments', expect.objectContaining({
+            method: 'POST',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+        }), ''));
+        const commentRequest = fetchTaskforceApi.mock.calls[3]?.[1];
+        expect(commentRequest).toBeTruthy();
+        const requestBody = JSON.parse(String(commentRequest.body || '{}'));
+        expect(requestBody.anchor).toMatchObject({
+            kind: 'quote',
+            quote: 'Selected rollout sentence for review.',
+        });
+        getSelectionSpy.mockRestore();
+    });
+    it('preserves the selected quote occurrence when text repeats in the document', async () => {
+        const user = userEvent.setup();
+        const getSelectionSpy = vi.spyOn(window, 'getSelection');
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Example\n\nRepeated sentence.\n\nSpacer paragraph.\n\nRepeated sentence.\n',
+        })
+            .mockResolvedValueOnce(createEmptyReviewSessionsResponse())
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                session: {
+                    id: 'review-1',
+                    tenantId: 'default',
+                    workspaceId: 'default',
+                    assetId: 'asset-doc-1',
+                    documentId: 'doc-1',
+                    documentVersion: 1,
+                    title: 'Review 1',
+                    status: 'open',
+                    createdByActorId: 'user',
+                    updatedByActorId: 'user',
+                    createdAt: '2026-03-19T12:00:00.000Z',
+                    updatedAt: '2026-03-19T12:00:00.000Z',
+                    deletedAt: null,
+                    createdByActor: null,
+                    updatedByActor: null,
+                    comments: [],
+                },
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                session: {
+                    id: 'review-1',
+                    tenantId: 'default',
+                    workspaceId: 'default',
+                    assetId: 'asset-doc-1',
+                    documentId: 'doc-1',
+                    documentVersion: 1,
+                    title: 'Review 1',
+                    status: 'open',
+                    createdByActorId: 'user',
+                    updatedByActorId: 'user',
+                    createdAt: '2026-03-19T12:00:00.000Z',
+                    updatedAt: '2026-03-19T12:04:00.000Z',
+                    deletedAt: null,
+                    createdByActor: null,
+                    updatedByActor: null,
+                    comments: [{
+                            id: 'comment-1',
+                            order: 0,
+                            body: 'Use the second repeated sentence.',
+                            anchor: { kind: 'quote', quote: 'Repeated sentence.', occurrenceIndex: 1 },
+                            authorActorId: 'user',
+                            authorActor: null,
+                            createdAt: '2026-03-19T12:04:00.000Z',
+                            updatedAt: '2026-03-19T12:04:00.000Z',
+                            deletedAt: null,
+                        }],
+                },
+            }),
+        });
+        render(_jsx(DocumentViewer, { doc: createDoc(), taskTitle: null }));
+        const repeatedTextNodes = await screen.findAllByText('Repeated sentence.');
+        const secondRepeatedText = repeatedTextNodes[1];
+        const secondSelectionNode = secondRepeatedText.firstChild || secondRepeatedText;
+        getSelectionSpy.mockReturnValue({
+            toString: () => 'Repeated sentence.',
+            rangeCount: 1,
+            getRangeAt: () => ({
+                commonAncestorContainer: secondSelectionNode,
+                startContainer: secondSelectionNode,
+                startOffset: 0,
+                endContainer: secondSelectionNode,
+                endOffset: 'Repeated sentence.'.length,
+            }),
+        });
+        fireEvent.mouseUp(secondRepeatedText);
+        await user.type(screen.getByPlaceholderText('Add a comment for the selected text…'), 'Use the second repeated sentence.');
+        await user.click(screen.getByRole('button', { name: /Send review comment/i }));
+        const commentRequest = fetchTaskforceApi.mock.calls[3]?.[1];
+        expect(commentRequest).toBeTruthy();
+        const requestBody = JSON.parse(String(commentRequest.body || '{}'));
+        expect(requestBody.anchor).toMatchObject({
+            kind: 'quote',
+            quote: 'Repeated sentence.',
+            occurrenceIndex: 1,
+        });
+        getSelectionSpy.mockRestore();
+    });
+    it('renames a document review session from the viewer', async () => {
+        const user = userEvent.setup();
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Example\n',
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                sessions: [{
+                        id: 'review-1',
+                        tenantId: 'default',
+                        workspaceId: 'default',
+                        assetId: 'asset-doc-1',
+                        documentId: 'doc-1',
+                        documentVersion: 1,
+                        title: 'Review 1',
+                        status: 'open',
+                        createdByActorId: 'user',
+                        updatedByActorId: 'user',
+                        createdAt: '2026-03-19T12:00:00.000Z',
+                        updatedAt: '2026-03-19T12:10:00.000Z',
+                        deletedAt: null,
+                        createdByActor: null,
+                        updatedByActor: null,
+                        comments: [],
+                    }],
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                session: {
+                    id: 'review-1',
+                    tenantId: 'default',
+                    workspaceId: 'default',
+                    assetId: 'asset-doc-1',
+                    documentId: 'doc-1',
+                    documentVersion: 1,
+                    title: 'Architecture Review',
+                    status: 'open',
+                    createdByActorId: 'user',
+                    updatedByActorId: 'user',
+                    createdAt: '2026-03-19T12:00:00.000Z',
+                    updatedAt: '2026-03-19T12:12:00.000Z',
+                    deletedAt: null,
+                    createdByActor: null,
+                    updatedByActor: null,
+                    comments: [],
+                },
+            }),
+        });
+        render(_jsx(DocumentViewer, { doc: createDoc(), taskTitle: null }));
+        await screen.findByText('Review 1');
+        await user.click(screen.getByRole('button', { name: /Rename Review/i }));
+        const titleInput = screen.getByDisplayValue('Review 1');
+        await user.clear(titleInput);
+        await user.type(titleInput, 'Architecture Review');
+        await user.click(screen.getByRole('button', { name: /Save Title/i }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(3, '/api/taskforce/document-reviews/sessions/review-1', expect.objectContaining({
+            method: 'PATCH',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+        }), ''));
+        expect(await screen.findByText('Architecture Review')).toBeInTheDocument();
+    });
+    it('clears a document review session title from the viewer', async () => {
+        const user = userEvent.setup();
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Example\n',
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                sessions: [{
+                        id: 'review-1',
+                        tenantId: 'default',
+                        workspaceId: 'default',
+                        assetId: 'asset-doc-1',
+                        documentId: 'doc-1',
+                        documentVersion: 1,
+                        title: 'Review 1',
+                        status: 'open',
+                        createdByActorId: 'user',
+                        updatedByActorId: 'user',
+                        createdAt: '2026-03-19T12:00:00.000Z',
+                        updatedAt: '2026-03-19T12:10:00.000Z',
+                        deletedAt: null,
+                        createdByActor: null,
+                        updatedByActor: null,
+                        comments: [],
+                    }],
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                session: {
+                    id: 'review-1',
+                    tenantId: 'default',
+                    workspaceId: 'default',
+                    assetId: 'asset-doc-1',
+                    documentId: 'doc-1',
+                    documentVersion: 1,
+                    title: null,
+                    status: 'open',
+                    createdByActorId: 'user',
+                    updatedByActorId: 'user',
+                    createdAt: '2026-03-19T12:00:00.000Z',
+                    updatedAt: '2026-03-19T12:12:00.000Z',
+                    deletedAt: null,
+                    createdByActor: null,
+                    updatedByActor: null,
+                    comments: [],
+                },
+            }),
+        });
+        render(_jsx(DocumentViewer, { doc: createDoc(), taskTitle: null }));
+        await screen.findByText('Review 1');
+        await user.click(screen.getByRole('button', { name: /Rename Review/i }));
+        const titleInput = screen.getByDisplayValue('Review 1');
+        await user.clear(titleInput);
+        await user.click(screen.getByRole('button', { name: /Save Title/i }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(3, '/api/taskforce/document-reviews/sessions/review-1', expect.objectContaining({
+            method: 'PATCH',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ title: null }),
+        }), ''));
+        expect(screen.queryByText('Review 1')).not.toBeInTheDocument();
+    });
+    it('edits a document review comment from the viewer', async () => {
+        const user = userEvent.setup();
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Example\n',
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                sessions: [{
+                        id: 'review-1',
+                        tenantId: 'default',
+                        workspaceId: 'default',
+                        assetId: 'asset-doc-1',
+                        documentId: 'doc-1',
+                        documentVersion: 1,
+                        title: 'Review 1',
+                        status: 'open',
+                        createdByActorId: 'user',
+                        updatedByActorId: 'user',
+                        createdAt: '2026-03-19T12:00:00.000Z',
+                        updatedAt: '2026-03-19T12:10:00.000Z',
+                        deletedAt: null,
+                        createdByActor: null,
+                        updatedByActor: null,
+                        comments: [{
+                                id: 'comment-1',
+                                order: 0,
+                                body: 'Original review note.',
+                                anchor: { kind: 'document' },
+                                authorActorId: 'user',
+                                authorActor: null,
+                                createdAt: '2026-03-19T12:05:00.000Z',
+                                updatedAt: '2026-03-19T12:05:00.000Z',
+                                deletedAt: null,
+                            }],
+                    }],
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                session: {
+                    id: 'review-1',
+                    tenantId: 'default',
+                    workspaceId: 'default',
+                    assetId: 'asset-doc-1',
+                    documentId: 'doc-1',
+                    documentVersion: 1,
+                    title: 'Review 1',
+                    status: 'open',
+                    createdByActorId: 'user',
+                    updatedByActorId: 'user',
+                    createdAt: '2026-03-19T12:00:00.000Z',
+                    updatedAt: '2026-03-19T12:12:00.000Z',
+                    deletedAt: null,
+                    createdByActor: null,
+                    updatedByActor: null,
+                    comments: [{
+                            id: 'comment-1',
+                            order: 0,
+                            body: 'Updated review note.',
+                            anchor: { kind: 'document' },
+                            authorActorId: 'user',
+                            authorActor: null,
+                            createdAt: '2026-03-19T12:05:00.000Z',
+                            updatedAt: '2026-03-19T12:12:00.000Z',
+                            deletedAt: null,
+                        }],
+                },
+            }),
+        });
+        render(_jsx(DocumentViewer, { doc: createDoc(), taskTitle: null }));
+        const originalComment = await screen.findByText('Original review note.');
+        const commentCard = originalComment.closest('[class*="commentText"]')?.parentElement;
+        expect(commentCard).not.toBeNull();
+        await user.click(within(commentCard).getByRole('button', { name: 'Edit' }));
+        const editor = screen.getByDisplayValue('Original review note.');
+        await user.clear(editor);
+        await user.type(editor, 'Updated review note.');
+        await user.click(screen.getByRole('button', { name: /Save Comment/i }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(3, '/api/taskforce/document-reviews/sessions/review-1/comments/comment-1', expect.objectContaining({
+            method: 'PATCH',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+        }), ''));
+        expect(await screen.findByText('Updated review note.')).toBeInTheDocument();
+    });
+    it('deletes a document review comment from the viewer', async () => {
+        const user = userEvent.setup();
+        const confirmSpy = vi.spyOn(window, 'confirm').mockReturnValue(true);
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Example\n',
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                sessions: [{
+                        id: 'review-1',
+                        tenantId: 'default',
+                        workspaceId: 'default',
+                        assetId: 'asset-doc-1',
+                        documentId: 'doc-1',
+                        documentVersion: 1,
+                        title: 'Review 1',
+                        status: 'open',
+                        createdByActorId: 'user',
+                        updatedByActorId: 'user',
+                        createdAt: '2026-03-19T12:00:00.000Z',
+                        updatedAt: '2026-03-19T12:10:00.000Z',
+                        deletedAt: null,
+                        createdByActor: null,
+                        updatedByActor: null,
+                        comments: [{
+                                id: 'comment-1',
+                                order: 0,
+                                body: 'Delete me.',
+                                anchor: { kind: 'document' },
+                                authorActorId: 'user',
+                                authorActor: null,
+                                createdAt: '2026-03-19T12:05:00.000Z',
+                                updatedAt: '2026-03-19T12:05:00.000Z',
+                                deletedAt: null,
+                            }],
+                    }],
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                session: {
+                    id: 'review-1',
+                    tenantId: 'default',
+                    workspaceId: 'default',
+                    assetId: 'asset-doc-1',
+                    documentId: 'doc-1',
+                    documentVersion: 1,
+                    title: 'Review 1',
+                    status: 'open',
+                    createdByActorId: 'user',
+                    updatedByActorId: 'user',
+                    createdAt: '2026-03-19T12:00:00.000Z',
+                    updatedAt: '2026-03-19T12:12:00.000Z',
+                    deletedAt: null,
+                    createdByActor: null,
+                    updatedByActor: null,
+                    comments: [],
+                },
+            }),
+        });
+        render(_jsx(DocumentViewer, { doc: createDoc(), taskTitle: null }));
+        const commentToDelete = await screen.findByText('Delete me.');
+        const commentCard = commentToDelete.closest('[class*="commentText"]')?.parentElement;
+        expect(commentCard).not.toBeNull();
+        await user.click(within(commentCard).getByRole('button', { name: 'Delete' }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(3, '/api/taskforce/document-reviews/sessions/review-1/comments/comment-1', expect.objectContaining({
+            method: 'DELETE',
+            credentials: 'include',
+        }), ''));
+        await waitFor(() => expect(screen.queryByText('Delete me.')).not.toBeInTheDocument());
+        confirmSpy.mockRestore();
+    });
+    it('uses the resolved cloud api base for document list and save actions in cloud runtime', async () => {
+        const user = userEvent.setup();
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ documents: [createDoc()] }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Example\n',
+        })
+            .mockResolvedValueOnce(createEmptyReviewSessionsResponse())
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ updatedAt: '2026-03-19T12:00:00.000Z' }),
+        });
+        render(_jsx(DocumentWorkspaceShell, { tasks: [], runtimeMode: "cloud", apiBaseUrl: "https://api.taskforce.example", cloudAuthBaseUrl: "https://auth.taskforce.example" }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(1, '/api/taskforce/documents', expect.objectContaining({ credentials: 'include' }), 'https://api.taskforce.example'));
+        await screen.findAllByText('Technical Notes');
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(2, '/api/taskforce/documents/asset-doc-1/content', expect.objectContaining({ credentials: 'same-origin' }), 'https://api.taskforce.example'));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(3, '/api/taskforce/document-reviews/sessions?assetId=asset-doc-1', expect.objectContaining({ credentials: 'include' }), 'https://api.taskforce.example'));
+        await user.click(screen.getByRole('button', { name: /Edit/i }));
+        const editor = await screen.findByPlaceholderText('Write markdown here…');
+        await user.clear(editor);
+        await user.type(editor, '# Updated\n');
+        await user.click(screen.getByRole('button', { name: /^Save$/i }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(4, '/api/taskforce/documents/save', expect.objectContaining({
+            method: 'POST',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+        }), 'https://api.taskforce.example'));
+    });
+    it('uses the forwarded api base url for rename, delete, and task generation actions', async () => {
+        const user = userEvent.setup();
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Example\n',
+        })
+            .mockResolvedValueOnce(createEmptyReviewSessionsResponse())
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ updatedAt: '2026-03-19T12:00:00.000Z' }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ success: true, softDeleted: true }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                tasks: [{
+                        idempotencyKey: 'task-1',
+                        title: 'Generated task',
+                        description: 'Generated description',
+                        type: 'feature',
+                        priority: 2,
+                        children: [],
+                        selected: true,
+                    }]
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ created: 1 }),
+        });
+        const confirmSpy = vi.spyOn(window, 'confirm').mockReturnValue(true);
+        const alertSpy = vi.spyOn(window, 'alert').mockImplementation(() => { });
+        const doc = createDoc({
+            attachmentCount: 0,
+            attachmentState: 'unattached',
+        });
+        const { rerender } = render(_jsx(DocumentViewer, { doc: doc, taskTitle: null, apiBaseUrl: "http://127.0.0.1:4280", enableTaskGeneration: true }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(1, '/api/taskforce/documents/asset-doc-1/content', expect.objectContaining({ credentials: 'same-origin' }), 'http://127.0.0.1:4280'));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(2, '/api/taskforce/document-reviews/sessions?assetId=asset-doc-1', expect.objectContaining({ credentials: 'include' }), 'http://127.0.0.1:4280'));
+        await user.dblClick(screen.getByText('Technical Notes'));
+        const renameInput = await screen.findByDisplayValue('Technical Notes');
+        await user.clear(renameInput);
+        await user.type(renameInput, 'Renamed Doc');
+        fireEvent.blur(renameInput);
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(3, '/api/taskforce/documents/asset-doc-1', expect.objectContaining({
+            method: 'PATCH',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+        }), 'http://127.0.0.1:4280'));
+        expect(await screen.findByText('Renamed Doc')).toBeInTheDocument();
+        await user.click(screen.getByRole('button', { name: /Delete Permanently/i }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(4, '/api/taskforce/documents/asset-doc-1', expect.objectContaining({
+            method: 'DELETE',
+            credentials: 'include',
+        }), 'http://127.0.0.1:4280'));
+        rerender(_jsx(DocumentGenerateModal, { content: "# Plan", docTitle: "Renamed Doc", apiBaseUrl: "http://127.0.0.1:4280", onClose: () => { }, onGenerated: () => { } }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(5, '/api/taskforce/documents/generate-tasks/preview', expect.objectContaining({
+            method: 'POST',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+        }), 'http://127.0.0.1:4280'));
+        await user.click(screen.getByRole('button', { name: /Generate 1 Task/i }));
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(6, '/api/taskforce/documents/generate-tasks/commit', expect.objectContaining({
+            method: 'POST',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+        }), 'http://127.0.0.1:4280'));
+        confirmSpy.mockRestore();
+        alertSpy.mockRestore();
+    });
+    it('falls back to the readable document name in the viewer when displayName is missing', async () => {
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Example\n',
+        })
+            .mockResolvedValueOnce(createEmptyReviewSessionsResponse());
+        render(_jsx(DocumentViewer, { doc: {
+                id: 'doc-readable-fallback',
+                assetId: 'asset-readable-fallback',
+                fsPath: 'workspaces/default/assets/documents/technical-notes.md',
+                apiUrl: '/api/taskforce/documents/asset-readable-fallback/content',
+                taskId: null,
+                displayName: '',
+                title: 'Technical Notes',
+                docType: 'other',
+                sizeBytes: 64,
+                updatedAt: '2026-03-19T11:00:00.000Z',
+                editable: true,
+                attachmentCount: 0,
+                attachmentState: 'unattached',
+            }, taskTitle: null }));
+        expect(await screen.findByText('Technical Notes')).toBeInTheDocument();
+        expect(screen.queryByText('asset-readable-fallback')).not.toBeInTheDocument();
+    });
+    it('syncs editor and preview scrolling in split edit mode', async () => {
+        const user = userEvent.setup();
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => Array.from({ length: 80 }, (_, index) => `- item ${index + 1}`).join('\n'),
+        })
+            .mockResolvedValueOnce(createEmptyReviewSessionsResponse());
+        render(_jsx(DocumentViewer, { doc: createDoc(), taskTitle: null }));
+        await screen.findByText('item 1');
+        await user.click(screen.getByRole('button', { name: /Edit/i }));
+        const editor = await screen.findByPlaceholderText('Write markdown here…');
+        const preview = await screen.findByTestId('doc-preview-scroll');
+        Object.defineProperty(editor, 'scrollHeight', { configurable: true, value: 1000 });
+        Object.defineProperty(editor, 'clientHeight', { configurable: true, value: 200 });
+        Object.defineProperty(preview, 'scrollHeight', { configurable: true, value: 1600 });
+        Object.defineProperty(preview, 'clientHeight', { configurable: true, value: 400 });
+        editor.scrollTop = 400;
+        fireEvent.scroll(editor);
+        await waitFor(() => expect(preview.scrollTop).toBeCloseTo(600, 4));
+        preview.scrollTop = 300;
+        fireEvent.scroll(preview);
+        await waitFor(() => expect(editor.scrollTop).toBeCloseTo(200, 4));
+    });
+    it('builds isolated print html without injecting the viewer file name as a second header', () => {
+        const html = buildPrintDocumentHtml(`# Implementation Plan
+
+**Goal**
+
+Body copy.
+
+- [x] Done
+- [ ] Todo
+`);
+        expect(html).toContain('@page');
+        expect(html).toContain('margin: 0.94in 1.02in 1in;');
+        expect(html).toContain('font: 12.15pt/1.66 Georgia, "Times New Roman", Times, serif;');
+        expect(html).toContain('max-width: 5.95in;');
+        expect(html).toContain('.tf-print-document h1');
+        expect(html).toContain('font-size: 32pt;');
+        expect(html).toContain('max-width: 84%;');
+        expect(html).toContain('.tf-print-document h2');
+        expect(html).toContain('font-size: 16.5pt;');
+        expect(html).toContain('padding-left: 1.1em;');
+        expect(html).toContain('background: transparent;');
+        expect(html).toContain('.tf-print-section-label');
+        expect(html).toContain('font-size: 10.7pt;');
+        expect(html).toContain('letter-spacing: 0.12em;');
+        expect(html).toContain('text-transform: uppercase;');
+        expect(html).toContain('tf-print-document');
+        expect(html).toContain('<h1>Implementation Plan</h1>');
+        expect(html).toContain('class="tf-print-section-label"');
+        expect(html).toContain('>Goal</p>');
+        expect(html).toContain('type="checkbox"');
+        expect(html).toContain('readOnly=""');
+        expect(html).toContain('checked=""');
+        expect(html).not.toContain('Technical Notes');
+        expect(html).not.toContain('docViewerTitle');
+    });
+    it('prints through an isolated iframe document and cleans it up after afterprint', async () => {
+        const user = userEvent.setup();
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => 'Polished print body\n\nSecond paragraph.',
+        })
+            .mockResolvedValueOnce(createEmptyReviewSessionsResponse());
+        const realCreateElement = document.createElement.bind(document);
+        const iframe = realCreateElement('iframe');
+        const openSpy = vi.fn();
+        const writeSpy = vi.fn();
+        const closeSpy = vi.fn();
+        const removeSpy = vi.spyOn(iframe, 'remove').mockImplementation(() => { });
+        const afterprintHandlers = [];
+        const iframePrintSpy = vi.fn();
+        const iframeFocusSpy = vi.fn();
+        const iframeWindow = {
+            focus: iframeFocusSpy,
+            print: iframePrintSpy,
+            requestAnimationFrame: (callback) => {
+                callback(0);
+                return 1;
+            },
+            addEventListener: (eventName, handler) => {
+                if (eventName === 'afterprint' && typeof handler === 'function')
+                    afterprintHandlers.push(handler);
+            },
+            removeEventListener: vi.fn(),
+        };
+        const iframeDocument = {
+            open: openSpy,
+            write: writeSpy,
+            close: closeSpy,
+            fonts: { ready: Promise.resolve() },
+        };
+        Object.defineProperty(iframe, 'contentWindow', { configurable: true, value: iframeWindow });
+        Object.defineProperty(iframe, 'contentDocument', { configurable: true, value: iframeDocument });
+        vi.spyOn(document, 'createElement').mockImplementation(((tagName, options) => {
+            if (tagName.toLowerCase() === 'iframe')
+                return iframe;
+            return realCreateElement(tagName, options);
+        }));
+        render(_jsx(DocumentViewer, { doc: createDoc(), taskTitle: "Parent task" }));
+        await screen.findByText('Polished print body');
+        await user.click(screen.getByRole('button', { name: /Print/i }));
+        await waitFor(() => expect(writeSpy).toHaveBeenCalledTimes(1));
+        expect(writeSpy.mock.calls[0]?.[0]).toContain('Polished print body');
+        expect(writeSpy.mock.calls[0]?.[0]).not.toContain('Technical Notes');
+        await waitFor(() => expect(iframePrintSpy).toHaveBeenCalledTimes(1));
+        expect(afterprintHandlers).toHaveLength(1);
+        afterprintHandlers[0](new Event('afterprint'));
+        expect(removeSpy).toHaveBeenCalled();
+    });
+    it('schedules print cleanup with the expected fallback delay', () => {
+        const cleanup = vi.fn();
+        const timeoutSpy = vi.spyOn(window, 'setTimeout').mockReturnValue(1);
+        schedulePrintCleanup(cleanup);
+        expect(timeoutSpy).toHaveBeenCalledWith(cleanup, 1500);
+    });
+    it('falls back to attachmentCount when attachmentState is missing', async () => {
+        const user = userEvent.setup();
+        const docs = [
+            {
+                id: 'doc-attached-fallback',
+                assetId: 'doc-attached-fallback',
+                fsPath: 'workspaces/default/assets/documents/doc-attached-fallback.md',
+                apiUrl: '/api/taskforce/documents/doc-attached-fallback/content',
+                taskId: 'task-1',
+                displayName: 'Attached fallback',
+                title: 'Attached fallback',
+                docType: 'other',
+                sizeBytes: 128,
+                updatedAt: '2026-03-19T10:00:00.000Z',
+                editable: true,
+                attachmentCount: 1,
+            },
+            {
+                id: 'doc-unattached-fallback',
+                assetId: 'doc-unattached-fallback',
+                fsPath: 'workspaces/default/assets/documents/doc-unattached-fallback.md',
+                apiUrl: '/api/taskforce/documents/doc-unattached-fallback/content',
+                taskId: null,
+                displayName: 'Unattached fallback',
+                title: 'Unattached fallback',
+                docType: 'other',
+                sizeBytes: 64,
+                updatedAt: '2026-03-19T11:00:00.000Z',
+                editable: true,
+                attachmentCount: 0,
+            },
+        ];
+        const { rerender } = render(_jsx(DocumentWorkspace, { tasks: [{ id: 'task-1', title: 'Parent task' }], documents: docs, loading: false, error: null, selectedDoc: null, searchQuery: "", typeFilters: [], attachmentFilters: ['attached'], onSearchChange: () => { }, onSelectDoc: () => { }, onRefresh: () => { } }));
+        expect(screen.getByText('Attached fallback')).toBeInTheDocument();
+        expect(screen.queryByText('Unattached fallback')).not.toBeInTheDocument();
+        rerender(_jsx(DocumentWorkspace, { tasks: [{ id: 'task-1', title: 'Parent task' }], documents: docs, loading: false, error: null, selectedDoc: null, searchQuery: "", typeFilters: [], attachmentFilters: ['unattached'], onSearchChange: () => { }, onSelectDoc: () => { }, onRefresh: () => { } }));
+        expect(screen.getByText('Unattached fallback')).toBeInTheDocument();
+        expect(screen.queryByText('Attached fallback')).not.toBeInTheDocument();
+    });
+    it('selects a requested document by asset id when normalized paths differ', async () => {
+        const docs = [
+            {
+                id: 'asset-doc-unattached',
+                assetId: 'asset-doc-unattached',
+                fsPath: 'workspaces/default/assets/documents/asset-doc-unattached-random.md',
+                apiUrl: '/api/taskforce/documents/asset-doc-unattached/content',
+                taskId: null,
+                displayName: 'Unattached doc',
+                title: 'Unattached doc',
+                docType: 'other',
+                sizeBytes: 10,
+                updatedAt: '2026-03-19T10:00:00.000Z',
+                editable: true,
+                attachmentCount: 0,
+                attachmentState: 'unattached',
+            },
+            {
+                id: 'asset-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+                assetId: 'asset-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+                fsPath: 'workspaces/default/assets/documents/asset-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-notes.md',
+                apiUrl: '/api/taskforce/documents/asset-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/content',
+                taskId: 'task-1',
+                displayName: 'Attached notes',
+                title: 'Attached notes',
+                docType: 'other',
+                sizeBytes: 20,
+                updatedAt: '2026-03-19T11:00:00.000Z',
+                editable: true,
+                attachmentCount: 1,
+                attachmentState: 'attached',
+            }
+        ];
+        function Harness() {
+            return (_jsx(DocumentWorkspaceShell, { tasks: [{ id: 'task-1', title: 'Parent task' }], runtimeMode: "local", requestedDocPath: "workspaces/default/assets/documents/path-aliases/asset-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }));
+        }
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ documents: docs }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Attached notes\n',
+        })
+            .mockResolvedValueOnce(createEmptyReviewSessionsResponse());
+        render(_jsx(Harness, {}));
+        await waitFor(() => {
+            expect(screen.getByText('Attached notes')).toBeInTheDocument();
+        });
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(2, '/api/taskforce/documents/asset-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/content', expect.objectContaining({ credentials: 'same-origin' }), ''));
+        expect(screen.queryByText('Unattached doc')).toBeInTheDocument();
+    });
+    it('selects a requested document directly by canonical asset id in cloud mode', async () => {
+        const docs = [
+            {
+                id: 'asset-doc-unattached',
+                assetId: 'asset-doc-unattached',
+                fsPath: 'workspaces/default/assets/documents/asset-doc-unattached-random.md',
+                apiUrl: '/api/taskforce/documents/asset-doc-unattached/content',
+                taskId: null,
+                displayName: 'Unattached doc',
+                title: 'Unattached doc',
+                docType: 'other',
+                sizeBytes: 10,
+                updatedAt: '2026-03-19T10:00:00.000Z',
+                editable: true,
+                attachmentCount: 0,
+                attachmentState: 'unattached',
+            },
+            {
+                id: 'asset-doc-cloud-1',
+                assetId: 'asset-doc-cloud-1',
+                fsPath: 'workspaces/workspace-1/assets/documents/asset-doc-cloud-1-implementation-plan.md',
+                apiUrl: '/api/taskforce/documents/asset-doc-cloud-1/content',
+                taskId: 'task-1',
+                displayName: 'Implementation plan',
+                title: 'Implementation plan',
+                docType: 'implementation-plan',
+                sizeBytes: 20,
+                updatedAt: '2026-03-19T11:00:00.000Z',
+                editable: true,
+                attachmentCount: 1,
+                attachmentState: 'attached',
+            }
+        ];
+        function Harness() {
+            return (_jsx(DocumentWorkspaceShell, { tasks: [{ id: 'task-1', title: 'Parent task' }], runtimeMode: "cloud", apiBaseUrl: "https://performance-app.taskforcehq.ai", requestedDocAssetId: "asset-doc-cloud-1" }));
+        }
+        fetchTaskforceApi
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ documents: docs }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            text: async () => '# Implementation plan\n',
+        })
+            .mockResolvedValueOnce(createEmptyReviewSessionsResponse());
+        render(_jsx(Harness, {}));
+        await waitFor(() => {
+            expect(screen.getByText('Implementation plan')).toBeInTheDocument();
+        });
+        await waitFor(() => expect(fetchTaskforceApi).toHaveBeenNthCalledWith(2, '/api/taskforce/documents/asset-doc-cloud-1/content', expect.objectContaining({ credentials: 'same-origin' }), 'https://performance-app.taskforcehq.ai'));
+    });
+});