mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-10-08 21:03:51 +02:00
4600 lines
167 KiB
TypeScript
4600 lines
167 KiB
TypeScript
// @vitest-environment jsdom
|
||
|
||
import type { ComponentProps, ReactElement } from "react";
|
||
import { act, forwardRef, useImperativeHandle, type ForwardedRef } from "react";
|
||
import { flushSync } from "react-dom";
|
||
import { createRoot, type Root } from "react-dom/client";
|
||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||
import { ThemeProvider } from "@/context/ThemeContext";
|
||
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
|
||
import { TaskChatThread } from "./TaskChatThread";
|
||
import type {
|
||
IssueDocument,
|
||
IssueQueuedCommentQueue,
|
||
IssueThreadInteraction,
|
||
TaskBrowser,
|
||
} from "@paperclipai/shared";
|
||
import { heartbeatsApi } from "@/api/heartbeats";
|
||
import { nativeRunEventsToTranscript } from "./transcript/native-run-events";
|
||
import { pendingConnectionIntentInteraction } from "@/fixtures/issueThreadInteractionFixtures";
|
||
import type { HeartbeatRunEvent } from "@paperclipai/shared";
|
||
|
||
const transcriptState = vi.hoisted(() => ({
|
||
transcriptByRun: new Map(),
|
||
isInitialHydrating: false,
|
||
hydratedRunIds: undefined as Set<string> | undefined,
|
||
}));
|
||
const nativeTranscriptState = vi.hoisted(() => ({
|
||
transcriptByRun: new Map(),
|
||
errorsByRun: new Map(),
|
||
hydratedRunIds: undefined as Set<string> | undefined,
|
||
}));
|
||
const transcriptHookRuns = vi.hoisted(() => ({
|
||
legacy: [] as unknown[][],
|
||
native: [] as unknown[][],
|
||
}));
|
||
const sidebarState = vi.hoisted(() => ({ isMobile: false }));
|
||
const planState = vi.hoisted(() => ({ data: null as IssueDocument | null }));
|
||
const DIRECT_ADAPTER_TYPES = [
|
||
"codex_local",
|
||
"claude_local",
|
||
"opencode_local",
|
||
"process",
|
||
"http",
|
||
"custom_plugin",
|
||
] as const;
|
||
const editorCallbacks = vi.hoisted(() => ({ change: (_value: string) => {} }));
|
||
const streamlinedState = vi.hoisted(() => ({ enabled: true }));
|
||
|
||
vi.mock("@/components/transcript/useLiveRunTranscripts", () => ({
|
||
useLiveRunTranscripts: ({ runs }: { runs: unknown[] }) => {
|
||
transcriptHookRuns.legacy.push(runs);
|
||
return {
|
||
transcriptByRun: new Map(transcriptState.transcriptByRun),
|
||
isInitialHydrating: transcriptState.isInitialHydrating,
|
||
hydratedRunIds: transcriptState.hydratedRunIds,
|
||
};
|
||
},
|
||
}));
|
||
vi.mock("@/components/transcript/useNativeRunTranscripts", () => ({
|
||
useNativeRunTranscripts: (runs: unknown[]) => {
|
||
transcriptHookRuns.native.push(runs);
|
||
return {
|
||
transcriptByRun: new Map(nativeTranscriptState.transcriptByRun),
|
||
errorsByRun: new Map(nativeTranscriptState.errorsByRun),
|
||
hydratedRunIds: nativeTranscriptState.hydratedRunIds,
|
||
};
|
||
},
|
||
}));
|
||
vi.mock("@/context/SidebarContext", () => ({
|
||
useSidebar: () => ({ isMobile: sidebarState.isMobile }),
|
||
}));
|
||
vi.mock("@/hooks/useIssuePlanDocument", () => ({
|
||
useIssuePlanDocument: () => planState,
|
||
}));
|
||
vi.mock("@/hooks/useStreamlinedUiEnabled", () => ({
|
||
useStreamlinedUiEnabled: () => ({
|
||
enabled: streamlinedState.enabled,
|
||
loaded: true,
|
||
}),
|
||
}));
|
||
vi.mock("@/lib/router", () => ({
|
||
Link: ({
|
||
to,
|
||
children,
|
||
...props
|
||
}: {
|
||
to: string;
|
||
children: React.ReactNode;
|
||
}) => (
|
||
<a href={to} {...props}>
|
||
{children}
|
||
</a>
|
||
),
|
||
}));
|
||
vi.mock("@/components/MarkdownEditor", () => ({
|
||
MarkdownEditor: forwardRef(function MockMarkdownEditor(
|
||
{ value, onChange }: { value: string; onChange: (value: string) => void },
|
||
ref: ForwardedRef<unknown>,
|
||
) {
|
||
useImperativeHandle(ref, () => ({
|
||
insertMarkdown: () => {},
|
||
focus: () => {},
|
||
}));
|
||
editorCallbacks.change = onChange;
|
||
return <div data-testid="mock-editor">{value}</div>;
|
||
}),
|
||
}));
|
||
|
||
let container: HTMLDivElement;
|
||
let root: Root | null = null;
|
||
let queryClient: QueryClient;
|
||
|
||
beforeEach(() => {
|
||
localStorage.clear();
|
||
transcriptState.transcriptByRun.clear();
|
||
transcriptState.isInitialHydrating = false;
|
||
transcriptState.hydratedRunIds = undefined;
|
||
nativeTranscriptState.transcriptByRun.clear();
|
||
nativeTranscriptState.errorsByRun.clear();
|
||
nativeTranscriptState.hydratedRunIds = undefined;
|
||
transcriptHookRuns.legacy.length = 0;
|
||
transcriptHookRuns.native.length = 0;
|
||
sidebarState.isMobile = false;
|
||
planState.data = null;
|
||
streamlinedState.enabled = true;
|
||
container = document.createElement("div");
|
||
document.body.appendChild(container);
|
||
root = createRoot(container);
|
||
queryClient = new QueryClient({
|
||
defaultOptions: {
|
||
queries: { retry: false },
|
||
mutations: { retry: false },
|
||
},
|
||
});
|
||
});
|
||
|
||
afterEach(() => {
|
||
flushSync(() => root?.unmount());
|
||
queryClient.clear();
|
||
root = null;
|
||
container.remove();
|
||
localStorage.clear();
|
||
vi.restoreAllMocks();
|
||
});
|
||
|
||
function render(ui: ReactElement) {
|
||
flushSync(() =>
|
||
root!.render(
|
||
<QueryClientProvider client={queryClient}>
|
||
<ThemeProvider>{ui}</ThemeProvider>
|
||
</QueryClientProvider>,
|
||
),
|
||
);
|
||
}
|
||
|
||
describe.each(["legacy", "native"] as const)("historical %s system status", (runtimeMode) => {
|
||
const run = (id: string, status: string, minute: number) => ({
|
||
runId: id, status, runtimeMode, agentId: "agent", agentName: "Assistant",
|
||
adapterType: runtimeMode === "native" ? "paperclip_runner" : "claude_local",
|
||
createdAt: `2025-01-01T10:0${minute}:00Z`, startedAt: `2025-01-01T10:0${minute}:01Z`,
|
||
finishedAt: `2025-01-01T10:0${minute}:30Z`,
|
||
});
|
||
const comment = (id: string, body: string, runId?: string) => ({
|
||
id, body, runId, companyId: "company", issueId: "issue", authorType: "agent" as const,
|
||
authorAgentId: "agent", authorUserId: null, presentation: null, metadata: null,
|
||
createdAt: new Date("2025-01-01T10:00:20Z"), updatedAt: new Date("2025-01-01T10:00:20Z"),
|
||
});
|
||
const setTranscript = (id: string) => {
|
||
const state = runtimeMode === "native" ? nativeTranscriptState : transcriptState;
|
||
state.transcriptByRun.set(id, [
|
||
{ kind: "assistant", channel: "progress", ts: "2025-01-01T10:00:02Z", text: "Inspected the source." },
|
||
{ kind: "tool_call", ts: "2025-01-01T10:00:03Z", name: "Read", input: { path: "README.md" }, toolUseId: "read" },
|
||
{ kind: "tool_result", ts: "2025-01-01T10:00:04Z", toolUseId: "read", content: "Source content" },
|
||
{ kind: "assistant", channel: "final", ts: "2025-01-01T10:00:20Z", text: "Saved the useful response." },
|
||
]);
|
||
};
|
||
|
||
it.each([true, false].flatMap(streamlined => ["done", "cancelled"].map(issueStatus => ({ streamlined, issueStatus }))))("removes failures, stops, waits and stored notices on $issueStatus tasks (streamlined=$streamlined)", ({ streamlined, issueStatus }) => {
|
||
streamlinedState.enabled = streamlined;
|
||
setTranscript("failed");
|
||
const props = {
|
||
comments: [
|
||
comment("response", "Saved the useful response.", "failed"),
|
||
{ ...comment("notice", "The previous execution needs to be checked.", "failed"), authorType: "system" as const,
|
||
presentation: { kind: "system_notice" as const, tone: "warning" as const, title: "Recovery pending", detailsDefaultOpen: true } },
|
||
{ ...comment("human", "Please keep this message."), authorType: "user" as const, authorAgentId: null, authorUserId: "board" },
|
||
{ ...comment("session", "/new"), conversationSessionGeneration: 1 },
|
||
],
|
||
linkedRuns: [run("failed", "failed", 0), run("stopped", "cancelled", 1),
|
||
{ ...run("wait", "cancelled", 2), startedAt: null, errorCode: "execution_reconciliation_required" },
|
||
run("empty-success", "succeeded", 3)],
|
||
onAdd: async () => {},
|
||
};
|
||
render(<TaskChatThread {...props} issueStatus="blocked" />);
|
||
render(<TaskChatThread {...props} issueStatus={issueStatus} />);
|
||
expect(container.textContent).toContain("Saved the useful response.");
|
||
expect(container.textContent).toContain("Please keep this message.");
|
||
expect(container.textContent).toContain("New session");
|
||
for (const status of ["Run failed", "Stopped", "Worked", "Run cancelled", "Waiting to resume", "Recovery pending", "Run completed", "previous execution needs"]) {
|
||
expect(container.textContent).not.toContain(status);
|
||
}
|
||
if (runtimeMode === "legacy") {
|
||
const activity = Array.from(container.querySelectorAll<HTMLButtonElement>('button')).find(button => button.textContent?.startsWith("Activity"));
|
||
expect(activity).toBeDefined();
|
||
flushSync(() => activity!.click());
|
||
expect(container.textContent).toContain("Inspected the source.");
|
||
} else {
|
||
expect(container.textContent).toContain("Inspected the source.");
|
||
}
|
||
expect(props.linkedRuns[0].status).toBe("failed");
|
||
expect(props.comments).toHaveLength(4);
|
||
});
|
||
|
||
it("replaces old failure and wait notices when a new attempt succeeds, regardless of fetch order", () => {
|
||
setTranscript("old");
|
||
const notice = { ...comment("notice", "Old recovery details."), authorType: "system" as const,
|
||
metadata: { version: 1 as const, sourceRunId: "old", sections: [] } };
|
||
const wait = { ...run("wait", "cancelled", 1), startedAt: null, errorCode: "execution_reconciliation_required" };
|
||
const props = { comments: [notice, comment("response", "Saved the useful response.", "old")], onAdd: async () => {}, issueStatus: "in_progress" };
|
||
render(<TaskChatThread {...props} linkedRuns={[run("old", "failed", 0), wait]} />);
|
||
expect(container.textContent).toContain("Run failed");
|
||
expect(container.textContent).toContain("Waiting to resume");
|
||
for (const linkedRuns of [[run("new", "succeeded", 2), wait, run("old", "failed", 0)], [run("old", "failed", 0), wait, run("new", "succeeded", 2)]]) {
|
||
render(<TaskChatThread {...props} linkedRuns={linkedRuns} />);
|
||
expect(container.textContent).not.toContain("Run failed");
|
||
expect(container.textContent).not.toContain("Waiting to resume");
|
||
expect(container.textContent).not.toContain("Stopped");
|
||
expect(container.querySelector('[data-testid="task-chat-system-notice"]')).toBeNull();
|
||
expect(container.textContent).toContain("Saved the useful response.");
|
||
}
|
||
});
|
||
|
||
it("keeps the latest failure actionable after hiding earlier errors", async () => {
|
||
const retry = vi.fn();
|
||
const linkedRuns = [run("new-failure", "failed", 2), run("old-failure", "failed", 0)];
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} issueStatus="blocked" linkedRuns={linkedRuns} onRetryFailedRun={retry} />);
|
||
expect(container.textContent?.match(/Run failed/g)).toHaveLength(1);
|
||
const button = container.querySelector<HTMLButtonElement>('[data-testid="task-chat-run-failed-try-again"]');
|
||
expect(button).not.toBeNull();
|
||
flushSync(() => button!.click());
|
||
await Promise.resolve();
|
||
expect(retry).toHaveBeenCalledExactlyOnceWith("new-failure");
|
||
});
|
||
|
||
it.each(["in_progress", "done"])("preserves a child's stop relay after parent work (%s)", (issueStatus) => {
|
||
const relay = { ...comment("child-relay", "System relay: [Child task](/issues/child) transitioned to `blocked`."),
|
||
authorType: "system" as const, authorAgentId: null };
|
||
render(<TaskChatThread comments={[relay]} onAdd={async () => {}} issueStatus={issueStatus}
|
||
linkedRuns={[run("parent-follow-up", "succeeded", 1)]} />);
|
||
expect(container.querySelector('[data-thread-anchor="child-relay"]')).not.toBeNull();
|
||
expect(container.textContent).toContain("Child task");
|
||
});
|
||
|
||
it("clears old notices as soon as a successor is live, before history refreshes", () => {
|
||
const old = run("old", "failed", 0);
|
||
const live = { ...run("live", "running", 1), id: "live", finishedAt: null,
|
||
invocationSource: "on_demand", triggerDetail: null };
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} issueStatus="in_progress"
|
||
linkedRuns={[old]} activeRun={live} liveRuns={[live]} />);
|
||
expect(container.textContent).not.toContain("Run failed");
|
||
expect(container.querySelector('[data-testid="task-chat-run-failed-try-again"]')).toBeNull();
|
||
});
|
||
|
||
it("does not carry an old failure into a successful same-agent activity summary", () => {
|
||
setTranscript("old");
|
||
setTranscript("new");
|
||
const response = comment("new-response", "The follow-up succeeded.", "new");
|
||
response.createdAt = new Date("2025-01-01T10:01:20Z");
|
||
render(<TaskChatThread comments={[comment("old-response", "Saved the useful response.", "old"), response]}
|
||
onAdd={async () => {}} issueStatus="in_progress" linkedRuns={[run("old", "failed", 0), run("new", "succeeded", 1)]} />);
|
||
expect(container.textContent).toContain("The follow-up succeeded.");
|
||
expect(container.textContent).toContain("Worked");
|
||
expect(container.textContent).not.toContain("Stopped");
|
||
expect(container.textContent).not.toContain("Run failed");
|
||
});
|
||
});
|
||
|
||
it.each([true, false])("interleaves browser sessions with their requests and preserves position on status updates (streamlined=%s)", (streamlined) => {
|
||
streamlinedState.enabled = streamlined;
|
||
const onOpenBrowser = vi.fn();
|
||
const comments = [0, 2, 4].map((minute) => ({
|
||
id: `comment-${minute}`, companyId: "company", issueId: "issue",
|
||
authorType: "user" as const, authorAgentId: null, authorUserId: "board",
|
||
body: `Request at minute ${minute}`, presentation: null, metadata: null,
|
||
createdAt: new Date(`2026-09-29T12:0${minute}:00Z`), updatedAt: new Date(`2026-09-29T12:0${minute}:00Z`),
|
||
}));
|
||
const browsers: TaskBrowser[] = [1, 3].map((minute) => ({
|
||
id: `browser-${minute}`, sessionId: `session-${minute}`, issueId: "issue",
|
||
status: "idle" as const, runStatus: "completed" as const, progress: null,
|
||
costCents: 0, error: null, idleDeadline: null, expiresAt: null,
|
||
createdAt: `2026-09-29T12:0${minute}:00Z`,
|
||
}));
|
||
const show = (next = browsers) => render(<TaskChatThread comments={comments} browsers={next} onOpenBrowser={onOpenBrowser} threadHeader={<div>Task title</div>} onAdd={async () => {}} />);
|
||
show();
|
||
const anchors = () => Array.from(container.querySelectorAll('[data-thread-anchor]')).map(el => el.getAttribute('data-thread-anchor'));
|
||
const expected = ['comment-0', 'browser:session-1', 'comment-2', 'browser:session-3', 'comment-4'];
|
||
expect(anchors()).toEqual(expected);
|
||
expect(container.querySelector('[data-testid="task-chat-thread-header"]')?.textContent).toBe("Task title");
|
||
const row = container.querySelector('[data-thread-anchor="browser:session-1"]');
|
||
act(() => row?.querySelector<HTMLButtonElement>('button')?.click());
|
||
expect(onOpenBrowser).toHaveBeenCalledWith('browser-1');
|
||
// Provider IDs can become available after startup; session identity stays put.
|
||
show([{ ...browsers[0], id: 'provider-browser-1', status: 'closed' }, browsers[1]]);
|
||
expect(anchors()).toEqual(expected);
|
||
expect(container.querySelector('[data-thread-anchor="browser:session-1"]')).toBe(row);
|
||
expect(row?.textContent).toContain("View session");
|
||
act(() => row?.querySelector<HTMLButtonElement>('button')?.click());
|
||
expect(onOpenBrowser).toHaveBeenLastCalledWith('provider-browser-1');
|
||
render(<TaskChatThread comments={comments.slice(1)} browsers={browsers} hasOlderComments onAdd={async () => {}} />);
|
||
expect(anchors()).toEqual(['comment-2', 'browser:session-3', 'comment-4']);
|
||
show();
|
||
expect(anchors()).toEqual(expected);
|
||
});
|
||
|
||
it("coordinates first reveal while keeping the composer and visible history mounted through refresh", async () => {
|
||
sidebarState.isMobile = true;
|
||
const props = {
|
||
issueId: "coordinated-issue",
|
||
comments: [],
|
||
onAdd: async () => {},
|
||
};
|
||
render(<TaskChatThread {...props} initialHistoryPending />);
|
||
const composer = container.querySelector('[data-testid="mock-editor"]');
|
||
expect(composer).not.toBeNull();
|
||
expect(container.querySelector('[aria-busy="true"]')).not.toBeNull();
|
||
expect(container.querySelector('.task-chat-history-pending')).not.toBeNull();
|
||
expect(container.querySelector('[data-testid="task-chat-composer-dock"]')?.hasAttribute("inert")).toBe(true);
|
||
render(<TaskChatThread {...props} initialHistoryPending={false} />);
|
||
await act(async () => {
|
||
await new Promise((resolve) => requestAnimationFrame(resolve));
|
||
});
|
||
expect(container.querySelector('[aria-busy="false"]')).not.toBeNull();
|
||
expect(container.querySelector('.task-chat-history-pending')).toBeNull();
|
||
expect(container.querySelector('[data-testid="task-chat-composer-dock"]')?.hasAttribute("inert")).toBe(false);
|
||
expect(container.querySelector('[data-testid="mock-editor"]')).toBe(composer);
|
||
render(<TaskChatThread {...props} initialHistoryPending />);
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-history-loading"]'),
|
||
).toBeNull();
|
||
expect(container.querySelector('[data-testid="mock-editor"]')).toBe(composer);
|
||
expect(container.querySelector('.task-chat-history-pending')).toBeNull();
|
||
});
|
||
|
||
it.each([true, false])("reveals saved conversation when initial history stalls (mobile=%s)", async (mobile) => {
|
||
vi.useFakeTimers();
|
||
try {
|
||
sidebarState.isMobile = mobile;
|
||
const props = {
|
||
issueId: "stalled-issue",
|
||
comments: [{
|
||
id: "saved-comment", body: "An already saved reply.", runId: null,
|
||
companyId: "company", issueId: "stalled-issue", authorType: "agent" as const,
|
||
authorAgentId: "agent", authorUserId: null, presentation: null, metadata: null,
|
||
createdAt: new Date("2025-01-01T10:00:20Z"), updatedAt: new Date("2025-01-01T10:00:20Z"),
|
||
}],
|
||
onAdd: async () => {},
|
||
};
|
||
render(<TaskChatThread {...props} initialHistoryPending />);
|
||
const composer = container.querySelector('[data-testid="mock-editor"]');
|
||
await act(async () => { await vi.advanceTimersByTimeAsync(14_999); });
|
||
expect(container.querySelector('[data-testid="task-chat-history-loading"]')).not.toBeNull();
|
||
await act(async () => { await vi.advanceTimersByTimeAsync(1); });
|
||
expect(container.querySelector('[data-testid="task-chat-history-loading"]')).toBeNull();
|
||
expect(container.querySelector('[data-testid="task-chat-history-content"]')?.hasAttribute("inert")).toBe(false);
|
||
expect(container.querySelector('[data-testid="task-chat-composer-dock"]')?.hasAttribute("inert")).toBe(false);
|
||
expect(container.textContent).toContain("An already saved reply.");
|
||
expect(container.textContent).toContain("Some task history is still loading.");
|
||
expect(container.querySelector('[data-testid="mock-editor"]')).toBe(composer);
|
||
render(<TaskChatThread {...props} initialHistoryPending={false} />);
|
||
expect(container.textContent).not.toContain("Some task history is still loading.");
|
||
expect(container.querySelector('[data-testid="mock-editor"]')).toBe(composer);
|
||
|
||
// A timeout on one task must not bypass coordination on the next task.
|
||
render(<TaskChatThread {...props} issueId="next-issue" initialHistoryPending />);
|
||
expect(container.querySelector('[data-testid="task-chat-history-loading"]')).not.toBeNull();
|
||
await act(async () => { await vi.advanceTimersByTimeAsync(15_000); });
|
||
expect(container.querySelector('[data-testid="task-chat-history-loading"]')).toBeNull();
|
||
} finally {
|
||
vi.useRealTimers();
|
||
}
|
||
});
|
||
|
||
describe.each(["legacy", "native"] as const)("%s task history readiness", (runtimeMode) => {
|
||
const retryRun = {
|
||
runId: "scheduled-run",
|
||
runtimeMode,
|
||
status: "scheduled_retry",
|
||
agentId: "agent-1",
|
||
adapterType: runtimeMode === "native" ? "paperclip_runner" : "codex_local",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: null,
|
||
};
|
||
|
||
beforeEach(() => {
|
||
transcriptState.hydratedRunIds = new Set();
|
||
nativeTranscriptState.hydratedRunIds = new Set();
|
||
});
|
||
|
||
it("reveals comments while a scheduled retry has no transcript to hydrate", () => {
|
||
render(
|
||
<TaskChatThread
|
||
issueId="issue-1"
|
||
comments={createLongThreadComments()}
|
||
onAdd={async () => {}}
|
||
linkedRuns={[retryRun]}
|
||
/>,
|
||
);
|
||
|
||
expect(container.querySelector('[aria-busy="false"]')).not.toBeNull();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-history-loading"]'),
|
||
).toBeNull();
|
||
expect(
|
||
container.querySelector('[data-thread-anchor="comment-1"]')?.closest("[inert]"),
|
||
).toBeNull();
|
||
expect(container.textContent).toContain("Thread message 1");
|
||
});
|
||
|
||
it("does not delay the first reveal for an older run outside the loaded comment window", () => {
|
||
render(<TaskChatThread
|
||
issueId="issue-1"
|
||
comments={createLongThreadComments()}
|
||
onAdd={async () => {}}
|
||
linkedRuns={[{
|
||
...retryRun,
|
||
runId: "older-run",
|
||
status: "succeeded",
|
||
createdAt: "2026-08-01T12:00:00.000Z",
|
||
startedAt: "2026-08-01T12:00:00.000Z",
|
||
finishedAt: "2026-08-01T12:01:00.000Z",
|
||
}]}
|
||
/>);
|
||
expect(container.querySelector('[aria-busy="false"]')).not.toBeNull();
|
||
});
|
||
|
||
it.each(["running", "succeeded"])(
|
||
"reveals durable comments together with a %s run's initial history",
|
||
async (status) => {
|
||
const props = {
|
||
issueId: "issue-1",
|
||
comments: [...createLongThreadComments(), {
|
||
...createLongThreadComments()[3],
|
||
id: "agent-answer",
|
||
authorType: "agent" as const,
|
||
authorAgentId: "agent-1",
|
||
body: "Final saved reply",
|
||
runId: "started-run",
|
||
createdAt: new Date("2026-08-25T18:00:02.000Z"),
|
||
}],
|
||
onAdd: async () => {},
|
||
linkedRuns: [
|
||
retryRun,
|
||
{
|
||
...retryRun,
|
||
runId: "started-run",
|
||
status,
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
},
|
||
],
|
||
};
|
||
render(<TaskChatThread {...props} />);
|
||
expect(container.querySelector('[aria-busy="true"]')).not.toBeNull();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-history-loading"]'),
|
||
).not.toBeNull();
|
||
expect(container.textContent).toContain("Thread message 1");
|
||
expect(container.querySelector('[data-thread-anchor="comment-1"]')?.closest('[inert]')).not.toBeNull();
|
||
transcriptState.hydratedRunIds = new Set(["started-run"]);
|
||
nativeTranscriptState.hydratedRunIds = new Set(["started-run"]);
|
||
transcriptState.transcriptByRun.set("started-run", [{
|
||
kind: "thinking", text: "Reasoning before the reply",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
}]);
|
||
nativeTranscriptState.transcriptByRun.set("started-run", [{
|
||
kind: "assistant", text: "Reasoning before the reply", channel: "progress",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
}]);
|
||
render(<TaskChatThread {...props} />);
|
||
await act(async () => {
|
||
await new Promise((resolve) => requestAnimationFrame(resolve));
|
||
});
|
||
|
||
expect(container.querySelector('[aria-busy="false"]')).not.toBeNull();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-history-loading"]'),
|
||
).toBeNull();
|
||
expect(container.querySelector('[data-thread-anchor="comment-1"]')?.closest('[inert]')).toBeNull();
|
||
expect(container.textContent).toContain("Thread message 1");
|
||
if (status === "succeeded" && runtimeMode === "native") {
|
||
expect(container.textContent).toContain("Reasoning before the reply");
|
||
expect(container.textContent).toContain("Final saved reply");
|
||
expect(container.textContent!.indexOf("Reasoning before the reply")).toBeLessThan(
|
||
container.textContent!.indexOf("Final saved reply"),
|
||
);
|
||
}
|
||
},
|
||
);
|
||
});
|
||
|
||
it("preserves the typed disposition notice through the task-chat adapter", () => {
|
||
render(<TaskChatThread comments={[{
|
||
id: "typed-recovery", companyId: "company", issueId: "issue", authorType: "system", authorAgentId: null, authorUserId: null,
|
||
body: "Unrelated prose", createdAt: new Date(), updatedAt: new Date(),
|
||
presentation: { kind: "system_notice", title: "Different wording", tone: "warning", detailsDefaultOpen: false, density: "compact" },
|
||
metadata: { version: 1, sections: [], recovery: { kind: "disposition_repair_escalated", actionId: "action", assigneeAgentId: "agent", attemptCount: 2, maxAttempts: 2, reason: "unchanged_source_state_exhausted" } },
|
||
}]} onAdd={async () => {}} issueStatus="blocked" />);
|
||
expect(container.querySelector('[data-testid="disposition-recovery-notice"]')).not.toBeNull();
|
||
expect(container.textContent).toContain("Two automatic attempts");
|
||
expect(container.textContent).not.toContain("Unrelated prose");
|
||
});
|
||
|
||
it("keeps an acknowledged optimistic bubble mounted with its canonical comment target", () => {
|
||
const comment = {
|
||
companyId: "company",
|
||
issueId: "issue",
|
||
authorAgentId: null,
|
||
presentation: null,
|
||
metadata: null,
|
||
updatedAt: new Date("2026-09-09T12:00:00Z"),
|
||
id: "optimistic-one",
|
||
clientId: "optimistic-one",
|
||
body: "Keep this message in place",
|
||
authorType: "user" as const,
|
||
authorUserId: "board",
|
||
createdAt: new Date("2026-09-09T12:00:00Z"),
|
||
};
|
||
render(<TaskChatThread comments={[comment]} onAdd={async () => {}} />);
|
||
const row = container.querySelector('[data-thread-anchor="optimistic-one"]');
|
||
expect(row).not.toBeNull();
|
||
render(
|
||
<TaskChatThread
|
||
comments={[{ ...comment, id: "canonical-one" }]}
|
||
onAdd={async () => {}}
|
||
/>,
|
||
);
|
||
expect(container.querySelector('[data-thread-anchor="optimistic-one"]')).toBe(
|
||
row,
|
||
);
|
||
expect(row?.id).toBe("comment-canonical-one");
|
||
expect(
|
||
container.textContent?.match(/Keep this message in place/g),
|
||
).toHaveLength(1);
|
||
});
|
||
|
||
function fakeScrollGeometry(
|
||
element: HTMLElement,
|
||
{ scrollHeight = 1000, clientHeight = 400, scrollTop = 600 } = {},
|
||
) {
|
||
let currentScrollTop = scrollTop;
|
||
Object.defineProperty(element, "scrollHeight", {
|
||
value: scrollHeight,
|
||
configurable: true,
|
||
});
|
||
Object.defineProperty(element, "clientHeight", {
|
||
value: clientHeight,
|
||
configurable: true,
|
||
});
|
||
Object.defineProperty(element, "scrollTop", {
|
||
get: () => currentScrollTop,
|
||
set: (value: number) => {
|
||
currentScrollTop = value;
|
||
},
|
||
configurable: true,
|
||
});
|
||
}
|
||
|
||
function planDocument(overrides: Partial<IssueDocument> = {}): IssueDocument {
|
||
return {
|
||
id: "document-plan",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
key: "plan",
|
||
title: "Plan",
|
||
format: "markdown",
|
||
body: "# Preview the Plan\n- Reuse the review card.\n- Stream live steps.\n- Reconcile the revision.",
|
||
latestRevisionId: "revision-3",
|
||
latestRevisionNumber: 3,
|
||
createdByAgentId: "agent-1",
|
||
createdByUserId: null,
|
||
updatedByAgentId: "agent-1",
|
||
updatedByUserId: null,
|
||
lockedAt: null,
|
||
lockedByAgentId: null,
|
||
lockedByUserId: null,
|
||
createdAt: new Date("2026-08-23T10:00:00.000Z"),
|
||
updatedAt: new Date("2026-08-23T10:01:00.000Z"),
|
||
...overrides,
|
||
};
|
||
}
|
||
|
||
function planReviewInteraction(
|
||
status: "pending" | "accepted" | "expired" = "pending",
|
||
revisionId = "revision-3",
|
||
sourceRunId: string | null = "run-plan",
|
||
): IssueThreadInteraction {
|
||
const isResolved = status !== "pending";
|
||
return {
|
||
id: "plan-review",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
kind: "request_confirmation",
|
||
title: "Review the Plan",
|
||
summary: null,
|
||
status,
|
||
continuationPolicy: "wake_assignee",
|
||
resolverPolicy: "anyone",
|
||
requestedResolverPolicy: "anyone",
|
||
effectiveResolverPolicy: "anyone",
|
||
resolverPolicyProvenance: "inherited",
|
||
effectiveResolverPolicySource: "requested",
|
||
legacyResolverPolicyAliases: {
|
||
requested: "board_or_agents",
|
||
effective: "board_or_agents",
|
||
},
|
||
createdByAgentId: "agent-1",
|
||
createdByUserId: null,
|
||
sourceRunId,
|
||
resolvedByAgentId: null,
|
||
resolvedByUserId: isResolved ? "user-1" : null,
|
||
createdAt: new Date("2026-08-23T10:01:01.000Z"),
|
||
updatedAt: new Date("2026-08-23T10:01:01.000Z"),
|
||
resolvedAt: isResolved ? new Date("2026-08-23T10:02:00.000Z") : null,
|
||
payload: {
|
||
version: 1,
|
||
prompt: "Approve this Plan?",
|
||
target: {
|
||
type: "issue_document",
|
||
issueId: "issue-1",
|
||
documentId: "document-plan",
|
||
key: "plan",
|
||
revisionId,
|
||
revisionNumber: 3,
|
||
label: "Plan revision 3",
|
||
},
|
||
},
|
||
result:
|
||
status === "accepted"
|
||
? { outcome: "accepted" }
|
||
: status === "expired"
|
||
? {
|
||
outcome: "superseded_by_comment",
|
||
commentId: "follow-up-comment",
|
||
}
|
||
: null,
|
||
} as IssueThreadInteraction;
|
||
}
|
||
|
||
function questionInteraction(
|
||
id: string,
|
||
prompt: string,
|
||
createdAt: string,
|
||
): IssueThreadInteraction {
|
||
return {
|
||
id,
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
kind: "ask_user_questions",
|
||
title: prompt,
|
||
status: "pending",
|
||
continuationPolicy: "wake_assignee",
|
||
resolverPolicy: "anyone",
|
||
requestedResolverPolicy: "anyone",
|
||
effectiveResolverPolicy: "anyone",
|
||
resolverPolicyProvenance: "inherited",
|
||
effectiveResolverPolicySource: "requested",
|
||
legacyResolverPolicyAliases: {
|
||
requested: "board_or_agents",
|
||
effective: "board_or_agents",
|
||
},
|
||
createdByAgentId: "agent-1",
|
||
createdByUserId: null,
|
||
resolvedByAgentId: null,
|
||
resolvedByUserId: null,
|
||
createdAt: new Date(createdAt),
|
||
updatedAt: new Date(createdAt),
|
||
resolvedAt: null,
|
||
payload: {
|
||
version: 1,
|
||
questions: [
|
||
{
|
||
id: `${id}-question`,
|
||
prompt,
|
||
selectionMode: "single",
|
||
required: true,
|
||
options: [
|
||
{ id: "yes", label: "Yes" },
|
||
{ id: "no", label: "No" },
|
||
],
|
||
},
|
||
],
|
||
},
|
||
result: null,
|
||
} as IssueThreadInteraction;
|
||
}
|
||
|
||
function createLongThreadComments() {
|
||
return Array.from({ length: 4 }, (_, index) => ({
|
||
id: `comment-${index + 1}`,
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "user" as const,
|
||
authorAgentId: null,
|
||
authorUserId: "user-1",
|
||
body: `Thread message ${index + 1}`,
|
||
presentation: null,
|
||
metadata: null,
|
||
createdAt: new Date(`2026-08-15T12:0${index}:00.000Z`),
|
||
updatedAt: new Date(`2026-08-15T12:0${index}:00.000Z`),
|
||
}));
|
||
}
|
||
|
||
describe("TaskChatThread draft pass-through", () => {
|
||
it("aligns the desktop thread header with the side-panel tab row", () => {
|
||
render(
|
||
<TaskChatThread
|
||
comments={[
|
||
{
|
||
id: "comment-1",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "user",
|
||
authorAgentId: null,
|
||
authorUserId: "user-1",
|
||
body: "Header alignment fixture.",
|
||
presentation: null,
|
||
metadata: null,
|
||
createdAt: new Date("2026-08-15T12:00:00.000Z"),
|
||
updatedAt: new Date("2026-08-15T12:00:00.000Z"),
|
||
},
|
||
]}
|
||
onAdd={async () => {}}
|
||
/>,
|
||
);
|
||
|
||
const scroller = container.querySelector(
|
||
'[data-testid="task-chat-scroller"]',
|
||
);
|
||
expect(scroller?.firstElementChild?.classList).toContain("pt-3");
|
||
});
|
||
|
||
it("lets the mobile composer dock use the full thread width", () => {
|
||
render(
|
||
<TaskChatThread
|
||
comments={[
|
||
{
|
||
id: "comment-1",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "user",
|
||
authorAgentId: null,
|
||
authorUserId: "user-1",
|
||
body: "Waiting for the dependency.",
|
||
presentation: null,
|
||
metadata: null,
|
||
createdAt: new Date("2026-08-15T12:00:00.000Z"),
|
||
updatedAt: new Date("2026-08-15T12:00:00.000Z"),
|
||
},
|
||
]}
|
||
onAdd={async () => {}}
|
||
/>,
|
||
);
|
||
|
||
const dock = container.querySelector(
|
||
'[data-testid="task-chat-composer-dock"]',
|
||
);
|
||
const thread = container.querySelector('[data-testid="task-chat-thread"]');
|
||
expect(thread?.classList).not.toContain("h-(--tc-thread-max-h)");
|
||
expect(thread?.classList).toContain("flex-1");
|
||
expect(dock?.classList).toContain("px-1");
|
||
expect(dock?.classList).toContain("md:px-0");
|
||
expect(dock?.classList).not.toContain("px-2");
|
||
expect(dock?.classList).not.toContain("-mt-(--radius-task-composer)");
|
||
expect(dock?.classList).not.toContain("pt-1");
|
||
expect(dock?.classList).toContain("md:pb-0");
|
||
expect(dock?.classList).not.toContain("md:pb-4");
|
||
expect(dock?.classList).not.toContain("bg-background/80");
|
||
expect(dock?.classList).not.toContain("backdrop-blur");
|
||
});
|
||
|
||
it("forwards draftKey so the composer restores a task's saved draft", () => {
|
||
localStorage.setItem("task-chat-draft:issue-1", "half-written thought");
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={createLongThreadComments()}
|
||
onAdd={async () => {}}
|
||
draftKey="task-chat-draft:issue-1"
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-testid="mock-editor"]')?.textContent,
|
||
).toBe("half-written thought");
|
||
});
|
||
|
||
it("forwards human profiles to the selected composer assignee", () => {
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
enableReassign
|
||
reassignOptions={[{ id: "user:user-1", label: "Riley Board" }]}
|
||
currentAssigneeValue="user:user-1"
|
||
userProfileMap={
|
||
new Map([
|
||
["user-1", { label: "Riley Board", image: "/riley-avatar.png" }],
|
||
])
|
||
}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-assignee-trigger-avatar="user-1"]'),
|
||
).not.toBeNull();
|
||
});
|
||
});
|
||
|
||
describe("TaskChatThread runtime transcript selection", () => {
|
||
it.each(["queued", "running"])("retains the live log transport for a %s native run with event history", (status) => {
|
||
nativeTranscriptState.hydratedRunIds = new Set(["native-run"]);
|
||
nativeTranscriptState.transcriptByRun.set("native-run", [
|
||
{ kind: "assistant", text: "Native progress", ts: "2026-08-25T18:00:01.000Z", channel: "progress" },
|
||
]);
|
||
const props = {
|
||
issueId: "native-live", comments: [], onAdd: async () => {},
|
||
linkedRuns: [{ runId: "native-run", runtimeMode: "native" as const,
|
||
status, agentId: "agent-1", adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z", startedAt: "2026-08-25T18:00:00.000Z" }],
|
||
};
|
||
render(<TaskChatThread {...props} />);
|
||
expect(transcriptHookRuns.legacy.at(-1)).toMatchObject([{ id: "native-run", status }]);
|
||
|
||
render(<TaskChatThread {...props} linkedRuns={[{ ...props.linkedRuns[0], status: "succeeded" }]} />);
|
||
expect(transcriptHookRuns.legacy.at(-1)).toEqual([]);
|
||
});
|
||
|
||
it("does not download fallback logs until native events are empty or fail", () => {
|
||
const props = {
|
||
issueId: "native-history", comments: [], onAdd: async () => {},
|
||
linkedRuns: [{ runId: "native-run", runtimeMode: "native" as const,
|
||
status: "succeeded", agentId: "agent-1", adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z", startedAt: "2026-08-25T18:00:00.000Z" }],
|
||
};
|
||
nativeTranscriptState.hydratedRunIds = new Set();
|
||
render(<TaskChatThread {...props} />);
|
||
expect(transcriptHookRuns.legacy.at(-1)).toEqual([]);
|
||
expect(container.querySelector('[aria-busy="true"]')).not.toBeNull();
|
||
|
||
nativeTranscriptState.hydratedRunIds = new Set(["native-run"]);
|
||
nativeTranscriptState.transcriptByRun.set("native-run", [{ kind: "assistant", text: "Native response", ts: "2026-08-25T18:00:01.000Z", channel: "final" }]);
|
||
render(<TaskChatThread {...props} />);
|
||
expect(transcriptHookRuns.legacy.at(-1)).toEqual([]);
|
||
|
||
nativeTranscriptState.transcriptByRun.clear();
|
||
render(<TaskChatThread {...props} />);
|
||
expect(transcriptHookRuns.legacy.at(-1)).toMatchObject([{ id: "native-run" }]);
|
||
|
||
nativeTranscriptState.hydratedRunIds = new Set();
|
||
nativeTranscriptState.errorsByRun.set("native-run", { message: "Unavailable" });
|
||
render(<TaskChatThread {...props} />);
|
||
expect(transcriptHookRuns.legacy.at(-1)).toMatchObject([{ id: "native-run" }]);
|
||
});
|
||
|
||
it("selects persisted runtime facts while retaining the log parser as native fallback", () => {
|
||
nativeTranscriptState.hydratedRunIds = new Set(["native-run"]);
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
linkedRuns={[
|
||
{
|
||
runId: "native-run",
|
||
runtimeMode: "native",
|
||
status: "succeeded",
|
||
agentId: "agent-1",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
},
|
||
...DIRECT_ADAPTER_TYPES.map((adapterType, index) => ({
|
||
runId: `legacy-run-${index}`,
|
||
runtimeMode: "legacy" as const,
|
||
status: "succeeded",
|
||
agentId: `agent-${index + 2}`,
|
||
adapterType,
|
||
createdAt: `2026-08-25T18:0${index + 1}:00.000Z`,
|
||
startedAt: `2026-08-25T18:0${index + 1}:00.000Z`,
|
||
})),
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
const legacyRuns = transcriptHookRuns.legacy.at(-1) as Array<{
|
||
id: string;
|
||
}>;
|
||
const nativeRuns = transcriptHookRuns.native.at(-1) as Array<{
|
||
id: string;
|
||
}>;
|
||
expect(legacyRuns.map((run) => run.id)).toEqual([
|
||
"native-run",
|
||
...DIRECT_ADAPTER_TYPES.map((_, index) => `legacy-run-${index}`),
|
||
]);
|
||
expect(nativeRuns.map((run) => run.id)).toEqual(["native-run"]);
|
||
});
|
||
|
||
it("uses runner-only controls only for an actual native Paperclip Runner run", () => {
|
||
nativeTranscriptState.transcriptByRun.set("native-run", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Checking the task.",
|
||
channel: "progress",
|
||
},
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:02.000Z",
|
||
text: "The task is ready.",
|
||
channel: "final",
|
||
},
|
||
]);
|
||
|
||
const run = {
|
||
id: "native-run",
|
||
runtimeMode: "native" as const,
|
||
status: "running" as const,
|
||
invocationSource: "issue" as const,
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
};
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={run}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-runner-turn"]'),
|
||
).not.toBeNull();
|
||
expect(container.textContent).toContain("Checking the task.");
|
||
expect(container.textContent).toContain("The task is ready.");
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{ ...run, runtimeMode: "legacy" }}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-runner-turn"]'),
|
||
).toBeNull();
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{ ...run, adapterType: "codex_local" }}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-runner-turn"]'),
|
||
).toBeNull();
|
||
});
|
||
|
||
|
||
it.each(["matching", "document_only", "absent", "other_revision"] as const)("reports a restore failure with %s saved-plan evidence", (evidence) => {
|
||
if (evidence !== "absent") planState.data = planDocument();
|
||
render(<TaskChatThread issueId="issue-1" comments={[]} onAdd={async () => {}} issueStatus="blocked"
|
||
interactions={evidence === "absent" || evidence === "document_only" ? [] : [planReviewInteraction("accepted", evidence === "matching" ? "revision-3" : "revision-2", "restore-run")]}
|
||
onRetryFailedRun={vi.fn()} linkedRuns={[{
|
||
runId: "restore-run", runtimeMode: "legacy", status: "failed", errorCode: "workspace_restore_failed",
|
||
agentId: "agent-1", agentName: "Runner", adapterType: "grok_local",
|
||
createdAt: "2026-08-25T18:00:00.000Z", startedAt: "2026-08-25T18:00:00.000Z", finishedAt: "2026-08-25T18:00:02.000Z",
|
||
resultJson: { workspaceRestoreFailure: "restore_unsafe_archive", workspaceRestorePath: ".claude/skills/paperclip", finalResponseRecorded: false,
|
||
...(evidence === "document_only" ? { savedPlanRevisionId: "revision-3" } : {}),
|
||
},
|
||
}]} />);
|
||
const marker = container.querySelector('[data-testid="task-chat-collapsible-marker"]');
|
||
expect(marker?.textContent).toContain("Workspace restore failed");
|
||
flushSync(() => marker!.querySelector<HTMLButtonElement>('button[aria-expanded]')!.click());
|
||
expect(marker?.textContent).toContain("Workspace files need recovery");
|
||
expect(marker?.textContent).toContain("No final response was recorded");
|
||
expect(marker?.textContent).toContain(".claude/skills/paperclip");
|
||
expect(marker?.querySelector('a[href*="/runs/restore-run"]')).not.toBeNull();
|
||
expect(marker?.textContent.includes("after the plan was saved")).toBe(evidence === "matching" || evidence === "document_only");
|
||
expect(Boolean(marker?.querySelector('a[href*="document-plan"]'))).toBe(evidence === "matching" || evidence === "document_only");
|
||
expect(marker?.querySelector('[data-testid="task-chat-run-failed-try-again"]')).toBeNull();
|
||
});
|
||
|
||
it("uses neutral wording for an unclassified historical legacy failure", () => {
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} linkedRuns={[{
|
||
runId: "old-run", runtimeMode: "legacy", status: "failed", errorCode: "adapter_failed",
|
||
agentId: "agent-1", agentName: "Runner", adapterType: "grok_local",
|
||
createdAt: "2026-08-25T18:00:00.000Z", startedAt: null, finishedAt: "2026-08-25T18:00:02.000Z",
|
||
}]} />);
|
||
expect(container.textContent).toContain("The run failed");
|
||
expect(container.textContent).not.toContain("before returning an answer");
|
||
expect(container.textContent).not.toContain("Workspace restore failed");
|
||
});
|
||
|
||
it("directs a missing personal AI credential to its card without offering a premature retry", () => {
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} issueStatus="blocked"
|
||
onRetryFailedRun={vi.fn()} interactions={[{
|
||
...pendingConnectionIntentInteraction, sourceRunId: "missing-ai-run",
|
||
payload: { ...pendingConnectionIntentInteraction.payload, purpose: "ai" },
|
||
}]} linkedRuns={[{
|
||
runId: "missing-ai-run", runtimeMode: "legacy", status: "failed", errorCode: "configuration_incomplete",
|
||
agentId: "agent-1", agentName: "Chief of Staff", adapterType: "claude_local",
|
||
createdAt: "2026-08-25T18:00:00.000Z", startedAt: null, finishedAt: "2026-08-25T18:00:02.000Z",
|
||
}]} />);
|
||
expect(container.textContent).toContain("AI connection needed");
|
||
expect(container.textContent).toContain("Use the connection card below to continue.");
|
||
expect(container.textContent).not.toContain("The selected AI account is unavailable");
|
||
expect(container.querySelector('[data-testid="task-chat-run-failed-try-again"]')).toBeNull();
|
||
});
|
||
|
||
it("projects the saved Plan inline at its native write_document boundary", () => {
|
||
planState.data = planDocument({
|
||
updatedAt: new Date("2026-08-25T18:00:02.000Z"),
|
||
});
|
||
nativeTranscriptState.transcriptByRun.set("native-plan", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Preparing the Plan.",
|
||
channel: "progress",
|
||
},
|
||
{
|
||
kind: "tool_call",
|
||
ts: "2026-08-25T18:00:02.000Z",
|
||
name: "write_document",
|
||
toolUseId: "write-plan",
|
||
input: { key: "plan" },
|
||
},
|
||
{
|
||
kind: "tool_result",
|
||
ts: "2026-08-25T18:00:02.100Z",
|
||
toolUseId: "write-plan",
|
||
toolName: "write_document",
|
||
content: "revision-3",
|
||
},
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:03.000Z",
|
||
text: "Plan revision is ready for review.",
|
||
channel: "progress",
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{
|
||
id: "native-plan",
|
||
status: "running",
|
||
invocationSource: "issue",
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
runtimeMode: "native",
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
const preview = container.querySelector(
|
||
'[data-testid="task-chat-plan-preview"]',
|
||
);
|
||
expect(preview).not.toBeNull();
|
||
expect(preview?.textContent).toContain("Preview the Plan");
|
||
expect(
|
||
preview?.closest('[data-testid="task-chat-runner-turn"]'),
|
||
).not.toBeNull();
|
||
const rows = [
|
||
...container.querySelectorAll(
|
||
'[data-testid="task-chat-turn-timeline-row"]',
|
||
),
|
||
];
|
||
expect(rows.findIndex((row) => row.contains(preview))).toBeGreaterThan(0);
|
||
});
|
||
|
||
it.each([
|
||
{ name: "write_document", anchored: true },
|
||
{ name: "mcp__paperclip__write_document", anchored: false },
|
||
])("anchors a settled ACP Plan only at the normalized display name $name", ({ name, anchored }) => {
|
||
const runId = "acpx-plan";
|
||
planState.data = planDocument({ updatedAt: new Date("2026-08-25T18:00:02.000Z") });
|
||
const events = ["started", "completed"].map((phase, index) => ({
|
||
id: index + 1,
|
||
companyId: "company-1",
|
||
agentId: "agent-1",
|
||
stream: "system",
|
||
level: "info",
|
||
color: null,
|
||
message: null,
|
||
runId,
|
||
seq: index + 1,
|
||
eventType: `tool.execution.${phase}`,
|
||
createdAt: new Date(`2026-08-25T18:00:0${index + 1}.000Z`),
|
||
payload: {
|
||
prpEvent: {
|
||
schema: "paperclip.prp.event.v1",
|
||
schemaVersion: 1,
|
||
runId,
|
||
eventType: `tool.execution.${phase}`,
|
||
sourceEventId: `acpx-write-${index + 1}`,
|
||
sourceKind: "runner",
|
||
sourceInstanceId: "runner-1",
|
||
sourceSeq: index + 1,
|
||
normalizedSessionId: "session-1",
|
||
emittedAt: `2026-08-25T18:00:0${index + 1}.000Z`,
|
||
payload: {
|
||
schema: "paperclip.tool.execution.v1",
|
||
executionId: "write-plan",
|
||
transport: anchored ? "mcp" : "builtin",
|
||
namespace: anchored ? "paperclip" : null,
|
||
name,
|
||
operation: "execute",
|
||
readOnly: false,
|
||
status: phase === "completed" ? "completed" : "running",
|
||
output: null,
|
||
outputBytes: 0,
|
||
outputTruncated: false,
|
||
outputDigest: null,
|
||
},
|
||
},
|
||
},
|
||
} satisfies HeartbeatRunEvent));
|
||
// Exercise persisted ACP display events, without native raw arguments or
|
||
// a fabricated semantic-tool receipt, through the actual transcript parser.
|
||
nativeTranscriptState.transcriptByRun.set(runId, nativeRunEventsToTranscript(events));
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} issueStatus="blocked" linkedRuns={[{
|
||
runId,
|
||
runtimeMode: "native",
|
||
status: "succeeded",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:03.000Z",
|
||
}]} />);
|
||
const preview = container.querySelector('[data-testid="task-chat-plan-preview"]');
|
||
const fallback = container.querySelector('[data-testid="task-chat-plan-preview-fallback"]');
|
||
expect(Boolean(preview)).toBe(anchored);
|
||
expect(Boolean(fallback)).toBe(!anchored);
|
||
expect((preview ?? fallback)?.textContent).toContain("Preview the Plan");
|
||
expect((preview ?? fallback)?.closest('[data-testid="task-chat-turn"][data-settled="true"]')).not.toBeNull();
|
||
});
|
||
|
||
it("retains a native Plan as a visible fallback while its write boundary is unavailable", () => {
|
||
planState.data = planDocument({
|
||
updatedAt: new Date("2026-08-25T18:00:02.000Z"),
|
||
});
|
||
nativeTranscriptState.transcriptByRun.set("native-plan-fallback", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Recovering the Plan transcript.",
|
||
channel: "progress",
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{
|
||
id: "native-plan-fallback",
|
||
status: "running",
|
||
invocationSource: "issue",
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
runtimeMode: "native",
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
const fallback = container.querySelector(
|
||
'[data-testid="task-chat-plan-preview-fallback"]',
|
||
);
|
||
expect(fallback?.textContent).toContain("Preview the Plan");
|
||
expect(
|
||
fallback?.closest('[data-testid="task-chat-runner-turn"]'),
|
||
).not.toBeNull();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-plan-preview"]'),
|
||
).toBeNull();
|
||
});
|
||
|
||
it("suppresses early provider wait prose when its native interaction is pending", () => {
|
||
nativeTranscriptState.transcriptByRun.set("native-wait", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Waiting for Plan approval.",
|
||
channel: "final",
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
interactions={[
|
||
planReviewInteraction("pending", "revision-3", "native-wait"),
|
||
]}
|
||
activeRun={{
|
||
id: "native-wait",
|
||
status: "running",
|
||
invocationSource: "issue",
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
runtimeMode: "native",
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
expect(container.textContent).toContain("Review the Plan");
|
||
expect(container.textContent).not.toContain("Waiting for Plan approval.");
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-final-response"]'),
|
||
).toBeNull();
|
||
});
|
||
|
||
it("uses the live log when a native run has no persisted event transcript", () => {
|
||
transcriptState.transcriptByRun.set("native-run", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Visible from the runner log fallback.",
|
||
channel: "progress",
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{
|
||
id: "native-run",
|
||
runtimeMode: "native",
|
||
status: "running",
|
||
invocationSource: "issue",
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
expect(container.textContent).toContain(
|
||
"Visible from the runner log fallback.",
|
||
);
|
||
});
|
||
|
||
it("uses a fresher live log when native event polling fails after earlier events", () => {
|
||
nativeTranscriptState.transcriptByRun.set("native-run", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Stale native activity.",
|
||
channel: "progress",
|
||
},
|
||
]);
|
||
nativeTranscriptState.errorsByRun.set("native-run", {
|
||
message: "event endpoint unavailable",
|
||
failedAt: "2026-08-25T18:00:02.000Z",
|
||
});
|
||
transcriptState.transcriptByRun.set("native-run", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:03.000Z",
|
||
text: "Fresh activity from the runner log.",
|
||
channel: "progress",
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{
|
||
id: "native-run",
|
||
runtimeMode: "native",
|
||
status: "running",
|
||
invocationSource: "issue",
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
expect(container.textContent).toContain(
|
||
"Fresh activity from the runner log.",
|
||
);
|
||
expect(container.textContent).not.toContain("Stale native activity.");
|
||
expect(container.textContent).not.toContain("temporarily unavailable");
|
||
});
|
||
|
||
it("keeps legacy channel-less native messages readable across settlement", () => {
|
||
nativeTranscriptState.transcriptByRun.set("native-run", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Persisted before message channels existed.",
|
||
channel: "unknown",
|
||
},
|
||
]);
|
||
|
||
const run = {
|
||
id: "native-run",
|
||
runtimeMode: "native" as const,
|
||
status: "running" as const,
|
||
invocationSource: "issue" as const,
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
};
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={run}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-phase-interstitial"]')
|
||
?.textContent,
|
||
).toContain("Persisted before message channels existed.");
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-final-response"]'),
|
||
).toBeNull();
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="done"
|
||
activeRun={{
|
||
...run,
|
||
status: "succeeded",
|
||
finishedAt: "2026-08-25T18:00:02.000Z",
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-phase-interstitial"]'),
|
||
).toBeNull();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-final-response"]')
|
||
?.textContent,
|
||
).toContain("Persisted before message channels existed.");
|
||
});
|
||
|
||
it("recomputes a runner turn when only the message channel changes", () => {
|
||
const run = {
|
||
id: "native-run",
|
||
runtimeMode: "native" as const,
|
||
status: "running" as const,
|
||
invocationSource: "issue" as const,
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
};
|
||
const renderRun = () =>
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={run}
|
||
/>,
|
||
);
|
||
|
||
nativeTranscriptState.transcriptByRun.set("native-run", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Same text.",
|
||
channel: "progress",
|
||
},
|
||
]);
|
||
renderRun();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-phase-interstitial"]')
|
||
?.textContent,
|
||
).toContain("Same text.");
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-final-response"]'),
|
||
).toBeNull();
|
||
|
||
nativeTranscriptState.transcriptByRun.set("native-run", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Same text.",
|
||
channel: "final",
|
||
},
|
||
]);
|
||
renderRun();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-phase-interstitial"]'),
|
||
).toBeNull();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-final-response"]')
|
||
?.textContent,
|
||
).toContain("Same text.");
|
||
});
|
||
|
||
it("recomputes a runner turn when only usage totals change", () => {
|
||
const run = {
|
||
id: "native-run",
|
||
runtimeMode: "native" as const,
|
||
status: "running" as const,
|
||
invocationSource: "issue" as const,
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
};
|
||
const usageEntry = (inputTokens: number) => ({
|
||
kind: "result" as const,
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "",
|
||
inputTokens,
|
||
outputTokens: 5,
|
||
cachedTokens: 0,
|
||
costUsd: 0,
|
||
subtype: "paperclip_runner_usage",
|
||
isError: false,
|
||
errors: [],
|
||
});
|
||
const renderRun = () =>
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={run}
|
||
/>,
|
||
);
|
||
const revealUsage = () => {
|
||
const summary = container.querySelector<HTMLButtonElement>(
|
||
'[data-testid="task-chat-activity-phase-toggle"]',
|
||
);
|
||
expect(summary).not.toBeNull();
|
||
if (summary?.getAttribute("aria-expanded") !== "true") {
|
||
flushSync(() => summary!.click());
|
||
}
|
||
};
|
||
|
||
nativeTranscriptState.transcriptByRun.set("native-run", [usageEntry(10)]);
|
||
renderRun();
|
||
revealUsage();
|
||
expect(container.textContent).toContain("↑10");
|
||
|
||
nativeTranscriptState.transcriptByRun.set("native-run", [usageEntry(20)]);
|
||
renderRun();
|
||
revealUsage();
|
||
expect(container.textContent).toContain("↑20");
|
||
expect(container.textContent).not.toContain("↑10");
|
||
});
|
||
|
||
it("keeps a failed native run actionable after progress was rendered", async () => {
|
||
const onRetryFailedRun = vi.fn();
|
||
nativeTranscriptState.transcriptByRun.set("native-failed", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Started the provider request.",
|
||
channel: "progress",
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="blocked"
|
||
onRetryFailedRun={onRetryFailedRun}
|
||
linkedRuns={[
|
||
{
|
||
runId: "native-failed",
|
||
runtimeMode: "native",
|
||
status: "failed",
|
||
errorCode: "provider_transport_failed",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:02.000Z",
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
expect(container.textContent).toContain("Started the provider request.");
|
||
const marker = container.querySelector(
|
||
'[data-testid="task-chat-collapsible-marker"]',
|
||
);
|
||
expect(marker?.textContent).toContain("Run failed");
|
||
const retry = container.querySelector<HTMLButtonElement>(
|
||
'[data-testid="task-chat-run-failed-try-again"]',
|
||
);
|
||
expect(retry).not.toBeNull();
|
||
flushSync(() => retry!.click());
|
||
await Promise.resolve();
|
||
expect(onRetryFailedRun).toHaveBeenCalledWith("native-failed");
|
||
});
|
||
|
||
it.each([false, true])("keeps a later bootstrap failure actionable only after the old recovery has a successor: %s", async (continued) => {
|
||
const onRetryFailedRun = vi.fn();
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} issueStatus="blocked"
|
||
onRetryFailedRun={onRetryFailedRun} linkedRuns={[
|
||
{
|
||
runId: "old-native", runtimeMode: "native", status: "failed", errorCode: "adapter_failed",
|
||
agentId: "agent-1", agentName: "Runner", adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z", startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:02.000Z",
|
||
execution: {
|
||
phase: continued ? "completed" : "recovery_needed", label: continued ? "Continued in another run" : "Stopped",
|
||
cause: "native_continuation_requires_reconciliation", lastConfirmedActivityAt: null,
|
||
retryAt: null, attempt: 1, maxAttempts: 3, recoveryOwner: null, nextAction: null,
|
||
permittedActions: ["inspect_run"], predecessorRunId: null, successorRunId: continued ? "failed-bootstrap" : null,
|
||
},
|
||
},
|
||
{
|
||
runId: "failed-bootstrap", runtimeMode: "legacy", status: "failed", errorCode: "setup_failed",
|
||
agentId: "agent-1", agentName: "Runner", adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:01:00.000Z", startedAt: "2026-08-25T18:01:00.000Z",
|
||
finishedAt: "2026-08-25T18:01:02.000Z",
|
||
},
|
||
]} />);
|
||
const retryButtons = Array.from(container.querySelectorAll<HTMLButtonElement>('[data-testid="task-chat-run-failed-try-again"]'));
|
||
if (!continued) {
|
||
expect(retryButtons).toHaveLength(0);
|
||
return;
|
||
}
|
||
expect(retryButtons.length).toBeGreaterThan(0);
|
||
flushSync(() => retryButtons.at(-1)!.click());
|
||
await Promise.resolve();
|
||
expect(onRetryFailedRun).toHaveBeenCalledExactlyOnceWith("failed-bootstrap");
|
||
});
|
||
|
||
it.each([false, true])("never offers the old quarantined run as Try again after continuation: %s", continued => {
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} issueStatus="in_progress"
|
||
onRetryFailedRun={vi.fn()} linkedRuns={[{
|
||
runId: "quarantined", runtimeMode: "native", status: "failed", errorCode: "native_session_cleanup_quarantined",
|
||
agentId: "agent-1", agentName: "Runner", adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z", startedAt: "2026-08-25T18:00:00.000Z", finishedAt: "2026-08-25T18:00:02.000Z",
|
||
...(continued ? { execution: { phase: "completed" as const, label: "Continued in another run", cause: "native_session_cleanup_quarantined",
|
||
lastConfirmedActivityAt: null, retryAt: null, attempt: 2, maxAttempts: 3, recoveryOwner: null, nextAction: null,
|
||
permittedActions: ["inspect_run" as const], predecessorRunId: null, successorRunId: "fresh-run" } } : {}),
|
||
}]} />);
|
||
expect(container.textContent?.includes("Run failed")).toBe(!continued);
|
||
expect(container.querySelector('[data-testid="task-chat-run-failed-try-again"]')).toBeNull();
|
||
});
|
||
|
||
it("explains a native provider usage limit without exposing its error code", async () => {
|
||
const onRetryFailedRun = vi.fn();
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="blocked"
|
||
onRetryFailedRun={onRetryFailedRun}
|
||
linkedRuns={[
|
||
{
|
||
runId: "native-usage-limit",
|
||
runtimeMode: "native",
|
||
status: "failed",
|
||
errorCode: "native_provider_usage_limit",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:02.000Z",
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
const marker = container.querySelector(
|
||
'[data-testid="task-chat-collapsible-marker"]',
|
||
);
|
||
expect(marker?.textContent).toContain("Usage limit reached");
|
||
expect(marker?.textContent).not.toContain("Run failed");
|
||
const disclosure = marker?.querySelector<HTMLButtonElement>(
|
||
'button[aria-expanded="false"]',
|
||
);
|
||
expect(disclosure).not.toBeNull();
|
||
flushSync(() => disclosure!.click());
|
||
const details = container.querySelector(
|
||
'[data-testid="task-chat-collapsible-marker-details"]',
|
||
);
|
||
expect(details?.textContent).toContain(
|
||
"The model provider has reached its current usage limit. Try again after the limit resets.",
|
||
);
|
||
expect(details?.textContent).not.toContain("native_provider_usage_limit");
|
||
const retry = container.querySelector<HTMLButtonElement>(
|
||
'[data-testid="task-chat-run-failed-try-again"]',
|
||
);
|
||
expect(retry).not.toBeNull();
|
||
flushSync(() => retry!.click());
|
||
await Promise.resolve();
|
||
expect(onRetryFailedRun).toHaveBeenCalledWith("native-usage-limit");
|
||
});
|
||
|
||
it("explains a legacy run prevented from starting by a reconciliation hold", () => {
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} linkedRuns={[{
|
||
runId: "blocked-legacy", runtimeMode: "legacy", status: "cancelled",
|
||
errorCode: "execution_reconciliation_required", agentId: "agent-1", agentName: "Runner",
|
||
adapterType: "claude_local", createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: null, finishedAt: "2026-08-25T18:00:00.012Z",
|
||
}]} />);
|
||
expect(container.textContent).toContain("Waiting to resume");
|
||
expect(container.textContent).not.toContain("No user-facing response");
|
||
expect(container.textContent).not.toContain("Run completed");
|
||
expect(container.querySelector(".text-destructive")).toBeNull();
|
||
});
|
||
|
||
it.each(["legacy", "native"] as const)("groups repeated %s pre-start holds without hiding executed work", (runtimeMode) => {
|
||
const heldRun = (id: string, recoveryActionId: string, startedAt: string | null = null) => ({
|
||
runId: id, runtimeMode, status: "cancelled", errorCode: "execution_reconciliation_required",
|
||
agentId: "agent-1", adapterType: runtimeMode === "native" ? "paperclip_runner" : "claude_local",
|
||
createdAt: "2026-09-10T18:00:00.000Z", finishedAt: "2026-09-10T18:00:01.000Z", startedAt,
|
||
resultJson: { executionWait: { recoveryActionId } },
|
||
});
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} linkedRuns={[
|
||
...Array.from({ length: 100 }, (_, i) => heldRun(`wait-${i}`, "hold-1")),
|
||
heldRun("ran", "hold-1", "2026-09-10T18:00:00.500Z"),
|
||
heldRun("new-hold", "hold-2"),
|
||
heldRun("same-new-hold", "hold-2"),
|
||
]} />);
|
||
expect(container.textContent?.match(/Waiting to resume/g)).toHaveLength(2);
|
||
expect(container.textContent).not.toContain("Couldn't start");
|
||
expect(container.textContent).toContain(runtimeMode === "native" ? "Run cancelled" : "Stopped");
|
||
});
|
||
|
||
it("shows cancellation after native progress without offering a retry", () => {
|
||
nativeTranscriptState.transcriptByRun.set("native-cancelled", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Work was in progress.",
|
||
channel: "progress",
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
linkedRuns={[
|
||
{
|
||
runId: "native-cancelled",
|
||
runtimeMode: "native",
|
||
status: "cancelled",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:02.000Z",
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
expect(container.textContent).toContain("Work was in progress.");
|
||
expect(container.querySelector('[data-testid="task-chat-collapsible-marker"] button')?.classList).toContain("text-muted-foreground");
|
||
expect(container.querySelector('[data-testid="task-chat-collapsible-marker"] .text-destructive')).toBeNull();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-collapsible-marker"]')
|
||
?.textContent,
|
||
).toContain("Run cancelled");
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-run-failed-try-again"]'),
|
||
).toBeNull();
|
||
});
|
||
|
||
it.each([
|
||
["failed", "Run failed"],
|
||
["timed_out", "Run timed out"],
|
||
["cancelled", "Run cancelled"],
|
||
["interrupted", "Run interrupted"],
|
||
] as const)(
|
||
"does not claim a native %s run returned no answer when its final response is visible",
|
||
(status, expectedLabel) => {
|
||
nativeTranscriptState.transcriptByRun.set(`native-${status}`, [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: `Final response before ${status}.`,
|
||
channel: "final",
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
linkedRuns={[
|
||
{
|
||
runId: `native-${status}`,
|
||
runtimeMode: "native",
|
||
status,
|
||
errorCode: `native_${status}`,
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:02.000Z",
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
const finalResponses = container.querySelectorAll(
|
||
'[data-testid="task-chat-final-response"]',
|
||
);
|
||
expect(finalResponses).toHaveLength(1);
|
||
expect(finalResponses[0]?.textContent).toContain(
|
||
`Final response before ${status}.`,
|
||
);
|
||
|
||
const marker = container.querySelector(
|
||
'[data-testid="task-chat-collapsible-marker"]',
|
||
);
|
||
expect(marker?.textContent).toContain(expectedLabel);
|
||
const markerToggle = marker?.querySelector<HTMLButtonElement>(
|
||
'button[aria-expanded="false"]',
|
||
);
|
||
expect(markerToggle).not.toBeNull();
|
||
flushSync(() => markerToggle!.click());
|
||
|
||
const detail = container.querySelector(
|
||
'[data-testid="task-chat-collapsible-marker-details"]',
|
||
);
|
||
expect(detail?.textContent).toContain("after returning a final response");
|
||
expect(detail?.textContent).not.toContain("before returning an answer");
|
||
expect(container.textContent).not.toContain(
|
||
"The runner returned no user-facing response.",
|
||
);
|
||
},
|
||
);
|
||
|
||
it("shows an actionable approval-required reason for a stopped native run", () => {
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} linkedRuns={[{
|
||
runId: "approval-required", runtimeMode: "native", status: "failed",
|
||
errorCode: "native_provider_approval_required",
|
||
agentId: "agent-1", agentName: "Runner", adapterType: "paperclip_runner",
|
||
startedAt: "2026-09-14T15:00:00.000Z", createdAt: "2026-09-14T15:00:00.000Z",
|
||
finishedAt: "2026-09-14T15:00:02.000Z",
|
||
}]} />);
|
||
const marker = container.querySelector('[data-testid="task-chat-collapsible-marker"]');
|
||
expect(marker?.textContent).toContain("Approval required");
|
||
flushSync(() => marker!.querySelector<HTMLButtonElement>('button[aria-expanded="false"]')!.click());
|
||
expect(container.textContent).toContain("Review the operation and update the agent's permission setting before retrying");
|
||
expect(container.textContent).not.toContain("The runner stopped");
|
||
});
|
||
|
||
it.each([
|
||
"The 'gpt-6.1-sol' model is not supported when using Codex with a ChatGPT account.",
|
||
"The selected model is not supported by the current ChatGPT connection. Choose a supported model or a compatible AI connection.",
|
||
])("promotes a rejected model above the runner's generated failure response: %s", (error) => {
|
||
nativeTranscriptState.transcriptByRun.set("model-rejected", [{
|
||
kind: "run_result", ts: "2026-08-25T18:00:01.000Z",
|
||
summary: "The Codex run failed before it completed.",
|
||
disposition: "needs_review", objectiveSatisfied: false, verification: [],
|
||
remainingWork: [], blocker: null, artifacts: [],
|
||
}]);
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} linkedRuns={[{
|
||
runId: "model-rejected", runtimeMode: "native", status: "failed",
|
||
errorCode: "native_provider_model_rejected",
|
||
error,
|
||
agentId: "agent-1", agentName: "Runner", adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z", startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:02.000Z",
|
||
}]} />);
|
||
const marker = container.querySelector('[data-testid="task-chat-collapsible-marker"]');
|
||
expect(marker?.textContent).toContain("Model unavailable");
|
||
flushSync(() => marker!.querySelector<HTMLButtonElement>('button[aria-expanded="false"]')!.click());
|
||
expect(container.textContent).toContain(error);
|
||
expect(container.textContent).toContain("clear the task's model override, then retry");
|
||
expect(container.textContent).not.toContain("after returning a final response");
|
||
});
|
||
|
||
it("keeps workspace contention out of the conversation's cancellation markers", () => {
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} linkedRuns={[{
|
||
runId: "workspace-wait", runtimeMode: "native", status: "cancelled", errorCode: "workspace_busy",
|
||
agentId: "agent-1", agentName: "Runner", adapterType: "paperclip_runner", startedAt: null,
|
||
createdAt: "2026-09-12T18:00:00.000Z", finishedAt: "2026-09-12T18:00:01.000Z",
|
||
}]} />);
|
||
expect(container.textContent).not.toContain("Run cancelled");
|
||
expect(container.textContent).not.toContain("Run failed");
|
||
expect(container.textContent).not.toContain("before returning an answer");
|
||
});
|
||
|
||
it("does not render an empty response notice for a conversation reset", () => {
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} linkedRuns={[{
|
||
runId: "chat-reset", status: "succeeded", startedAt: null, resultJson: { conversationReset: true },
|
||
agentId: "agent-1", agentName: "Claude", adapterType: "claude_local",
|
||
createdAt: "2026-09-11T18:00:00.000Z", finishedAt: "2026-09-11T18:00:01.000Z",
|
||
}]} />);
|
||
expect(container.textContent).not.toContain("The runner returned no user-facing response.");
|
||
expect(container.textContent).not.toContain("Run completed");
|
||
});
|
||
|
||
it.each([
|
||
["legacy", "issue_not_in_progress"],
|
||
["native", "issue_not_in_progress"],
|
||
["legacy", "issue_terminal_status"],
|
||
["native", "issue_terminal_status"],
|
||
] as const)(
|
||
"hides a redundant cancelled continuation (%s, %s)",
|
||
(runtimeMode, errorCode) => {
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
linkedRuns={[
|
||
{
|
||
runId: "connection-continuation-skipped",
|
||
runtimeMode,
|
||
status: "cancelled",
|
||
errorCode,
|
||
startedAt: null,
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-09-07T18:00:00.000Z",
|
||
finishedAt: "2026-09-07T18:00:01.000Z",
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
expect(container.textContent).not.toContain(
|
||
"The runner returned no user-facing response.",
|
||
);
|
||
expect(container.textContent).not.toContain("Run completed");
|
||
expect(container.textContent).not.toContain("Couldn't start");
|
||
expect(container.textContent).not.toContain("Run cancelled");
|
||
expect(container.textContent).not.toContain("before returning an answer");
|
||
},
|
||
);
|
||
|
||
it.each(["legacy", "native"] as const)(
|
||
"keeps a cancellation visible when the %s run had already started",
|
||
(runtimeMode) => {
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
linkedRuns={[
|
||
{
|
||
runId: "started-cancellation",
|
||
runtimeMode,
|
||
status: "cancelled",
|
||
errorCode: "issue_terminal_status",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-09-07T18:00:00.000Z",
|
||
startedAt: "2026-09-07T18:00:00.500Z",
|
||
finishedAt: "2026-09-07T18:00:01.000Z",
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
expect(container.textContent).toContain(
|
||
runtimeMode === "native" ? "Run cancelled" : "Stopped",
|
||
);
|
||
},
|
||
);
|
||
|
||
it("does not treat a progress comment as the final response of a failed native run", () => {
|
||
nativeTranscriptState.transcriptByRun.set("native-progress-failed", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Still working through the provider request.",
|
||
channel: "progress",
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[
|
||
{
|
||
id: "progress-comment",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "agent",
|
||
authorAgentId: "agent-1",
|
||
authorUserId: null,
|
||
body: "Progress checkpoint only.",
|
||
presentation: null,
|
||
metadata: null,
|
||
runId: "native-progress-failed",
|
||
createdAt: new Date("2026-08-25T18:00:01.500Z"),
|
||
updatedAt: new Date("2026-08-25T18:00:01.500Z"),
|
||
},
|
||
]}
|
||
onAdd={async () => {}}
|
||
linkedRuns={[
|
||
{
|
||
runId: "native-progress-failed",
|
||
runtimeMode: "native",
|
||
status: "failed",
|
||
errorCode: "provider_transport_failed",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:02.000Z",
|
||
resultJson: {
|
||
presentationDecision: {
|
||
schema: "paperclip.run_presentation_decision.v1",
|
||
chosenSource: "none",
|
||
commentId: null,
|
||
},
|
||
},
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
const marker = container.querySelector(
|
||
'[data-testid="task-chat-collapsible-marker"]',
|
||
);
|
||
const markerToggle = marker?.querySelector<HTMLButtonElement>(
|
||
'button[aria-expanded="false"]',
|
||
);
|
||
expect(markerToggle).not.toBeNull();
|
||
flushSync(() => markerToggle!.click());
|
||
expect(
|
||
container.querySelector(
|
||
'[data-testid="task-chat-collapsible-marker-details"]',
|
||
)?.textContent,
|
||
).toContain("The runner stopped (provider_transport_failed).");
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-final-response"]'),
|
||
).toBeNull();
|
||
});
|
||
|
||
it("does not repeat progress when the persisted completion comment owns the same text", () => {
|
||
const repeated = "BASELINE-DONE";
|
||
nativeTranscriptState.transcriptByRun.set("native-repeated-final", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: repeated,
|
||
channel: "progress",
|
||
},
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:02.000Z",
|
||
text: repeated,
|
||
channel: "final",
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[
|
||
{
|
||
id: "native-repeated-final-comment",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "agent",
|
||
authorAgentId: "agent-1",
|
||
authorUserId: null,
|
||
body: repeated,
|
||
presentation: null,
|
||
metadata: null,
|
||
runId: "native-repeated-final",
|
||
createdAt: new Date("2026-08-25T18:00:03.000Z"),
|
||
updatedAt: new Date("2026-08-25T18:00:03.000Z"),
|
||
},
|
||
]}
|
||
onAdd={async () => {}}
|
||
linkedRuns={[
|
||
{
|
||
runId: "native-repeated-final",
|
||
runtimeMode: "native",
|
||
status: "succeeded",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:03.000Z",
|
||
resultJson: {
|
||
presentationDecision: {
|
||
schema: "paperclip.run_presentation_decision.v1",
|
||
chosenSource: "final_agent_message",
|
||
commentId: "native-repeated-final-comment",
|
||
},
|
||
},
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
expect(container.textContent?.split(repeated)).toHaveLength(2);
|
||
expect(
|
||
Array.from(
|
||
container.querySelectorAll(
|
||
'[data-testid="task-chat-phase-interstitial"]',
|
||
),
|
||
).some((element) => element.textContent?.includes(repeated)),
|
||
).toBe(false);
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-agent-bubble"]')
|
||
?.textContent,
|
||
).toContain(repeated);
|
||
});
|
||
|
||
it("removes only the final repeated progress across steering segments", () => {
|
||
const repeated = "SAME-BEFORE-AND-AFTER";
|
||
nativeTranscriptState.transcriptByRun.set("native-steered-repetition", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: repeated,
|
||
channel: "progress",
|
||
},
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:03.000Z",
|
||
text: repeated,
|
||
channel: "progress",
|
||
},
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:04.000Z",
|
||
text: repeated,
|
||
channel: "final",
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[
|
||
{
|
||
id: "steering-comment",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "user",
|
||
authorAgentId: null,
|
||
authorUserId: "user-1",
|
||
body: "Steer this run.",
|
||
presentation: null,
|
||
metadata: null,
|
||
runId: null,
|
||
followUpRequested: true,
|
||
consumedByRunId: "native-steered-repetition",
|
||
steeredIntoRunId: "native-steered-repetition",
|
||
conversationAnchorAt: new Date("2026-08-25T18:00:02.000Z"),
|
||
createdAt: new Date("2026-08-25T17:59:32.000Z"),
|
||
updatedAt: new Date("2026-08-25T18:00:02.000Z"),
|
||
},
|
||
{
|
||
id: "native-steered-repetition-final",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "agent",
|
||
authorAgentId: "agent-1",
|
||
authorUserId: null,
|
||
body: repeated,
|
||
presentation: null,
|
||
metadata: null,
|
||
runId: "native-steered-repetition",
|
||
createdAt: new Date("2026-08-25T18:00:05.000Z"),
|
||
updatedAt: new Date("2026-08-25T18:00:05.000Z"),
|
||
},
|
||
]}
|
||
onAdd={async () => {}}
|
||
linkedRuns={[
|
||
{
|
||
runId: "native-steered-repetition",
|
||
runtimeMode: "native",
|
||
status: "succeeded",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:05.000Z",
|
||
resultJson: {
|
||
presentationDecision: {
|
||
schema: "paperclip.run_presentation_decision.v1",
|
||
chosenSource: "final_agent_message",
|
||
commentId: "native-steered-repetition-final",
|
||
},
|
||
},
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
const matchingPhases = Array.from(
|
||
container.querySelectorAll(
|
||
'[data-testid="task-chat-phase-interstitial"]',
|
||
),
|
||
).filter((element) => element.textContent?.includes(repeated));
|
||
expect(matchingPhases).toHaveLength(1);
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-agent-bubble"]')
|
||
?.textContent,
|
||
).toContain(repeated);
|
||
expect(container.textContent).toContain(
|
||
new Date("2026-08-25T17:59:32.000Z").toLocaleTimeString([], { hour: "numeric", minute: "2-digit" }),
|
||
);
|
||
const turnHeaders = Array.from(
|
||
container.querySelectorAll('[data-testid="task-chat-turn-summary"]'),
|
||
);
|
||
expect(turnHeaders).toHaveLength(2);
|
||
expect(turnHeaders[0]?.textContent).not.toContain(
|
||
"Continued after steering",
|
||
);
|
||
expect(turnHeaders[1]?.textContent).toContain(
|
||
"Continued after steering · Worked for",
|
||
);
|
||
});
|
||
|
||
it("labels the live tail as a continuation after the steering bubble", () => {
|
||
nativeTranscriptState.transcriptByRun.set("native-live-steered", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Work before steering.",
|
||
channel: "progress",
|
||
},
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:03.000Z",
|
||
text: "Work after steering.",
|
||
channel: "progress",
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[
|
||
{
|
||
id: "live-steering-comment",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "user",
|
||
authorAgentId: null,
|
||
authorUserId: "user-1",
|
||
body: "Change course now.",
|
||
presentation: null,
|
||
metadata: null,
|
||
runId: null,
|
||
consumedByRunId: "native-live-steered",
|
||
steeredIntoRunId: "native-live-steered",
|
||
conversationAnchorAt: new Date("2026-08-25T18:00:02.000Z"),
|
||
createdAt: new Date("2026-08-25T17:59:32.000Z"),
|
||
updatedAt: new Date("2026-08-25T18:00:02.000Z"),
|
||
},
|
||
]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{
|
||
id: "native-live-steered",
|
||
runtimeMode: "native",
|
||
status: "running",
|
||
invocationSource: "issue",
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-turn-summary"]')
|
||
?.textContent,
|
||
).not.toContain("Continued after steering");
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-turn-status-header"]')
|
||
?.textContent,
|
||
).toContain("Continued after steering · Working for");
|
||
expect(container.textContent).toContain(
|
||
new Date("2026-08-25T17:59:32.000Z").toLocaleTimeString([], { hour: "numeric", minute: "2-digit" }),
|
||
);
|
||
});
|
||
|
||
it.each([
|
||
"missing_result_metadata",
|
||
"yielded_result_metadata",
|
||
"steered_missing_result_metadata",
|
||
"persisted_response_comment",
|
||
"pending_attention",
|
||
"live",
|
||
"failed",
|
||
"proposed",
|
||
"question",
|
||
"approval",
|
||
])("renders only an authorized terminal response-wake answer: %s", (mode) => {
|
||
const runId = "native-checklist-response";
|
||
const summary =
|
||
"**Before release**\n- Test and rehearse rollback.\n\n**During release**\n- Deploy incrementally and watch errors.\n\n**After release**\n- Verify workflows and record follow-ups.";
|
||
const result = {
|
||
schema: "paperclip.run_result.v1",
|
||
reportedWorkDisposition: "yielded",
|
||
summary,
|
||
completionClaim: { objectiveSatisfied: true, remainingWork: [] },
|
||
continuation: {
|
||
kind: "response_wake",
|
||
idempotencyKey: "next-chat-input",
|
||
},
|
||
attentionRequests:
|
||
mode === "question" || mode === "approval"
|
||
? [
|
||
{
|
||
kind:
|
||
mode === "question"
|
||
? "ask_user_questions"
|
||
: "request_confirmation",
|
||
},
|
||
]
|
||
: [],
|
||
evidence: [],
|
||
verification: [],
|
||
artifacts: [],
|
||
};
|
||
const event = (
|
||
seq: number,
|
||
eventType: string,
|
||
payload: Record<string, unknown>,
|
||
) =>
|
||
({
|
||
id: seq,
|
||
companyId: "company-1",
|
||
agentId: "agent-1",
|
||
stream: "system",
|
||
level: "info",
|
||
color: null,
|
||
message: null,
|
||
runId,
|
||
seq,
|
||
eventType,
|
||
createdAt: new Date("2026-08-25T18:00:00Z"),
|
||
payload: {
|
||
prpEvent: {
|
||
schema: "paperclip.prp.event.v1",
|
||
schemaVersion: 1,
|
||
runId,
|
||
eventType,
|
||
sourceEventId: `checklist-${seq}`,
|
||
sourceKind:
|
||
eventType === "run.result.accepted" ||
|
||
eventType === "run.terminal"
|
||
? "control_plane"
|
||
: "runner",
|
||
sourceInstanceId: "runner-1",
|
||
sourceSeq: seq,
|
||
normalizedSessionId: "session-1",
|
||
emittedAt: `2026-08-25T18:00:0${seq}Z`,
|
||
payload,
|
||
},
|
||
},
|
||
}) satisfies HeartbeatRunEvent;
|
||
nativeTranscriptState.transcriptByRun.set(
|
||
runId,
|
||
nativeRunEventsToTranscript([
|
||
event(1, "item.completed", {
|
||
kind: "agentMessage",
|
||
channel: "progress",
|
||
item: {
|
||
id: "preamble",
|
||
type: "agentMessage",
|
||
channel: "progress",
|
||
text: "I’m providing the requested checklist and leaving the task open.",
|
||
},
|
||
}),
|
||
event(2, "run.result.proposed", result),
|
||
...(mode === "proposed"
|
||
? []
|
||
: [event(3, "run.result.accepted", { result })]),
|
||
event(4, "run.terminal", {
|
||
schema: "paperclip.prp.terminal.v1",
|
||
turnTerminalState: "completed",
|
||
runTerminalState: "succeeded",
|
||
reportedWorkDisposition: "yielded",
|
||
}),
|
||
]),
|
||
);
|
||
render(
|
||
<TaskChatThread
|
||
comments={
|
||
mode === "steered_missing_result_metadata"
|
||
? [
|
||
{
|
||
id: "response-wake-steering",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "user",
|
||
authorAgentId: null,
|
||
authorUserId: "user-1",
|
||
body: "Keep the task open for follow-up.",
|
||
presentation: null,
|
||
metadata: null,
|
||
runId: null,
|
||
followUpRequested: true,
|
||
consumedByRunId: runId,
|
||
steeredIntoRunId: runId,
|
||
conversationAnchorAt: new Date("2026-08-25T18:00:03.500Z"),
|
||
createdAt: new Date("2026-08-25T18:00:03.000Z"),
|
||
updatedAt: new Date("2026-08-25T18:00:03.500Z"),
|
||
},
|
||
]
|
||
: mode === "persisted_response_comment"
|
||
? [
|
||
{
|
||
id: "private-board-response",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "agent",
|
||
authorAgentId: "agent-1",
|
||
authorUserId: null,
|
||
body: summary,
|
||
presentation: null,
|
||
metadata: null,
|
||
createdByRunId: runId,
|
||
runId,
|
||
createdAt: new Date("2026-08-25T18:00:29.000Z"),
|
||
updatedAt: new Date("2026-08-25T18:00:29.000Z"),
|
||
},
|
||
]
|
||
: []
|
||
}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
interactions={
|
||
mode === "pending_attention"
|
||
? [planReviewInteraction("pending", "revision-3", runId)]
|
||
: []
|
||
}
|
||
activeRun={
|
||
mode === "live"
|
||
? {
|
||
id: runId,
|
||
runtimeMode: "native",
|
||
status: "running",
|
||
invocationSource: "issue",
|
||
triggerDetail: null,
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00Z",
|
||
startedAt: "2026-08-25T18:00:00Z",
|
||
finishedAt: null,
|
||
}
|
||
: undefined
|
||
}
|
||
linkedRuns={[
|
||
{
|
||
runId,
|
||
runtimeMode: "native",
|
||
status:
|
||
mode === "live"
|
||
? "running"
|
||
: mode === "failed"
|
||
? "failed"
|
||
: "succeeded",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00Z",
|
||
startedAt: "2026-08-25T18:00:00Z",
|
||
finishedAt: mode === "live" ? null : "2026-08-25T18:00:30Z",
|
||
resultJson: mode.endsWith("missing_result_metadata")
|
||
? { recoveredExecutionFailure: { errorCode: "adapter_failed" } }
|
||
: {
|
||
nativeResult: result,
|
||
...(mode === "persisted_response_comment"
|
||
? {
|
||
presentationDecision: {
|
||
schema: "paperclip.run_presentation_decision.v1",
|
||
chosenSource: "existing_issue_comment",
|
||
commentId: "private-board-response",
|
||
},
|
||
}
|
||
: {}),
|
||
},
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
const responses = container.querySelectorAll(
|
||
'[data-testid="task-chat-final-response"]',
|
||
);
|
||
if (mode === "persisted_response_comment") {
|
||
expect(responses).toHaveLength(0);
|
||
expect(container.textContent?.split("Before release")).toHaveLength(2);
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-agent-bubble"]')
|
||
?.textContent,
|
||
).toContain("After release");
|
||
return;
|
||
}
|
||
if (
|
||
mode !== "missing_result_metadata" &&
|
||
mode !== "yielded_result_metadata" &&
|
||
mode !== "steered_missing_result_metadata"
|
||
) {
|
||
expect(responses).toHaveLength(0);
|
||
return;
|
||
}
|
||
expect(responses).toHaveLength(1);
|
||
expect(responses[0]?.textContent).toContain("Before release");
|
||
expect(responses[0]?.textContent).toContain("After release");
|
||
expect(responses[0]?.textContent).not.toContain("I’m providing");
|
||
expect(container.textContent).not.toContain(
|
||
"The runner returned no user-facing response.",
|
||
);
|
||
});
|
||
|
||
it("keeps a yielded question turn out of the final-response slot", () => {
|
||
nativeTranscriptState.transcriptByRun.set("native-question", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: "Preparing the verification question.",
|
||
channel: "progress",
|
||
},
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:02.000Z",
|
||
text: "Waiting for Choose the verification word.",
|
||
channel: "final",
|
||
},
|
||
]);
|
||
nativeTranscriptState.transcriptByRun.set("native-continuation", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:01:01.000Z",
|
||
text: "Cobalt was selected and the task is complete.",
|
||
channel: "final",
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[
|
||
{
|
||
id: "native-question-placeholder",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "agent",
|
||
authorAgentId: "agent-1",
|
||
authorUserId: null,
|
||
body: "Run completed. Agent did not post a summary comment this run (transcript withheld — see run log).",
|
||
presentation: null,
|
||
metadata: null,
|
||
runId: "native-question",
|
||
createdAt: new Date("2026-08-25T18:00:03.000Z"),
|
||
updatedAt: new Date("2026-08-25T18:00:03.000Z"),
|
||
},
|
||
]}
|
||
onAdd={async () => {}}
|
||
linkedRuns={[
|
||
{
|
||
runId: "native-question",
|
||
runtimeMode: "native",
|
||
status: "succeeded",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:03.000Z",
|
||
resultJson: {
|
||
nativeResult: {
|
||
schema: "paperclip.run_result.v1",
|
||
reportedWorkDisposition: "yielded",
|
||
summary: "Waiting for Choose the verification word.",
|
||
},
|
||
presentationDecision: {
|
||
schema: "paperclip.run_presentation_decision.v1",
|
||
chosenSource: "none",
|
||
commentId: null,
|
||
},
|
||
},
|
||
},
|
||
{
|
||
runId: "native-continuation",
|
||
runtimeMode: "native",
|
||
status: "succeeded",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
createdAt: "2026-08-25T18:01:00.000Z",
|
||
startedAt: "2026-08-25T18:01:00.000Z",
|
||
finishedAt: "2026-08-25T18:01:02.000Z",
|
||
resultJson: {
|
||
nativeResult: {
|
||
schema: "paperclip.run_result.v1",
|
||
reportedWorkDisposition: "done",
|
||
summary: "Cobalt was selected and the task is complete.",
|
||
},
|
||
presentationDecision: {
|
||
schema: "paperclip.run_presentation_decision.v1",
|
||
chosenSource: "none",
|
||
commentId: null,
|
||
},
|
||
},
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
const finalResponses = container.querySelectorAll(
|
||
'[data-testid="task-chat-final-response"]',
|
||
);
|
||
expect(finalResponses).toHaveLength(1);
|
||
expect(finalResponses[0]?.textContent).toContain(
|
||
"Cobalt was selected and the task is complete.",
|
||
);
|
||
expect(container.textContent).toContain(
|
||
"Preparing the verification question.",
|
||
);
|
||
expect(container.textContent).not.toContain(
|
||
"Waiting for Choose the verification word.",
|
||
);
|
||
expect(container.textContent).not.toContain("transcript withheld");
|
||
});
|
||
|
||
it.each(["failed", "timed_out", "cancelled"] as const)(
|
||
"keeps an empty legacy %s actionable without turning Stop into Retry",
|
||
async (status) => {
|
||
const onRetryFailedRun = vi.fn();
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="blocked"
|
||
onRetryFailedRun={onRetryFailedRun}
|
||
linkedRuns={[
|
||
{
|
||
runId: "legacy-failed",
|
||
runtimeMode: "legacy",
|
||
status,
|
||
errorCode: "legacy_process_exited",
|
||
agentId: "agent-1",
|
||
agentName: "Direct Codex",
|
||
adapterType: "codex_local",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:02.000Z",
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
expect(container.textContent).toContain(status === "cancelled" ? "Stopped" : "Run failed");
|
||
if (status !== "cancelled") {
|
||
expect(container.textContent).toContain("You can retry this message now.");
|
||
}
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-collapsible-marker"]'),
|
||
).toBeNull();
|
||
const retry = container.querySelector<HTMLButtonElement>('[data-testid="task-chat-run-failed-try-again"]');
|
||
if (status === "cancelled") {
|
||
expect(retry).toBeNull();
|
||
} else {
|
||
expect(retry).not.toBeNull();
|
||
flushSync(() => retry!.click());
|
||
await Promise.resolve();
|
||
expect(onRetryFailedRun).toHaveBeenCalledExactlyOnceWith("legacy-failed");
|
||
}
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-runner-turn"]'),
|
||
).toBeNull();
|
||
},
|
||
);
|
||
|
||
it.each(["failed", "timed_out"] as const)(
|
||
"retries the latest legacy %s attempt even when it has a transcript and final comment",
|
||
async (status) => {
|
||
const onRetryFailedRun = vi.fn();
|
||
transcriptState.transcriptByRun.set("latest-attempt", [{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:01:01.000Z",
|
||
text: "Starting the requested revision.",
|
||
}]);
|
||
const run = {
|
||
runtimeMode: "legacy" as const,
|
||
adapterType: "claude_local",
|
||
agentId: "agent-1",
|
||
agentName: "Direct agent",
|
||
startedAt: null,
|
||
};
|
||
render(
|
||
<TaskChatThread
|
||
comments={[{
|
||
id: "failure-comment",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorAgentId: "agent-1",
|
||
authorUserId: null,
|
||
authorType: "agent",
|
||
presentation: null,
|
||
metadata: null,
|
||
body: "The startup handshake timed out.",
|
||
runId: "latest-attempt",
|
||
createdAt: new Date("2026-08-25T18:01:02.000Z"),
|
||
updatedAt: new Date("2026-08-25T18:01:02.000Z"),
|
||
}]}
|
||
onAdd={async () => {}}
|
||
issueStatus="todo"
|
||
onRetryFailedRun={onRetryFailedRun}
|
||
linkedRuns={[
|
||
{ ...run, runId: "original-failure", status: "failed",
|
||
createdAt: "2026-08-25T18:00:00.000Z", startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:02.000Z" },
|
||
{ ...run, runId: "latest-attempt", status, errorCode: "acpx_handshake_timeout",
|
||
createdAt: "2026-08-25T18:01:00.000Z", startedAt: "2026-08-25T18:01:00.000Z",
|
||
finishedAt: "2026-08-25T18:01:02.000Z",
|
||
resultJson: { presentationDecision: { commentId: "failure-comment" } } },
|
||
{ ...run, runId: "cancelled-automatic-retry", status: "cancelled",
|
||
errorCode: "execution_reconciliation_required",
|
||
createdAt: "2026-08-25T18:02:00.000Z", finishedAt: "2026-08-25T18:02:02.000Z" },
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
expect(container.textContent).toContain("The startup handshake timed out.");
|
||
const buttons = container.querySelectorAll<HTMLButtonElement>('[data-testid="task-chat-run-failed-try-again"]');
|
||
expect(buttons).toHaveLength(1);
|
||
flushSync(() => buttons[0]!.click());
|
||
await Promise.resolve();
|
||
expect(onRetryFailedRun).toHaveBeenCalledExactlyOnceWith("latest-attempt");
|
||
},
|
||
);
|
||
|
||
it.each(["active execution", "pending decision", "recovery hold"].flatMap(
|
||
(gate) => [false, true].map((hasTranscript) => ({ gate, hasTranscript })),
|
||
))(
|
||
"does not promise legacy Retry during $gate (transcript: $hasTranscript) and restores it when the gate clears",
|
||
({ gate, hasTranscript }) => {
|
||
const onRetryFailedRun = vi.fn();
|
||
if (hasTranscript) transcriptState.transcriptByRun.set("legacy-failed", [{
|
||
kind: "assistant", ts: "2026-08-25T18:00:01.000Z", text: "Starting the task.",
|
||
}]);
|
||
const failedRun = {
|
||
runId: "legacy-failed",
|
||
runtimeMode: "legacy" as const,
|
||
status: "failed",
|
||
errorCode: "legacy_process_exited",
|
||
agentId: "agent-1",
|
||
agentName: "Direct Codex",
|
||
adapterType: "codex_local",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:02.000Z",
|
||
};
|
||
const gateProps: Partial<ComponentProps<typeof TaskChatThread>> =
|
||
gate === "pending decision"
|
||
? { interactions: [planReviewInteraction()] }
|
||
: {
|
||
linkedRuns: [{
|
||
...failedRun,
|
||
execution: {
|
||
phase: gate === "active execution" ? "working" : "recovery_needed",
|
||
label: "Waiting",
|
||
cause: null,
|
||
lastConfirmedActivityAt: null,
|
||
retryAt: null,
|
||
attempt: 1,
|
||
maxAttempts: 3,
|
||
recoveryOwner: null,
|
||
nextAction: null,
|
||
permittedActions: [],
|
||
predecessorRunId: null,
|
||
successorRunId: null,
|
||
},
|
||
}],
|
||
};
|
||
const renderRun = (held: boolean) => render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="blocked"
|
||
onRetryFailedRun={onRetryFailedRun}
|
||
linkedRuns={[failedRun]}
|
||
{...(held ? gateProps : {})}
|
||
/>,
|
||
);
|
||
renderRun(true);
|
||
expect(container.textContent).toContain("Your message is preserved.");
|
||
expect(container.textContent).not.toContain("You can retry this message now.");
|
||
expect(container.querySelector('[data-testid="task-chat-run-failed-try-again"]')).toBeNull();
|
||
renderRun(false);
|
||
expect(container.textContent).toContain("You can retry this message now.");
|
||
expect(container.querySelector('[data-testid="task-chat-run-failed-try-again"]')).not.toBeNull();
|
||
},
|
||
);
|
||
|
||
it.each([
|
||
...["claude_local", "codex_local", "cursor", "gemini_local", "opencode_local",
|
||
"pi_local", "grok_local", "kimi_local", "hermes_local"].flatMap((adapterType) =>
|
||
["failed", "timed_out"].map((status) => ({ adapterType, status, runtimeMode: "legacy" as const,
|
||
cause: "legacy_execution_requires_reconciliation", canRetry: true }))),
|
||
{ adapterType: "paperclip_runner", status: "failed", runtimeMode: "native" as const,
|
||
cause: "legacy_execution_requires_reconciliation", canRetry: false },
|
||
{ adapterType: "process", status: "failed", runtimeMode: "legacy" as const,
|
||
cause: "legacy_execution_requires_reconciliation", canRetry: false },
|
||
{ adapterType: "claude_local", status: "failed", runtimeMode: "legacy" as const,
|
||
cause: "uncertain_provider_action", canRetry: false },
|
||
{ adapterType: "claude_local", status: "cancelled", runtimeMode: "legacy" as const,
|
||
cause: "legacy_execution_requires_reconciliation", canRetry: false },
|
||
])("offers only explicit conversation retries: $runtimeMode/$adapterType/$status/$cause", (testCase) => {
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="blocked"
|
||
onRetryFailedRun={vi.fn()}
|
||
linkedRuns={[{
|
||
runId: "stopped-run",
|
||
runtimeMode: testCase.runtimeMode,
|
||
adapterType: testCase.adapterType,
|
||
status: testCase.status,
|
||
agentId: "agent-1",
|
||
agentName: "Stopped agent",
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:02.000Z",
|
||
execution: {
|
||
phase: "recovery_needed", label: "Stopped", cause: testCase.cause,
|
||
lastConfirmedActivityAt: null, retryAt: null, attempt: 1, maxAttempts: 3,
|
||
recoveryOwner: null, nextAction: null, permittedActions: [],
|
||
predecessorRunId: null, successorRunId: null,
|
||
},
|
||
}]}
|
||
/>,
|
||
);
|
||
expect(Boolean(container.querySelector('[data-testid="task-chat-run-failed-try-again"]')))
|
||
.toBe(testCase.canRetry);
|
||
if (testCase.canRetry) expect(container.textContent).toContain("You can retry this message now.");
|
||
else expect(container.textContent).not.toContain("You can retry this message now.");
|
||
});
|
||
|
||
it.each(DIRECT_ADAPTER_TYPES)(
|
||
"keeps active %s output on the legacy live-tail surface",
|
||
(adapterType) => {
|
||
const runId = `active-${adapterType}`;
|
||
transcriptState.transcriptByRun.set(runId, [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
text: `Active ${adapterType} output`,
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{
|
||
id: runId,
|
||
runtimeMode: "legacy",
|
||
status: "running",
|
||
invocationSource: "issue",
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Direct agent",
|
||
adapterType,
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-live-run-pill"]'),
|
||
).not.toBeNull();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-phase-interstitial"]')
|
||
?.textContent,
|
||
).toContain(`Active ${adapterType} output`);
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-runner-turn"]'),
|
||
).toBeNull();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-queued-messages"]'),
|
||
).toBeNull();
|
||
},
|
||
);
|
||
|
||
it.each(DIRECT_ADAPTER_TYPES)(
|
||
"keeps settled %s activity in the shared legacy turn",
|
||
(adapterType) => {
|
||
const runId = `settled-${adapterType}`;
|
||
transcriptState.transcriptByRun.set(runId, [
|
||
{
|
||
kind: "tool_call",
|
||
ts: "2026-08-25T18:00:01.000Z",
|
||
name: "Read",
|
||
toolUseId: `${runId}-tool`,
|
||
input: { file_path: "src/legacy.ts" },
|
||
},
|
||
{
|
||
kind: "tool_result",
|
||
ts: "2026-08-25T18:00:02.000Z",
|
||
toolUseId: `${runId}-tool`,
|
||
toolName: "Read",
|
||
content: "legacy contents",
|
||
isError: false,
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
linkedRuns={[
|
||
{
|
||
runId,
|
||
runtimeMode: "legacy",
|
||
status: "succeeded",
|
||
agentId: "agent-1",
|
||
agentName: "Direct agent",
|
||
adapterType,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: "2026-08-25T18:00:03.000Z",
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-turn"]'),
|
||
).not.toBeNull();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-turn-summary"]')
|
||
?.textContent,
|
||
).toContain("Worked");
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-runner-turn"]'),
|
||
).toBeNull();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-final-response"]'),
|
||
).toBeNull();
|
||
},
|
||
);
|
||
|
||
it.each(DIRECT_ADAPTER_TYPES)(
|
||
"keeps an empty active %s run on the legacy status surface",
|
||
(adapterType) => {
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{
|
||
id: `empty-${adapterType}`,
|
||
runtimeMode: "legacy",
|
||
status: "running",
|
||
invocationSource: "issue",
|
||
triggerDetail: null,
|
||
currentStatusMessage: "Preparing direct runtime",
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Direct agent",
|
||
adapterType,
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
const tail = container.querySelector(
|
||
'[data-testid="task-chat-live-transcript"]',
|
||
);
|
||
expect(tail?.textContent).toContain("Preparing direct runtime");
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-runner-turn"]'),
|
||
).toBeNull();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-composer-takeover"]'),
|
||
).toBeNull();
|
||
},
|
||
);
|
||
|
||
it.each(DIRECT_ADAPTER_TYPES)(
|
||
"keeps durable questions usable for an active %s run without runner controls",
|
||
(adapterType) => {
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
interactions={[
|
||
questionInteraction(
|
||
`question-${adapterType}`,
|
||
"Which legacy path should continue?",
|
||
"2026-08-25T18:00:01.000Z",
|
||
),
|
||
]}
|
||
onAdd={async () => {}}
|
||
onSubmitInteractionAnswers={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{
|
||
id: `question-run-${adapterType}`,
|
||
runtimeMode: "legacy",
|
||
status: "running",
|
||
invocationSource: "issue",
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-25T18:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-25T18:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Direct agent",
|
||
adapterType,
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-composer-takeover"]')
|
||
?.textContent,
|
||
).toContain("Which legacy path should continue?");
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-runner-turn"]'),
|
||
).toBeNull();
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-queued-messages"]'),
|
||
).toBeNull();
|
||
},
|
||
);
|
||
});
|
||
|
||
describe.each([true, false])("Unanswered question history (conversationMode=%s)", conversationMode => {
|
||
const old = questionInteraction("old", "Which color?", "2026-08-15T12:00:01Z");
|
||
const newer = questionInteraction("new", "Which tone?", "2026-08-15T12:05:00Z");
|
||
const movedOn = createLongThreadComments();
|
||
const props = { conversationMode, issueId: "issue-1", currentUserId: "user-board", onAdd: async () => {}, onSubmitInteractionAnswers: vi.fn() };
|
||
const takeover = () => container.querySelector('[data-testid="task-chat-composer-takeover"]');
|
||
const pendingIndicator = () => container.querySelector<HTMLButtonElement>('[data-testid="task-chat-pending-input-indicator"]');
|
||
const dismiss = async () => {
|
||
await act(async () => takeover()!.querySelector<HTMLButtonElement>('[aria-label^="Dismiss "]')!.click());
|
||
};
|
||
const click = async (text: string) => {
|
||
const button = Array.from(container.querySelectorAll<HTMLButtonElement>("button")).find(button => button.textContent?.trim() === text);
|
||
expect(button).toBeTruthy();
|
||
await act(async () => button!.click());
|
||
};
|
||
|
||
it("leaves a compact, reopenable question on reload after moving on", async () => {
|
||
render(<TaskChatThread {...props} comments={movedOn} interactions={[old]} />);
|
||
expect(takeover()).toBeNull();
|
||
expect(pendingIndicator()).toBeNull();
|
||
const row = container.querySelector<HTMLButtonElement>('[data-testid="task-chat-unanswered-question"]');
|
||
expect(row?.textContent).toContain("Which color?");
|
||
await act(async () => row!.click());
|
||
expect(takeover()?.textContent).toContain("Which color?");
|
||
await click("Yes");
|
||
await click("Submit answers");
|
||
expect(props.onSubmitInteractionAnswers).toHaveBeenCalledWith(old, [{ questionId: "old-question", optionIds: ["yes"] }]);
|
||
});
|
||
|
||
it("collapses a displayed question when a new user message arrives", async () => {
|
||
render(<TaskChatThread {...props} comments={[]} interactions={[old]} />);
|
||
expect(takeover()).not.toBeNull();
|
||
await act(async () => render(<TaskChatThread {...props} comments={movedOn} interactions={[old]} />));
|
||
expect(takeover()).toBeNull();
|
||
expect(pendingIndicator()).toBeNull();
|
||
expect(container.querySelector('[data-testid="task-chat-unanswered-question"]')).not.toBeNull();
|
||
});
|
||
|
||
it.each(["Cancel", "dismiss"])("leaves only the history card after %s on a fresh question", async action => {
|
||
render(<TaskChatThread {...props} comments={[]} interactions={[old]} />);
|
||
await click("Yes");
|
||
if (action === "Cancel") await click("Cancel");
|
||
else await dismiss();
|
||
expect(takeover()).toBeNull();
|
||
expect(pendingIndicator()).toBeNull();
|
||
await act(async () => container.querySelector<HTMLButtonElement>('[aria-label="Answer question: Which color?"]')!.click());
|
||
expect(takeover()?.querySelector('[role="radio"][aria-checked="true"]')?.textContent).toContain("Yes");
|
||
});
|
||
|
||
it("keeps multiple historical questions out of the composer after reopening and dismissing one", async () => {
|
||
const anotherOld = questionInteraction("another-old", "Which format?", "2026-08-15T12:00:02Z");
|
||
render(<TaskChatThread {...props} comments={movedOn} interactions={[old, anotherOld]} />);
|
||
expect(container.querySelectorAll('[data-testid="task-chat-unanswered-question"]')).toHaveLength(2);
|
||
expect(pendingIndicator()).toBeNull();
|
||
await act(async () => container.querySelector<HTMLButtonElement>('[aria-label="Answer question: Which color?"]')!.click());
|
||
expect(takeover()?.textContent).toContain("Which color?");
|
||
expect(takeover()?.textContent).not.toContain("2 pending");
|
||
await dismiss();
|
||
expect(takeover()).toBeNull();
|
||
expect(pendingIndicator()).toBeNull();
|
||
});
|
||
|
||
it("counts and cycles approvals without including fresh or historical question cards", async () => {
|
||
const approval = { ...planReviewInteraction(), id: "approval", title: "Approve the outline?", payload: { version: 1, prompt: "Approve the outline?" } } as IssueThreadInteraction;
|
||
const nextApproval = { ...approval, id: "next-approval", title: "Approve the note?", createdAt: new Date("2026-08-23T10:02:00Z"), payload: { version: 1, prompt: "Approve the note?" } } as IssueThreadInteraction;
|
||
render(<TaskChatThread {...props} comments={movedOn} interactions={[old, newer, approval, nextApproval]} />);
|
||
expect(takeover()?.textContent).toContain("Approve the note?");
|
||
await click("2 pending");
|
||
expect(takeover()?.textContent).toContain("Approve the outline?");
|
||
await click("2 pending");
|
||
expect(takeover()?.textContent).toContain("Approve the note?");
|
||
await act(async () => container.querySelector<HTMLButtonElement>('[aria-label="Answer question: Which color?"]')!.click());
|
||
expect(takeover()?.textContent).toContain("Which color?");
|
||
expect(takeover()?.textContent).toContain("2 pending");
|
||
expect(takeover()?.textContent).not.toContain("3 pending");
|
||
await dismiss();
|
||
expect(pendingIndicator()?.textContent).toContain("2 pending inputs");
|
||
await act(async () => pendingIndicator()!.click());
|
||
expect(takeover()?.textContent).toContain("Approve the note?");
|
||
});
|
||
|
||
it("opens the new question but can reopen the exact historical native question", async () => {
|
||
const nativeOld = { ...old, sourceRunId: "old-run", payload: { ...old.payload, runtimeRequestId: "old-request" } } as IssueThreadInteraction;
|
||
render(<TaskChatThread {...props} comments={movedOn} interactions={[nativeOld, newer]} />);
|
||
expect(takeover()?.textContent).toContain("Which tone?");
|
||
const oldRow = container.querySelector<HTMLButtonElement>('[aria-label="Answer question: Which color?"]');
|
||
await act(async () => oldRow!.click());
|
||
expect(takeover()?.textContent).toContain("Which color?");
|
||
expect(takeover()?.textContent).not.toContain("2 pending");
|
||
render(<TaskChatThread {...props} comments={[...movedOn]} interactions={[nativeOld, newer]} />);
|
||
expect(takeover()?.textContent).toContain("Which color?");
|
||
await dismiss();
|
||
expect(pendingIndicator()).toBeNull();
|
||
await act(async () => container.querySelector<HTMLButtonElement>('[aria-label="Answer question: Which tone?"]')!.click());
|
||
expect(takeover()?.textContent).toContain("Which tone?");
|
||
});
|
||
|
||
it.each([true, false])("only collapses the question after a successful send (success=%s)", async success => {
|
||
const onAdd = success ? vi.fn().mockResolvedValue(undefined) : vi.fn().mockRejectedValue(new Error("Message not sent"));
|
||
render(<TaskChatThread {...props} comments={[]} interactions={[old]} onAdd={onAdd} />);
|
||
await click("Yes");
|
||
await act(async () => editorCallbacks.change("Let's talk about tasks instead."));
|
||
const send = container.querySelector<HTMLButtonElement>('[data-testid="task-chat-composer-send"]');
|
||
expect(send?.disabled).toBe(false);
|
||
await act(async () => send!.click());
|
||
expect(onAdd).toHaveBeenCalledTimes(1);
|
||
if (success) {
|
||
expect(takeover()).toBeNull();
|
||
expect(pendingIndicator()).toBeNull();
|
||
await act(async () => container.querySelector<HTMLButtonElement>('[data-testid="task-chat-unanswered-question"]')!.click());
|
||
}
|
||
expect(takeover()).not.toBeNull();
|
||
expect(takeover()?.querySelector('[role="radio"][aria-checked="true"]')?.textContent).toContain("Yes");
|
||
expect(container.querySelector('[data-testid="task-chat-unanswered-question"]')).not.toBeNull();
|
||
});
|
||
|
||
it.each(["Cancel", "dismiss"])("keeps a fresh question dismissed after remounting (%s)", async action => {
|
||
const show = () => render(<TaskChatThread {...props} comments={[]} interactions={[old]} />);
|
||
show();
|
||
await click("Yes");
|
||
if (action === "Cancel") await click("Cancel");
|
||
else await dismiss();
|
||
flushSync(() => root!.unmount());
|
||
root = createRoot(container);
|
||
show();
|
||
expect(takeover()).toBeNull();
|
||
expect(pendingIndicator()).toBeNull();
|
||
await act(async () => container.querySelector<HTMLButtonElement>('[aria-label="Answer question: Which color?"]')!.click());
|
||
expect(takeover()?.querySelector('[role="radio"][aria-checked="true"]')?.textContent).toContain("Yes");
|
||
});
|
||
|
||
it("shows a newly asked question after dismissing an older one", async () => {
|
||
render(<TaskChatThread {...props} comments={[]} interactions={[old]} />);
|
||
await dismiss();
|
||
await act(async () => render(<TaskChatThread {...props} comments={[]} interactions={[old, newer]} />));
|
||
expect(takeover()?.textContent).toContain("Which tone?");
|
||
expect(takeover()?.textContent).not.toContain("Which color?");
|
||
expect(container.querySelectorAll('[data-testid="task-chat-unanswered-question"]')).toHaveLength(2);
|
||
});
|
||
|
||
it("preserves a question dismissal saved by another tab", async () => {
|
||
render(<TaskChatThread {...props} comments={[]} interactions={[old]} />);
|
||
// The other tab saves after this thread has loaded its dismissal state.
|
||
localStorage.setItem("paperclip:task-question-dismissals:user-board:issue-1", JSON.stringify([newer.id]));
|
||
await dismiss();
|
||
flushSync(() => root!.unmount());
|
||
root = createRoot(container);
|
||
render(<TaskChatThread {...props} comments={[]} interactions={[old, newer]} />);
|
||
expect(takeover()).toBeNull();
|
||
expect(pendingIndicator()).toBeNull();
|
||
expect(container.querySelectorAll('[data-testid="task-chat-unanswered-question"]')).toHaveLength(2);
|
||
});
|
||
|
||
it("scopes dismissal to the person and task", async () => {
|
||
const show = (userId: string, issueId: string) => render(<TaskChatThread {...props} currentUserId={userId} issueId={issueId} comments={[]} interactions={[old]} />);
|
||
show("user-board", "issue-1");
|
||
await dismiss();
|
||
flushSync(() => root!.unmount());
|
||
root = createRoot(container);
|
||
show("another-user", "issue-1");
|
||
expect(takeover()).not.toBeNull();
|
||
flushSync(() => root!.unmount());
|
||
root = createRoot(container);
|
||
show("user-board", "issue-2");
|
||
expect(takeover()).not.toBeNull();
|
||
});
|
||
});
|
||
|
||
describe("TaskChatThread composer alignment", () => {
|
||
it("matches the thread width at every breakpoint", () => {
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} />);
|
||
|
||
const dock = container
|
||
.querySelector('[data-testid="mock-editor"]')
|
||
?.closest("div.sticky") as HTMLElement | null;
|
||
|
||
expect(dock?.className).toContain("w-full");
|
||
expect(dock?.className).toContain("max-w-(--tc-shell-max-w)");
|
||
expect(dock?.className).not.toContain("md:w-(--pct-80)");
|
||
});
|
||
|
||
it("uses master's production composer and gutters when Streamlined UI is off", () => {
|
||
streamlinedState.enabled = false;
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} />);
|
||
|
||
const dock = container.querySelector(
|
||
'[data-testid="task-chat-composer-dock"]',
|
||
);
|
||
const composer = container.querySelector(".paperclip-task-chat-composer");
|
||
const send = container.querySelector(
|
||
'[data-testid="task-chat-composer-send"]',
|
||
);
|
||
|
||
expect(dock?.classList).not.toContain("md:px-0");
|
||
expect(dock?.classList).not.toContain("md:pb-4");
|
||
expect(dock?.classList).toContain("bg-background/80");
|
||
expect(dock?.classList).toContain("pt-1");
|
||
expect(dock?.classList).not.toContain("-mt-(--radius-task-composer)");
|
||
expect(composer?.classList).not.toContain("border");
|
||
expect(composer?.classList).toContain("bg-card");
|
||
expect(send?.classList).toContain("rounded-full");
|
||
expect(send?.classList).not.toContain("rounded-md");
|
||
});
|
||
});
|
||
|
||
describe("TaskChatThread no-live-execution-path recovery", () => {
|
||
const noLivePathComment = {
|
||
id: "comment-no-live-path",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "system" as const,
|
||
authorAgentId: null,
|
||
authorUserId: null,
|
||
body: "Paperclip retried continuation, but it still has no live execution path.",
|
||
presentation: {
|
||
kind: "system_notice" as const,
|
||
tone: "danger" as const,
|
||
title: "No live execution path",
|
||
detailsDefaultOpen: false,
|
||
},
|
||
metadata: null,
|
||
createdAt: new Date("2026-08-26T12:00:00.000Z"),
|
||
updatedAt: new Date("2026-08-26T12:00:00.000Z"),
|
||
};
|
||
|
||
it("offers Try again only while the task is blocked", async () => {
|
||
const onTryAgain = vi.fn();
|
||
const props = {
|
||
comments: [noLivePathComment],
|
||
onAdd: async () => {},
|
||
onTryAgainNoLiveExecutionPath: onTryAgain,
|
||
showComposer: false,
|
||
};
|
||
|
||
render(<TaskChatThread {...props} issueStatus="blocked" />);
|
||
const tryAgain = container.querySelector<HTMLButtonElement>(
|
||
'[data-testid="task-chat-no-live-path-try-again"]',
|
||
);
|
||
expect(tryAgain).not.toBeNull();
|
||
|
||
flushSync(() => tryAgain!.click());
|
||
await Promise.resolve();
|
||
expect(onTryAgain).toHaveBeenCalledTimes(1);
|
||
|
||
render(<TaskChatThread {...props} issueStatus="todo" />);
|
||
expect(
|
||
container.querySelector(
|
||
'[data-testid="task-chat-no-live-path-try-again"]',
|
||
),
|
||
).toBeNull();
|
||
});
|
||
});
|
||
|
||
describe("TaskChatThread blocker links", () => {
|
||
it("shows the direct and server-selected terminal blocker at the top and bottom", () => {
|
||
const terminalBlocker = {
|
||
id: "terminal-2",
|
||
identifier: "PAP-777",
|
||
title: "Actual work",
|
||
status: "in_progress" as const,
|
||
priority: "high" as const,
|
||
assigneeAgentId: "agent-2",
|
||
assigneeUserId: null,
|
||
};
|
||
const directBlocker = {
|
||
id: "direct-2",
|
||
identifier: "PAP-600",
|
||
title: "Waiting in review",
|
||
status: "in_review" as const,
|
||
priority: "medium" as const,
|
||
assigneeAgentId: "agent-1",
|
||
assigneeUserId: null,
|
||
terminalBlockers: [terminalBlocker],
|
||
};
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={createLongThreadComments()}
|
||
onAdd={async () => {}}
|
||
issueStatus="blocked"
|
||
blockedBy={[
|
||
{
|
||
id: "direct-1",
|
||
identifier: "PAP-500",
|
||
title: "Different dependency",
|
||
status: "todo",
|
||
priority: "low",
|
||
assigneeAgentId: null,
|
||
assigneeUserId: null,
|
||
},
|
||
directBlocker,
|
||
]}
|
||
blockerAttention={{
|
||
state: "needs_attention",
|
||
reason: "attention_required",
|
||
unresolvedBlockerCount: 2,
|
||
coveredBlockerCount: 0,
|
||
stalledBlockerCount: 0,
|
||
attentionBlockerCount: 1,
|
||
sampleBlockerIdentifier: "PAP-777",
|
||
sampleStalledBlockerIdentifier: null,
|
||
terminalBlockerIssueId: terminalBlocker.id,
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
const notices = container.querySelectorAll(
|
||
'[data-testid="task-chat-blocker-links"]',
|
||
);
|
||
expect(notices).toHaveLength(2);
|
||
expect(notices[0]?.getAttribute("data-placement")).toBe("top");
|
||
expect(notices[1]?.getAttribute("data-placement")).toBe("bottom");
|
||
expect(notices[0]?.textContent).toContain(
|
||
"Blocked byPAP-600Waiting in review",
|
||
);
|
||
expect(notices[0]?.textContent).toContain("Root blockerPAP-777Actual work");
|
||
expect(notices[1]?.textContent).toContain(
|
||
"Still blocked byPAP-600Waiting in review",
|
||
);
|
||
expect(notices[1]?.textContent).toContain(
|
||
"Root blocker remainsPAP-777Actual work",
|
||
);
|
||
for (const notice of notices) {
|
||
expect(notice.querySelector('a[href="/issues/PAP-600"]')).not.toBeNull();
|
||
expect(notice.querySelector('a[href="/issues/PAP-777"]')).not.toBeNull();
|
||
}
|
||
expect(container.textContent).not.toContain("Different dependency");
|
||
expect(container.textContent).not.toContain(
|
||
"This task resumes automatically",
|
||
);
|
||
});
|
||
|
||
it("shows the ordered live-work queue at the top and bottom", () => {
|
||
const terminalBlocker = {
|
||
id: "terminal-running",
|
||
identifier: "PAP-17426",
|
||
title: "Restore live alias projection",
|
||
status: "in_progress" as const,
|
||
priority: "high" as const,
|
||
assigneeAgentId: "agent-3",
|
||
assigneeUserId: null,
|
||
};
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={createLongThreadComments()}
|
||
onAdd={async () => {}}
|
||
issueStatus="blocked"
|
||
liveIssueIds={new Set(["direct-running", "terminal-running"])}
|
||
blockerAttention={{
|
||
state: "covered",
|
||
reason: "active_dependency",
|
||
unresolvedBlockerCount: 2,
|
||
coveredBlockerCount: 2,
|
||
stalledBlockerCount: 0,
|
||
attentionBlockerCount: 0,
|
||
sampleBlockerIdentifier: "PAP-17426",
|
||
sampleStalledBlockerIdentifier: null,
|
||
blockingTreeLive: true,
|
||
directBlockerIssueId: "direct-running",
|
||
terminalBlockerIssueId: terminalBlocker.id,
|
||
terminalBlocker,
|
||
}}
|
||
blockedBy={[
|
||
{
|
||
id: "direct-queued",
|
||
identifier: "PAP-17427",
|
||
title: "Verify the completed projection",
|
||
status: "todo",
|
||
priority: "medium",
|
||
assigneeAgentId: "agent-4",
|
||
assigneeUserId: null,
|
||
},
|
||
{
|
||
id: "direct-running",
|
||
identifier: "PAP-17425",
|
||
title: "Verify the live projection",
|
||
status: "in_progress",
|
||
priority: "medium",
|
||
assigneeAgentId: "agent-2",
|
||
assigneeUserId: null,
|
||
terminalBlockers: [terminalBlocker],
|
||
},
|
||
{
|
||
id: "direct-done",
|
||
identifier: "PAP-17424",
|
||
title: "Run the guarded cutover",
|
||
status: "done",
|
||
priority: "medium",
|
||
assigneeAgentId: "agent-1",
|
||
assigneeUserId: null,
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
const notices = container.querySelectorAll(
|
||
'[data-testid="task-chat-live-work-links"]',
|
||
);
|
||
expect(notices).toHaveLength(2);
|
||
expect(notices[0]?.getAttribute("data-placement")).toBe("top");
|
||
expect(notices[1]?.getAttribute("data-placement")).toBe("bottom");
|
||
expect(notices[0]?.textContent).toContain("Waiting on live work");
|
||
expect(notices[1]?.textContent).toContain("Still waiting on live work");
|
||
for (const notice of notices) {
|
||
const orderedLinks = [
|
||
...notice.querySelectorAll(
|
||
'[data-testid="task-chat-live-work-step"] a',
|
||
),
|
||
].map((link) => link.textContent);
|
||
expect(orderedLinks).toEqual([
|
||
"PAP-17424Run the guarded cutover",
|
||
"PAP-17425Verify the live projection",
|
||
"PAP-17427Verify the completed projection",
|
||
]);
|
||
expect(notice.textContent).toContain(
|
||
"Now runningPAP-17426Restore live alias projection",
|
||
);
|
||
expect(
|
||
notice.querySelector('a[href="/issues/PAP-17426"]'),
|
||
).not.toBeNull();
|
||
expect(
|
||
notice.querySelector('[data-testid="task-chat-live-work-step"] > a'),
|
||
).not.toBeNull();
|
||
expect(
|
||
notice.querySelector('[data-testid="task-chat-live-work-step"] > span'),
|
||
).toBeNull();
|
||
}
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-blocker-links"]'),
|
||
).toBeNull();
|
||
});
|
||
|
||
it("keeps the compact blocker rows when covered work is no longer live", () => {
|
||
render(
|
||
<TaskChatThread
|
||
comments={createLongThreadComments()}
|
||
onAdd={async () => {}}
|
||
issueStatus="blocked"
|
||
liveIssueIds={new Set()}
|
||
blockerAttention={{
|
||
state: "covered",
|
||
reason: "active_dependency",
|
||
unresolvedBlockerCount: 1,
|
||
coveredBlockerCount: 1,
|
||
stalledBlockerCount: 0,
|
||
attentionBlockerCount: 0,
|
||
sampleBlockerIdentifier: "PAP-500",
|
||
sampleStalledBlockerIdentifier: null,
|
||
blockingTreeLive: false,
|
||
}}
|
||
blockedBy={[
|
||
{
|
||
id: "direct-1",
|
||
identifier: "PAP-500",
|
||
title: "Direct dependency",
|
||
status: "todo",
|
||
priority: "medium",
|
||
assigneeAgentId: "agent-1",
|
||
assigneeUserId: null,
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-live-work-links"]'),
|
||
).toBeNull();
|
||
expect(
|
||
container.querySelectorAll('[data-testid="task-chat-blocker-links"]'),
|
||
).toHaveLength(2);
|
||
});
|
||
|
||
it("shows only the direct row when the blocker has no deeper unresolved leaf", () => {
|
||
render(
|
||
<TaskChatThread
|
||
comments={createLongThreadComments()}
|
||
onAdd={async () => {}}
|
||
issueStatus="blocked"
|
||
blockedBy={[
|
||
{
|
||
id: "direct-1",
|
||
identifier: "PAP-500",
|
||
title: "Direct dependency",
|
||
status: "in_progress",
|
||
priority: "medium",
|
||
assigneeAgentId: "agent-1",
|
||
assigneeUserId: null,
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelectorAll('[data-testid="task-chat-blocker-links"]'),
|
||
).toHaveLength(2);
|
||
expect(container.textContent).toContain(
|
||
"Blocked byPAP-500Direct dependency",
|
||
);
|
||
expect(container.textContent).not.toContain("Ultimately blocked by");
|
||
expect(container.textContent).not.toContain("Root blocker");
|
||
});
|
||
|
||
it("keeps a server-selected intermediate blocker on its direct chain", () => {
|
||
const selectedIntermediate = {
|
||
id: "intermediate-2",
|
||
identifier: "PAP-650",
|
||
title: "Stalled intermediate review",
|
||
};
|
||
const selectedDirect = {
|
||
id: "direct-2",
|
||
identifier: "PAP-600",
|
||
title: "Selected dependency",
|
||
status: "blocked" as const,
|
||
priority: "medium" as const,
|
||
assigneeAgentId: "agent-1",
|
||
assigneeUserId: null,
|
||
terminalBlockers: [
|
||
{
|
||
id: "leaf-2",
|
||
identifier: "PAP-700",
|
||
title: "Deeper structural leaf",
|
||
status: "todo" as const,
|
||
priority: "medium" as const,
|
||
assigneeAgentId: "agent-2",
|
||
assigneeUserId: null,
|
||
},
|
||
],
|
||
};
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={createLongThreadComments()}
|
||
onAdd={async () => {}}
|
||
issueStatus="blocked"
|
||
blockedBy={[
|
||
{
|
||
id: "direct-1",
|
||
identifier: "PAP-500",
|
||
title: "Unrelated dependency",
|
||
status: "todo",
|
||
priority: "low",
|
||
assigneeAgentId: null,
|
||
assigneeUserId: null,
|
||
},
|
||
selectedDirect,
|
||
]}
|
||
blockerAttention={{
|
||
state: "stalled",
|
||
reason: "stalled_review",
|
||
unresolvedBlockerCount: 2,
|
||
coveredBlockerCount: 0,
|
||
stalledBlockerCount: 1,
|
||
attentionBlockerCount: 1,
|
||
sampleBlockerIdentifier: "PAP-650",
|
||
sampleStalledBlockerIdentifier: "PAP-650",
|
||
directBlockerIssueId: selectedDirect.id,
|
||
terminalBlockerIssueId: selectedIntermediate.id,
|
||
terminalBlocker: selectedIntermediate,
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
const notices = container.querySelectorAll(
|
||
'[data-testid="task-chat-blocker-links"]',
|
||
);
|
||
expect(notices[0]?.textContent).toContain(
|
||
"Blocked byPAP-600Selected dependency",
|
||
);
|
||
expect(notices[0]?.textContent).toContain(
|
||
"Root blockerPAP-650Stalled intermediate review",
|
||
);
|
||
expect(notices[1]?.textContent).toContain(
|
||
"Still blocked byPAP-600Selected dependency",
|
||
);
|
||
expect(notices[1]?.textContent).toContain(
|
||
"Root blocker remainsPAP-650Stalled intermediate review",
|
||
);
|
||
expect(container.textContent).not.toContain("Unrelated dependency");
|
||
expect(container.textContent).not.toContain("Deeper structural leaf");
|
||
});
|
||
|
||
it("auto-follows the new bottom blocker row when a pinned thread becomes blocked", () => {
|
||
const directBlocker = {
|
||
id: "direct-1",
|
||
identifier: "PAP-500",
|
||
title: "Direct dependency",
|
||
status: "in_progress" as const,
|
||
priority: "medium" as const,
|
||
assigneeAgentId: "agent-1",
|
||
assigneeUserId: null,
|
||
};
|
||
const baseProps = {
|
||
comments: createLongThreadComments(),
|
||
onAdd: async () => {},
|
||
blockedBy: [directBlocker],
|
||
};
|
||
|
||
render(<TaskChatThread {...baseProps} issueStatus="in_progress" />);
|
||
const scroller = container.querySelector<HTMLElement>(
|
||
'[data-testid="task-chat-scroller"]',
|
||
)!;
|
||
fakeScrollGeometry(scroller);
|
||
|
||
render(<TaskChatThread {...baseProps} issueStatus="blocked" />);
|
||
|
||
expect(scroller.scrollTop).toBe(scroller.scrollHeight);
|
||
});
|
||
|
||
it("keeps a short blocked thread to one top affordance", () => {
|
||
render(
|
||
<TaskChatThread
|
||
comments={createLongThreadComments().slice(0, 1)}
|
||
onAdd={async () => {}}
|
||
issueStatus="blocked"
|
||
blockedBy={[
|
||
{
|
||
id: "direct-1",
|
||
identifier: "PAP-500",
|
||
title: "Direct dependency",
|
||
status: "todo",
|
||
priority: "medium",
|
||
assigneeAgentId: null,
|
||
assigneeUserId: null,
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
const notices = container.querySelectorAll(
|
||
'[data-testid="task-chat-blocker-links"]',
|
||
);
|
||
expect(notices).toHaveLength(1);
|
||
expect(notices[0]?.getAttribute("data-placement")).toBe("top");
|
||
});
|
||
|
||
it("does not show blocker rows outside the blocked state", () => {
|
||
render(
|
||
<TaskChatThread
|
||
comments={createLongThreadComments()}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
blockedBy={[
|
||
{
|
||
id: "direct-1",
|
||
identifier: "PAP-500",
|
||
title: "Direct dependency",
|
||
status: "in_progress",
|
||
priority: "medium",
|
||
assigneeAgentId: "agent-1",
|
||
assigneeUserId: null,
|
||
},
|
||
]}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-blocker-links"]'),
|
||
).toBeNull();
|
||
});
|
||
});
|
||
|
||
describe("TaskChatThread queued message actions", () => {
|
||
it("interrupts the exact run that a persisted queued message is waiting behind", () => {
|
||
const onInterruptQueued = vi.fn(async () => {});
|
||
const queuedComment = {
|
||
id: "comment-queued",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "user" as const,
|
||
authorAgentId: null,
|
||
authorUserId: "user-1",
|
||
body: "Use the latest requirements instead.",
|
||
presentation: null,
|
||
metadata: null,
|
||
queueState: "queued" as const,
|
||
queueTargetRunId: "run-active",
|
||
createdAt: new Date("2026-08-14T12:00:00.000Z"),
|
||
updatedAt: new Date("2026-08-14T12:00:00.000Z"),
|
||
};
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[queuedComment]}
|
||
onAdd={async () => {}}
|
||
onInterruptQueued={onInterruptQueued}
|
||
/>,
|
||
);
|
||
|
||
const interrupt = [...container.querySelectorAll("button")].find(
|
||
(button) => button.textContent === "Interrupt",
|
||
);
|
||
expect(container.textContent).toContain("Queued");
|
||
expect(interrupt).not.toBeUndefined();
|
||
|
||
flushSync(() => interrupt!.click());
|
||
expect(onInterruptQueued).toHaveBeenCalledOnce();
|
||
expect(onInterruptQueued).toHaveBeenCalledWith("run-active");
|
||
});
|
||
|
||
it("disables the action while the queued run is being interrupted", () => {
|
||
render(
|
||
<TaskChatThread
|
||
comments={[
|
||
{
|
||
id: "comment-queued",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "user",
|
||
authorAgentId: null,
|
||
authorUserId: "user-1",
|
||
body: "Use the latest requirements instead.",
|
||
presentation: null,
|
||
metadata: null,
|
||
clientStatus: "queued",
|
||
queueTargetRunId: "run-active",
|
||
createdAt: new Date("2026-08-14T12:00:00.000Z"),
|
||
updatedAt: new Date("2026-08-14T12:00:00.000Z"),
|
||
},
|
||
]}
|
||
onAdd={async () => {}}
|
||
onInterruptQueued={async () => {}}
|
||
interruptingQueuedRunId="run-active"
|
||
/>,
|
||
);
|
||
|
||
const interrupting = [...container.querySelectorAll("button")].find(
|
||
(button) => button.textContent === "Interrupting…",
|
||
);
|
||
expect(interrupting).not.toBeUndefined();
|
||
expect(interrupting?.disabled).toBe(true);
|
||
});
|
||
});
|
||
|
||
describe("TaskChatThread Paperclip Runner queue", () => {
|
||
const queuedComment = {
|
||
id: "queued-prp-1",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "user" as const,
|
||
authorAgentId: null,
|
||
authorUserId: "user-1",
|
||
body: "Render this queued message exactly once.",
|
||
presentation: null,
|
||
metadata: null,
|
||
createdAt: new Date("2026-08-22T15:00:00.000Z"),
|
||
updatedAt: new Date("2026-08-22T15:00:00.000Z"),
|
||
};
|
||
const queue: IssueQueuedCommentQueue = {
|
||
issueId: "issue-1",
|
||
queueId: "wake-1",
|
||
state: "deferred",
|
||
targetRunId: "run-1",
|
||
revision: "revision-1",
|
||
protocol: "paperclip_runner_v1",
|
||
steeringDisposition: "available",
|
||
entries: [
|
||
{ comment: queuedComment, position: 0, canEdit: true, canDiscard: true },
|
||
],
|
||
};
|
||
|
||
function occurrenceCount(text: string) {
|
||
return container.textContent?.split(text).length! - 1;
|
||
}
|
||
|
||
it("hides queued actions while paused and restores the queue after resume", () => {
|
||
const onSteerQueuedComment = vi.fn(async () => {});
|
||
const props = {
|
||
comments: [queuedComment],
|
||
onAdd: async () => {},
|
||
queuedCommentQueue: queue,
|
||
onEditQueuedComment: async () => {},
|
||
onReorderQueuedComments: async () => {},
|
||
onSteerQueuedComment,
|
||
onDiscardQueuedComment: async () => {},
|
||
};
|
||
render(<TaskChatThread {...props} />);
|
||
expect(container.querySelector('[data-testid="task-chat-queued-messages"]')).not.toBeNull();
|
||
|
||
render(<TaskChatThread {...props} composerPause={{ scope: "leaf", onResume: () => {} }} />);
|
||
expect(container.querySelector('[data-testid="paused-composer-takeover"]')).not.toBeNull();
|
||
expect(container.querySelector('[data-testid="task-chat-queued-messages"]')).toBeNull();
|
||
expect(onSteerQueuedComment).not.toHaveBeenCalled();
|
||
|
||
render(<TaskChatThread {...props} />);
|
||
expect(container.querySelector('[data-testid="task-chat-queued-messages"]')).not.toBeNull();
|
||
expect(occurrenceCount(queuedComment.body)).toBe(1);
|
||
});
|
||
|
||
it("hides legacy transcript interrupt actions while paused", () => {
|
||
render(<TaskChatThread
|
||
comments={[{ ...queuedComment, queueState: "queued", queueTargetRunId: "run-1" }]}
|
||
onAdd={async () => {}}
|
||
onInterruptQueued={async () => {}}
|
||
composerPause={{ scope: "leaf", onResume: () => {} }}
|
||
/>);
|
||
expect(container.querySelector('[data-testid="paused-composer-takeover"]')).not.toBeNull();
|
||
expect([...container.querySelectorAll("button")].some((button) => button.textContent === "Interrupt")).toBe(false);
|
||
});
|
||
|
||
it("suppresses the transcript echo until the queued entry is consumed", async () => {
|
||
const props = {
|
||
comments: [queuedComment],
|
||
onAdd: async () => {},
|
||
queuedCommentQueue: queue,
|
||
onEditQueuedComment: async () => {},
|
||
onReorderQueuedComments: async () => {},
|
||
onSteerQueuedComment: async () => {},
|
||
onDiscardQueuedComment: async () => {},
|
||
};
|
||
render(<TaskChatThread {...props} />);
|
||
|
||
const stack = container.querySelector(
|
||
'[data-testid="task-chat-composer-stack"]',
|
||
);
|
||
const queuePane = container.querySelector(
|
||
'[data-testid="task-chat-queued-messages"]',
|
||
);
|
||
expect(queuePane?.parentElement).toBe(stack);
|
||
expect(stack?.classList).not.toContain("gap-2");
|
||
expect(
|
||
container.querySelector(
|
||
'[data-testid="task-chat-queued-message-queued-prp-1"]',
|
||
),
|
||
).not.toBeNull();
|
||
expect(occurrenceCount(queuedComment.body)).toBe(1);
|
||
|
||
await act(async () => {
|
||
render(
|
||
<TaskChatThread
|
||
{...props}
|
||
queuedCommentQueue={{ ...queue, revision: "revision-2", entries: [] }}
|
||
/>,
|
||
);
|
||
await Promise.resolve();
|
||
});
|
||
|
||
expect(
|
||
container.querySelector(
|
||
'[data-testid="task-chat-queued-message-queued-prp-1"]',
|
||
),
|
||
).toBeNull();
|
||
expect(occurrenceCount(queuedComment.body)).toBe(1);
|
||
});
|
||
|
||
it.each(["steer", "interrupt"] as const)("preserves inline %s errors after the optimistic last row clears", async action => {
|
||
let rejectDelivery!: (error: Error) => void;
|
||
const delivery = new Promise<void>((_, reject) => { rejectDelivery = reject; });
|
||
const actionQueue = { ...queue, protocol: action === "interrupt" ? "legacy" as const : queue.protocol };
|
||
const props = { comments: [queuedComment], onAdd: async () => {}, queuedCommentQueue: actionQueue,
|
||
onSteerQueuedComment: () => delivery, onInterruptQueued: () => delivery };
|
||
render(<TaskChatThread {...props} />);
|
||
await act(async () => {
|
||
container.querySelector<HTMLButtonElement>(`[data-testid="task-chat-queued-${action}-queued-prp-1"]`)!.click();
|
||
});
|
||
render(<TaskChatThread {...props} queuedCommentQueue={null} />);
|
||
expect(container.querySelector('[data-testid="task-chat-queued-messages"]')).toBeNull();
|
||
await act(async () => {
|
||
rejectDelivery(new Error("Connection lost"));
|
||
await delivery.catch(() => undefined);
|
||
});
|
||
await act(async () => { render(<TaskChatThread {...props} />); });
|
||
expect(container.textContent).toContain(action === "steer"
|
||
? "Couldn’t steer. Message is still queued." : "Couldn’t interrupt. Message is still queued.");
|
||
expect(occurrenceCount(queuedComment.body)).toBe(1);
|
||
});
|
||
|
||
it.each(["run-1", null])("keeps legacy queued delivery available with target %s", (targetRunId) => {
|
||
const onInterruptQueued = vi.fn(async () => {});
|
||
render(
|
||
<TaskChatThread
|
||
comments={[
|
||
{
|
||
...queuedComment,
|
||
clientStatus: "queued",
|
||
queueTargetRunId: "run-1",
|
||
},
|
||
]}
|
||
onAdd={async () => {}}
|
||
onInterruptQueued={onInterruptQueued}
|
||
queuedCommentQueue={{
|
||
...queue,
|
||
targetRunId,
|
||
protocol: "legacy",
|
||
steeringDisposition: "unsupported",
|
||
}}
|
||
onEditQueuedComment={async () => {}}
|
||
onReorderQueuedComments={async () => {}}
|
||
onSteerQueuedComment={async () => {}}
|
||
onDiscardQueuedComment={async () => {}}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector(
|
||
'[data-testid="task-chat-queued-message-queued-prp-1"]',
|
||
),
|
||
).not.toBeNull();
|
||
expect(occurrenceCount(queuedComment.body)).toBe(1);
|
||
expect(container.textContent).not.toContain("QueuedInterrupt");
|
||
|
||
const interrupt = container.querySelector<HTMLButtonElement>(
|
||
'[data-testid="task-chat-queued-interrupt-queued-prp-1"]',
|
||
);
|
||
expect(interrupt).not.toBeNull();
|
||
flushSync(() => interrupt!.click());
|
||
expect(onInterruptQueued).toHaveBeenCalledWith(targetRunId);
|
||
});
|
||
|
||
it("cancels an optimistic queued row locally before server acknowledgement", async () => {
|
||
const onCancelQueued = vi.fn();
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
onCancelQueued={onCancelQueued}
|
||
queuedCommentQueue={{
|
||
...queue,
|
||
queueId: null,
|
||
entries: [
|
||
{
|
||
...queue.entries[0],
|
||
comment: {
|
||
...queuedComment,
|
||
id: "optimistic-local-1",
|
||
body: "Delete before acknowledgement",
|
||
},
|
||
canEdit: false,
|
||
},
|
||
],
|
||
}}
|
||
onEditQueuedComment={async () => {}}
|
||
onReorderQueuedComments={async () => {}}
|
||
onSteerQueuedComment={async () => {}}
|
||
onDiscardQueuedComment={async () => {}}
|
||
/>,
|
||
);
|
||
|
||
await act(async () => {
|
||
container
|
||
.querySelector<HTMLButtonElement>(
|
||
'[data-testid="task-chat-queued-discard-optimistic-local-1"]',
|
||
)
|
||
?.click();
|
||
});
|
||
|
||
expect(onCancelQueued).toHaveBeenCalledWith("optimistic-local-1");
|
||
expect(
|
||
container.querySelector(
|
||
'[data-testid="task-chat-queued-message-optimistic-local-1"]',
|
||
),
|
||
).toBeNull();
|
||
});
|
||
});
|
||
|
||
describe("TaskChatThread mobile composer dock (PAP-495)", () => {
|
||
it("pins the composer to the nav-aware bottom offset so its action row clears the auto-hiding bottom nav", () => {
|
||
sidebarState.isMobile = true;
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
draftKey="task-chat-draft:issue-mobile"
|
||
/>,
|
||
);
|
||
|
||
const dock = container
|
||
.querySelector('[data-testid="mock-editor"]')
|
||
?.closest("div.sticky") as HTMLElement | null;
|
||
|
||
expect(dock).not.toBeNull();
|
||
// Bottom offset comes from --tc-composer-bottom (Layout raises it to the nav
|
||
// height while the nav is on screen) — NOT the raw safe-area dock, which is
|
||
// what let the nav occlude the action row before PAP-495.
|
||
expect(dock?.className).toContain("bottom-(--tc-composer-bottom)");
|
||
expect(dock?.className).not.toContain("bottom-(--sz-calc-8)");
|
||
});
|
||
});
|
||
|
||
describe("TaskChatThread live transcript", () => {
|
||
it("places the turn status island below composer accessories and hides it when the turn is terminal", () => {
|
||
nativeTranscriptState.transcriptByRun.set("run-status", [
|
||
{
|
||
kind: "provider_activity",
|
||
ts: "2026-08-24T12:00:01.000Z",
|
||
family: "plan",
|
||
eventType: "plan.updated",
|
||
status: "running",
|
||
title: "Plan",
|
||
payload: {
|
||
planId: "turn-1",
|
||
steps: [
|
||
{ stepId: "one", body: "Inspect", status: "completed" },
|
||
{ stepId: "two", body: "Build", status: "in_progress" },
|
||
],
|
||
},
|
||
},
|
||
{
|
||
kind: "workspace_change",
|
||
ts: "2026-08-24T12:00:02.000Z",
|
||
changeSetId: "turn-1:workspace",
|
||
revision: 1,
|
||
source: "harness_reported",
|
||
complete: false,
|
||
files: [
|
||
{
|
||
path: "ui/src/App.tsx",
|
||
operation: "modify",
|
||
previousPath: null,
|
||
additions: 4,
|
||
deletions: 1,
|
||
binary: false,
|
||
diff: null,
|
||
},
|
||
],
|
||
totals: { files: 1, additions: 4, deletions: 1 },
|
||
patchArtifactRef: null,
|
||
},
|
||
]);
|
||
const activeRun = {
|
||
id: "run-status",
|
||
status: "running" as const,
|
||
invocationSource: "issue" as const,
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-24T12:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-24T12:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Codex",
|
||
adapterType: "paperclip_runner",
|
||
runtimeMode: "native" as const,
|
||
};
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={activeRun}
|
||
composerAccessory={<div data-testid="composer-accessory">Monitor</div>}
|
||
/>,
|
||
);
|
||
|
||
const dock = container.querySelector(
|
||
'[data-testid="task-chat-composer-dock"]',
|
||
)!;
|
||
const accessory = container.querySelector(
|
||
'[data-testid="composer-accessory"]',
|
||
)!;
|
||
const island = container.querySelector(
|
||
'[data-testid="task-chat-turn-status-island"]',
|
||
)!;
|
||
const stack = container.querySelector(
|
||
'[data-testid="task-chat-composer-stack"]',
|
||
)!;
|
||
expect(island.textContent).toContain("Step 2 / 2");
|
||
expect(island.textContent).toContain("1 file changed");
|
||
expect(accessory.compareDocumentPosition(island)).toBe(
|
||
Node.DOCUMENT_POSITION_FOLLOWING,
|
||
);
|
||
expect(island.compareDocumentPosition(stack)).toBe(
|
||
Node.DOCUMENT_POSITION_FOLLOWING,
|
||
);
|
||
expect(dock.contains(island)).toBe(true);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{
|
||
...activeRun,
|
||
status: "succeeded",
|
||
finishedAt: "2026-08-24T12:01:00.000Z",
|
||
}}
|
||
/>,
|
||
);
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-turn-status-island"]'),
|
||
).toBeNull();
|
||
});
|
||
|
||
it("keeps an unlinked persisted runner reply hidden while the live turn still owns that response", () => {
|
||
nativeTranscriptState.transcriptByRun.set("run-runner", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-21T15:44:20.000Z",
|
||
text: "Completed the requested streaming test.",
|
||
channel: "final",
|
||
delta: true,
|
||
},
|
||
]);
|
||
const comment = {
|
||
id: "comment-runner",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "agent" as const,
|
||
authorAgentId: "agent-1",
|
||
authorUserId: null,
|
||
body: "Completed the requested streaming test.",
|
||
presentation: null,
|
||
metadata: null,
|
||
runId: null,
|
||
createdAt: new Date("2026-08-21T15:44:22.000Z"),
|
||
updatedAt: new Date("2026-08-21T15:44:22.000Z"),
|
||
};
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[comment]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{
|
||
id: "run-runner",
|
||
status: "running",
|
||
invocationSource: "issue",
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-21T15:44:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-21T15:44:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
runtimeMode: "native",
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.textContent?.match(/Completed the requested streaming test\./g),
|
||
).toHaveLength(1);
|
||
expect(
|
||
container.querySelectorAll('[data-testid="task-chat-agent-bubble"]'),
|
||
).toHaveLength(1);
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-live-transcript"]'),
|
||
).not.toBeNull();
|
||
});
|
||
|
||
it("surfaces the live runtime status while no transcript has streamed yet", () => {
|
||
// Sandbox runs spend their first minutes in preparation phases (config
|
||
// seed, workspace sync) with zero transcript entries. The tail must show
|
||
// the run's runtime-progress status instead of an opaque wait message.
|
||
const baseRun = {
|
||
id: "run-prep",
|
||
status: "running" as const,
|
||
invocationSource: "issue" as const,
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-07T00:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-07T00:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Coder",
|
||
adapterType: "claude_local",
|
||
};
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{
|
||
...baseRun,
|
||
currentStatusMessage: "Syncing workspace to environment",
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
const tail = container.querySelector(
|
||
'[data-testid="task-chat-live-transcript"]',
|
||
);
|
||
expect(tail).not.toBeNull();
|
||
expect(tail!.textContent).toContain("Syncing workspace to environment");
|
||
expect(tail!.textContent).not.toContain("Waiting for transcript...");
|
||
|
||
// Without a runtime status, the generic wait message still shows.
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{ ...baseRun, id: "run-prep-2" }}
|
||
/>,
|
||
);
|
||
const tail2 = container.querySelector(
|
||
'[data-testid="task-chat-live-transcript"]',
|
||
);
|
||
expect(tail2!.textContent).toContain("Waiting for transcript...");
|
||
});
|
||
|
||
it("does not send a workspace bootstrap failure to connection settings", () => {
|
||
const run = { id: "workspace-prep", status: "running" as const, invocationSource: "issue", triggerDetail: null,
|
||
startedAt: "2026-09-15T10:00:00Z", finishedAt: null, createdAt: "2026-09-15T10:00:00Z",
|
||
agentId: "agent-1", agentName: "Worker", adapterType: "process" };
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} issueStatus="in_progress" activeRun={run} />);
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} issueStatus="in_progress" linkedRuns={[
|
||
{ ...run, runId: run.id, status: "failed", errorCode: "workspace_git_scan_timeout", finishedAt: "2026-09-15T10:00:10Z" },
|
||
]} />);
|
||
expect(container.textContent).toContain("Workspace setup failed before the agent started.");
|
||
expect(container.textContent).not.toContain("Review the task’s connection");
|
||
});
|
||
|
||
it("renders in-flight output through TaskChatLiveTail, dropping the debug plumbing (PAP-463 C1)", () => {
|
||
// Interleave the exact noise the old RunTranscriptView tail surfaced (init
|
||
// row, stdout/stderr/system dumps) with real content. Only the streamed
|
||
// reply markdown and the tool row may reach the thread.
|
||
transcriptState.transcriptByRun.set("run-1", [
|
||
{
|
||
kind: "init",
|
||
ts: "2026-08-07T00:00:00.000Z",
|
||
model: "claude",
|
||
sessionId: "sess-INITMARKER",
|
||
},
|
||
{
|
||
kind: "system",
|
||
ts: "2026-08-07T00:00:00.000Z",
|
||
text: "SYSTEMNOISE environment hint",
|
||
},
|
||
{
|
||
kind: "stdout",
|
||
ts: "2026-08-07T00:00:00.000Z",
|
||
text: "STDOUTNOISE raw json dump",
|
||
},
|
||
{
|
||
kind: "stderr",
|
||
ts: "2026-08-07T00:00:00.000Z",
|
||
text: "STDERRNOISE adapter timeout note",
|
||
},
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-07T00:00:00.000Z",
|
||
text: "Streaming through the shared renderer",
|
||
},
|
||
{
|
||
kind: "tool_call",
|
||
ts: "2026-08-07T00:00:00.000Z",
|
||
name: "Read",
|
||
toolUseId: "t1",
|
||
input: { file_path: "src/app.ts" },
|
||
},
|
||
]);
|
||
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{
|
||
id: "run-1",
|
||
status: "running",
|
||
invocationSource: "issue",
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-07T00:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-07T00:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Coder",
|
||
adapterType: "codex_local",
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
const tail = container.querySelector(
|
||
'[data-testid="task-chat-live-transcript"]',
|
||
);
|
||
expect(tail).not.toBeNull();
|
||
// Clean content survives: streamed reply markdown + compact phase summary.
|
||
expect(tail!.textContent).toContain(
|
||
"Streaming through the shared renderer",
|
||
);
|
||
const phaseSummary = tail!.querySelector<HTMLButtonElement>(
|
||
'[data-testid="task-chat-activity-phase-toggle"]',
|
||
);
|
||
expect(phaseSummary?.getAttribute("aria-expanded")).toBe("false");
|
||
expect(tail!.textContent).toContain("src/app.ts");
|
||
// None of the debug plumbing reaches the thread.
|
||
for (const noise of [
|
||
"INITMARKER",
|
||
"SYSTEMNOISE",
|
||
"STDOUTNOISE",
|
||
"STDERRNOISE",
|
||
]) {
|
||
expect(container.textContent).not.toContain(noise);
|
||
}
|
||
});
|
||
|
||
it.each([false, true])("resolves canonical input with stale adapter metadata (saved card: %s)", async (hasSavedCard) => {
|
||
transcriptState.transcriptByRun.set("run-input", [
|
||
{
|
||
kind: "runtime_request",
|
||
ts: "2026-08-23T20:00:00.000Z",
|
||
requestId: "question-1",
|
||
requestKind: "runtime",
|
||
turnId: "turn-1",
|
||
requestType: "input",
|
||
status: "pending",
|
||
prompt: "Codex needs your input.",
|
||
choices: [],
|
||
fields: [],
|
||
questionSet: {
|
||
schema: "paperclip.question_set.v1",
|
||
questions: [
|
||
{
|
||
id: "goal",
|
||
prompt: "What should the server do?",
|
||
required: true,
|
||
answerMode: "single_select",
|
||
options: [{ id: "api", label: "Starter API" }, { id: "worker", label: "Background worker" }],
|
||
},
|
||
],
|
||
},
|
||
},
|
||
]);
|
||
const resolveRuntimeRequest = vi
|
||
.spyOn(heartbeatsApi, "resolveRuntimeRequest")
|
||
.mockResolvedValue({} as never);
|
||
|
||
const onSubmitInteractionAnswers = vi.fn().mockResolvedValue(undefined);
|
||
const saved = {
|
||
...questionInteraction("saved-question", "What should the server do?", "2026-08-23T20:00:00.000Z"),
|
||
sourceRunId: "run-input", continuationPolicy: "none",
|
||
payload: { version: 1, runtimeRequestId: "question-1",
|
||
questionSet: transcriptState.transcriptByRun.get("run-input")[0].questionSet,
|
||
questions: [{ id: "goal", prompt: "What should the server do?", required: true, selectionMode: "single",
|
||
options: [{ id: "api", label: "Starter API" }, { id: "worker", label: "Background worker" }] }] },
|
||
} as IssueThreadInteraction;
|
||
render(
|
||
<TaskChatThread
|
||
interactions={hasSavedCard ? [saved] : []}
|
||
onSubmitInteractionAnswers={onSubmitInteractionAnswers}
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={{
|
||
id: "run-input",
|
||
status: "running",
|
||
invocationSource: "issue",
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-23T20:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-23T20:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
// Reproduces the lag that caused DOT-202: the transcript already has
|
||
// a Paperclip request while the linked-run adapter classification is
|
||
// still stale.
|
||
adapterType: "codex_local",
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
const option = Array.from(container.querySelectorAll("button")).find(
|
||
(button) => button.textContent?.includes("Starter API"),
|
||
);
|
||
await act(async () => option?.click());
|
||
const submit = Array.from(container.querySelectorAll("button")).find(
|
||
(button) => button.textContent?.trim() === "Submit answers",
|
||
);
|
||
await act(async () => submit?.click());
|
||
|
||
if (hasSavedCard) {
|
||
expect(resolveRuntimeRequest).not.toHaveBeenCalled();
|
||
expect(onSubmitInteractionAnswers).toHaveBeenCalledWith(saved, [{ questionId: "goal", optionIds: ["api"] }]);
|
||
} else expect(resolveRuntimeRequest).toHaveBeenCalledWith({
|
||
runId: "run-input",
|
||
requestId: "question-1",
|
||
turnId: "turn-1",
|
||
requestKind: "runtime",
|
||
resolution: {
|
||
action: "submit",
|
||
response: {
|
||
schema: "paperclip.question_response.v1",
|
||
answers: { goal: { selectedOptionIds: ["api"] } },
|
||
},
|
||
},
|
||
});
|
||
expect(container.textContent).not.toContain("no longer attached");
|
||
});
|
||
|
||
it.each(["done", "yielded"])(
|
||
"renders one native turn while its completion comment refresh is delayed: %s",
|
||
(disposition) => {
|
||
const runId = "native-delayed-comment";
|
||
const summary = "DELAYED-CANONICAL-REPLY";
|
||
nativeTranscriptState.transcriptByRun.set(runId, [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-07T00:00:01Z",
|
||
text: "UNIQUE-PROGRESS-LINE",
|
||
channel: "progress",
|
||
},
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-07T00:00:02Z",
|
||
text: summary,
|
||
channel: "final",
|
||
},
|
||
{
|
||
kind: "run_result",
|
||
ts: "2026-08-07T00:00:03Z",
|
||
disposition,
|
||
summary,
|
||
objectiveSatisfied: true,
|
||
verification: [],
|
||
remainingWork: [],
|
||
blocker: null,
|
||
artifacts: [],
|
||
...(disposition === "yielded"
|
||
? {
|
||
acceptedResponseWake: {
|
||
runId,
|
||
sourceEventId: "accepted-result",
|
||
},
|
||
}
|
||
: {}),
|
||
},
|
||
{
|
||
kind: "run_terminal",
|
||
ts: "2026-08-07T00:00:04Z",
|
||
turnState: "completed",
|
||
runState: "succeeded",
|
||
disposition,
|
||
},
|
||
]);
|
||
const activeRun = {
|
||
id: runId,
|
||
runtimeMode: "native" as const,
|
||
status: "running",
|
||
invocationSource: "issue" as const,
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-07T00:00:00Z",
|
||
createdAt: "2026-08-07T00:00:00Z",
|
||
finishedAt: null,
|
||
agentId: "agent-1",
|
||
agentName: "Runner",
|
||
adapterType: "paperclip_runner",
|
||
};
|
||
const linkedRun = {
|
||
...activeRun,
|
||
runId,
|
||
status: "succeeded",
|
||
finishedAt: "2026-08-07T00:00:05Z",
|
||
resultJson: {
|
||
nativeResult: {
|
||
schema: "paperclip.run_result.v1",
|
||
reportedWorkDisposition: disposition,
|
||
summary,
|
||
},
|
||
presentationDecision: {
|
||
schema: "paperclip.run_presentation_decision.v1",
|
||
chosenSource: "existing_issue_comment",
|
||
commentId: "delayed-comment",
|
||
},
|
||
},
|
||
};
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
activeRun={activeRun}
|
||
/>,
|
||
);
|
||
// The terminal run/event query wins the race, but the canonical comment
|
||
// request is still pending. The settled answer already owns the turn.
|
||
render(
|
||
<TaskChatThread
|
||
comments={[]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
linkedRuns={[linkedRun]}
|
||
/>,
|
||
);
|
||
expect(container.textContent?.split("UNIQUE-PROGRESS-LINE")).toHaveLength(
|
||
2,
|
||
);
|
||
expect(container.textContent?.split(summary)).toHaveLength(2);
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-live-transcript"]'),
|
||
).toBeNull();
|
||
render(
|
||
<TaskChatThread
|
||
comments={[
|
||
{
|
||
id: "delayed-comment",
|
||
companyId: "company-1",
|
||
issueId: "issue-1",
|
||
authorType: "agent",
|
||
authorAgentId: "agent-1",
|
||
authorUserId: null,
|
||
createdByRunId: runId,
|
||
runId,
|
||
body: summary,
|
||
presentation: null,
|
||
metadata: null,
|
||
createdAt: new Date("2026-08-07T00:00:05Z"),
|
||
updatedAt: new Date("2026-08-07T00:00:05Z"),
|
||
},
|
||
]}
|
||
onAdd={async () => {}}
|
||
issueStatus="in_progress"
|
||
linkedRuns={[linkedRun]}
|
||
/>,
|
||
);
|
||
expect(container.textContent?.split("UNIQUE-PROGRESS-LINE")).toHaveLength(
|
||
2,
|
||
);
|
||
expect(container.textContent?.split(summary)).toHaveLength(2);
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-final-response"]'),
|
||
).toBeNull();
|
||
},
|
||
);
|
||
|
||
it("keeps the transcript mounted through run settle until the settled turn renders (PAP-462 B4)", () => {
|
||
transcriptState.transcriptByRun.set("run-1", [
|
||
{
|
||
kind: "assistant",
|
||
ts: "2026-08-07T00:00:00.000Z",
|
||
text: "Last words before the run stops",
|
||
},
|
||
]);
|
||
|
||
const liveProps = {
|
||
comments: [] as never[],
|
||
onAdd: async () => {},
|
||
issueStatus: "in_progress",
|
||
activeRun: {
|
||
id: "run-1",
|
||
status: "running",
|
||
invocationSource: "issue" as const,
|
||
triggerDetail: null,
|
||
startedAt: "2026-08-07T00:00:00.000Z",
|
||
finishedAt: null,
|
||
createdAt: "2026-08-07T00:00:00.000Z",
|
||
agentId: "agent-1",
|
||
agentName: "Coder",
|
||
adapterType: "codex_local",
|
||
},
|
||
};
|
||
|
||
render(<TaskChatThread {...liveProps} />);
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-live-transcript"]'),
|
||
).not.toBeNull();
|
||
|
||
// The run settles: the issue goes terminal and the run reports succeeded, so
|
||
// `liveRun` flips to null — but no reply comment has landed yet. The
|
||
// transcript must NOT vanish; it stays mounted (now as a settled tail) until
|
||
// its settled turn/comment renders.
|
||
render(
|
||
<TaskChatThread
|
||
{...liveProps}
|
||
issueStatus="done"
|
||
activeRun={{
|
||
...liveProps.activeRun,
|
||
status: "succeeded",
|
||
finishedAt: "2026-08-07T00:01:00.000Z",
|
||
}}
|
||
/>,
|
||
);
|
||
|
||
expect(
|
||
container.querySelector('[data-testid="task-chat-live-transcript"]'),
|
||
).not.toBeNull();
|
||
expect(container.textContent).toContain("Last words before the run stops");
|
||
// The pill has settled to its "Worked" state rather than flipping back to a
|
||
// spinner while it waits for the reply comment.
|
||
expect(container.textContent).toContain("Worked");
|
||
});
|
||
});
|
||
|
||
describe("TaskChatThread composer execution controls", () => {
|
||
it.each(["process", "paperclip_runner"])("passes the task's stop action through for %s execution", async (adapterType) => {
|
||
const onStop = vi.fn(async () => {});
|
||
const run = {
|
||
id: "task-run", status: "running", runtimeMode: adapterType === "process" ? "legacy" as const : "native" as const,
|
||
invocationSource: "issue", triggerDetail: null, startedAt: "2026-09-09T12:00:00Z", finishedAt: null,
|
||
createdAt: "2026-09-09T12:00:00Z", agentId: "agent-1", agentName: "Alex", adapterType,
|
||
};
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} issueStatus="in_progress" activeRun={run} onCancelRun={onStop} stopScope="subtree" />);
|
||
const button = container.querySelector<HTMLButtonElement>('[data-testid="task-chat-composer-stop"]')!;
|
||
expect(button.title).toBe("Stop response");
|
||
await act(async () => { button.click(); });
|
||
expect(onStop).toHaveBeenCalledOnce();
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} issueStatus="in_progress" activeRun={run} onCancelRun={onStop} stopPending />);
|
||
expect(container.querySelector<HTMLButtonElement>('[data-testid="task-chat-composer-stop"]')?.disabled).toBe(true);
|
||
});
|
||
it("does not offer Stop for settled work even when a callback is available", () => {
|
||
render(<TaskChatThread comments={[]} onAdd={async () => {}} issueStatus="todo" onCancelRun={vi.fn()} />);
|
||
expect(container.querySelector('[data-testid="task-chat-composer-stop"]')).toBeNull();
|
||
});
|
||
});
|