Files
PaperClipAI/server/src/__tests__/chat-completion-proof.test.ts
T
f4337bb5fb test(evals): land the chat catalog eval harness on master (#19614)
## Thinking Path

> - Paperclip is the open source app people use to manage AI agents for
work
> - The chat-feature evals measure whether agents complete real chat
requests through the product
> - The chat catalog eval harness and its repairs live on the
`chat-eval/master-candidate` branch, not on master
> - Today's work made 139 of 242 chat evals pass in verified single-case
live runs. Each product fix landed on master as its own pull request
> - The eval-side changes (setups, graders, fault seams, evidence
capture) still exist only on the candidate
> - This pull request lands the harness on master. Master stays the
source of truth for product behavior
> - The benefit is one tree: evals run against master commits, and
product fixes reach the evals as soon as they merge

## Linked Issues or Issue Description

Refs #19441, Refs #19599, Refs #20270, Refs #20334, Refs #20342, Refs
#20344, Refs #20354, Refs #20360, Refs #20373, Refs #20382, Refs #20409

**What existing behavior does this improve?**
The chat catalog eval harness and the product it evaluates live on a
long-running branch outside master. Eval fixes do not reach master, so
master-based eval runs use old setups and graders.

**Subsystem affected**
`tests/runner-e2e` chat catalog harness, plus a small set of product
changes that exist only on the candidate.

**Proposed change**
Land the harness on master. Every product fix from this eval work
already merged to master as its own pull request. Conflicts keep
master's product behavior.

## What Changed

- Most of the diff (808 of 851 files) is under `tests/runner-e2e/`:
chat-catalog domains, scenarios, descriptors, the TestOps manifest,
private evidence tooling, and their tests.
- Graders now check saved state, setup literals and rendered or clicked
links. Many keyword and regex checks on free-form replies are removed.
Each changed grader has a bumped `oracleVersion` and calibration tests
(a valid reply, a reworded valid reply, and broken variants that must
fail).
- The shared link helper `hasLink` no longer treats a list link (for
example `/COM/issues?view=mine`) as a link to every task without a URL
key.
- Setup fixes build real state through supported product routes: routine
history, agent grants through the board grant route, budget holds with a
real cap, and a storage-layer archive fault for
`inbox-search.archive-partial-failure`.
- Browser boundary journeys (sign-in, chat-disabled, onboarding) now
write the standard pass evidence files.
- Retargeted cases, approved by the maintainer:
`agent-chat.chat-disabled` (Conference Room gate),
`agents.restore-instructions` (no saved instruction history),
`access.manage-membership` (member permission edits stay board-only).
- The private evidence trusted files (`manual-private-handoff.ts`,
`manual-private-retention.ts`, `manual-private-report-assets.ts`) are
byte-identical to master.
- Product files outside `tests/` (43 files, +1,328 −49) carry
candidate-only changes that master does not yet have. Most are tests.
The main code changes are in `request-human-input.ts`,
`heartbeat-run-summary.ts`, `native-completion-feedback.ts`,
`native-run-finalizer.ts`, `openapi.ts`, `secrets.ts` and
`IssueChatLongThreadPerf.tsx`.

## Verification

- `pnpm vitest run chat-catalog-domains chat-catalog-contract.test.ts
chat-catalog-consistency.test.ts unit-launcher.test.mjs
--testTimeout=180000` in `tests/runner-e2e`: 269 files pass, 3,550 tests
pass.
- `node --test chat-full-catalog-testops-manifest.test.mjs`: 10 pass.
- `node tests/runner-e2e/source-sdk-public-inputs.mjs <HEAD> --check`:
no change.
- `tsc` for `server` and `tests/runner-e2e`: clean.
- Live single-case verification: 139 of 242 cases passed on paid runs,
and a person read the saved evidence for each. These are single-case
runs, not one full-cohort run.

## Risks

- Large diff. Most of it is test-only, but the 43 non-test files change
product code paths. Review those files first.
- Some graders are now less strict on reply wording. A person must read
replies for meaning on those cases.
- 42 cases need disposable outside accounts (Notion, Slack, GitHub,
Daytona and others) and stay blocked. `access.invite-teammate` stays
failing until local agent isolation lands, because the runner's durable
state keeps a live invite token.
- The paid workflow compares the trusted private-evidence files with
master. They are unchanged, so this risk is low.

## Model Used

Anthropic Claude Opus 5.5 (`claude-opus-5-5`), with tool use and code
execution, in Claude Code. Subagents used the same model.

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [ ] All Paperclip CI gates are green
- [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [x] I will address all Greptile and reviewer comments before
requesting merge

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Paperclip <noreply@paperclip.ing>
2026-11-10 08:02:11 -06:00

215 lines
16 KiB
TypeScript

import { describe, expect, it, vi } from "vitest";
import { assertChatFlowRunCount, collectChatRunEvidence, retryChatCompletionObservation } from "../../../tests/runner-e2e/chat-flow.js";
import { needsChatCompletionProof, verifyChatCompletion, type ChatCompletionEvidence } from "../../../tests/runner-e2e/chat-completion-proof.js";
import { pollUntil } from "../../../tests/runner-e2e/api.js";
import { chatTasks } from "../../../tests/runner-e2e/chat-cases.js";
// Shape and ordering from run 41915965118's three retained failing journeys.
// The ordinary turns keep their existing bound; the one real completion turn
// must prove its own child, delivery, native tools, reply and rendered link.
function completionRecording(id = "multi-repository", ordinaryRunCount = 2) {
const task = chatTasks.find(task => task.id === id);
if (!task) throw new Error("Completion recording must bind an actual catalog task");
const companyId = "company", agentId = "agent", sourceId = "chat", childId = "child";
const completedAt = "2026-11-04T21:35:52.000Z";
const issue = { id: sourceId, companyId, conversationAgentId: agentId, conversationSessionGeneration: 0 };
const child = { id: childId, companyId, assigneeAgentId: agentId, status: "done", completedAt, identifier: "RUN-2" };
const ordinary = Array.from({ length: ordinaryRunCount }, (_, index) => ({
id: `ordinary-${index}`, companyId, agentId, status: "succeeded", runtimeMode: "native",
issueId: index === ordinaryRunCount - 1 ? childId : sourceId, nativeIssueId: index === ordinaryRunCount - 1 ? childId : sourceId,
contextSnapshot: { issueId: index === ordinaryRunCount - 1 ? childId : sourceId },
startedAt: "2026-11-04T21:35:00.000Z", processStartedAt: "2026-11-04T21:35:01.000Z",
finishedAt: "2026-11-04T21:35:51.000Z",
nativeSessionId: `native-${index}`, usageJson: { accountingReceiptReady: true, outputTokens: 10 },
}));
const notification = {
id: "notification", companyId, agentId, issueId: sourceId, nativeIssueId: sourceId,
status: "succeeded", runtimeMode: "native", invocationSource: "automation", triggerDetail: "system",
startedAt: "2026-11-04T21:35:53.000Z", processStartedAt: "2026-11-04T21:35:54.000Z",
finishedAt: "2026-11-04T21:36:15.000Z", nativeSessionId: "native-chat-session",
contextSnapshot: { issueId: sourceId, wakeReason: "chat_task_completed", wakeSource: "automation",
conversationSessionGeneration: 0, chatCompletionDeliveryIds: ["delivery"],
chatCompletionUpdates: [{ id: childId, status: "done", completedAt, identifier: "RUN-2", url: "/issues/RUN-2" }] },
usageJson: { inputTokens: 40_178, outputTokens: 2071, cachedInputTokens: 222_147,
costUsdExact: "0.290990800", costStatus: "estimated", accountingReceiptReady: true },
};
const comments = [{ id: "reply", companyId, issueId: sourceId, authorAgentId: agentId, authorType: "agent",
createdByRunId: notification.id, conversationSessionGeneration: 0,
createdAt: "2026-11-04T21:36:15.100Z", deletedAt: null,
body: "[RUN-2](/issues/RUN-2) is complete. Its requested document is saved on the task." }];
const events: ChatCompletionEvidence["runEvidence"][number]["events"] = ["tool.execution.started", "tool.execution.completed", "run.result.accepted"].map((eventType, index) => ({
companyId, runId: notification.id, agentId, eventType, seq: index + 1,
payload: { prpEvent: { schema: "paperclip.prp.event.v1", runId: notification.id, eventType,
payload: eventType.startsWith("tool.") ? { schema: "paperclip.tool.execution.v1", name: "paperclip_finish",
executionId: "finish", status: index === 0 ? "running" : "completed" } : {} } },
}));
const runs = [...ordinary, notification];
return { suiteId: "agent-chat", profileId: "runner-codex", environmentId: "local", notification,
task: { ...task }, runs,
completionEvidence: { companyId, agentId, companyPrefix: "RUN", baseURL: "http://fixture.invalid", issue, child,
tasks: [child], comments, runEvidence: [{ runId: notification.id, events,
workspaceOperations: [] as Array<Record<string, unknown>> }],
renderedLinks: [{ commentId: "reply", href: "/RUN/issues/RUN-2" }] } };
}
describe("delegated chat completion provider accounting", () => {
it("reports a permanent completion proof failure without retrying to the idle deadline", async () => {
vi.useFakeTimers();
try {
const input = completionRecording();
input.completionEvidence.tasks.push({ ...input.completionEvidence.child, id: "extra-child" });
const load = vi.fn(async () => verifyChatCompletion(input.runs, input.completionEvidence));
const outcome = pollUntil({ label: "chat turn settles to waiting", deadlineAt: Date.now() + 240_000,
intervalMs: 1000, load, accept: Boolean, retryOnError: retryChatCompletionObservation })
.then(value => ({ value, error: undefined }), error => ({ value: undefined, error }));
await vi.advanceTimersByTimeAsync(240_000);
expect((await outcome).error?.message).toBe("Chat completion proof: extra_work");
expect(load).toHaveBeenCalledTimes(1);
expect(vi.getTimerCount()).toBe(0);
} finally { vi.useRealTimers(); }
});
it("still retries a transient observation error within the original idle deadline", async () => {
vi.useFakeTimers();
try {
const input = completionRecording();
const load = vi.fn(async () => verifyChatCompletion(input.runs, input.completionEvidence));
load.mockRejectedValueOnce(new Error("temporary API observation failure"));
const outcome = pollUntil({ label: "chat turn settles to waiting", deadlineAt: Date.now() + 240_000,
intervalMs: 1000, load, accept: Boolean, retryOnError: retryChatCompletionObservation });
await vi.advanceTimersByTimeAsync(1000);
expect(await outcome).toMatchObject({ ordinaryProviderRuns: 2, totalProviderRuns: 3 });
expect(load).toHaveBeenCalledTimes(2);
expect(vi.getTimerCount()).toBe(0);
} finally { vi.useRealTimers(); }
});
it("collects the live run API evidence before proving a completion", async () => {
const input = completionRecording();
const recorded = input.completionEvidence.runEvidence[0]!;
const native = (eventType: string, payload: Record<string, unknown>) => ({ companyId: "company", agentId: "agent",
runId: input.notification.id, eventType,
payload: { prpEvent: { schema: "paperclip.prp.event.v1", runId: input.notification.id, eventType, payload } } });
// The native item/tool shapes come from the retained completion stream.
// Use the actual collector, including its complete paged-event read.
recorded.events = [
native("item.completed", { kind: "model", model: "gpt-5.6-sol" }),
native("item.completed", { kind: "reasoning", item: { type: "reasoning" } }),
native("item.started", { kind: "dynamicToolCall", item: { type: "tool_use", id: "read", name: "get_task" } }),
native("tool.execution.started", { schema: "paperclip.tool.execution.v1", name: "get_task", executionId: "read", status: "running" }),
native("item.completed", { kind: "dynamicToolCall", item: { type: "tool_result", id: "read", tool_use_id: "read" } }),
native("tool.execution.completed", { schema: "paperclip.tool.execution.v1", name: "get_task", executionId: "read", status: "completed" }),
native("item.completed", { kind: "agentMessage", item: { type: "agentMessage" } }),
...recorded.events,
native("item.completed", { kind: "usage", usage: input.notification.usageJson }),
].map((event, index) => ({ ...event, seq: index + 1 }));
const workspaceOperations = [{ companyId: "company", heartbeatRunId: input.notification.id,
phase: "workspace_finalize", status: "succeeded", command: null }];
const requested: string[] = [];
async function read<T>(path: string): Promise<T> {
requested.push(path);
const url = new URL(path, "http://fixture.invalid");
if (url.pathname.endsWith("/workspace-operations")) return workspaceOperations as T;
if (url.pathname.endsWith("/log")) return { content: "recorded completion notification" } as T;
if (url.pathname.endsWith("/events")) return recorded.events.filter(e => e.seq > Number(url.searchParams.get("afterSeq"))) as T;
throw new Error("Unexpected evidence endpoint");
}
const api = { get: read, getRunObservation: read };
const collected = await collectChatRunEvidence(api, input.notification, false, true);
expect(verifyChatCompletion(input.runs, { ...input.completionEvidence, runEvidence: [collected] }))
.toMatchObject({ ordinaryProviderRuns: 2, totalProviderRuns: 3 });
expect(requested).toContain(`/api/heartbeat-runs/${input.notification.id}/workspace-operations`);
expect(collected).toMatchObject({ workspaceOperations });
requested.length = 0;
await collectChatRunEvidence(api, input.notification);
expect(requested).not.toContain(`/api/heartbeat-runs/${input.notification.id}/workspace-operations`);
});
for (const [eventType, payload] of [
["item.completed", { kind: "fileChange", item: { type: "fileChange", changes: [{ path: "extra.txt" }] } }],
["item.started", { kind: "commandExecution", item: { type: "commandExecution", command: "unexpected work" } }],
["item.completed", { kind: "webSearch", item: { type: "webSearch" } }],
["workspace.change.updated", { schema: "paperclip.workspace.diff.v1", files: [{ path: "extra.txt", operation: "add" }] }],
["research.search.started", { query: "unexpected research" }],
["item.completed", { kind: "dynamicToolCall", item: { type: "tool_use", id: "hidden", name: "create_task" } }],
["item.completed", { kind: "unknown_provider_work" }],
["item.completed", { kind: "agentMessage", item: { type: "fileChange" } }],
["unrecognized.provider.work", {}],
] as const) it(`rejects native work without a Paperclip tool event: ${eventType}/${"kind" in payload ? payload.kind : "event"}`, () => {
const input = completionRecording();
input.completionEvidence.runEvidence[0]!.events.push({ companyId: "company", agentId: "agent",
runId: input.notification.id, eventType, seq: 4,
payload: { prpEvent: { schema: "paperclip.prp.event.v1", runId: input.notification.id, eventType, payload } } });
expect(() => verifyChatCompletion(input.runs, input.completionEvidence)).toThrow(/Chat completion proof:/);
});
for (const [id, bound] of [["multi-repository", 2], ["clarify-reuse", 3], ["plan-handoff", 4]] as const) {
it(`accounts for the required verified notification after ${id}`, () => {
const input = completionRecording(id, bound);
const original = JSON.stringify(input);
expect(input.task.expectedRunCount).toBe(bound + 1);
expect(input.task.minimumExpectedRunCount).toBeUndefined();
expect(() => assertChatFlowRunCount(input)).not.toThrow();
expect(verifyChatCompletion(input.runs, input.completionEvidence)).toMatchObject({ ordinaryProviderRuns: bound,
totalProviderRuns: bound + 1, allRunIds: input.runs.map(r => r.id), notificationRunId: input.notification.id });
expect(input.runs).toHaveLength(bound + 1);
expect(input.runs.at(-1)?.usageJson?.outputTokens).toBe(2071);
expect(JSON.stringify(input)).toBe(original);
});
}
const invalid: Array<[string, (input: ReturnType<typeof completionRecording>) => void]> = [
["missing required notification", f => { f.runs.pop(); }],
["duplicate paid notification", f => { f.runs.push({ ...f.notification, id: "duplicate" }); }],
["wrong source company", f => { f.completionEvidence.issue.companyId = "other-company"; }],
["wrong child company", f => { f.completionEvidence.child.companyId = "other-company"; }],
["cross-scope notification", f => { f.notification.companyId = "other-company"; }],
["old conversation generation", f => { f.notification.contextSnapshot.conversationSessionGeneration = 1; }],
["unknown automatic work", f => { f.notification.contextSnapshot.wakeReason = "unrelated_automation"; }],
["two delivery receipts", f => { f.notification.contextSnapshot.chatCompletionDeliveryIds.push("other-delivery"); }],
["wrong completed child", f => { f.notification.contextSnapshot.chatCompletionUpdates[0]!.id = "other-child"; }],
["unfinished child", f => { f.completionEvidence.child.status = "in_review"; }],
["never-started native work", f => { f.notification.processStartedAt = ""; }],
["missing actual native completion", f => { f.notification.finishedAt = ""; }],
["unaccounted provider work", f => { f.notification.usageJson.accountingReceiptReady = false; }],
["missing intended reply", f => { f.completionEvidence.comments.length = 0; }],
["duplicate completion replies", f => { f.completionEvidence.comments.push({ ...f.completionEvidence.comments[0]!, id: "other-reply" }); }],
["deleted reply", f => { Object.assign(f.completionEvidence.comments[0]!, { deletedAt: "2026-11-04T21:36:16Z" }); }],
["cross-generation reply", f => { f.completionEvidence.comments[0]!.conversationSessionGeneration = 1; }],
["missing rendered result access", f => { f.completionEvidence.renderedLinks.length = 0; }],
["foreign-origin task link", f => { f.completionEvidence.renderedLinks[0]!.href = "https://other.invalid/RUN/issues/RUN-2"; }],
["foreign-company task route", f => { f.completionEvidence.renderedLinks[0]!.href = "/OTHER/issues/RUN-2"; }],
["extra delegated work", f => { f.completionEvidence.tasks.push({ ...f.completionEvidence.child, id: "extra-child" }); }],
["missing native result stream", f => { f.completionEvidence.runEvidence[0]!.events.length = 0; }],
["cross-scope native events", f => { f.completionEvidence.runEvidence[0]!.events[0]!.companyId = "other-company"; }],
["accepted result for another native run", f => { f.completionEvidence.runEvidence[0]!.events[2]!.payload.prpEvent.runId = "other-run"; }],
["unfinished native tool", f => { f.completionEvidence.runEvidence[0]!.events.splice(1, 1); }],
["tool completion before execution", f => { f.completionEvidence.runEvidence[0]!.events.reverse(); }],
["missing workspace observation", f => { Object.assign(f.completionEvidence.runEvidence[0]!, { workspaceOperations: undefined }); }],
["new task tool inside a notification", f => {
for (const e of f.completionEvidence.runEvidence[0]!.events.slice(0, 2)) e.payload.prpEvent.payload.name = "create_task";
}],
["additional workspace command", f => { f.completionEvidence.runEvidence[0]!.workspaceOperations.push({
companyId: "company", heartbeatRunId: "notification", phase: "command", status: "succeeded", command: "unexpected work" }); }],
];
for (const [name, mutate] of invalid) it(`rejects ${name}`, () => {
const input = completionRecording(); mutate(input);
expect(() => assertChatFlowRunCount(input)).toThrow(/Chat completion proof:/);
});
it("keeps the existing ordinary-turn count exact", () => {
const missing = completionRecording(); missing.runs.splice(0, 1);
expect(() => assertChatFlowRunCount(missing)).toThrow(/Declared total provider-run bounds/);
const extra = completionRecording(); extra.runs.splice(0, 0, { ...extra.runs[0]!, id: "extra-ordinary" });
expect(() => assertChatFlowRunCount(extra)).toThrow(/Declared total provider-run bounds/);
});
it("keeps every other case, profile and environment on its original total bound", () => {
for (const patch of [{ task: { id: "create-backlog", expectedRunCount: 2 } },
{ profileId: "runner-opencode" }, { environmentId: "daytona" }, { suiteId: "other-suite" }]) {
const input = { ...completionRecording(), ...patch };
input.runs.push({ ...input.runs[0]!, id: "extra-run" });
expect(() => assertChatFlowRunCount(input)).toThrow(/Declared total provider-run bounds/);
}
expect(needsChatCompletionProof("agent-chat", undefined, "runner-codex", "local")).toBe(false);
});
});