From a4d75b2d3ea9da9b920a39ac1d1d775d06836e39 Mon Sep 17 00:00:00 2001 From: Nicky Leach Date: Wed, 18 Nov 2026 19:39:32 -0800 Subject: [PATCH] Resolve session and agent identity only where queued admission needs them --- .../wake-queue/adapters/postgres.test.ts | 21 +++++++++++++ .../modules/wake-queue/adapters/postgres.ts | 10 +++---- .../wake-queue/application/fresh-issue-run.ts | 4 +-- server/src/services/heartbeat/queue.test.ts | 30 +++++++++++++++++-- server/src/services/heartbeat/queue.ts | 18 +++++------ server/src/services/heartbeat/run-state.ts | 11 ++++--- 6 files changed, 70 insertions(+), 24 deletions(-) diff --git a/server/src/modules/wake-queue/adapters/postgres.test.ts b/server/src/modules/wake-queue/adapters/postgres.test.ts index 73f3bace9c2..41890c69acf 100644 --- a/server/src/modules/wake-queue/adapters/postgres.test.ts +++ b/server/src/modules/wake-queue/adapters/postgres.test.ts @@ -29,6 +29,7 @@ import { import { createPostgresIssueWakeAdmission, createPostgresWakeQueueAdapter, + createWakeAdmissionReader, createWakeAdmissionWriter, } from "./postgres.js"; import type { WakeQueuePostgresAdapterDeps } from "./postgres.js"; @@ -184,6 +185,26 @@ describeEmbeddedPostgres("wake-queue postgres adapter", () => { return id; } + it("uses the issue execution name key before reading the agent's current name", async () => { + const companyId = await seedCompany(); + const agentId = await seedAgent({ companyId, name: "Renamed agent" }); + await db.transaction(async (tx) => { + const select = vi.spyOn(tx, "select"); + const reader = createWakeAdmissionReader(tx, companyId); + const input = { companyId, activeExecutionRunAgentId: agentId, + issueExecutionAgentNameKey: " Original Name ", agentNameKey: "original name" }; + await expect(reader.isSameExecutionAgent({ ...input, companyId: randomUUID() })) + .rejects.toThrow("admission is locked for a different company"); + await expect(reader.isSameExecutionAgent(input)).resolves.toBe(true); + await expect(reader.isSameExecutionAgent({ ...input, agentNameKey: "renamed agent" })).resolves.toBe(false); + expect(select).not.toHaveBeenCalled(); + + await expect(reader.isSameExecutionAgent({ ...input, issueExecutionAgentNameKey: null, agentNameKey: "renamed agent" })) + .resolves.toBe(true); + expect(select).toHaveBeenCalledTimes(1); + }); + }); + it("checks execution holds only when the scoped saved receipt exists, inside the issue admission transaction", async () => { const companyId = await seedCompany(); const agentId = await seedAgent({ companyId }); diff --git a/server/src/modules/wake-queue/adapters/postgres.ts b/server/src/modules/wake-queue/adapters/postgres.ts index 85bea20fecf..ec2dcf9ada0 100644 --- a/server/src/modules/wake-queue/adapters/postgres.ts +++ b/server/src/modules/wake-queue/adapters/postgres.ts @@ -1021,6 +1021,8 @@ export function createWakeAdmissionReader(rawTx: IssueAdmissionDbTransaction, ad }, ) { assertAdmissionCompany(admittedCompanyId, companyId); + const storedNameKey = normalizeAgentNameKey(issueExecutionAgentNameKey); + if (storedNameKey !== null) return storedNameKey === agentNameKey; const executionAgent = await tx .select({ name: agents.name }) .from(agents) @@ -1031,12 +1033,8 @@ export function createWakeAdmissionReader(rawTx: IssueAdmissionDbTransaction, ad ), ) .then((rows) => rows[0] ?? null); - const executionAgentNameKey = - normalizeAgentNameKey(issueExecutionAgentNameKey) ?? - normalizeAgentNameKey(executionAgent?.name); - return ( - Boolean(executionAgentNameKey) && executionAgentNameKey === agentNameKey - ); + const executionAgentNameKey = normalizeAgentNameKey(executionAgent?.name); + return executionAgentNameKey !== null && executionAgentNameKey === agentNameKey; }, async findExistingDeferredWake( diff --git a/server/src/modules/wake-queue/application/fresh-issue-run.ts b/server/src/modules/wake-queue/application/fresh-issue-run.ts index 1ef05f937ba..31e33571e9a 100644 --- a/server/src/modules/wake-queue/application/fresh-issue-run.ts +++ b/server/src/modules/wake-queue/application/fresh-issue-run.ts @@ -82,7 +82,7 @@ type FreshIssueRunInput = { failedChatRetryReceiptId?: string; ownsReconstructionContinuation: boolean; contextSnapshot: Record; - sessionIdBefore: string | null; + resolveSessionIdBefore(): Promise; continuationAttempt: number; explicitContinuationRunId: string | null; retryOfRunId: string | null; @@ -161,7 +161,7 @@ export function createFreshIssueRunAdmission(store: wakeupRequestId: primary.id, retryOfRunId: input.reconciledSourceRunId || input.retryOfRunId, contextSnapshot: adopted.length ? withQueuedCommentIdsInRunContext(contextSnapshot, commentIds, adoptedWakeIds) : contextSnapshot, - sessionIdBefore: input.explicitContinuationRunId ? null : input.sessionIdBefore, + sessionIdBefore: input.explicitContinuationRunId ? null : await input.resolveSessionIdBefore(), continuationAttempt: input.continuationAttempt, ...(input.reconciledRestoreRetryCount !== null ? { scheduledRetryAttempt: input.reconciledRestoreRetryCount, diff --git a/server/src/services/heartbeat/queue.test.ts b/server/src/services/heartbeat/queue.test.ts index 3f0d8757902..e29dddafa32 100644 --- a/server/src/services/heartbeat/queue.test.ts +++ b/server/src/services/heartbeat/queue.test.ts @@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto"; import { contextCompactionService } from "../context-compaction.js"; import { claimNativeSessionResumptions } from "../native-runtime/native-finalization-reconciler.js"; import type { Db } from "@paperclipai/db"; -import { authUsers, agents, agentWakeupRequests, budgetIncidents, budgetPolicies, caseHandoffs, cases, chatCompletionDeliveries, companies, companyMemberships, costEvents, createDb, EMBEDDED_POSTGRES_TEST_TIMEOUT_MS, environmentLeases, heartbeatRuns, issueComments, issueThreadInteractions, issues, nativeRunFinalizations } from "@paperclipai/db"; +import { authUsers, agents, agentTaskSessions, agentWakeupRequests, budgetIncidents, budgetPolicies, caseHandoffs, cases, chatCompletionDeliveries, companies, companyMemberships, costEvents, createDb, EMBEDDED_POSTGRES_TEST_TIMEOUT_MS, environmentLeases, heartbeatRuns, issueComments, issueThreadInteractions, issues, nativeRunFinalizations } from "@paperclipai/db"; import { eq, inArray, sql } from "drizzle-orm"; import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; import { resolveExternalTestDatabaseUrl } from "../../__tests__/helpers/external-test-database.js"; @@ -599,6 +599,12 @@ describe.skipIf(!support.supported)("heartbeat queue database wiring", () => { payload: withQueuedCommentIdsInWakePayload({ issueId: issue.id, mutation }, [commentId]), }))).returning(); + const admit = deps.wakeQueue.admitIssueWake.getMockImplementation()!; + deps.wakeQueue.admitIssueWake.mockImplementation((target, evaluate, effects) => admit(target, async (tx, admission) => { + await tx.insert(agentTaskSessions).values({ companyId: company.id, agentId: agent.id, + adapterType: agent.adapterType, taskKey: issue.id, sessionDisplayId: "session-available-in-admission" }); + return evaluate(tx, admission); + }, effects)); const run = await queue.enqueueWakeup(agent.id, { source: "assignment", triggerDetail: "system", reason: "issue_assigned", requestedByActorType: "system", payload: { issueId: issue.id }, contextSnapshot: { issueId: issue.id, interruptedRunId: interruptedRun.id }, @@ -606,6 +612,7 @@ describe.skipIf(!support.supported)("heartbeat queue database wiring", () => { const commentIds = matchingIssue ? [earlier.id, later.id] : [later.id]; expect(run).toMatchObject({ status: "queued", responsibleUserId: user.id, invocationSource: "assignment", + sessionIdBefore: "session-available-in-admission", contextSnapshot: { wakeCommentIds: commentIds, wakeCommentId: later.id, queuedCommentSourceWakeIds: matchingIssue ? [handoff.id, local.id] : [local.id] } }); const receipts = new Map((await db.select().from(agentWakeupRequests)).map(wake => [wake.id, wake])); @@ -923,7 +930,7 @@ describe.skipIf(!support.supported)("heartbeat queue database wiring", () => { expect((await db.select().from(issues).where(eq(issues.id, f.issue.id)))[0].executionRunId).toBe(f.source.id); }); - it.each((["process", "paperclip_runner"] as const).flatMap(adapterType => (["coalesced", "claimed-primary", "legacy-envelope", "delete-old", "delete-new", "stopped", "running", "system-primary", "foreign-primary", "same-named-agent", "mixed-author"] as const).map(scenario => ({ adapterType, scenario }))))("protects a queued comment batch across $adapterType/$scenario", async ({ adapterType, scenario }) => { + it.each((["process", "paperclip_runner"] as const).flatMap(adapterType => (["coalesced", "missing-execution-key", "stale-execution-key", "claimed-primary", "legacy-envelope", "delete-old", "delete-new", "stopped", "running", "system-primary", "foreign-primary", "same-named-agent", "mixed-author"] as const).map(scenario => ({ adapterType, scenario }))))("protects a queued comment batch across $adapterType/$scenario", async ({ adapterType, scenario }) => { const f = await fixture("queued"); let admissionAgent: typeof agents.$inferSelect = { ...f.agent, adapterType, adapterConfig: adapterType === "paperclip_runner" ? { provider: "codex" } : {} }; await db.update(agents).set({ adapterType, adapterConfig: admissionAgent.adapterConfig }).where(eq(agents.id, f.agent.id)); @@ -951,6 +958,13 @@ describe.skipIf(!support.supported)("heartbeat queue database wiring", () => { const [scanned] = await db.update(heartbeatRuns).set({ responsibleUserId: userId, contextSnapshot: withQueuedCommentIdsInRunContext({ issueId: f.issue.id, wakeReason: "issue_commented" }, [oldComment.id]), }).where(eq(heartbeatRuns.id, f.run.id)).returning(); + if (scenario === "missing-execution-key" || scenario === "stale-execution-key") { + const [staleRun] = scenario === "stale-execution-key" ? await db.insert(heartbeatRuns).values({ + companyId: f.company.id, agentId: f.agent.id, status: "succeeded", contextSnapshot: { issueId: f.issue.id }, + }).returning() : []; + await db.update(issues).set({ executionRunId: staleRun?.id ?? null, + executionAgentNameKey: staleRun ? "previous agent name" : null }).where(eq(issues.id, f.issue.id)); + } let foreignPrimary: typeof agentWakeupRequests.$inferSelect | undefined; if (scenario === "foreign-primary") { const [company] = await db.insert(companies).values({ name: "Foreign source", issuePrefix: "FOREIGN" }).returning(); @@ -960,6 +974,7 @@ describe.skipIf(!support.supported)("heartbeat queue database wiring", () => { } if (scenario === "delete-old") await db.update(issueComments).set({ deletedAt: new Date() }).where(eq(issueComments.id, oldComment.id)); const deps = callbacks(db); + const resolveSession = vi.spyOn(deps, "resolveSessionBeforeForWakeup"); deps.getAgent.mockResolvedValue(admissionAgent); deps.canStartNewExternalBotWork.mockResolvedValue(false); deps.instanceSettings.getExperimental.mockResolvedValue({ enableIsolatedWorkspaces: false, enableNativeRunner: true } as Awaited>); @@ -971,7 +986,12 @@ describe.skipIf(!support.supported)("heartbeat queue database wiring", () => { mergeCoalescedContextSnapshot, shouldDeferFollowupWakeForSameIssue, shouldQueueFollowupForRunningIssueWake }, recovery: { escalateStrandedAssignedIssue: async () => undefined, escalateStrandedRecoveryIssueInPlace: async () => undefined }, }); - deps.wakeQueue.admitIssueWake.mockImplementation(admission.admitIssueWake); + const busyAdmission = vi.fn(); + deps.wakeQueue.admitIssueWake.mockImplementation((target, evaluate, effects) => admission.admitIssueWake(target, + (tx, stores) => evaluate(tx, { ...stores, admitWakeBehindIssueExecution(input) { + busyAdmission(input.activeExecutionRun.id, input.issueExecutionAgentNameKey); + return stores.admitWakeBehindIssueExecution(input); + } }), effects)); const queue = createHeartbeatQueue(db, deps); if (scenario === "running") { deps.canStartNewExternalBotWork.mockResolvedValue(true); @@ -1000,6 +1020,10 @@ describe.skipIf(!support.supported)("heartbeat queue database wiring", () => { return; } expect(coalesced).toMatchObject({ id: f.run.id, status: "queued", contextSnapshot: { wakeCommentIds: [oldComment.id, newComment.id] } }); + expect(resolveSession).not.toHaveBeenCalled(); + if (scenario === "missing-execution-key" || scenario === "stale-execution-key") { + expect(busyAdmission).toHaveBeenCalledExactlyOnceWith(f.run.id, f.agent.name.toLowerCase()); + } const accepted = await db.select().from(agentWakeupRequests).where(eq(agentWakeupRequests.companyId, f.company.id)); expect(accepted.find(row => row.id !== f.wake.id)).toMatchObject({ status: "coalesced", runId: f.run.id, finishedAt: expect.any(Date), requestedByActorType: "user", requestedByActorId: incomingActorId }); diff --git a/server/src/services/heartbeat/queue.ts b/server/src/services/heartbeat/queue.ts index 8a74404ace2..f3c1983c382 100644 --- a/server/src/services/heartbeat/queue.ts +++ b/server/src/services/heartbeat/queue.ts @@ -3270,9 +3270,9 @@ export function createHeartbeatQueue(db: Db, dependencies: HeartbeatQueueDepende // Old or direct timer producers cannot create a doomed taskless Runner // run. Explicit session restoration above can supply a real task scope. if (genericTimerWake && !supportsUnscopedTimerHeartbeat(agent)) return null; - const sessionBefore = + const resolveSessionBefore = async (tx: Pick) => explicitResumeSession?.sessionDisplayId ?? - (await resolveSessionBeforeForWakeup(agent, effectiveTaskKey)); + resolveSessionBeforeForWakeup(agent, effectiveTaskKey, tx); let hasResolvablePriorSessionWorkspace: boolean | null = null; const resolveHasResolvablePriorSessionWorkspace = async () => { if (hasResolvablePriorSessionWorkspace !== null) @@ -4306,6 +4306,7 @@ export function createHeartbeatQueue(db: Db, dependencies: HeartbeatQueueDepende .where(eq(heartbeatRuns.id, issue.executionRunId)) .then((rows) => rows[0] ?? null) : null; + let activeExecutionAgentNameKey = issue.executionAgentNameKey; const manualExecutionHold = activeExecutionRun && await nativeManualAdmissionHoldsExecution(tx as unknown as Db, { companyId: issue.companyId, runId: activeExecutionRun.id, issueId: issue.id }); @@ -4435,16 +4436,15 @@ export function createHeartbeatQueue(db: Db, dependencies: HeartbeatQueueDepende const legacyAgent = await tx .select({ name: agents.name }) .from(agents) - .where(eq(agents.id, legacyRun.agentId)) + .where(and(eq(agents.companyId, issue.companyId), eq(agents.id, legacyRun.agentId))) .then((rows) => rows[0] ?? null); + activeExecutionAgentNameKey = normalizeAgentNameKey(legacyAgent?.name); await notifyStatusCardIssueChange(tx, issue.companyId); await tx .update(issues) .set({ executionRunId: legacyRun.id, - executionAgentNameKey: normalizeAgentNameKey( - legacyAgent?.name, - ), + executionAgentNameKey: activeExecutionAgentNameKey, executionLockedAt: new Date(), updatedAt: new Date(), }) @@ -4777,7 +4777,7 @@ export function createHeartbeatQueue(db: Db, dependencies: HeartbeatQueueDepende issueId: issue.id, agentId, agentNameKey, - issueExecutionAgentNameKey: issue.executionAgentNameKey, + issueExecutionAgentNameKey: activeExecutionAgentNameKey, activeExecutionRun: { id: activeExecutionRun.id, agentId: activeExecutionRun.agentId, @@ -5064,7 +5064,7 @@ export function createHeartbeatQueue(db: Db, dependencies: HeartbeatQueueDepende ? durableRequest!.failedRunRetry!.failedRunId : opts.failedRunId ?? automaticParentRunId, contextSnapshot: enrichedContextSnapshot, - sessionIdBefore: sessionBefore, + resolveSessionIdBefore: () => resolveSessionBefore(tx), continuationAttempt, reconciledSourceRunId, reconciledRestoreRetryCount, @@ -5299,7 +5299,7 @@ export function createHeartbeatQueue(db: Db, dependencies: HeartbeatQueueDepende responsibleUserId: await resolveQueuedResponsibleUserId(), wakeupRequestId: wakeupRequest.id, contextSnapshot: enrichedContextSnapshot, - sessionIdBefore: sessionBefore, + sessionIdBefore: await resolveSessionBefore(tx), continuationAttempt, }) .returning() diff --git a/server/src/services/heartbeat/run-state.ts b/server/src/services/heartbeat/run-state.ts index e23a84cdad5..c47a5cf70bd 100644 --- a/server/src/services/heartbeat/run-state.ts +++ b/server/src/services/heartbeat/run-state.ts @@ -1235,8 +1235,8 @@ export function createHeartbeatRunState(db: Db) { }).from(heartbeatRuns).where(eq(heartbeatRuns.id, runId)).then(rows => rows[0] ?? null); } - async function getRuntimeState(agentId: string) { - return db + async function getRuntimeState(agentId: string, reader: Pick = db) { + return reader .select() .from(agentRuntimeState) .where(eq(agentRuntimeState.agentId, agentId)) @@ -1273,8 +1273,9 @@ export function createHeartbeatRunState(db: Db) { agentId: string, adapterType: string, taskKey: string, + reader: Pick = db, ) { - return db + return reader .select() .from(agentTaskSessions) .where( @@ -1507,6 +1508,7 @@ export function createHeartbeatRunState(db: Db) { async function resolveSessionBeforeForWakeup( agent: typeof agents.$inferSelect, taskKey: string | null, + reader: Pick = db, ) { if (taskKey) { const codec = getAdapterSessionCodec(agent.adapterType); @@ -1515,6 +1517,7 @@ export function createHeartbeatRunState(db: Db) { agent.id, agent.adapterType, taskKey, + reader, ); const parsedParams = normalizeSessionParams( codec.deserialize(existingTaskSession?.sessionParamsJson ?? null), @@ -1526,7 +1529,7 @@ export function createHeartbeatRunState(db: Db) { ); } - const runtimeForRun = await getRuntimeState(agent.id); + const runtimeForRun = await getRuntimeState(agent.id, reader); return runtimeForRun?.sessionId ?? null; }