import express from "express"; import { probeReviewApproval } from "../../../tests/runner-e2e/chat-catalog-domains/external-app-review-probe.js"; import request from "supertest"; import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; import type { TaskWatchdogMutationScope } from "../services/task-watchdog-scope.js"; const ASSIGNEE_AGENT_ID = "11111111-1111-4111-8111-111111111111"; const UNRELATED_AGENT_ID = "33333333-3333-4333-8333-333333333333"; const CREATED_AGENT_ID = "22222222-2222-4222-8222-222222222222"; const ISSUE_ID = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"; const OTHER_ISSUE_ID = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb"; // Authenticated run ids are real UUIDs in production, and the per-run // cross-issue influence counter fails closed on a malformed one before it can // reach the database, so the fixtures must look like the real thing. const RUN_1 = "d1111111-1111-4111-8111-111111111111"; const RUN_2 = "d2222222-2222-4222-8222-222222222222"; const RUN_3 = "d3333333-3333-4333-8333-333333333333"; const RUN_9 = "d9999999-9999-4999-8999-999999999999"; const RUN_CROSS_COMPANY = "dccccccc-cccc-4ccc-8ccc-cccccccccccc"; const RUN_INVALID = "d0000000-0000-4000-8000-000000000000"; const RUN_LOW_TRUST = "d0000000-0000-4000-8000-000000000001"; const RUN_TASK_BRIDGE = "d0000000-0000-4000-8000-000000000002"; const RUN_WATCHDOG = "d0000000-0000-4000-8000-000000000003"; const mockIssueService = vi.hoisted(() => ({ getById: vi.fn(), listReviewAttention: vi.fn(), addComment: vi.fn(), })); const mockDecisionReceipts = vi.hoisted(() => ({ list: vi.fn(), listCreatedTasks: vi.fn() })); const mockDocumentService = vi.hoisted(() => ({ getIssueDocumentRevision: vi.fn() })); const mockProjectService = vi.hoisted(() => ({ getById: vi.fn() })); const mockInteractionService = vi.hoisted(() => ({ listForIssue: vi.fn(), getForIssue: vi.fn(), create: vi.fn(), acceptInteraction: vi.fn(), acceptSuggestedTasks: vi.fn(), rejectInteraction: vi.fn(), rejectSuggestedTasks: vi.fn(), expireRequestConfirmationsSupersededByHistoricalComments: vi.fn(), expirePendingInteractionsForTerminalIssue: vi.fn(), answerQuestions: vi.fn(), submitItemVerdicts: vi.fn(), cancelQuestions: vi.fn(), skipInteraction: vi.fn(), dismissInteraction: vi.fn(), withdrawInteraction: vi.fn(), recordSecretProposalExecutionResult: vi.fn(), })); const mockSecretProposals = vi.hoisted(() => ({ getById: vi.fn(), approve: vi.fn() })); vi.mock("../services/secret-proposals.js", () => ({ createSecretProposalsService: () => mockSecretProposals })); const mockHeartbeatService = vi.hoisted(() => ({ wakeup: vi.fn(async (_agentId: string, _options: { payload?: unknown; contextSnapshot?: unknown }) => undefined), cancelRun: vi.fn(async () => null), })); const mockEnqueueOwnQuestionDismissalWake = vi.hoisted(() => vi.fn(async (): Promise => null)); vi.mock("../services/native-runtime/own-question-wait.js", () => ({ enqueueOwnQuestionDismissalWake: mockEnqueueOwnQuestionDismissalWake, })); const mockRequestNativeQuestionRunCancellation = vi.hoisted(() => vi.fn(async () => null as string | null) ); vi.mock("../services/native-runtime/native-question-bridge.js", () => ({ deliverNativeQuestionResponse: vi.fn(async () => "not_native"), requestNativeQuestionRunCancellation: mockRequestNativeQuestionRunCancellation, validateNativeQuestionResponseInput: vi.fn(), })); const mockQuestionResponseDeliveries = vi.hoisted(() => ({ deliver: vi.fn(async () => null), })); const mockResolveTaskWatchdogMutationScope = vi.hoisted(() => vi.fn(async (): Promise => ({ kind: "none" }))); const mockResolveCoreTrustPreset = vi.hoisted(() => vi.fn(() => ({ kind: "standard" }))); const mockRunAttribution = vi.hoisted(() => ({ value: { companyId: "company-1", agentId: "22222222-2222-4222-8222-222222222222", responsibleUserId: null, } as Record | null, })); const mockAccessDecide = vi.hoisted(() => vi.fn(async (input: { action?: string; resource?: { projectId?: string; assigneeAgentId?: string; issueId?: string } }) => ({ allowed: true, action: input.action, reason: "allow_explicit_grant", explanation: "Allowed by test grant.", }))); const mockLogActivity = vi.hoisted(() => vi.fn(async () => undefined)); const mockReviewTransition = vi.hoisted(() => ({ value: null as null | { actorType: string; actorId: string; details: Record }, })); const mockDbSelectWhere = vi.hoisted(() => vi.fn(() => ({ then: (onFulfilled: (rows: unknown[]) => unknown, onRejected?: (reason: unknown) => unknown) => Promise.resolve([{ companyId: "company-1", agentId: CREATED_AGENT_ID, contextSnapshot: null }]).then( onFulfilled, onRejected, ), }))); const mockDbSelectFrom = vi.hoisted(() => vi.fn(() => ({ where: mockDbSelectWhere }))); const mockDbSelect = vi.hoisted(() => vi.fn(() => ({ from: mockDbSelectFrom }))); // The per-run cross-issue influence counter runs in its own locking // transaction, so the route harness has to model it: the locked run row (whose // persisted context snapshot names the source issue) and the observation count. const mockCrossIssueInfluence = vi.hoisted(() => ({ sourceIssueId: null as string | null, priorCount: 0, inserted: [] as Array>, })); const mockDbTransaction = vi.hoisted(() => vi.fn(async (callback: (tx: unknown) => unknown) => callback({ select: (selection: Record) => ({ from: () => ({ where: () => { if (Object.keys(selection).includes("count")) { return { then: (resolve: (rows: unknown[]) => unknown) => resolve([{ count: mockCrossIssueInfluence.priorCount }]), }; } const run = mockRunAttribution.value; return { for: () => ({ then: (resolve: (rows: unknown[]) => unknown) => resolve(run ? [{ id: run.runId ?? null, companyId: run.companyId ?? null, agentId: run.agentId ?? null, responsibleUserId: run.responsibleUserId ?? null, contextSnapshot: { issueId: mockCrossIssueInfluence.sourceIssueId }, }] : []), }), }; }, }), }), insert: () => ({ values: async (value: Record) => { mockCrossIssueInfluence.inserted.push(value); if (value.action === "issue.cross_issue_influence_observed") mockCrossIssueInfluence.priorCount += 1; }, }), }))); const mockDb = vi.hoisted(() => ({ select: mockDbSelect, transaction: mockDbTransaction, })); vi.mock("@paperclipai/shared/telemetry", () => ({ trackAgentTaskCompleted: vi.fn(), trackErrorHandlerCrash: vi.fn(), })); vi.mock("../telemetry.js", () => ({ getTelemetryClient: vi.fn(() => ({ track: vi.fn() })), })); vi.mock("../services/task-watchdog-scope.js", () => ({ TASK_WATCHDOG_ORIGIN_KIND: "task_watchdog", resolveTaskWatchdogMutationScope: mockResolveTaskWatchdogMutationScope, taskWatchdogScopeAllowsIssueMutation: vi.fn(async (_db, scope) => scope), })); vi.mock("../services/trust-preset-resolver.js", () => ({ LOW_TRUST_ISSUE_ANCESTRY_MAX_DEPTH: 100, resolveCoreTrustPreset: mockResolveCoreTrustPreset, })); function registerModuleMocks() { vi.doMock("../services/conversation-decision-receipts.js", () => ({ conversationDecisionReceiptsService: () => mockDecisionReceipts, })); vi.doMock("../services/question-response-delivery.js", () => ({ questionResponseDeliveryService: () => mockQuestionResponseDeliveries, })); vi.doMock("../services/index.js", () => ({ companyService: () => ({ getById: vi.fn(async () => ({ id: "company-1" })), }), accessService: () => ({ canUser: vi.fn(async () => true), decide: mockAccessDecide, hasPermission: vi.fn(async () => true), }), agentService: () => ({ getById: vi.fn(async () => ({ id: CREATED_AGENT_ID, companyId: "company-1", permissions: null })), resolveByReference: vi.fn(async (_companyId: string, raw: string) => ({ ambiguous: false, agent: { id: raw }, })), }), clampIssueListLimit: (value: number) => value, companySkillService: () => ({ completeTestRunForIssue: vi.fn(async () => null), }), ISSUE_LIST_DEFAULT_LIMIT: 500, ISSUE_LIST_MAX_LIMIT: 1000, documentAnnotationService: () => ({ remapOpenThreadsForDocument: async () => [] }), documentService: () => mockDocumentService, executionWorkspaceService: () => ({}), feedbackService: () => ({ listIssueVotesForUser: vi.fn(async () => []), saveIssueVote: vi.fn(async () => ({ vote: null, consentEnabledNow: false, sharingEnabled: false })), }), goalService: () => ({}), heartbeatService: () => mockHeartbeatService, instanceSettingsService: () => ({ get: vi.fn(async () => ({ id: "instance-settings-1", general: { censorUsernameInLogs: false, feedbackDataSharingPreference: "prompt", }, })), listCompanyIds: vi.fn(async () => ["company-1"]), }), issueApprovalService: () => ({}), issueReferenceService: () => ({ deleteDocumentSource: async () => undefined, diffIssueReferenceSummary: () => ({ addedReferencedIssues: [], removedReferencedIssues: [], currentReferencedIssues: [], }), emptySummary: () => ({ outbound: [], inbound: [] }), listIssueReferenceSummary: async () => ({ outbound: [], inbound: [] }), syncComment: async () => undefined, syncDocument: async () => undefined, syncIssue: async () => undefined, }), issueRecoveryActionService: () => ({ getActiveForIssue: vi.fn(async () => null), listActiveForIssues: vi.fn(async () => new Map()), }), issueService: () => mockIssueService, issueThreadInteractionService: () => mockInteractionService, taskWatchdogService: () => ({ getActiveForIssue: vi.fn(async () => null), upsertForIssue: vi.fn(), disableForIssue: vi.fn(async () => null), revalidateMutationScope: vi.fn(async (scope: unknown) => ({ allowed: true, scope })), }), logActivity: mockLogActivity, projectService: () => mockProjectService, routineService: () => ({ syncRunStatusForIssue: vi.fn(async () => undefined), }), workProductService: () => ({}), })); } function createIssue(overrides: Record = {}) { return { id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", companyId: "company-1", status: "in_progress", workMode: "standard", priority: "medium", projectId: null, goalId: null, parentId: null, assigneeAgentId: ASSIGNEE_AGENT_ID, assigneeUserId: null, createdByUserId: "local-board", identifier: "PAP-1714", title: "Persist interactions", executionPolicy: null, executionState: null, hiddenAt: null, ...overrides, }; } async function loadAppModules() { const routes = await import("../routes/issues.js"); const middleware = await import("../middleware/index.js"); return [routes, middleware] as const; } async function createApp(actor: Record = { type: "board", userId: "local-board", companyIds: ["company-1"], source: "local_implicit", isInstanceAdmin: false, }, routeOptions: Record = {}) { if (actor.type === "agent") { mockRunAttribution.value = { runId: actor.runId, companyId: actor.companyId ?? "company-1", agentId: actor.agentId, responsibleUserId: actor.onBehalfOfUserId ?? null, }; } const [{ issueRoutes }, { errorHandler }] = await loadAppModules(); const app = express(); app.use(express.json()); app.use((req, _res, next) => { (req as any).actor = actor; next(); }); app.use("/api", issueRoutes(mockDb as any, {} as any, routeOptions)); app.use(errorHandler); return app; } async function resolveMockInteraction( args: unknown[], interaction: Record, ) { const mutationOptions = args[4] as { afterResolveInTransaction?: ( tx: Record, resolved: Record, ) => Promise; } | undefined; await mutationOptions?.afterResolveInTransaction?.({}, interaction); return interaction; } describe("issue thread interaction routes", () => { beforeAll(async () => { vi.resetModules(); vi.doUnmock("../routes/issues.js"); vi.doUnmock("../routes/authz.js"); vi.doUnmock("../middleware/index.js"); vi.doUnmock("../services/index.js"); registerModuleMocks(); await loadAppModules(); }, 60_000); beforeEach(() => { // Every mock here is a vi.hoisted() singleton. All 70+ tests share it. // A queued mockResolvedValueOnce() value can outlive its own test and // leak into a later, unrelated test. vi.resetAllMocks() drains that // queue for every mock in one call. It also keeps each mock's // constructor-provided vi.fn(impl) default. So the code below only // sets values that must differ from that default. // vi.clearAllMocks() clears call history only. It does not drain the // queue. That gap once let a leftover queued value deny an unrelated // later test. vi.resetAllMocks(); // mockRunAttribution.value is a plain object, not a vi.fn(). // resetAllMocks() does not reset it. createApp() overwrites it for an // agent actor. A board actor leaves whatever value a prior test set here. mockRunAttribution.value = { companyId: "company-1", agentId: CREATED_AGENT_ID, responsibleUserId: null, }; mockQuestionResponseDeliveries.deliver.mockResolvedValue(null); mockRequestNativeQuestionRunCancellation.mockResolvedValue(null); mockResolveTaskWatchdogMutationScope.mockResolvedValue({ kind: "none" }); mockResolveCoreTrustPreset.mockReturnValue({ kind: "standard" }); mockAccessDecide.mockImplementation(async (input: { action?: string }) => ({ allowed: true, action: input.action, reason: "allow_explicit_grant", explanation: "Allowed by test grant.", })); mockIssueService.getById.mockResolvedValue(createIssue()); mockDecisionReceipts.list.mockResolvedValue({ items: [], nextCursor: null }); mockDecisionReceipts.listCreatedTasks.mockResolvedValue({ items: [], nextCursor: null }); mockDocumentService.getIssueDocumentRevision.mockResolvedValue(null); mockProjectService.getById.mockImplementation(async (id: string) => ({ id, companyId: "company-1" })); mockIssueService.listReviewAttention.mockResolvedValue(new Map()); mockInteractionService.listForIssue.mockResolvedValue([]); mockInteractionService.expireRequestConfirmationsSupersededByHistoricalComments.mockResolvedValue([]); mockInteractionService.expirePendingInteractionsForTerminalIssue.mockResolvedValue([]); mockInteractionService.getForIssue.mockResolvedValue({ id: "interaction-withdraw", kind: "ask_user_questions", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "board_or_agents", effectiveResolverPolicy: "board_or_agents", continuationPolicy: "wake_assignee", status: "pending", payload: { version: 1, questions: [] }, }); mockInteractionService.withdrawInteraction.mockImplementation((...args) => resolveMockInteraction(args, { id: "interaction-withdraw", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", createdByAgentId: CREATED_AGENT_ID, status: "cancelled", continuationPolicy: "wake_assignee", payload: { version: 1, prompt: "Proceed?" }, result: { version: 1, outcome: "withdrawn", reason: "Replanning" }, })); mockInteractionService.recordSecretProposalExecutionResult.mockImplementation( async (_issue, _interactionId, _proposalId, execution) => ({ ...(await mockInteractionService.acceptInteraction.mock.results.at(-1)?.value)?.interaction, id: _interactionId, companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "accepted", continuationPolicy: "wake_assignee", payload: { version: 1, prompt: "Create the binding?", secretProposal: { version: 1, proposalId: _proposalId, configPath: "access.NEW_ALIAS", }, }, result: { version: 1, outcome: "accepted", secretProposal: { version: 1, ...execution } }, }), ); mockInteractionService.create.mockResolvedValue({ id: "interaction-1", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "suggest_tasks", status: "pending", continuationPolicy: "wake_assignee", idempotencyKey: null, sourceCommentId: null, sourceRunId: RUN_1, payload: { version: 1, tasks: [{ clientKey: "task-1", title: "One" }], }, result: null, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:00:00.000Z", }); mockInteractionService.acceptInteraction.mockResolvedValue({ interaction: { id: "interaction-1", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "suggest_tasks", status: "accepted", continuationPolicy: "wake_assignee", idempotencyKey: null, sourceCommentId: "comment-1", sourceRunId: RUN_1, payload: { version: 1, tasks: [{ clientKey: "task-1", title: "One" }], }, result: { version: 1, createdTasks: [{ clientKey: "task-1", issueId: "child-1" }], skippedClientKeys: ["task-2"], }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }, createdIssues: [ { id: "child-1", assigneeAgentId: CREATED_AGENT_ID, status: "todo", }, ], }); mockInteractionService.rejectInteraction.mockResolvedValue({ id: "interaction-1", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "suggest_tasks", status: "rejected", continuationPolicy: "wake_assignee", idempotencyKey: null, sourceCommentId: "comment-1", sourceRunId: RUN_1, payload: { version: 1, tasks: [{ clientKey: "task-1", title: "One" }], }, result: { version: 1, rejectionReason: "Not actionable enough", }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }); mockInteractionService.answerQuestions.mockResolvedValue({ id: "interaction-2", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "ask_user_questions", status: "answered", continuationPolicy: "wake_assignee", idempotencyKey: null, sourceCommentId: "comment-2", sourceRunId: RUN_2, payload: { version: 1, questions: [{ id: "scope", prompt: "Scope?", selectionMode: "single", options: [{ id: "phase-1", label: "Phase 1" }], }], }, result: { version: 1, answers: [{ questionId: "scope", optionIds: ["phase-1"] }], }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:06:00.000Z", resolvedAt: "2026-04-20T12:06:00.000Z", }); mockInteractionService.submitItemVerdicts.mockResolvedValue({ interaction: { id: "interaction-verdicts", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_item_verdicts", status: "pending", continuationPolicy: "wake_assignee", idempotencyKey: null, sourceCommentId: "comment-verdicts", sourceRunId: "run-verdicts", payload: { version: 1, prompt: "Review generated artifacts.", items: [ { id: "api", label: "API route" }, { id: "docs", label: "Docs" }, ], verdicts: ["approve", "reject"], requireReasonOn: ["reject"], allowBulkApprove: true, }, result: { version: 1, outcome: "resolved", complete: false, items: [ { id: "docs", verdict: "reject", reason: "Missing examples", resolvedByUserId: "local-board", resolvedAt: "2026-04-20T12:06:00.000Z", }, ], }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:06:00.000Z", resolvedAt: null, }, newlyResolvedItemIds: ["docs"], }); mockInteractionService.cancelQuestions.mockImplementation((...args) => resolveMockInteraction(args, { id: "interaction-2", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "ask_user_questions", status: "cancelled", continuationPolicy: "wake_assignee", idempotencyKey: null, sourceCommentId: "comment-2", sourceRunId: RUN_2, payload: { version: 1, questions: [{ id: "scope", prompt: "Scope?", selectionMode: "single", options: [{ id: "phase-1", label: "Phase 1" }], }], }, result: { version: 1, answers: [], cancelled: true, cancellationReason: null, summaryMarkdown: null, }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", })); mockDbSelect.mockImplementation(() => ({ from: mockDbSelectFrom })); mockDbSelectFrom.mockImplementation(() => ({ where: mockDbSelectWhere })); mockDbSelectWhere.mockImplementation(() => ({ then: (onFulfilled: (rows: unknown[]) => unknown, onRejected?: (reason: unknown) => unknown) => Promise.resolve(mockRunAttribution.value ? [mockRunAttribution.value] : []).then( onFulfilled, onRejected, ), orderBy: () => ({ limit: () => Promise.resolve(mockReviewTransition.value ? [mockReviewTransition.value] : []), }), })); mockReviewTransition.value = null; // Default: the authenticated run is already working the issue under test, so // resolution is a same-issue write and the cross-issue counter must ignore it. mockCrossIssueInfluence.sourceIssueId = ISSUE_ID; mockCrossIssueInfluence.priorCount = 0; mockCrossIssueInfluence.inserted.length = 0; }); describe.each([ { route: "decision-receipts", method: "list" as const }, { route: "chat-handoffs", method: "listCreatedTasks" as const }, ])("owned conversation $route", ({ route, method }) => { const owner = { type: "board", userId: "paperclip-id:chat-owner", source: "cloud_tenant", companyIds: ["company-1"], isInstanceAdmin: false, }; const path = `/api/issues/${ISSUE_ID}/${route}`; const list = mockDecisionReceipts[method]; beforeEach(() => { mockIssueService.getById.mockResolvedValue(createIssue({ conversationAgentId: ASSIGNEE_AGENT_ID, conversationUserId: owner.userId, })); }); it("returns the owner's canonical records with bounded pagination and no writes or wake", async () => { const page = { items: [method === "list" ? { id: "interaction:decision-1", issueId: OTHER_ISSUE_ID } : { id: `chat_handoff:${OTHER_ISSUE_ID}`, issueId: OTHER_ISSUE_ID, identifier: "PAP-1715", title: "Write the launch post", status: "todo", createdAt: "2026-10-26T15:00:00Z", sourceRunId: null, suggestionInteractionId: null }], nextCursor: "next-page" }; list.mockResolvedValue(page); const response = await request(await createApp(owner)).get(path).query({ limit: 100, cursor: "prior-page" }); expect(response.status).toBe(200); expect(response.body).toEqual(page); expect(mockAccessDecide).toHaveBeenCalledWith(expect.objectContaining({ actor: owner, action: "issue:read", resource: expect.objectContaining({ issueId: ISSUE_ID }), })); expect(list).toHaveBeenCalledWith("company-1", ISSUE_ID, { actor: owner, userId: owner.userId, cursor: "prior-page", limit: 100, }); expect(mockLogActivity).not.toHaveBeenCalled(); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); }); it("leaves omitted pagination to the history service defaults", async () => { const response = await request(await createApp(owner)).get(path); expect(response.status).toBe(200); expect(list).toHaveBeenCalledWith("company-1", ISSUE_ID, { actor: owner, userId: owner.userId, }); }); it.each(["chat-owner", "paperclip-id:another-user"])("does not treat another identity as the owner: %s", async (userId) => { const response = await request(await createApp({ ...owner, userId })).get(path); expect(response.status).toBe(404); expect(list).not.toHaveBeenCalled(); }); it.each([ { name: "agent", actor: { type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_1 } }, { name: "board without user", actor: { ...owner, userId: undefined } }, ])("denies $name before reading conversation content", async ({ actor }) => { const response = await request(await createApp(actor)).get(path); expect(response.status).toBe(403); expect(list).not.toHaveBeenCalled(); }); it("rejects a normal task even when the user can read it", async () => { mockIssueService.getById.mockResolvedValue(createIssue({ conversationUserId: owner.userId })); expect((await request(await createApp(owner)).get(path)).status).toBe(404); expect(list).not.toHaveBeenCalled(); }); it("rechecks current conversation access even for the owner", async () => { mockAccessDecide.mockResolvedValue({ allowed: false, action: "issue:read", reason: "deny_issue_private", explanation: "Access revoked", }); expect((await request(await createApp(owner)).get(path)).status).toBe(404); expect(list).not.toHaveBeenCalled(); }); it("does not read conversation records across the company boundary", async () => { mockIssueService.getById.mockResolvedValue(createIssue({ companyId: "company-2", conversationAgentId: ASSIGNEE_AGENT_ID, conversationUserId: owner.userId, })); expect((await request(await createApp(owner)).get(path)).status).toBe(404); expect(list).not.toHaveBeenCalled(); }); it.each([ { limit: 0 }, { limit: 101 }, { limit: 1.5 }, { limit: "not-a-number" }, { cursor: "x".repeat(1001) }, { agentId: ASSIGNEE_AGENT_ID }, ])("rejects unsupported or unbounded conversation query %j", async (query) => { expect((await request(await createApp(owner)).get(path).query(query)).status).toBe(400); expect(list).not.toHaveBeenCalled(); }); }); describe("exact document revision reads", () => { const path = (key = "launch-post", revisionId = RUN_1) => `/api/issues/${ISSUE_ID}/documents/${encodeURIComponent(key)}/revisions/${encodeURIComponent(revisionId)}`; const board = { type: "board", userId: "reviewer", companyIds: ["company-1"], source: "session" }; const agent = { type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2 }; it.each([{ name: "board", actor: board }, { name: "agent", actor: agent }])( "returns the requested immutable revision for an authorized $name", async ({ actor }) => { const revision = { id: RUN_1, documentId: OTHER_ISSUE_ID, revision: 2, title: "Launch draft", body: "The exact version that was reviewed.", }; mockDocumentService.getIssueDocumentRevision.mockResolvedValue(revision); const response = await request(await createApp(actor)).get(path(" Launch-Post ")); expect(response.status).toBe(200); expect(response.body).toEqual(revision); expect(mockAccessDecide).toHaveBeenCalledWith(expect.objectContaining({ actor, action: "issue:read", resource: expect.objectContaining({ issueId: ISSUE_ID }), })); expect(mockDocumentService.getIssueDocumentRevision).toHaveBeenCalledWith(ISSUE_ID, "launch-post", RUN_1); expect(mockLogActivity).not.toHaveBeenCalled(); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); }, ); it.each([{ name: "board", actor: board }, { name: "agent", actor: agent }])( "denies a $name without current issue read access before looking up the revision", async ({ actor }) => { mockAccessDecide.mockResolvedValue({ allowed: false, action: "issue:read", reason: "deny_issue_private", explanation: "Revoked" }); const response = await request(await createApp(actor)).get(path()); expect(response.status).toBe(404); expect(mockDocumentService.getIssueDocumentRevision).not.toHaveBeenCalled(); }, ); it("denies a cross-company issue before looking up the revision", async () => { mockIssueService.getById.mockResolvedValue(createIssue({ companyId: "company-2" })); expect((await request(await createApp(board)).get(path())).status).toBe(404); expect(mockDocumentService.getIssueDocumentRevision).not.toHaveBeenCalled(); }); it("returns not found for a missing issue without asking for its document", async () => { mockIssueService.getById.mockResolvedValue(null); expect((await request(await createApp(board)).get(path())).status).toBe(404); expect(mockDocumentService.getIssueDocumentRevision).not.toHaveBeenCalled(); }); it("returns not found when the revision does not belong to the requested issue and key", async () => { mockDocumentService.getIssueDocumentRevision.mockResolvedValue(null); const response = await request(await createApp(board)).get(path()); expect(response.status).toBe(404); expect(response.body).toEqual({ error: "Document revision not found" }); expect(mockDocumentService.getIssueDocumentRevision).toHaveBeenCalledWith(ISSUE_ID, "launch-post", RUN_1); expect(mockLogActivity).not.toHaveBeenCalled(); }); it.each([ { name: "invalid key characters", key: "draft.html", revisionId: RUN_1 }, { name: "empty trimmed key", key: " ", revisionId: RUN_1 }, { name: "overlong key", key: "a".repeat(65), revisionId: RUN_1 }, { name: "invalid revision ID", key: "launch-post", revisionId: "latest" }, ])("rejects $name before document lookup", async ({ key, revisionId }) => { const response = await request(await createApp(board)).get(path(key, revisionId)); expect(response.status).toBe(400); expect(response.body).toMatchObject({ error: "Invalid document revision reference" }); expect(mockDocumentService.getIssueDocumentRevision).not.toHaveBeenCalled(); }); }); it("creates board-authored interactions", async () => { const app = await createApp(); const createRes = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions") .send({ kind: "suggest_tasks", payload: { version: 1, tasks: [{ clientKey: "task-1", title: "One" }], }, }); expect(createRes.status).toBe(201); expect(mockInteractionService.create).toHaveBeenCalled(); expect(mockLogActivity).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ action: "issue.thread_interaction_created", details: expect.objectContaining({ interactionId: "interaction-1", interactionKind: "suggest_tasks", }), }), ); }, 10_000); it("records a board dismissal without resolving or waking, and denies agent dismissal", async () => { mockInteractionService.dismissInteraction.mockResolvedValue({ id: "request-1", kind: "request_confirmation", status: "pending", dismissedAt: "2026-10-22T12:00:00Z" }); const path = "/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/request-1/dismiss"; const result = await request(await createApp()).post(path).send({}); expect(result.status).toBe(200); expect(result.body).toMatchObject({ status: "pending", dismissedAt: "2026-10-22T12:00:00Z" }); expect(mockInteractionService.dismissInteraction).toHaveBeenCalledWith(expect.objectContaining({ companyId: "company-1" }), "request-1", { userId: "local-board" }, expect.any(Function)); expect(mockLogActivity).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ action: "issue.thread_interaction_dismissed" })); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); mockInteractionService.dismissInteraction.mockClear(); expect((await request(await createApp({ type: "agent", agentId: CREATED_AGENT_ID, companyId: "company-1", runId: RUN_1 })).post(path).send({})).status).toBe(403); expect(mockInteractionService.dismissInteraction).not.toHaveBeenCalled(); }); it("saves the dismissal wake intent in the dismissal transaction only when the card is dismissed", async () => { const dismissed = { id: "request-1", kind: "ask_user_questions", status: "pending", dismissedAt: "2026-10-22T12:00:00Z" }; mockInteractionService.dismissInteraction.mockResolvedValue(dismissed); const path = "/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/request-1/dismiss"; expect((await request(await createApp()).post(path).send({})).status).toBe(200); expect(mockEnqueueOwnQuestionDismissalWake).not.toHaveBeenCalled(); const tx = { transaction: "dismissal" }; mockInteractionService.dismissInteraction.mockImplementationOnce( async (_issue: unknown, _id: string, _actor: unknown, afterDismissed?: (tx: unknown) => Promise) => { await afterDismissed?.(tx); return dismissed; }); expect((await request(await createApp()).post(path).send({})).status).toBe(200); expect(mockEnqueueOwnQuestionDismissalWake).toHaveBeenCalledWith(tx, { companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", interactionId: "request-1" }); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); }); it("hides private task requests from same-company members without task access before dismissal", async () => { mockAccessDecide.mockResolvedValue({ allowed: false, action: "issue:read", reason: "deny_issue_private", explanation: "Task access was revoked.", }); const app = await createApp({ type: "board", userId: "same-company-member", companyIds: ["company-1"], source: "session", isInstanceAdmin: false, }); const result = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/request-1/dismiss").send({}); expect(result.status).toBe(404); expect(result.body).toEqual({ error: "Issue not found" }); expect(mockInteractionService.dismissInteraction).not.toHaveBeenCalled(); expect(mockInteractionService.getForIssue).not.toHaveBeenCalled(); expect(mockLogActivity).not.toHaveBeenCalled(); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); }); it("normalizes a canonical-only mixed question form at the HTTP boundary", async () => { const questionSet = { schema: "paperclip.question_set.v1", questions: [ { id: "repo", prompt: "Repository URL?", required: true, answerMode: "text" }, { id: "scope", prompt: "Review scope?", required: true, answerMode: "single_select", options: [{ id: "all", label: "All changes" }, { id: "selected", label: "Selected changes" }] }, ] }; const res = await request(await createApp()) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions") .send({ kind: "ask_user_questions", payload: { version: 1, questionSet } }); expect(res.status).toBe(201); expect(mockInteractionService.create).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ payload: expect.objectContaining({ questionSet, questions: [ expect.objectContaining({ id: "repo", options: [{ id: "paperclip_text_answer", label: "Type an answer", freeText: true }] }), expect.objectContaining({ id: "scope", options: questionSet.questions[1].options }), ] }), }), expect.anything()); }); it.each(["in_review", "done"])("keeps interaction reads free of expiry, activity writes, and recovery while %s", async (status) => { mockIssueService.getById.mockResolvedValue(createIssue({ status, assigneeAgentId: ASSIGNEE_AGENT_ID, })); mockInteractionService.listForIssue.mockResolvedValue([]); await request(await createApp()) .get("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions") .expect(200, []); expect(mockInteractionService.listForIssue).toHaveBeenCalledExactlyOnceWith(ISSUE_ID, expect.objectContaining({ id: ISSUE_ID, status })); expect(mockInteractionService.expireRequestConfirmationsSupersededByHistoricalComments).not.toHaveBeenCalled(); expect(mockInteractionService.expirePendingInteractionsForTerminalIssue).not.toHaveBeenCalled(); expect(mockLogActivity).not.toHaveBeenCalled(); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); }); it("wakes the addressed agent when an interaction is created", async () => { mockInteractionService.create.mockResolvedValueOnce({ id: "interaction-addressed", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "ask_user_questions", status: "pending", continuationPolicy: "wake_assignee", addresseeAgentId: ASSIGNEE_AGENT_ID, requestedResolverPolicy: "anyone", effectiveResolverPolicy: "anyone", idempotencyKey: null, sourceCommentId: null, sourceRunId: null, payload: { version: 1, questions: [] }, result: null, createdAt: "2026-07-25T12:00:00.000Z", updatedAt: "2026-07-25T12:00:00.000Z", }); const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions") .send({ kind: "ask_user_questions", addresseeAgentId: ASSIGNEE_AGENT_ID, payload: { version: 1, questions: [{ id: "scope", prompt: "Which scope?", selectionMode: "single", options: [{ id: "phase-1", label: "Phase 1" }], }], }, }); expect(res.status).toBe(201); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ reason: "interaction_pending", idempotencyKey: "interaction-pending:interaction-addressed", payload: expect.objectContaining({ issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", interactionId: "interaction-addressed", }), contextSnapshot: expect.objectContaining({ wakeReason: "interaction_pending" }), }), ); }); it("does not route agent attention for a human-only interaction", async () => { mockInteractionService.create.mockResolvedValueOnce({ id: "interaction-human-attention", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "ask_user_questions", status: "pending", continuationPolicy: "wake_assignee", addresseeAgentId: ASSIGNEE_AGENT_ID, requestedResolverPolicy: "human_only", effectiveResolverPolicy: "human_only", resolverPolicyProvenance: "explicit", effectiveResolverPolicySource: "requested", idempotencyKey: null, sourceCommentId: null, sourceRunId: null, createdByAgentId: null, payload: { version: 1, questions: [] }, result: null, createdAt: "2026-07-25T12:00:00.000Z", updatedAt: "2026-07-25T12:00:00.000Z", }); const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions") .send({ kind: "ask_user_questions", addresseeAgentId: ASSIGNEE_AGENT_ID, resolverPolicy: "human_only", payload: { version: 1, questions: [{ id: "scope", prompt: "Which scope?", selectionMode: "single", options: [{ id: "phase-1", label: "Phase 1" }], }], }, }); expect(res.status).toBe(201); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); }); it("returns 400 for agent-addressed tool-action confirmations", async () => { const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions") .send({ kind: "request_confirmation", addresseeAgentId: ASSIGNEE_AGENT_ID, payload: { version: 1, prompt: "Run the tool?", toolAction: { version: 1, actionRequestId: "11111111-1111-4111-8111-111111111111", invocationId: "22222222-2222-4222-8222-222222222222", toolName: "send_email", toolDisplayName: "Send email", connectionId: "33333333-3333-4333-8333-333333333333", applicationId: "44444444-4444-4444-8444-444444444444", appDisplayName: "Gmail", risk: "write", previewMarkdown: "Send an email to the reviewed recipient.", argumentsSummaryJson: '{"to":"recipient@example.com"}', argumentsHash: "reviewed-arguments-hash", expiresAt: "2026-07-25T16:00:00.000Z", }, }, }); expect(res.status).toBe(400); expect(res.body.error).toContain("cannot be addressed"); expect(mockInteractionService.create).not.toHaveBeenCalled(); }); it("accepts suggested tasks and wakes created assignees plus the current assignee", async () => { const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-1/accept") .send({ selectedClientKeys: ["task-1"] }); expect(res.status).toBe(200); expect(mockInteractionService.acceptInteraction).toHaveBeenCalledWith( expect.objectContaining({ id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa" }), "interaction-1", { selectedClientKeys: ["task-1"] }, expect.objectContaining({ userId: "local-board" }), ); expect(mockHeartbeatService.wakeup).toHaveBeenCalledTimes(2); expect(mockHeartbeatService.wakeup).toHaveBeenNthCalledWith( 1, CREATED_AGENT_ID, expect.objectContaining({ source: "assignment", reason: "issue_assigned", payload: expect.objectContaining({ issueId: "child-1", mutation: "interaction_accept", }), }), ); expect(mockHeartbeatService.wakeup).toHaveBeenNthCalledWith( 2, ASSIGNEE_AGENT_ID, expect.objectContaining({ source: "automation", reason: "issue_commented", payload: expect.objectContaining({ issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", interactionId: "interaction-1", interactionStatus: "accepted", sourceCommentId: "comment-1", sourceRunId: RUN_1, }), }), ); }); it("answers questions through the durable delivery service", async () => { const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-2/respond") .send({ answers: [{ questionId: "scope", optionIds: ["phase-1"] }], }); expect(res.status).toBe(200); expect(mockInteractionService.answerQuestions).toHaveBeenCalled(); expect(mockQuestionResponseDeliveries.deliver).toHaveBeenCalledWith( "interaction-2", ); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); expect(mockLogActivity).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ action: "issue.thread_interaction_answered", }), ); }); it.each(["paperclip-id:chat-owner", "chat-owner", "paperclip-id:another-user"])("keeps chat response delivery limited to the exact owner: %s", async (userId) => { const issue = createIssue({ conversationAgentId: ASSIGNEE_AGENT_ID, conversationUserId: "paperclip-id:chat-owner" }); mockIssueService.getById.mockResolvedValue(issue); mockInteractionService.getForIssue.mockResolvedValue({ id: "interaction-2", kind: "ask_user_questions", status: "pending", requestedResolverPolicy: "human_only", effectiveResolverPolicy: "human_only", addresseeUserId: "paperclip-id:chat-owner", continuationPolicy: "wake_assignee", payload: { version: 1, questions: [] }, }); const app = await createApp({ type: "board", userId, source: "cloud_tenant", companyIds: ["company-1"] }); const response = await request(app).post(`/api/issues/${ISSUE_ID}/interactions/interaction-2/respond`) .send({ answers: [{ questionId: "scope", optionIds: ["phase-1"] }] }); if (userId === "paperclip-id:chat-owner") { expect(response.status).toBe(200); expect(mockInteractionService.answerQuestions).toHaveBeenCalledWith(expect.anything(), "interaction-2", expect.anything(), expect.objectContaining({ userId })); expect(mockQuestionResponseDeliveries.deliver).toHaveBeenCalledWith("interaction-2"); } else { expect(response.status).toBe(403); expect(mockInteractionService.answerQuestions).not.toHaveBeenCalled(); expect(mockQuestionResponseDeliveries.deliver).not.toHaveBeenCalled(); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); } }); it("routes wake-on-accept question answers through the same causal delivery service", async () => { mockInteractionService.answerQuestions.mockResolvedValueOnce({ id: "interaction-2", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "ask_user_questions", status: "answered", continuationPolicy: "wake_assignee_on_accept", sourceCommentId: "comment-2", sourceRunId: RUN_2, payload: { version: 1, questions: [] }, result: { version: 1, answers: [{ questionId: "scope", optionIds: ["phase-1"] }] }, }); const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-2/respond") .send({ answers: [{ questionId: "scope", optionIds: ["phase-1"] }] }); expect(res.status).toBe(200); expect(mockQuestionResponseDeliveries.deliver).toHaveBeenCalledWith("interaction-2"); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); }); it.each([ ["an app's question (MCP elicitation)", "mcp-elicit:round-1:abc", 1], ["an ordinary question", "agent-question-1", 0], ] as const)("wakes the assignee when a person skips %s, so the app receives the decline", async (_name, idempotencyKey, wakes) => { mockInteractionService.skipInteraction.mockResolvedValue({ id: "interaction-skip", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "ask_user_questions", status: "cancelled", continuationPolicy: "wake_assignee", idempotencyKey, sourceCommentId: null, sourceRunId: RUN_2, payload: { version: 1, questions: [] }, result: { version: 1, answers: [], outcome: "skipped" }, }); const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-skip/skip") .send({}); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledTimes(wakes); if (wakes) expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith(ASSIGNEE_AGENT_ID, expect.anything()); }); it("submits item verdicts and emits one continuation wake with resolved item ids", async () => { const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-verdicts/verdicts") .send({ verdicts: [{ id: "docs", verdict: "reject", reason: "Missing examples" }], }); expect(res.status).toBe(200); expect(mockInteractionService.submitItemVerdicts).toHaveBeenCalledWith( expect.objectContaining({ id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa" }), "interaction-verdicts", { verdicts: [{ id: "docs", verdict: "reject", reason: "Missing examples" }] }, expect.objectContaining({ userId: "local-board" }), ); expect(mockHeartbeatService.wakeup).toHaveBeenCalledTimes(1); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ reason: "issue_commented", idempotencyKey: expect.stringMatching( /^request_item_verdicts:aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa:interaction-verdicts:/, ), payload: expect.objectContaining({ interactionId: "interaction-verdicts", interactionKind: "request_item_verdicts", interactionStatus: "pending", sourceCommentId: "comment-verdicts", sourceRunId: "run-verdicts", newlyResolvedItemIds: ["docs"], itemVerdicts: { newlyResolvedItemIds: ["docs"], coalesceWindowMs: 2000, }, }), contextSnapshot: expect.objectContaining({ interactionId: "interaction-verdicts", interactionKind: "request_item_verdicts", interactionStatus: "pending", newlyResolvedItemIds: ["docs"], itemVerdicts: { newlyResolvedItemIds: ["docs"], coalesceWindowMs: 2000, }, }), }), ); expect(mockLogActivity).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ action: "issue.thread_interaction_item_verdicts_submitted", details: expect.objectContaining({ interactionKind: "request_item_verdicts", newlyResolvedItemCount: 1, newlyResolvedItemIds: ["docs"], complete: false, }), }), ); }); it("allows a board user to withdraw and wakes the assignee", async () => { const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-withdraw/withdraw") .send({ reason: "Replanning" }); expect(res.status).toBe(200); expect(mockInteractionService.withdrawInteraction).toHaveBeenCalledWith( expect.objectContaining({ id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa" }), "interaction-withdraw", { reason: "Replanning" }, expect.objectContaining({ userId: "local-board" }), expect.objectContaining({ afterResolveInTransaction: expect.any(Function) }), ); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith(ASSIGNEE_AGENT_ID, expect.objectContaining({ payload: expect.objectContaining({ interactionStatus: "cancelled" }), })); expect(mockLogActivity).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ action: "issue.thread_interaction_withdrawn", })); }); it("cancels the bound native run when its question is withdrawn", async () => { mockInteractionService.withdrawInteraction.mockImplementationOnce((...args) => resolveMockInteraction(args, { id: "interaction-withdraw", companyId: "company-1", issueId: ISSUE_ID, kind: "ask_user_questions", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, status: "cancelled", continuationPolicy: "none", payload: { version: 1, questions: [] }, result: { version: 1, answers: [], cancelled: true }, })); mockRequestNativeQuestionRunCancellation.mockResolvedValueOnce(RUN_1); const res = await request(await createApp()) .post(`/api/issues/${ISSUE_ID}/interactions/interaction-withdraw/withdraw`) .send({ reason: "No longer needed" }); expect(res.status).toBe(200); expect(mockRequestNativeQuestionRunCancellation).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ id: "interaction-withdraw", sourceRunId: RUN_1 }), { kind: "interaction_withdrawn", interactionId: "interaction-withdraw" }, ); expect(mockHeartbeatService.cancelRun).toHaveBeenCalledWith( RUN_1, "Question withdrawn while waiting for operator input", expect.objectContaining({ resultJson: expect.objectContaining({ withdrawnInteractionId: "interaction-withdraw", withdrawnByActorType: "user", }), }), ); }); it("keeps a durable withdrawal intent when immediate native cancellation fails", async () => { mockInteractionService.withdrawInteraction.mockImplementationOnce((...args) => resolveMockInteraction(args, { id: "interaction-withdraw", companyId: "company-1", issueId: ISSUE_ID, kind: "ask_user_questions", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, status: "cancelled", continuationPolicy: "none", payload: { version: 1, questions: [] }, result: { version: 1, answers: [], cancelled: true }, })); mockRequestNativeQuestionRunCancellation.mockResolvedValueOnce(RUN_1); mockHeartbeatService.cancelRun.mockRejectedValueOnce(new Error("process unavailable")); const res = await request(await createApp()) .post(`/api/issues/${ISSUE_ID}/interactions/interaction-withdraw/withdraw`) .send({ reason: "No longer needed" }); expect(res.status).toBe(200); expect(mockRequestNativeQuestionRunCancellation).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ id: "interaction-withdraw" }), { kind: "interaction_withdrawn", interactionId: "interaction-withdraw" }, ); }); it("allows the creator agent to withdraw and wakes a different assignee", async () => { mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "in_review", reviewPolicy: null })); mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-withdraw", kind: "request_confirmation", status: "pending", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "anyone", effectiveResolverPolicy: "anyone", payload: { version: 1, prompt: "Proceed?" }, }); const app = await createApp({ type: "agent", agentId: CREATED_AGENT_ID, companyId: "company-1", runId: RUN_1 }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-withdraw/withdraw") .send({}); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith(ASSIGNEE_AGENT_ID, expect.anything()); }); it("allows the assignee agent to withdraw without waking itself", async () => { mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "todo" })); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2 }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-withdraw/withdraw") .send({}); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); }); it("rejects withdrawal by an unrelated agent", async () => { const app = await createApp({ type: "agent", agentId: "33333333-3333-4333-8333-333333333333", companyId: "company-1", runId: RUN_3 }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-withdraw/withdraw") .send({}); expect(res.status).toBe(403); expect(mockInteractionService.withdrawInteraction).not.toHaveBeenCalled(); }); it("lets a watchdog-scoped assignee withdraw through ordinary containment", async () => { mockResolveTaskWatchdogMutationScope.mockResolvedValue({ kind: "watchdog", watchdogId: "watchdog-1", companyId: "company-1", watchedIssueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", watchdogIssueId: null, stopFingerprint: "stop-1", }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_WATCHDOG }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-withdraw/withdraw") .send({}); expect(mockInteractionService.withdrawInteraction).toHaveBeenCalledWith( expect.anything(), "interaction-withdraw", {}, expect.objectContaining({ agentId: ASSIGNEE_AGENT_ID, runId: RUN_WATCHDOG }), expect.objectContaining({ afterResolveInTransaction: expect.any(Function) }), ); expect(res.status).toBe(200); }); it("rejects withdrawal by low-trust actors", async () => { mockResolveCoreTrustPreset.mockReturnValueOnce({ kind: "low_trust_review" }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_LOW_TRUST }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-withdraw/withdraw") .send({}); expect(res.status).toBe(403); expect(res.body).toMatchObject({ code: "interaction_scope_denied" }); expect(mockInteractionService.withdrawInteraction).not.toHaveBeenCalled(); }); it("cancels question interactions and emits a continuation wake", async () => { const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-2/cancel") .send({}); expect(res.status).toBe(200); expect(res.body.status).toBe("cancelled"); expect(mockInteractionService.cancelQuestions).toHaveBeenCalledWith( expect.objectContaining({ id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa" }), "interaction-2", {}, expect.objectContaining({ userId: "local-board" }), expect.objectContaining({ afterResolveInTransaction: expect.any(Function) }), ); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ reason: "issue_commented", payload: expect.objectContaining({ interactionId: "interaction-2", interactionKind: "ask_user_questions", interactionStatus: "cancelled", sourceCommentId: "comment-2", sourceRunId: RUN_2, }), }), ); expect(mockLogActivity).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ action: "issue.thread_interaction_cancelled", }), ); }); it("durably marks a board-cancelled native question before cancelling its run", async () => { mockRequestNativeQuestionRunCancellation.mockResolvedValueOnce(RUN_2); const res = await request(await createApp()) .post(`/api/issues/${ISSUE_ID}/interactions/interaction-2/cancel`) .send({}); expect(res.status).toBe(200); expect(mockRequestNativeQuestionRunCancellation).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ id: "interaction-2", sourceRunId: RUN_2 }), { kind: "interaction_cancelled", interactionId: "interaction-2" }, ); expect(mockHeartbeatService.cancelRun).toHaveBeenCalledWith( RUN_2, "Cancelled while waiting for operator input", expect.objectContaining({ resultJson: expect.objectContaining({ cancelledInteractionId: "interaction-2" }), }), ); }); it("accepts request confirmations and wakes the current assignee when configured for accept-only wakeups", async () => { mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-3", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "accepted", continuationPolicy: "wake_assignee_on_accept", idempotencyKey: null, sourceCommentId: null, sourceRunId: RUN_3, payload: { version: 1, prompt: "Apply this plan?", }, result: { version: 1, outcome: "accepted", }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }, createdIssues: [], }); const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-3/accept") .send({}); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledTimes(1); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ reason: "issue_commented", payload: expect.objectContaining({ interactionId: "interaction-3", interactionKind: "request_confirmation", interactionStatus: "accepted", }), }), ); expect(mockHeartbeatService.wakeup.mock.calls[0]?.[1]?.payload).not.toHaveProperty("toolAction"); expect(mockHeartbeatService.wakeup.mock.calls[0]?.[1]?.contextSnapshot).not.toHaveProperty("toolAction"); }); it("executes an accepted tool-action confirmation through the gateway callback", async () => { const approveToolActionRequest = vi.fn().mockResolvedValue({ status: "executed", resultSummary: "Added row 42", }); mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-tool-action", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "accepted", continuationPolicy: "wake_assignee", payload: { version: 1, prompt: "Approve the action?", toolAction: { version: 1, actionRequestId: "action-request-1", toolName: "google_sheets_add_row", }, }, result: { version: 1, outcome: "accepted" }, }, createdIssues: [], }); const app = await createApp(undefined, { approveToolActionRequest }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-tool-action/accept") .send({}); expect(res.status).toBe(200); expect(approveToolActionRequest).toHaveBeenCalledWith({ companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", interactionId: "interaction-tool-action", actionRequestId: "action-request-1", actor: { agentId: null, userId: "local-board" }, }); const expectedToolAction = { toolName: "google_sheets_add_row", actionRequestId: "action-request-1", decision: "accepted", executionStatus: "executed", resultSummary: "Added row 42", instructions: "the approved google_sheets_add_row action already ran — do not call the tool again; continue with this result.", }; expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ payload: expect.objectContaining({ toolAction: expectedToolAction }), contextSnapshot: expect.objectContaining({ toolAction: expectedToolAction }), }), ); }); it("wakes with failure instructions after an accepted tool action fails", async () => { const approveToolActionRequest = vi.fn().mockResolvedValue({ status: "failed", error: "Connector timed out", }); mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-tool-action-failed", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "accepted", continuationPolicy: "wake_assignee", payload: { version: 1, prompt: "Approve the action?", toolAction: { version: 1, actionRequestId: "action-request-2", toolName: "google_sheets_add_row", }, }, result: { version: 1, outcome: "accepted" }, }, createdIssues: [], }); const app = await createApp(undefined, { approveToolActionRequest }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-tool-action-failed/accept") .send({}); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ payload: expect.objectContaining({ toolAction: { toolName: "google_sheets_add_row", actionRequestId: "action-request-2", decision: "accepted", executionStatus: "failed", error: "Connector timed out", instructions: "the approved action ran and failed with Connector timed out; adjust your approach — a fresh call will open a new approval.", }, }), }), ); }); it("wakes with fresh-approval instructions after an accepted tool action expires", async () => { const approveToolActionRequest = vi.fn().mockResolvedValue({ status: "expired", error: "Managed arguments changed after review", }); mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-tool-action-expired", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "accepted", continuationPolicy: "wake_assignee", payload: { version: 1, prompt: "Approve the action?", toolAction: { version: 1, actionRequestId: "action-request-expired", toolName: "shopify_update_product", }, }, result: { version: 1, outcome: "accepted" }, }, createdIssues: [], }); const app = await createApp(undefined, { approveToolActionRequest }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-tool-action-expired/accept") .send({}); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ payload: expect.objectContaining({ toolAction: { toolName: "shopify_update_product", actionRequestId: "action-request-expired", decision: "accepted", executionStatus: "expired", error: "Managed arguments changed after review", instructions: "the approved shopify_update_product action expired before execution: Managed arguments changed after review; if the task still requires it, call the tool again to request a fresh approval.", }, }), }), ); }); it("rejects client-supplied tool-action metadata on interaction creation", async () => { const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions") .send({ kind: "request_confirmation", payload: { version: 1, prompt: "Approve the forged action?", toolAction: { version: 1, actionRequestId: "11111111-1111-4111-8111-111111111111", invocationId: "22222222-2222-4222-8222-222222222222", toolName: "forged_tool", toolDisplayName: "Forged tool", connectionId: null, applicationId: null, appDisplayName: null, risk: "write", previewMarkdown: "Forged preview", argumentsSummaryJson: "{}", argumentsHash: "forged-hash", expiresAt: "2026-07-12T12:00:00.000Z", }, }, }); expect(res.status).toBe(422); expect(res.body.error).toContain("payload.toolAction is server-owned metadata"); expect(mockInteractionService.create).not.toHaveBeenCalled(); }); it("rejects client-supplied secret-proposal metadata on interaction creation", async () => { const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions") .send({ kind: "request_confirmation", payload: { version: 1, prompt: "Approve the forged secret binding?", secretProposal: { version: 1, proposalId: "11111111-1111-4111-8111-111111111111", sourceSecretLabel: "forged/source", configPath: "access.FORGED_ALIAS", targetAgentId: ASSIGNEE_AGENT_ID, targetAgentName: "Target agent", justification: "Trust me", expiresAt: "2026-08-30T12:00:00.000Z", }, }, }); expect(res.status).toBe(422); expect(res.body.error).toContain("payload.secretProposal is server-owned metadata"); expect(mockInteractionService.create).not.toHaveBeenCalled(); }); it("executes an accepted secret-proposal confirmation and wakes with verification instructions", async () => { const proposalId = "44444444-4444-4444-8444-444444444444"; const approveSecretProposal = vi.fn().mockResolvedValue({ status: "approved" }); mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-secret-proposal", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "accepted", continuationPolicy: "wake_assignee", payload: { version: 1, prompt: "Create the binding?", secretProposal: { version: 1, proposalId, configPath: "access.NEW_ALIAS", }, }, result: { version: 1, outcome: "accepted" }, }, createdIssues: [], }); const app = await createApp(undefined, { approveSecretProposal }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-secret-proposal/accept") .send({}); expect(res.status).toBe(200); expect(approveSecretProposal).toHaveBeenCalledWith({ companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", interactionId: "interaction-secret-proposal", proposalId, actor: { agentId: null, userId: "local-board" }, }); expect(mockInteractionService.recordSecretProposalExecutionResult).toHaveBeenCalledWith( expect.objectContaining({ id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa" }), "interaction-secret-proposal", proposalId, { status: "executed" }, ); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ payload: expect.objectContaining({ secretProposal: expect.objectContaining({ proposalId, configPath: "access.NEW_ALIAS", executionStatus: "executed", instructions: expect.stringContaining("GET /api/agents/me/secrets"), }), }), }), ); }); it("uses only the bound continuation for the production secret approval fallback", async () => { const proposalId = "44444444-4444-4444-8444-444444444444"; mockSecretProposals.getById.mockResolvedValue({ id: proposalId, kind: "binding", originIssueId: ISSUE_ID, interactionId: "interaction-secret-fallback", configPath: "env.DEPLOYMENT_API_KEY" }); mockSecretProposals.approve.mockResolvedValue({ status: "approved" }); mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-secret-fallback", companyId: "company-1", issueId: ISSUE_ID, kind: "request_confirmation", status: "accepted", continuationPolicy: "wake_assignee", sourceRunId: RUN_1, payload: { version: 1, prompt: "Create binding?", secretProposal: { version: 1, proposalId, configPath: "env.DEPLOYMENT_API_KEY" } }, result: { version: 1, outcome: "accepted" }, }, createdIssues: [] }); const app = await createApp(); const res = await request(app).post(`/api/issues/${ISSUE_ID}/interactions/interaction-secret-fallback/accept`).send({}); expect(res.status).toBe(200); expect(mockSecretProposals.approve).toHaveBeenCalledWith("company-1", proposalId, expect.objectContaining({ resolvedByUserId: "local-board" })); expect(res.body.result.secretProposal.status).toBe("executed"); expect.soft(mockIssueService.addComment).not.toHaveBeenCalled(); expect.soft(mockHeartbeatService.wakeup).toHaveBeenCalledTimes(1); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith(ASSIGNEE_AGENT_ID, expect.objectContaining({ contextSnapshot: expect.objectContaining({ issueId: ISSUE_ID, interactionId: "interaction-secret-fallback" }), payload: expect.objectContaining({ secretProposal: expect.objectContaining({ proposalId, executionStatus: "executed" }) }), })); }); it("records a failed secret-proposal execution and posts a thread comment", async () => { const proposalId = "55555555-5555-4555-8555-555555555555"; const approveSecretProposal = vi.fn().mockRejectedValue(new Error("binding failed")); mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-secret-proposal-failed", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "accepted", continuationPolicy: "wake_assignee", payload: { version: 1, prompt: "Create the binding?", secretProposal: { version: 1, proposalId, configPath: "access.NEW_ALIAS", }, }, result: { version: 1, outcome: "accepted" }, }, createdIssues: [], }); const app = await createApp(undefined, { approveSecretProposal }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-secret-proposal-failed/accept") .send({}); expect(res.status).toBe(200); expect(mockInteractionService.recordSecretProposalExecutionResult).toHaveBeenCalledWith( expect.anything(), "interaction-secret-proposal-failed", proposalId, { status: "failed", errorCode: "secret_proposal_execution_failed" }, ); expect(mockIssueService.addComment).toHaveBeenCalledWith( "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", expect.stringContaining("Binding created: **no**"), { userId: "local-board" }, ); expect(res.body.result.secretProposal).toMatchObject({ status: "failed", errorCode: "secret_proposal_execution_failed", }); }); it("forwards plan-document confirmations to the interaction service for revision validation", async () => { const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions") .send({ kind: "request_confirmation", payload: { version: 1, prompt: "Approve the plan?", target: { type: "issue_document", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", documentId: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb", key: "plan", revisionId: "cccccccc-cccc-4ccc-8ccc-cccccccccccc", revisionNumber: 1, }, }, }); // The route delegates plan-target validation to the service, which rejects a // stale/missing revision atomically inside its insert transaction // (assertRequestConfirmationTargetIsCurrent). The route must pass the target // through unchanged rather than pre-checking it non-atomically. expect(res.status).toBe(201); expect(mockInteractionService.create).toHaveBeenCalledWith( expect.objectContaining({ id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa" }), expect.objectContaining({ kind: "request_confirmation", payload: expect.objectContaining({ target: expect.objectContaining({ key: "plan", revisionId: "cccccccc-cccc-4ccc-8ccc-cccccccccccc", }), }), }), expect.anything(), ); }); it("accepts request checkbox confirmations with selected option ids and wakes the assignee", async () => { mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-checkbox", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_checkbox_confirmation", status: "accepted", continuationPolicy: "wake_assignee", idempotencyKey: null, sourceCommentId: null, sourceRunId: "run-checkbox", payload: { version: 1, prompt: "Delete selected files?", options: [ { id: "file-a", label: "a.txt" }, { id: "file-b", label: "b.txt", description: "Generated build output" }, ], }, result: { version: 1, outcome: "accepted", selectedOptionIds: ["file-b"], }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }, createdIssues: [], }); const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-checkbox/accept") .send({ selectedOptionIds: ["file-b"] }); expect(res.status).toBe(200); expect(mockInteractionService.acceptInteraction).toHaveBeenCalledWith( expect.objectContaining({ id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa" }), "interaction-checkbox", { selectedOptionIds: ["file-b"] }, expect.objectContaining({ userId: "local-board" }), ); expect(mockHeartbeatService.wakeup).toHaveBeenCalledTimes(1); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ reason: "issue_commented", payload: expect.objectContaining({ interactionId: "interaction-checkbox", interactionKind: "request_checkbox_confirmation", interactionStatus: "accepted", checkboxSelection: { prompt: "Delete selected files?", selectedOptionIds: ["file-b"], selectedOptions: [{ id: "file-b", label: "b.txt", description: "Generated build output" }], }, }), contextSnapshot: expect.objectContaining({ checkboxSelection: { prompt: "Delete selected files?", selectedOptionIds: ["file-b"], selectedOptions: [{ id: "file-b", label: "b.txt", description: "Generated build output" }], }, }), }), ); expect(mockLogActivity).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ action: "issue.thread_interaction_accepted", details: expect.objectContaining({ interactionKind: "request_checkbox_confirmation", interactionStatus: "accepted", }), }), ); }); it("preserves accepted empty checkbox selections in assignee wake context", async () => { mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-checkbox-empty", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_checkbox_confirmation", status: "accepted", continuationPolicy: "wake_assignee", idempotencyKey: null, sourceCommentId: null, sourceRunId: "run-checkbox", payload: { version: 1, prompt: "Delete selected files?", options: [ { id: "file-a", label: "a.txt", description: "Temporary export" }, { id: "file-b", label: "b.txt", description: "Generated build output" }, ], }, result: { version: 1, outcome: "accepted", selectedOptionIds: [], }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }, createdIssues: [], }); const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-checkbox-empty/accept") .send({ selectedOptionIds: [] }); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledTimes(1); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ payload: expect.objectContaining({ checkboxSelection: { prompt: "Delete selected files?", selectedOptionIds: [], selectedOptions: [], }, }), contextSnapshot: expect.objectContaining({ checkboxSelection: { prompt: "Delete selected files?", selectedOptionIds: [], selectedOptions: [], }, }), }), ); }); it.each([ { label: "explicit", targetIssueId: ISSUE_ID }, { label: "omitted", targetIssueId: undefined }, { label: "null", targetIssueId: null }, ])("forces a fresh workspace-aware session when accepting a planning confirmation with $label issueId", async ({ targetIssueId }) => { mockIssueService.getById.mockResolvedValueOnce(createIssue({ workMode: "planning" })); mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-plan", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "accepted", continuationPolicy: "wake_assignee_on_accept", idempotencyKey: "confirmation:issue:plan:revision", sourceCommentId: null, sourceRunId: "run-plan", payload: { version: 1, prompt: "Approve this plan?", target: { type: "issue_document", ...(targetIssueId !== undefined ? { issueId: targetIssueId } : {}), documentId: "document-plan", key: "plan", revisionId: "revision-plan", revisionNumber: 1, }, }, result: { version: 1, outcome: "accepted", }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }, createdIssues: [], continuationIssue: { id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", assigneeAgentId: ASSIGNEE_AGENT_ID, assigneeUserId: null, status: "todo", workMode: "standard", }, }); const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-plan/accept") .send({}); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledTimes(1); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ reason: "issue_commented", contextSnapshot: expect.objectContaining({ issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", interactionId: "interaction-plan", interactionKind: "request_confirmation", interactionStatus: "accepted", planReviewInteraction: expect.objectContaining({ id: "interaction-plan", kind: "request_confirmation", status: "accepted", acceptedTargetRevision: expect.objectContaining({ issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", documentId: "document-plan", key: "plan", revisionId: "revision-plan", revisionNumber: 1, }), result: expect.objectContaining({ outcome: "accepted", }), }), forceFreshSession: true, workspaceRefreshReason: "accepted_plan_confirmation", }), }), ); expect(mockLogActivity).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ action: "issue.updated", details: expect.objectContaining({ source: "request_confirmation_accept", workMode: "standard", _previous: expect.objectContaining({ workMode: "planning" }), }), }), ); }); it("does not project an explicitly different issue's approved plan into the current issue wake", async () => { mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-other-plan", companyId: "company-1", issueId: ISSUE_ID, kind: "request_confirmation", status: "accepted", continuationPolicy: "wake_assignee_on_accept", sourceRunId: RUN_1, payload: { version: 1, prompt: "Approve the other issue's plan?", target: { type: "issue_document", issueId: OTHER_ISSUE_ID, key: "plan", revisionId: "other-revision", revisionNumber: 2, }, }, result: { version: 1, outcome: "accepted" }, }, createdIssues: [], }); const response = await request(await createApp()) .post(`/api/issues/${ISSUE_ID}/interactions/interaction-other-plan/accept`) .send({}); expect(response.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledTimes(1); const wake = mockHeartbeatService.wakeup.mock.calls[0]?.[1] as unknown as { contextSnapshot: Record; payload: Record; }; expect(wake.contextSnapshot).not.toHaveProperty("planReviewInteraction"); expect(wake.payload).not.toHaveProperty("planReviewInteraction"); expect(wake.contextSnapshot).not.toHaveProperty("forceFreshSession"); }); it("forces a fresh workspace-aware session when accepting a plan document confirmation on a standard-work issue", async () => { mockIssueService.getById.mockResolvedValueOnce(createIssue({ workMode: "standard" })); mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-standard-plan", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "accepted", continuationPolicy: "wake_assignee_on_accept", idempotencyKey: "confirmation:issue:plan:revision-standard", sourceCommentId: null, sourceRunId: "run-standard-plan", payload: { version: 1, prompt: "Approve this plan?", target: { type: "issue_document", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", documentId: "document-plan", key: "plan", revisionId: "revision-standard", revisionNumber: 2, }, }, result: { version: 1, outcome: "accepted", }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }, createdIssues: [], }); const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-standard-plan/accept") .send({}); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledTimes(1); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ reason: "issue_commented", contextSnapshot: expect.objectContaining({ issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", interactionId: "interaction-standard-plan", interactionKind: "request_confirmation", interactionStatus: "accepted", forceFreshSession: true, workspaceRefreshReason: "accepted_plan_confirmation", }), }), ); }); it("wakes the returned agent when accepting an agent-authored confirmation from a board review assignee", async () => { mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "in_review", assigneeAgentId: null, assigneeUserId: "local-board", })); mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-4", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "accepted", continuationPolicy: "wake_assignee_on_accept", idempotencyKey: null, sourceCommentId: null, sourceRunId: "run-4", payload: { version: 1, prompt: "Approve this plan?", }, result: { version: 1, outcome: "accepted", }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }, createdIssues: [], continuationIssue: { id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", assigneeAgentId: CREATED_AGENT_ID, assigneeUserId: null, status: "todo", }, }); const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-4/accept") .send({}); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledTimes(1); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( CREATED_AGENT_ID, expect.objectContaining({ source: "automation", reason: "issue_commented", payload: expect.objectContaining({ issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", interactionId: "interaction-4", interactionKind: "request_confirmation", interactionStatus: "accepted", }), }), ); expect(mockLogActivity).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ action: "issue.updated", details: expect.objectContaining({ source: "request_confirmation_accept", assigneeAgentId: CREATED_AGENT_ID, assigneeUserId: null, _previous: expect.objectContaining({ assigneeUserId: "local-board", }), }), }), ); }); it("does not emit a continuation wake when request confirmations are rejected", async () => { mockInteractionService.rejectInteraction.mockResolvedValueOnce({ id: "interaction-3", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "rejected", continuationPolicy: "wake_assignee_on_accept", idempotencyKey: null, sourceCommentId: null, sourceRunId: RUN_3, payload: { version: 1, prompt: "Apply this plan?", }, result: { version: 1, outcome: "rejected", reason: "Needs changes", }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }); const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-3/reject") .send({ reason: "Needs changes" }); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); }); it("wakes the assignee to revise a rejected plan even when its policy is accept-only", async () => { mockInteractionService.rejectInteraction.mockResolvedValueOnce({ id: "interaction-rejected-plan", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "rejected", continuationPolicy: "wake_assignee_on_accept", idempotencyKey: "confirmation:issue:plan:revision-2", sourceCommentId: null, sourceRunId: RUN_3, payload: { version: 1, prompt: "Approve this plan?", target: { type: "issue_document", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", documentId: "document-plan", key: "plan", revisionId: "revision-2", revisionNumber: 2, }, }, result: { version: 1, outcome: "rejected", reason: "Keep the API smaller and add a Unicode test.", }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }); const res = await request(await createApp()) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-rejected-plan/reject") .send({ reason: "Keep the API smaller and add a Unicode test." }); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ payload: expect.objectContaining({ planReviewInteraction: expect.objectContaining({ id: "interaction-rejected-plan", status: "rejected", target: expect.objectContaining({ key: "plan", revisionId: "revision-2", }), result: expect.objectContaining({ outcome: "rejected", reason: "Keep the API smaller and add a Unicode test.", }), }), }), contextSnapshot: expect.objectContaining({ planReviewInteraction: expect.objectContaining({ status: "rejected" }), }), }), ); }); it("delivers generic confirmation rejection feedback as the next turn message", async () => { mockInteractionService.rejectInteraction.mockResolvedValueOnce({ id: "interaction-warm-turn", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "rejected", continuationPolicy: "wake_assignee", idempotencyKey: "warm-turn-1", sourceCommentId: null, sourceRunId: RUN_3, payload: { version: 1, prompt: "Continue to turn two?", target: { type: "custom", key: "warm_turn_1", revisionId: "turn-1", }, }, result: { version: 1, outcome: "rejected", reason: "Read T1, append T2, and verify both lines.", }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }); const res = await request(await createApp()) .post( "/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-warm-turn/reject", ) .send({ reason: "Read T1, append T2, and verify both lines." }); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ payload: expect.objectContaining({ paperclipAgentMessage: { text: "Read T1, append T2, and verify both lines.", source: "interaction_rejection", sessionId: "interaction-warm-turn", }, }), contextSnapshot: expect.objectContaining({ paperclipAgentMessage: expect.objectContaining({ text: "Read T1, append T2, and verify both lines.", }), }), }), ); }); it("returns a rejected native completion review with a narrow reviewer-reason continuation", async () => { const issue = createIssue({ status: "in_review" }); mockIssueService.getById.mockResolvedValue(issue); mockInteractionService.rejectInteraction.mockResolvedValueOnce({ id: "interaction-native-completion-review", companyId: "company-1", issueId: issue.id, kind: "request_confirmation", status: "rejected", continuationPolicy: "wake_assignee", idempotencyKey: null, sourceCommentId: null, sourceRunId: RUN_3, payload: { version: 1, prompt: "Approve completion?", target: { type: "custom", key: "native_completion_review", revisionId: "decision-29" }, }, result: { version: 1, outcome: "rejected", reason: "Run the external verification and report only that result.", }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }); const res = await request(await createApp()) .post(`/api/issues/${issue.id}/interactions/interaction-native-completion-review/reject`) .send({ reason: "Run the external verification and report only that result." }); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ payload: expect.objectContaining({ nativeCompletionReview: expect.objectContaining({ decisionId: "decision-29", outcome: "rejected", reviewerReason: "Run the external verification and report only that result.", instruction: expect.stringContaining("do not redo completed implementation"), }), }), contextSnapshot: expect.objectContaining({ nativeCompletionReview: expect.objectContaining({ reviewerReason: expect.any(String) }), }), }), ); }); it("overrides accept-only continuation when rejection consumes the last review path", async () => { const issue = createIssue({ status: "in_review" }); mockIssueService.getById.mockResolvedValue(issue); mockIssueService.listReviewAttention.mockResolvedValue(new Map([[ issue.id, { state: "stalled", paths: [], reason: "review path consumed" }, ]])); mockInteractionService.rejectInteraction.mockResolvedValueOnce({ id: "interaction-last-review-path", companyId: "company-1", issueId: issue.id, kind: "request_confirmation", status: "rejected", continuationPolicy: "wake_assignee_on_accept", idempotencyKey: null, sourceCommentId: null, sourceRunId: "run-last-review-path", payload: { version: 1, prompt: "Approve this?" }, result: { version: 1, outcome: "rejected", reason: "Needs changes" }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }); const res = await request(await createApp()) .post(`/api/issues/${issue.id}/interactions/interaction-last-review-path/reject`) .send({ reason: "Needs changes" }); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ payload: expect.objectContaining({ reviewPathLost: true, reviewPathConsumedRef: "interaction-last-review-path", }), contextSnapshot: expect.objectContaining({ reviewPathLost: true, reviewPathInstruction: expect.stringContaining("Restore a reviewer"), }), }), ); }); it("wakes with decline instructions when a tool-action confirmation is rejected", async () => { mockInteractionService.rejectInteraction.mockResolvedValueOnce({ id: "interaction-tool-action-rejected", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "rejected", continuationPolicy: "wake_assignee", idempotencyKey: null, sourceCommentId: null, sourceRunId: "run-tool-action-rejected", payload: { version: 1, prompt: "Approve the action?", toolAction: { version: 1, actionRequestId: "action-request-3", toolName: "google_sheets_add_row", }, }, result: { version: 1, outcome: "rejected", reason: "Use the sandbox sheet instead", }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }); const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-tool-action-rejected/reject") .send({ reason: "Use the sandbox sheet instead" }); expect(res.status).toBe(200); const expectedToolAction = { toolName: "google_sheets_add_row", actionRequestId: "action-request-3", decision: "rejected", executionStatus: "rejected", declineReason: "Use the sandbox sheet instead", instructions: "the action was declined: Use the sandbox sheet instead; do not retry the same call — adjust your approach or mark the task blocked/in_review with the decline reason.", }; expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith( ASSIGNEE_AGENT_ID, expect.objectContaining({ payload: expect.objectContaining({ toolAction: expectedToolAction }), contextSnapshot: expect.objectContaining({ toolAction: expectedToolAction }), }), ); }); it("does not emit an accept-only continuation wake for rejected suggested tasks", async () => { mockInteractionService.rejectInteraction.mockResolvedValueOnce({ id: "interaction-5", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "suggest_tasks", status: "rejected", continuationPolicy: "wake_assignee_on_accept", idempotencyKey: null, sourceCommentId: null, sourceRunId: "run-5", payload: { version: 1, tasks: [{ clientKey: "task-1", title: "One" }], }, result: { version: 1, rejectionReason: "Not now", }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }); const app = await createApp(); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-5/reject") .send({ reason: "Not now" }); expect(res.status).toBe(200); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); }); it("allows agent-authored interaction creation and stamps the active run id", async () => { const app = await createApp({ type: "agent", agentId: CREATED_AGENT_ID, companyId: "company-1", runId: RUN_1, }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions") .send({ kind: "suggest_tasks", idempotencyKey: "interaction:task-1", payload: { version: 1, tasks: [{ clientKey: "task-1", title: "One" }], }, }); expect(res.status).toBe(201); expect(mockInteractionService.create).toHaveBeenCalledWith( expect.objectContaining({ id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa" }), expect.objectContaining({ kind: "suggest_tasks", idempotencyKey: "interaction:task-1", sourceRunId: RUN_1, }), { agentId: CREATED_AGENT_ID, userId: null, }, ); }); it("allows a different in-scope agent run to respond when policy permits", async () => { mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "todo" })); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-2/respond") .send({ answers: [{ questionId: "scope", optionIds: ["phase-1"] }] }); expect(res.status).toBe(200); expect(mockInteractionService.answerQuestions).toHaveBeenCalledWith( expect.anything(), "interaction-2", expect.anything(), expect.objectContaining({ agentId: ASSIGNEE_AGENT_ID, runId: RUN_2, userId: null }), ); expect(mockQuestionResponseDeliveries.deliver).toHaveBeenCalledWith("interaction-2"); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); expect(mockLogActivity).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ actorType: "agent", agentId: ASSIGNEE_AGENT_ID, runId: RUN_2, details: expect.objectContaining({ resolutionActorKind: "agent" }), })); }); it("allows an agent to accept another agent's pending review confirmation by default", async () => { mockReviewTransition.value = { actorType: "agent", actorId: CREATED_AGENT_ID, details: { reviewInteractionId: "interaction-agent-review" }, }; mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "in_review", reviewPolicy: null, createdByAgentId: CREATED_AGENT_ID, createdByUserId: null, })); mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-agent-review", kind: "request_confirmation", status: "pending", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "anyone", effectiveResolverPolicy: "anyone", payload: { version: 1, prompt: "Approve this review?" }, }); mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-agent-review", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "accepted", continuationPolicy: "none", requestedResolverPolicy: "anyone", effectiveResolverPolicy: "anyone", payload: { version: 1, prompt: "Approve this review?" }, result: { version: 1, outcome: "accepted" }, }, createdIssues: [], }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-agent-review/accept") .send({}); expect(res.status).toBe(200); expect(mockInteractionService.acceptInteraction).toHaveBeenCalledWith( expect.anything(), "interaction-agent-review", {}, { agentId: ASSIGNEE_AGENT_ID, runId: RUN_2, userId: null, resolverPolicyRestriction: "anyone", suggestedTaskEffectsAuthorized: true, }, ); expect(mockLogActivity).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ actorType: "agent", agentId: ASSIGNEE_AGENT_ID, details: expect.objectContaining({ resolutionActorKind: "agent" }), })); }); it("allows an agent to reject a pending review confirmation by default", async () => { mockReviewTransition.value = { actorType: "agent", actorId: CREATED_AGENT_ID, details: { reviewInteractionId: "interaction-agent-reject" }, }; mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "in_review", reviewPolicy: null, createdByAgentId: CREATED_AGENT_ID, createdByUserId: null, })); mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-agent-reject", kind: "request_confirmation", status: "pending", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "anyone", effectiveResolverPolicy: "anyone", payload: { version: 1, prompt: "Approve this review?" }, }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-agent-reject/reject") .send({ reason: "Needs changes" }); expect(res.status).toBe(200); expect(mockInteractionService.rejectInteraction).toHaveBeenCalledWith( expect.anything(), "interaction-agent-reject", { reason: "Needs changes" }, expect.objectContaining({ agentId: ASSIGNEE_AGENT_ID, resolverPolicyRestriction: "anyone", }), ); }); it("keeps an unrelated pending confirmation human-only on an in-review issue", async () => { mockReviewTransition.value = { actorType: "agent", actorId: CREATED_AGENT_ID, details: { reviewInteractionId: "interaction-agent-review" }, }; mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "in_review", reviewPolicy: null, createdByAgentId: CREATED_AGENT_ID, createdByUserId: null, })); mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-unrelated-confirmation", kind: "request_confirmation", status: "pending", createdByAgentId: UNRELATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "board_only", effectiveResolverPolicy: "board_only", payload: { version: 1, prompt: "Approve an unrelated operation?" }, }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-unrelated-confirmation/accept") .send({}); expect(res.status).toBe(403); expect(res.body).toMatchObject({ error: "This issue-thread interaction is human-only", code: "interaction_human_only", }); expect(mockInteractionService.acceptInteraction).not.toHaveBeenCalled(); }); it("names the addressee as the only resolver when an agent tries another person's human-only card", async () => { mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "todo" })); mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-for-riley", kind: "request_confirmation", status: "pending", createdByAgentId: null, createdByUserId: "user-alex", addresseeUserId: "user-riley", sourceRunId: null, requestedResolverPolicy: "human_only", effectiveResolverPolicy: "human_only", payload: { version: 1, prompt: "Riley: approve?" }, }); const defaultWhere = mockDbSelectWhere.getMockImplementation()!; // The addressee name lookup ends in .limit(1); the other reads keep their defaults. mockDbSelectWhere.mockImplementation((() => ({ ...defaultWhere(), limit: () => Promise.resolve([{ name: "Riley" }]), })) as unknown as typeof defaultWhere); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2 }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-for-riley/accept") .send({}); expect(res.status).toBe(403); expect(res.body).toMatchObject({ code: "interaction_human_only", details: { addresseeUserId: "user-riley", addresseeName: "Riley" }, }); expect(res.body.error).toContain("addressed to Riley."); expect(res.body.error).toContain("Only Riley can accept or decline it"); // /accept carries no verified replying user, so the advice stays neutral. expect(res.body.error).not.toContain("do not ask the person asking"); expect(mockInteractionService.acceptInteraction).not.toHaveBeenCalled(); }); it("keeps a same-requester sibling confirmation human-only", async () => { mockReviewTransition.value = { actorType: "agent", actorId: CREATED_AGENT_ID, details: { reviewInteractionId: "interaction-agent-review" }, }; mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "in_review", reviewPolicy: null, createdByAgentId: CREATED_AGENT_ID, createdByUserId: null, })); mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-requester-sibling", kind: "request_confirmation", status: "pending", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "board_only", effectiveResolverPolicy: "board_only", payload: { version: 1, prompt: "Approve a different operation?" }, }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-requester-sibling/accept") .send({}); expect(res.status).toBe(403); expect(res.body).toMatchObject({ error: "This issue-thread interaction is human-only", code: "interaction_human_only", }); expect(mockInteractionService.acceptInteraction).not.toHaveBeenCalled(); }); it.each([ { name: "it addresses a different agent", requesterAgentId: CREATED_AGENT_ID, interaction: { addresseeAgentId: "agent-other-reviewer", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, }, code: "interaction_addressee_mismatch", }, { name: "the agent created it", requesterAgentId: ASSIGNEE_AGENT_ID, interaction: { createdByAgentId: ASSIGNEE_AGENT_ID, sourceRunId: RUN_1 }, code: "interaction_creator_excluded", }, { name: "the same run created it", requesterAgentId: CREATED_AGENT_ID, interaction: { createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_2 }, code: "interaction_creator_excluded", }, ])("rejects an agent review verdict when $name", async ({ interaction, code, requesterAgentId }) => { mockReviewTransition.value = { actorType: "agent", actorId: requesterAgentId, details: { reviewInteractionId: "interaction-agent-review-scope" }, }; mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "in_review", reviewPolicy: "not_creator", createdByAgentId: requesterAgentId, createdByUserId: null, })); mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-agent-review-scope", kind: "request_confirmation", status: "pending", requestedResolverPolicy: "anyone", effectiveResolverPolicy: "anyone", payload: { version: 1, prompt: "Approve this review?" }, ...interaction, }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-agent-review-scope/accept") .send({}); expect(res.status).toBe(403); expect(res.body).toMatchObject({ code }); expect(mockInteractionService.acceptInteraction).not.toHaveBeenCalled(); }); it("rejects an agent review-confirmation verdict under human_only with actionable copy", async () => { mockReviewTransition.value = { actorType: "agent", actorId: CREATED_AGENT_ID, details: { reviewInteractionId: "interaction-human-only" }, }; mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "in_review", reviewPolicy: "human_only", createdByAgentId: CREATED_AGENT_ID, createdByUserId: null, })); mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-human-only", kind: "request_confirmation", status: "pending", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "anyone", effectiveResolverPolicy: "anyone", payload: { version: 1, prompt: "Approve this review?" }, }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-human-only/accept") .send({}); expect(res.status).toBe(403); expect(res.body).toMatchObject({ error: "This issue-thread interaction is human-only", code: "interaction_human_only", details: { code: "interaction_human_only", effectiveResolverPolicy: "human_only" }, }); expect(mockInteractionService.acceptInteraction).not.toHaveBeenCalled(); }); it.each([ { action: "accept", body: {} }, { action: "reject", body: { reason: "Needs changes" } }, ])("rejects an agent $action verdict under human_only when a user review transition omitted the interaction binding", async ({ action, body }) => { mockReviewTransition.value = { actorType: "user", actorId: "local-board", details: { status: "in_review", _previous: { status: "in_progress" } }, }; mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "in_review", reviewPolicy: "human_only", createdByAgentId: null, createdByUserId: "local-board", })); mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-user-review-unbound", kind: "request_confirmation", status: "pending", createdByAgentId: null, createdByUserId: "local-board", sourceRunId: null, requestedResolverPolicy: "board_or_agents", effectiveResolverPolicy: "board_or_agents", payload: { version: 1, prompt: "Approve this review?" }, }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const res = await request(app) .post(`/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-user-review-unbound/${action}`) .send(body); expect(res.status).toBe(403); expect(res.body).toMatchObject({ details: { code: "review_policy_denied", policy: "human_only", }, }); expect(mockInteractionService.acceptInteraction).not.toHaveBeenCalled(); expect(mockInteractionService.rejectInteraction).not.toHaveBeenCalled(); }); it("allows an unrelated agent-resolvable confirmation under a restrictive issue review policy", async () => { mockReviewTransition.value = { actorType: "user", actorId: "local-board", details: { status: "in_review", _previous: { status: "in_progress" } }, }; mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "in_review", reviewPolicy: "human_only", createdByAgentId: null, createdByUserId: "local-board", })); mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-unrelated", kind: "request_confirmation", status: "pending", createdByAgentId: UNRELATED_AGENT_ID, createdByUserId: null, sourceRunId: "run-1", requestedResolverPolicy: "board_or_agents", effectiveResolverPolicy: "board_or_agents", payload: { version: 1, prompt: "Confirm an independent action?" }, }); mockInteractionService.acceptInteraction.mockResolvedValueOnce({ interaction: { id: "interaction-unrelated", companyId: "company-1", issueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", kind: "request_confirmation", status: "accepted", continuationPolicy: "none", idempotencyKey: null, sourceCommentId: null, sourceRunId: "run-1", payload: { version: 1, prompt: "Confirm an independent action?" }, result: { version: 1, outcome: "accepted" }, createdAt: "2026-04-20T12:00:00.000Z", updatedAt: "2026-04-20T12:05:00.000Z", resolvedAt: "2026-04-20T12:05:00.000Z", }, createdIssues: [], }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-unrelated/accept") .send({}); expect(res.status, JSON.stringify(res.body)).toBe(200); expect(mockInteractionService.acceptInteraction).toHaveBeenCalled(); }); it("allows only the addressed agent or board to resolve an addressed interaction", async () => { const addressed = { id: "interaction-addressed", kind: "ask_user_questions", createdByAgentId: CREATED_AGENT_ID, addresseeAgentId: ASSIGNEE_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "board_or_agents", effectiveResolverPolicy: "board_or_agents", payload: { version: 1, questions: [] }, }; mockInteractionService.answerQuestions.mockImplementationOnce(async (_issue, interactionId) => ({ ...addressed, id: interactionId, status: "answered", result: { version: 1, answers: [] }, })); mockInteractionService.getForIssue .mockResolvedValueOnce(addressed) .mockResolvedValueOnce(addressed) .mockResolvedValueOnce(addressed); mockIssueService.getById .mockResolvedValueOnce(createIssue({ status: "todo" })) .mockResolvedValueOnce(createIssue({ status: "todo" })) .mockResolvedValueOnce(createIssue({ status: "todo" })); const addresseeApp = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const addressee = await request(addresseeApp) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-addressed/respond") .send({ answers: [] }); expect(addressee.status).toBe(200); expect(mockQuestionResponseDeliveries.deliver).toHaveBeenCalledWith("interaction-addressed"); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); const unrelatedApp = await createApp({ type: "agent", agentId: UNRELATED_AGENT_ID, companyId: "company-1", runId: RUN_3, }); const unrelated = await request(unrelatedApp) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-addressed/respond") .send({ answers: [] }); expect(unrelated.status).toBe(403); expect(unrelated.body.error).toContain("addressed agent"); const boardApp = await createApp(); const board = await request(boardApp) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-addressed/respond") .send({ answers: [] }); expect(board.status).toBe(200); }); it("preserves creator exclusion for legacy board_or_agents rows", async () => { mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-2", kind: "ask_user_questions", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "board_or_agents", effectiveResolverPolicy: "board_or_agents", resolverPolicyProvenance: "legacy_inherited_restriction", payload: { version: 1, questions: [] }, }); mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "todo", assigneeAgentId: CREATED_AGENT_ID, })); const app = await createApp({ type: "agent", agentId: CREATED_AGENT_ID, companyId: "company-1", runId: RUN_9, }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-2/respond") .send({ answers: [] }); expect(res.status).toBe(403); expect(res.body).toMatchObject({ code: "interaction_creator_excluded" }); expect(mockInteractionService.answerQuestions).not.toHaveBeenCalled(); }); it.each([ { kind: "suggest_tasks", action: "accept", body: { selectedClientKeys: ["task-1"] }, payload: { version: 1, tasks: [{ clientKey: "task-1", title: "Task" }] }, service: "acceptInteraction", }, { kind: "ask_user_questions", action: "respond", body: { answers: [] }, payload: { version: 1, questions: [] }, service: "answerQuestions", }, { kind: "request_confirmation", action: "accept", body: {}, payload: { version: 1, prompt: "Continue?" }, service: "acceptInteraction", }, { kind: "request_checkbox_confirmation", action: "accept", body: { selectedOptionIds: [] }, payload: { version: 1, prompt: "Select", options: [] }, service: "acceptInteraction", }, { kind: "request_item_verdicts", action: "verdicts", body: { verdicts: [{ id: "item-1", verdict: "approve" }] }, payload: { version: 1, prompt: "Review", items: [{ id: "item-1", label: "Item" }], verdicts: ["approve", "reject"], }, service: "submitItemVerdicts", }, ])("lets the creator and same run resolve $kind through anyone", async ({ kind, action, body, payload, service, }) => { mockInteractionService.getForIssue.mockResolvedValueOnce({ id: `interaction-${kind}`, kind, status: "pending", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_9, requestedResolverPolicy: "anyone", effectiveResolverPolicy: "anyone", payload, }); mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "todo", assigneeAgentId: CREATED_AGENT_ID, })); const app = await createApp({ type: "agent", agentId: CREATED_AGENT_ID, companyId: "company-1", runId: RUN_9, }); const res = await request(app) .post(`/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-${kind}/${action}`) .send(body); expect(res.status).toBe(200); expect(mockInteractionService[service as keyof typeof mockInteractionService]).toHaveBeenCalledWith( expect.anything(), `interaction-${kind}`, body, expect.objectContaining({ agentId: CREATED_AGENT_ID, runId: RUN_9 }), ); }); it("enforces same-run exclusion under not_creator and requires a resolver run id", async () => { mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-2", kind: "ask_user_questions", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_2, requestedResolverPolicy: "not_creator", effectiveResolverPolicy: "not_creator", payload: { version: 1, questions: [] }, }); mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "todo" })); const sameRunApp = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const sameRun = await request(sameRunApp) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-2/respond") .send({ answers: [] }); expect(sameRun.status).toBe(403); expect(sameRun.body).toMatchObject({ code: "interaction_creator_excluded" }); mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "todo" })); const missingRunApp = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", }); const missingRun = await request(missingRunApp) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-2/respond") .send({ answers: [] }); expect(missingRun.status).toBe(422); expect(missingRun.body).toMatchObject({ code: "interaction_run_attribution_required" }); }); it.each([false, true])("the catalog approval probe distinguishes missing attribution from governed-action denial (drop header: %s)", async dropHeader => { const approveToolActionRequest = vi.fn(); const revokeKey = vi.fn(async () => undefined); mockIssueService.getById.mockResolvedValue(createIssue({ status: "todo" })); mockInteractionService.getForIssue.mockResolvedValue({ id: "interaction-tool-probe", companyId: "company-1", issueId: ISSUE_ID, kind: "request_confirmation", status: "pending", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, effectiveResolverPolicy: "human_only", payload: { version: 1, prompt: "Approve the action?", toolAction: { version: 1, actionRequestId: "action-probe", toolName: "notes_update" } }, }); const receipt = await probeReviewApproval({ baseURL: "https://fixture.example", companyId: "company-1", agentId: CREATED_AGENT_ID, issueId: ISSUE_ID, interaction: { id: "interaction-tool-probe", status: "pending", sourceRunId: RUN_1 }, run: { id: RUN_1, companyId: "company-1", agentId: CREATED_AGENT_ID, status: "succeeded", contextSnapshot: { issueId: ISSUE_ID } }, invocation: { companyId: "company-1", agentId: CREATED_AGENT_ID, issueId: ISSUE_ID, runId: RUN_1, status: "awaiting_approval" }, privateSecrets: [], createKey: async () => ({ id: "probe-key", token: "synthetic-test-key" }), revokeKey, boundary: async () => ({ interactionStatus: "pending", invocationStatus: "awaiting_approval", actionStatus: "pending", providerWrites: approveToolActionRequest.mock.calls.length, trustRuleIds: [] }), send: async (url, options) => { const headers = new Headers(options?.headers); const actorRun = dropHeader ? undefined : headers.get("x-paperclip-run-id"); const app = await createApp({ type: "agent", companyId: "company-1", agentId: CREATED_AGENT_ID, runId: actorRun }, { approveToolActionRequest }); const res = await request(app).post(new URL(String(url)).pathname) .set("Authorization", headers.get("authorization")!).send(JSON.parse(options?.body as string)); return Response.json(res.body, { status: res.status }); }, }); expect(receipt).toEqual({ status: dropHeader ? 422 : 403, code: dropHeader ? "interaction_run_attribution_required" : "interaction_governed_action_denied", boundaryUnchanged: true, keyRevoked: true }); expect(approveToolActionRequest).not.toHaveBeenCalled(); expect(mockInteractionService.acceptInteraction).not.toHaveBeenCalled(); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); expect(mockLogActivity).not.toHaveBeenCalled(); expect(revokeKey).toHaveBeenCalledExactlyOnceWith("probe-key"); }); it("rejects an invalid run attribution before resolving or waking", async () => { mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-invalid-run", kind: "ask_user_questions", status: "pending", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "anyone", effectiveResolverPolicy: "anyone", payload: { version: 1, questions: [] }, }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_INVALID, }); mockRunAttribution.value = null; const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-invalid-run/respond") .send({ answers: [] }); expect(res.status).toBe(422); expect(res.body).toMatchObject({ code: "interaction_run_attribution_required" }); expect(mockInteractionService.answerQuestions).not.toHaveBeenCalled(); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); expect(mockLogActivity).not.toHaveBeenCalled(); }); it("hides cross-company interactions before resolver evaluation", async () => { mockAccessDecide.mockResolvedValue({ allowed: false, action: "issue:read", reason: "deny_company_boundary", explanation: "Denied by company boundary.", }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-2", runId: RUN_CROSS_COMPANY, }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-2/respond") .send({ answers: [] }); expect(res.status).toBe(404); expect(mockInteractionService.getForIssue).not.toHaveBeenCalled(); expect(mockInteractionService.answerQuestions).not.toHaveBeenCalled(); }); it("contains task-bridge resolvers at the ordinary issue mutation boundary", async () => { mockAccessDecide.mockResolvedValue({ allowed: false, action: "issue:mutate", reason: "deny_task_bridge_scope", explanation: "Denied by task bridge scope.", }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_TASK_BRIDGE, source: "agent_key", keyId: "bridge-key", keyScope: { kind: "task_bridge" }, }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-2/respond") .send({ answers: [] }); expect(res.status).toBe(403); expect(res.body).toMatchObject({ code: "interaction_scope_denied" }); expect(mockInteractionService.answerQuestions).not.toHaveBeenCalled(); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); }); it("reauthorizes suggested-task effects before resolving the interaction", async () => { mockInteractionService.getForIssue.mockResolvedValueOnce({ id: "interaction-suggest-assigned", kind: "suggest_tasks", status: "pending", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "anyone", effectiveResolverPolicy: "anyone", payload: { version: 1, tasks: [{ clientKey: "assigned", title: "Assigned child", assigneeAgentId: UNRELATED_AGENT_ID, }], }, }); mockAccessDecide.mockImplementation(async (input: { action?: string }) => input.action === "tasks:assign" ? { allowed: false, action: input.action, reason: "deny_assignment", explanation: "Task assignment is not authorized.", } : { allowed: true, action: input.action, reason: "allow_explicit_grant", explanation: "Allowed by test grant.", }); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const res = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-suggest-assigned/accept") .send({ selectedClientKeys: ["assigned"] }); expect(res.status).toBe(403); expect(res.body).toMatchObject({ code: "interaction_governed_action_denied" }); expect(mockInteractionService.acceptInteraction).not.toHaveBeenCalled(); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); expect(mockLogActivity).not.toHaveBeenCalled(); }); describe("suggested-task effect authorization", () => { const path = `/api/issues/${ISSUE_ID}/interactions/interaction-suggest/accept`; const owner = { type: "board", userId: "local-board", companyIds: ["company-1"], source: "session" }; function suggest(task: Record = {}, payload: Record = {}) { mockInteractionService.getForIssue.mockResolvedValue({ id: "interaction-suggest", kind: "suggest_tasks", status: "pending", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "anyone", effectiveResolverPolicy: "anyone", payload: { version: 1, tasks: [{ clientKey: "task-1", title: "Write the launch post", ...task }], ...payload }, }); } function denyAction(action: string) { mockAccessDecide.mockImplementation(async (input: { action?: string }) => ({ allowed: input.action !== action, action: input.action, reason: input.action === action ? "deny_explicit_policy" : "allow_explicit_grant", explanation: "Test resource policy", })); } function expectNoEffects() { expect(mockInteractionService.acceptInteraction).not.toHaveBeenCalled(); expect(mockLogActivity).not.toHaveBeenCalled(); expect(mockHeartbeatService.wakeup).not.toHaveBeenCalled(); } beforeEach(() => { mockIssueService.getById.mockResolvedValue(createIssue({ conversationAgentId: ASSIGNEE_AGENT_ID, conversationUserId: owner.userId, })); suggest(); }); it.each([ {}, { assigneeAgentId: null }, { assigneeAgentId: CREATED_AGENT_ID }, { assigneeUserId: "reviewer" }, ])("requires board assignment authorization for %j", async (assignment) => { suggest(assignment); denyAction("tasks:assign"); const response = await request(await createApp(owner)).post(path).send({ selectedClientKeys: ["task-1"] }); expect(response.status).toBe(403); expect(response.body).toMatchObject({ code: "interaction_governed_action_denied" }); expect(mockAccessDecide).toHaveBeenCalledWith(expect.objectContaining({ action: "tasks:assign", actor: owner })); expectNoEffects(); }); it("authorizes the conversation agent before accepting an ownerless proposal", async () => { expect((await request(await createApp(owner)).post(path).send({})).status).toBe(200); expect(mockAccessDecide).toHaveBeenCalledWith(expect.objectContaining({ action: "tasks:assign", resource: expect.objectContaining({ assigneeAgentId: ASSIGNEE_AGENT_ID, assigneeUserId: null }), })); }); it.each(["implicit", "task-parent", "default-parent"])("authorizes a standalone commitment for a conversation's %s parent", async (parentMode) => { suggest({ assigneeAgentId: CREATED_AGENT_ID, ...(parentMode === "task-parent" ? { parentId: ISSUE_ID } : {}) }, parentMode === "default-parent" ? { defaultParentId: ISSUE_ID } : {}); const response = await request(await createApp(owner)).post(path).send({ selectedClientKeys: ["task-1"] }); expect(response.status).toBe(200); expect(mockAccessDecide).toHaveBeenCalledWith(expect.objectContaining({ action: "tasks:assign", resource: expect.objectContaining({ parentIssueId: null, assigneeAgentId: CREATED_AGENT_ID }), scope: expect.objectContaining({ parentIssueId: null }), })); expect(mockInteractionService.acceptInteraction).toHaveBeenCalledWith( expect.anything(), "interaction-suggest", expect.anything(), expect.objectContaining({ suggestedTaskEffectsAuthorized: true }), ); }); it("retains a real source task as the implicit parent", async () => { mockIssueService.getById.mockResolvedValue(createIssue()); suggest({ assigneeAgentId: CREATED_AGENT_ID }); expect((await request(await createApp(owner)).post(path).send({})).status).toBe(200); expect(mockAccessDecide).toHaveBeenCalledWith(expect.objectContaining({ action: "tasks:assign", scope: expect.objectContaining({ parentIssueId: ISSUE_ID }), })); }); it.each([false, true])("authorizes inherited proposal projects independently of array order (child first: %s)", async (childFirst) => { const projectId = "cccccccc-cccc-4ccc-8ccc-cccccccccccc"; const tasks = [ { clientKey: "root", title: "Launch", projectId }, { clientKey: "child", parentClientKey: "root", title: "Write copy" }, { clientKey: "grandchild", parentClientKey: "child", title: "Review copy" }, ]; suggest({}, { tasks: childFirst ? tasks.toReversed() : tasks }); mockAccessDecide.mockImplementation(async (input: { action?: string; resource?: { projectId?: string } }) => ({ allowed: input.action !== "tasks:assign" || input.resource?.projectId === projectId, action: input.action, reason: "project_scoped_grant", explanation: "Only project A assignments are permitted", })); expect((await request(await createApp(owner)).post(path).send({})).status).toBe(200); const assignments = mockAccessDecide.mock.calls.filter(([input]) => input.action === "tasks:assign"); expect(assignments).toHaveLength(3); expect(assignments.every(([input]) => input.resource?.projectId === projectId)).toBe(true); expect(mockInteractionService.acceptInteraction).toHaveBeenCalledOnce(); }); it("rejects a nested proposal's explicit project outside the assignment grant", async () => { const allowedProject = "cccccccc-cccc-4ccc-8ccc-cccccccccccc"; suggest({}, { tasks: [ { clientKey: "root", title: "Launch", projectId: allowedProject }, { clientKey: "child", parentClientKey: "root", title: "Write copy", projectId: OTHER_ISSUE_ID }, ] }); mockAccessDecide.mockImplementation(async (input: { action?: string; resource?: { projectId?: string } }) => ({ allowed: input.action !== "tasks:assign" || input.resource?.projectId === allowedProject, action: input.action, reason: "project_scoped_grant", explanation: "Only project A assignments are permitted", })); expect((await request(await createApp(owner)).post(path).send({})).status).toBe(403); expectNoEffects(); }); it("checks the selected subset without authorizing an unselected assignment", async () => { suggest({}, { tasks: [ { clientKey: "task-1", title: "Unassigned draft" }, { clientKey: "task-2", title: "Restricted assignment", assigneeAgentId: CREATED_AGENT_ID }, ] }); mockAccessDecide.mockImplementation(async (input: { action?: string; resource?: { assigneeAgentId?: string } }) => ({ allowed: input.action !== "tasks:assign" || input.resource?.assigneeAgentId === ASSIGNEE_AGENT_ID, action: input.action, reason: "test_policy", explanation: "Only the conversation agent may be assigned", })); expect((await request(await createApp(owner)).post(path).send({ selectedClientKeys: ["task-1"] })).status).toBe(200); expect(mockAccessDecide.mock.calls.filter(([input]) => input.action === "tasks:assign").map(([input]) => input.resource?.assigneeAgentId)).toEqual([ASSIGNEE_AGENT_ID]); }); it("denies an inaccessible explicit parent before creating an unassigned task", async () => { const conversation = createIssue({ conversationAgentId: ASSIGNEE_AGENT_ID, conversationUserId: owner.userId }); mockIssueService.getById.mockImplementation(async (id: string) => id === OTHER_ISSUE_ID ? createIssue({ id: OTHER_ISSUE_ID }) : conversation); suggest({ parentId: OTHER_ISSUE_ID }); mockAccessDecide.mockImplementation(async (input: { action?: string; resource?: { issueId?: string } }) => ({ allowed: !(input.action === "issue:read" && input.resource?.issueId === OTHER_ISSUE_ID), action: input.action, reason: "deny_issue_private", explanation: "Parent is private", })); expect((await request(await createApp(owner)).post(path).send({})).status).toBe(404); expectNoEffects(); }); it.each(["denied", "missing", "other-company"])("denies a %s project before creating an unassigned task", async (condition) => { suggest({ projectId: OTHER_ISSUE_ID }); if (condition === "denied") denyAction("project:read"); if (condition === "missing") mockProjectService.getById.mockResolvedValue(null); if (condition === "other-company") mockProjectService.getById.mockResolvedValue({ id: OTHER_ISSUE_ID, companyId: "company-2" }); const response = await request(await createApp(owner)).post(path).send({}); expect(response.status).toBe(403); expect(response.body).toMatchObject({ code: "interaction_governed_action_denied" }); expectNoEffects(); }); it("authorizes the source project that creation retains when an explicit parent has another project", async () => { const sourceProject = "cccccccc-cccc-4ccc-8ccc-cccccccccccc"; const parentProject = "dddddddd-dddd-4ddd-8ddd-dddddddddddd"; mockIssueService.getById.mockImplementation(async (id: string) => createIssue(id === OTHER_ISSUE_ID ? { id: OTHER_ISSUE_ID, projectId: parentProject } : { projectId: sourceProject })); suggest({ parentId: OTHER_ISSUE_ID, assigneeAgentId: CREATED_AGENT_ID }); expect((await request(await createApp(owner)).post(path).send({})).status).toBe(200); expect(mockAccessDecide).toHaveBeenCalledWith(expect.objectContaining({ action: "project:read", resource: expect.objectContaining({ projectId: sourceProject }), })); expect(mockAccessDecide).toHaveBeenCalledWith(expect.objectContaining({ action: "tasks:assign", scope: expect.objectContaining({ projectId: sourceProject, parentIssueId: OTHER_ISSUE_ID }), })); }); it("keeps agents subject to assignment authorization even for an unassigned task", async () => { mockIssueService.getById.mockResolvedValue(createIssue({ status: "todo" })); denyAction("tasks:assign"); const actor = { type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2 }; const response = await request(await createApp(actor)).post(path).send({}); expect(response.status).toBe(403); expect(mockAccessDecide).toHaveBeenCalledWith(expect.objectContaining({ action: "tasks:assign", actor })); expectNoEffects(); }); it("does not let a watchdog create an unrelated standalone task from a conversation", async () => { mockResolveTaskWatchdogMutationScope.mockResolvedValue({ kind: "watchdog", watchdogId: "watchdog-1", companyId: "company-1", watchedIssueId: ISSUE_ID, watchdogIssueId: null, stopFingerprint: "stop-1", }); const response = await request(await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, })).post(path).send({}); expect(response.status).toBe(403); expectNoEffects(); }); }); it("blocks human-only and tool-action interactions for agents", async () => { mockInteractionService.getForIssue .mockResolvedValueOnce({ id: "interaction-1", kind: "request_confirmation", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "board_or_agents", effectiveResolverPolicy: "board_only", payload: { version: 1, prompt: "Proceed?" }, }) .mockResolvedValueOnce({ id: "interaction-tool", kind: "request_confirmation", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "board_or_agents", effectiveResolverPolicy: "board_or_agents", payload: { version: 1, prompt: "Run?", toolAction: { actionRequestId: "action-1" } }, }); mockIssueService.getById .mockResolvedValueOnce(createIssue({ status: "todo" })) .mockResolvedValueOnce(createIssue({ status: "todo" })); const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const capped = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-1/accept") .send({}); expect(capped.status).toBe(403); expect(capped.body.error).toContain("human-only"); const toolAction = await request(app) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-tool/accept") .send({}); expect(toolAction.status).toBe(403); expect(toolAction.body).toMatchObject({ code: "interaction_governed_action_denied" }); }); it("lets watchdog-scoped agents use the ordinary resolver and contains low-trust agents", async () => { mockIssueService.getById.mockResolvedValue(createIssue({ status: "todo" })); const actor = { type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }; mockResolveTaskWatchdogMutationScope.mockResolvedValueOnce({ kind: "watchdog", watchdogId: "watchdog-1", companyId: "company-1", watchedIssueId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", watchdogIssueId: null, stopFingerprint: "stop-1", }); const watchdogApp = await createApp(actor); const watchdog = await request(watchdogApp) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-2/respond") .send({ answers: [] }); expect(watchdog.status).toBe(200); expect(mockInteractionService.answerQuestions).toHaveBeenCalledTimes(1); mockResolveCoreTrustPreset.mockReturnValueOnce({ kind: "low_trust_review" }); const lowTrustApp = await createApp(actor); const lowTrust = await request(lowTrustApp) .post("/api/issues/aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa/interactions/interaction-2/respond") .send({ answers: [] }); expect(lowTrust.status).toBe(403); expect(lowTrust.body).toMatchObject({ code: "interaction_scope_denied" }); expect(mockInteractionService.answerQuestions).toHaveBeenCalledTimes(1); }); const CROSS_ISSUE_RESOLUTION_ROUTES = [ { route: "accept", kind: "request_confirmation", body: {}, payload: { version: 1, prompt: "Proceed?" }, service: "acceptInteraction", }, { route: "reject", kind: "request_confirmation", body: { reason: "Not now" }, payload: { version: 1, prompt: "Proceed?" }, service: "rejectInteraction", }, { route: "respond", kind: "ask_user_questions", body: { answers: [] }, payload: { version: 1, questions: [] }, service: "answerQuestions", }, { route: "verdicts", kind: "request_item_verdicts", body: { verdicts: [{ id: "item-1", verdict: "approve" }] }, payload: { version: 1, prompt: "Review", items: [{ id: "item-1", label: "Item" }], verdicts: ["approve", "reject"], }, service: "submitItemVerdicts", }, ] as const; function stubCrossIssueResolution( { kind, payload }: { kind: string; payload: Record }, ) { // The run authenticated below is working OTHER_ISSUE_ID, so resolving this // card is a cross-issue mutation even though the audience is open. mockIssueService.getById.mockResolvedValueOnce(createIssue({ status: "todo" })); mockInteractionService.getForIssue.mockResolvedValueOnce({ id: `interaction-cross-${kind}`, kind, status: "pending", createdByAgentId: CREATED_AGENT_ID, sourceRunId: RUN_1, requestedResolverPolicy: "anyone", effectiveResolverPolicy: "anyone", payload, }); } it.each(CROSS_ISSUE_RESOLUTION_ROUTES)( "charges one shared cross-issue observation for an allowed $route", async ({ route, kind, body, payload, service }) => { stubCrossIssueResolution({ kind, payload }); mockCrossIssueInfluence.sourceIssueId = OTHER_ISSUE_ID; const app = await createApp({ type: "agent", agentId: ASSIGNEE_AGENT_ID, companyId: "company-1", runId: RUN_2, }); const res = await request(app) .post(`/api/issues/${ISSUE_ID}/interactions/interaction-cross-${kind}/${route}`) .send(body); expect(res.status).toBe(200); expect(mockInteractionService[service]).toHaveBeenCalledTimes(1); expect(mockCrossIssueInfluence.inserted).toEqual([ expect.objectContaining({ action: "issue.cross_issue_influence_observed", entityId: ISSUE_ID, details: expect.objectContaining({ kind: "interaction_resolution", sourceIssueId: OTHER_ISSUE_ID, targetIssueId: ISSUE_ID, count: 1, }), }), ]); }, ); });