Skip to content

The open-source app everyone uses to manage agents at work

fix: retain channel tools across task continuations (#16806)

Dotta2cbca4ceb0e6
diff --git a/maps/agent-access-map/chat-channels.md b/maps/agent-access-map/chat-channels.md
index 400aa48b95..961b84899b 100644
--- a/maps/agent-access-map/chat-channels.md
+++ b/maps/agent-access-map/chat-channels.md
@@ -147,6 +147,23 @@ the current bot token without resolving unrelated webhook credentials. See the
and [batch failure controls](../../server/src/services/connectors/slack-endpoint-preparation.test.ts).
These local controls do not establish live Slack latency or provider access.
+Native tool gateways use the durable run task binding for discovery and policy
+checks, with legacy JSON task fields as a fallback. GitHub and Slack follow
+accepted request provenance across task continuations. GitHub can retain the
+originating conversation after a board follow-up from the same accepted user.
+An inherited origin cannot cross a task, agent, company, or requester boundary.
+Cycle checks reject invalid history without a fixed limit on valid continuations.
+Endpoint settings, linked identity, tool profiles, and invocation policy still
+apply on each call. The native tool contract rotates older provider sessions so
+an empty retained catalog is not reused. PostgreSQL fixtures cover discovery,
+review publication, Slack reads, and revocation in
+[channel integration](../../server/src/__tests__/chat-channels.integration.test.ts)
+and [provenance controls](../../server/src/services/chat-channels/run-origin.test.ts).
+The [voice gateway fixture](../../server/src/__tests__/voice-session-store.integration.test.ts)
+also verifies durable task binding for a later personal callback invocation.
+Failure replies cannot replace final answers inherited from an earlier run.
+These fixtures do not prove live provider delivery.
+
Catalog authorization projection (2026-10-17): tool discovery uses the same live
service-owned task, company, agent, requester, endpoint and credential checks as
full authority resolution. It omits the revision digest and search-action token,
diff --git a/maps/feature-map/chat-channels.md b/maps/feature-map/chat-channels.md
index 7b51a48d6e..5288ba7ff4 100644
--- a/maps/feature-map/chat-channels.md
+++ b/maps/feature-map/chat-channels.md
@@ -75,6 +75,19 @@ identical catalog membership, absence of digest SQL during discovery, and
revocation on the next preparation. A faster component is not proof of a faster
Slack reaction or final reply; measure those separately on the deployed revision.
+For GitHub and Slack tool continuity, start a task from the channel, then admit
+a later monitor or retry run for the same task. Check that the later run can
+discover and call its channel tools without a new inbound message. For GitHub,
+also continue from a board message by the same accepted requester and complete
+the review in the original conversation, including when the original source is
+recorded only in legacy wake metadata. Revoke the linked identity and check
+that the next call fails. Repeat the boundary checks with another task, agent,
+company, and requester. The channel and provenance fixtures above cover these
+contracts with synthetic providers; record a live journey separately.
+For a long-lived task, repeat more than 100 continuations and check that tool
+access remains available. Fail a later GitHub run after a final answer and
+check that the earlier answer remains intact.
+
### `endpoint-management`
Automated: [channel integration](../../server/src/__tests__/chat-channels.integration.test.ts) covers shared endpoint/delivery behavior; live credential repair and provider ownership remain manual checks.
diff --git a/server/src/__tests__/chat-channels.integration.test.ts b/server/src/__tests__/chat-channels.integration.test.ts
index 539acdfca9..cd3b83ec97 100644
--- a/server/src/__tests__/chat-channels.integration.test.ts
+++ b/server/src/__tests__/chat-channels.integration.test.ts
@@ -27,6 +27,9 @@ import { githubResponseCommentService } from "../services/chat-github-response-c
import { githubReviewCheckService } from "../services/chat-github-checks.js";
import { githubAutomaticReviewEvent } from "../services/chat-github-events.js";
import { githubBotToolsForSession, syncGitHubBotTools } from "../services/chat-github-tools.js";
+import { buildPaperclipRuntimeMcpServers } from "../services/heartbeat/run-preparation.js";
+import { createAssignedMcpTools } from "../services/native-runtime/assigned-mcp-tools.js";
+import { createToolGatewayService } from "../services/tool-gateway.js";
import { resolveGitHubOperationCredentials } from "../services/github-operation-credentials.js";
import { initializeRunIdentity } from "../services/run-identity.js";
import { chatGitHubRegistrations, chatGitHubReviews, chatGitHubConfigurations, toolCatalogEntries } from "@paperclipai/db";
@@ -2786,6 +2789,55 @@ describeEmbeddedPostgres("chat channel control-plane integration", () => {
await expect(gateway.executeTool({ sessionToken: session.token, tool: tool.name, parameters: assessment, idempotencyKey })).rejects.toThrow();
expect(summaryAttempts).toBe(2);
}, 25_000);
+ it.each([
+ { boardFollowUp: false, legacyOrigin: false },
+ { boardFollowUp: true, legacyOrigin: false },
+ { boardFollowUp: false, legacyOrigin: true },
+ { boardFollowUp: true, legacyOrigin: true },
+ ])("keeps GitHub review tools callable through a later native task gateway (board follow-up: $boardFollowUp, legacy origin: $legacyOrigin)", async ({ boardFollowUp, legacyOrigin }) => {
+ vi.stubEnv("PAPERCLIP_API_URL", "https://paperclip.example.test");
+ onTestFinished(() => vi.unstubAllEnvs());
+ const f = await publicationRetryFixture();
+ const identity = await initializeRunIdentity(db, {
+ companyId: f.companyId, runId: f.run.id, issueId: f.conversation.issueId!,
+ responsibleUserId: "owner-user", messageIds: legacyOrigin ? [] : [String(f.run.contextSnapshot?.wakeCommentId)], cause: "instruction",
+ });
+ vi.stubGlobal("fetch", f.providerFetch);
+ onTestFinished(() => vi.unstubAllGlobals());
+ const [agent] = await db.select().from(agents).where(eq(agents.id, f.assignedAgentId));
+ const gateway = createToolGatewayService(db);
+ const first = await buildPaperclipRuntimeMcpServers({ db, agent: agent!, runId: f.run.id });
+ const firstTools = await createAssignedMcpTools({ gateway, gatewayPublicId: new URL(first[0].url).pathname.split("/").at(-1)!, bearerToken: first[0].token });
+ expect(await firstTools.execute({ tool: "paperclip_search_assigned_tools", arguments: { query: "begin_review" } })).toMatchObject({ tools: expect.arrayContaining([expect.objectContaining({ name: expect.stringContaining("begin_review") })]) });
+ await db.update(heartbeatRuns).set({ status: "succeeded" }).where(eq(heartbeatRuns.id, f.run.id));
+ const [later] = await db.insert(heartbeatRuns).values({
+ companyId: f.companyId, agentId: f.assignedAgentId, status: "running", runtimeMode: "native",
+ nativeIssueId: f.conversation.issueId, contextSnapshot: { wakeReason: "issue_monitor_due" },
+ }).returning();
+ const [boardMessage] = boardFollowUp ? await db.insert(issueComments).values({
+ companyId: f.companyId, issueId: f.conversation.issueId!, authorType: "user", authorUserId: "owner-user", body: "Finish the review",
+ }).returning() : [];
+ await initializeRunIdentity(db, {
+ companyId: f.companyId, runId: later.id, issueId: f.conversation.issueId!,
+ responsibleUserId: "owner-user", parentContextId: identity.id, messageIds: boardMessage ? [boardMessage.id] : [], cause: "monitor",
+ });
+ const servers = await buildPaperclipRuntimeMcpServers({ db, agent: agent!, runId: later.id });
+ expect(servers).toHaveLength(1);
+ await expect(gateway.createSession({ companyId: f.companyId, agentId: f.assignedAgentId, runId: later.id, issueId: randomUUID() }))
+ .rejects.toMatchObject({ reasonCode: "run_context_mismatch" });
+ const assigned = await createAssignedMcpTools({ gateway, gatewayPublicId: new URL(servers[0].url).pathname.split("/").at(-1)!, bearerToken: servers[0].token });
+ expect(await assigned.execute({ tool: "paperclip_search_assigned_tools", arguments: { query: "begin_review" } })).toMatchObject({ tools: expect.arrayContaining([expect.objectContaining({ name: expect.stringContaining("begin_review") })]) });
+ const read = assigned.definitions().find(tool => String(tool.name).includes("read_pull_request"))!;
+ expect(await assigned.execute({ tool: String(read.name), arguments: { section: "metadata" } })).toMatchObject({ data: { pull: { number: 418 } } });
+ const begin = assigned.definitions().find(tool => String(tool.name).includes("begin_review"))!;
+ await assigned.execute({ tool: String(begin.name), arguments: { reviewedCommit: f.head } });
+ const submit = assigned.definitions().find(tool => String(tool.name).includes("submit_review"))!;
+ expect(await assigned.execute({ tool: String(submit.name), arguments: f.assessment })).toMatchObject({ data: { status: "processed", score: 3 } });
+ expect(f.responseComments.size).toBe(1);
+ expect([...f.responseComments.values()][0].body).toContain("Advisory review");
+ await db.update(chatIdentityLinks).set({ status: "revoked" }).where(eq(chatIdentityLinks.endpointId, f.endpoint.id));
+ await expect(assigned.execute({ tool: String(read.name), arguments: { section: "metadata" } })).rejects.toThrow();
+ });
it.each([403, 401])("preserves GitHub connection intent after publication HTTP %s", async status => {
const f = await toolReplyFixture();
const initialEndpoint = await f.service.get(f.endpoint.id);
@@ -3307,6 +3359,18 @@ describeEmbeddedPostgres("chat channel control-plane integration", () => {
expect(fallback.state).toBe(expected === "none" ? "published" : "cancelled");
},
);
+ it("preserves an earlier final GitHub answer when a later continuation fails", async () => {
+ const f = await toolReplyFixture();
+ const identity = await initializeRunIdentity(db, { companyId: f.companyId, runId: f.run.id, issueId: f.conversation.issueId!, responsibleUserId: "owner-user", messageIds: [String(f.run.contextSnapshot?.wakeCommentId)], cause: "instruction" });
+ await githubChatReviewService(db, f.providerFetch).execute(f.session, "comment", { body: "Earlier final answer", idempotencyKey: randomUUID() });
+ await db.update(heartbeatRuns).set({ status: "succeeded" }).where(eq(heartbeatRuns.id, f.run.id));
+ const [later] = await db.insert(heartbeatRuns).values({ companyId: f.companyId, agentId: f.assignedAgentId, status: "failed", nativeIssueId: f.conversation.issueId, contextSnapshot: {} }).returning();
+ await initializeRunIdentity(db, { companyId: f.companyId, runId: later.id, issueId: f.conversation.issueId!, responsibleUserId: "owner-user", parentContextId: identity.id, cause: "monitor" });
+ const writes = f.responseWrites.length;
+ await expect(githubResponseCommentService(db, f.providerFetch).failRun({ companyId: f.companyId, endpointId: f.endpoint.id, issueId: f.conversation.issueId!, runId: later.id, body: "Later run failed" })).rejects.toMatchObject({ status: 403 });
+ expect(f.responseWrites).toHaveLength(writes);
+ expect([...f.responseComments.values()][0].body).toContain("Earlier final answer");
+ });
it("rechecks a GitHub fallback after waiting for the credential lane", async () => {
const f = await toolReplyFixture();
await db.update(heartbeatRuns).set({ status: "failed" }).where(eq(heartbeatRuns.id, f.run.id));
@@ -8228,6 +8292,40 @@ describeEmbeddedPostgres("chat channel control-plane integration", () => {
await expect(executeConnectorTool(db, binding, "slack_post_message", { channel: "DROUTINE", text: "Revoked", idempotencyKey: randomUUID() })).rejects.toThrow();
});
+ it("keeps Slack tools callable after a native task continuation without wake JSON", async () => {
+ const { resolveConnectorAssignments } = await import("../services/connector-runtime.js");
+ const { executeSlackTool } = await import("../services/connectors/slack.js");
+ await instanceSettingsService(db).updateExperimental({ enableChatConnectors: true });
+ const f = await seedCompany();
+ const { callbacks, endpoint, service } = await configuredSlackEndpoint(f, { allowUnlinkedPeople: false });
+ const [principal] = await db.insert(chatExternalPrincipals).values({ companyId: f.companyId, provider: "slack", providerAccountId: "T-PAPERCLIP", externalId: "UCONTINUE" }).returning();
+ await db.insert(chatIdentityLinks).values({ companyId: f.companyId, endpointId: endpoint.id, principalId: principal.id, paperclipUserId: "owner-user", status: "linked", confirmedAt: new Date() });
+ const thread = makeThread({ channelId: "slack:CCONTINUE", id: "slack:CCONTINUE:7100.1" });
+ await deliverMessage({ callbacks, endpointId: endpoint.id, thread: thread.thread, message: makeMessage({ id: "7100.1", text: "@maya read this channel", mentioned: true, userId: "UCONTINUE" }), trigger: "mention" });
+ const [conversation] = await readChatConversationsByEndpointId(endpoint.id);
+ const [action] = await db.select().from(chatActions).where(and(eq(chatActions.endpointId, endpoint.id), eq(chatActions.kind, "inbound_wakeup")));
+ const [first] = await db.insert(heartbeatRuns).values({ companyId: f.companyId, agentId: f.assignedAgentId, status: "running", contextSnapshot: { issueId: conversation.issueId } }).returning();
+ const origin = await initializeRunIdentity(db, { companyId: f.companyId, runId: first.id, issueId: conversation.issueId!, responsibleUserId: "owner-user", messageIds: [String(action.payload.commentId)], cause: "instruction" });
+ const binding = { companyId: f.companyId, agentId: f.assignedAgentId, issueId: conversation.issueId!, runId: first.id };
+ expect((await resolveConnectorAssignments(db, binding)).map(assignment => assignment.key)).toEqual(["slack"]);
+ await db.update(heartbeatRuns).set({ status: "succeeded" }).where(eq(heartbeatRuns.id, first.id));
+ const [later] = await db.insert(heartbeatRuns).values({ companyId: f.companyId, agentId: f.assignedAgentId, status: "running", runtimeMode: "native", nativeIssueId: conversation.issueId, contextSnapshot: { wakeReason: "issue_monitor_due" } }).returning();
+ await initializeRunIdentity(db, { companyId: f.companyId, runId: later.id, issueId: conversation.issueId!, responsibleUserId: "owner-user", parentContextId: origin.id, cause: "monitor" });
+ const continued = { ...binding, runId: later.id };
+ expect((await resolveConnectorAssignments(db, continued)).map(assignment => assignment.key)).toEqual(["slack"]);
+ const provider = vi.fn(async (input: RequestInfo | URL) => {
+ const method = String(input).split("/").at(-1);
+ if (method === "users.info") return Response.json({ ok: true, user: { id: "UCONTINUE", team_id: "T-PAPERCLIP" } });
+ if (method === "conversations.info") return Response.json({ ok: true, channel: { id: "CCONTINUE", is_member: true, is_private: false } });
+ if (method === "conversations.members") return Response.json({ ok: true, members: ["UCONTINUE"] });
+ if (method === "conversations.history") return Response.json({ ok: true, messages: [{ ts: "7000.1", text: "Retained channel history" }] });
+ throw new Error(`Unexpected Slack method ${method}`);
+ });
+ expect(await executeSlackTool(db, continued, "slack_history", { channel: "CCONTINUE" }, provider as typeof fetch)).toMatchObject({ messages: [{ text: "Retained channel history" }] });
+ await service.revokeLink(endpoint.id, principal.id, "owner-user");
+ expect(await resolveConnectorAssignments(db, continued)).toEqual([]);
+ await expect(executeSlackTool(db, continued, "slack_history", { channel: "CCONTINUE" }, provider as typeof fetch)).rejects.toThrow();
+ });
it("binds Slack tools to the admitted linked request, recovers its provenance and revokes retained access", async () => {
const { resolveConnectorAssignments, executeConnectorTool, applyConnectorSkills, prepareConnectorSkillDelivery } = await import("../services/connector-runtime.js");
const { executeSlackTool } = await import("../services/connectors/slack.js");
@@ -8327,7 +8425,7 @@ describeEmbeddedPostgres("chat channel control-plane integration", () => {
});
cliApp.use("/api", slackToolRoutes(db, "https://paperclip.example"));
cliApp.use(errorHandler);
- await request(cliApp).post(`/api/companies/${binding.companyId}/slack/tasks/${binding.issueId}/tools`).send({ tool: "slack_channel_info", arguments: { channel: "COTHER" } }).expect(200);
+ await request(cliApp).post(`/api/companies/${binding.companyId}/slack/tasks/${binding.issueId}/tools`).send({ tool: "slack_channel_info", arguments: { channel: "COTHER" } }).expect(response => expect(response.status, response.text).toBe(200));
await request(cliApp).post(`/api/companies/${randomUUID()}/slack/tasks/${binding.issueId}/tools`).send({ tool: "slack_history", arguments: { channel: "COTHER" } }).expect(403);
await request(cliApp).post(`/api/companies/${binding.companyId}/slack/tasks/${randomUUID()}/tools`).send({ tool: "slack_history", arguments: { channel: "COTHER" } }).expect(403);
await request(cliApp).post(`/api/companies/${binding.companyId}/slack/tasks/${binding.issueId}/tools`).send({ tool: "slack_history", arguments: { channel: "COTHER", token: "forged" } }).expect(400);
diff --git a/server/src/__tests__/voice-session-store.integration.test.ts b/server/src/__tests__/voice-session-store.integration.test.ts
index 276bdb353f..4b1d0dbf17 100644
--- a/server/src/__tests__/voice-session-store.integration.test.ts
+++ b/server/src/__tests__/voice-session-store.integration.test.ts
@@ -1301,8 +1301,14 @@ const support = await getEmbeddedPostgresTestSupport();
expect(removed.paperclipRuntimeSkills).toEqual([]);
});
- it("makes call_my_phone discoverable through the governed gateway and reuses a durable attempt", async () => {
+ it.each([false, true])("makes call_my_phone discoverable through the governed gateway and reuses a durable attempt (continued: %s)", async continued => {
const f = await phoneToolFixture();
+ if (continued) {
+ await db.update(heartbeatRuns).set({ status: "succeeded" }).where(eq(heartbeatRuns.id, f.runId));
+ const [run] = await db.insert(heartbeatRuns).values({ companyId: f.companyId, agentId: f.agentId, status: "running", nativeIssueId: f.issueId, contextSnapshot: {} }).returning();
+ await initializeRunIdentity(db, { companyId: f.companyId, agentId: f.agentId, runId: run.id, issueId: f.issueId, responsibleUserId: f.callerId, parentRunId: f.runId, cause: "monitor" });
+ f.gatewaySession = await f.gateway.createSession({ companyId: f.companyId, agentId: f.agentId, runId: run.id });
+ }
const tools = await f.gateway.listToolsForSession(f.gatewaySession.token);
const tool = tools.find(tool => tool.providerType === "paperclip_speko_voice");
expect(tool).toMatchObject({ upstreamToolName: "call_my_phone", connectionId: f.connectionId });
diff --git a/server/src/services/chat-channels/run-origin.test.ts b/server/src/services/chat-channels/run-origin.test.ts
new file mode 100644
index 0000000000..6289333d6d
--- /dev/null
+++ b/server/src/services/chat-channels/run-origin.test.ts
@@ -0,0 +1,130 @@
+import { randomUUID } from "node:crypto";
+import { eq } from "drizzle-orm";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { agents, companies, createDb, heartbeatRuns, issueComments, issues, runIdentityContexts } from "@paperclipai/db";
+import { getEmbeddedPostgresTestSupport, startEmbeddedPostgresTestDatabase } from "../../__tests__/helpers/embedded-postgres.js";
+import { boundRunIssueId, boundRunIssueIdSql } from "../run-task-binding.js";
+import { chatRunSourceMessageId } from "./run-origin.js";
+
+const support = await getEmbeddedPostgresTestSupport();
+(support.supported ? describe : describe.skip)("channel task provenance", () => {
+ let database: Awaited<ReturnType<typeof startEmbeddedPostgresTestDatabase>>;
+ let db: ReturnType<typeof createDb>;
+
+ beforeAll(async () => {
+ database = await startEmbeddedPostgresTestDatabase("paperclip-channel-origin-");
+ db = createDb(database.connectionString);
+ }, 30_000);
+ afterAll(async () => { await database?.cleanup(); }, 60_000);
+
+ async function fixture() {
+ const [company] = await db.insert(companies).values({ name: "Channel continuation", issuePrefix: randomUUID().slice(0, 8) }).returning();
+ const [agent] = await db.insert(agents).values({ companyId: company.id, name: "Channel agent", role: "general", adapterType: "codex_local" }).returning();
+ const [issue] = await db.insert(issues).values({ companyId: company.id, title: "Channel task", assigneeAgentId: agent.id }).returning();
+ const [source, continued] = await db.insert(heartbeatRuns).values([
+ { companyId: company.id, agentId: agent.id, status: "succeeded", contextSnapshot: { issueId: issue.id }, responsibleUserId: "requester" },
+ { companyId: company.id, agentId: agent.id, status: "running", nativeIssueId: issue.id, contextSnapshot: {}, responsibleUserId: "requester" },
+ ]).returning();
+ const messageId = randomUUID();
+ const [origin] = await db.insert(runIdentityContexts).values({ companyId: company.id, runId: source.id, revision: 1, responsibleUserId: "requester", messageId, cause: "instruction", correlationId: "message" }).returning();
+ const [context] = await db.insert(runIdentityContexts).values({ companyId: company.id, runId: continued.id, revision: 1, responsibleUserId: "requester", parentContextId: origin.id, cause: "monitor", correlationId: "dispatch" }).returning();
+ const [run] = await db.update(heartbeatRuns).set({ activeIdentityContextId: context.id }).where(eq(heartbeatRuns.id, continued.id)).returning();
+ return { company, agent, issue, source, run, origin, context, messageId };
+ }
+
+ it("recovers the accepted message across repeated native and legacy task continuations", async () => {
+ const f = await fixture();
+ expect(await chatRunSourceMessageId(db, f.run)).toBe(f.messageId);
+ const [next] = await db.insert(heartbeatRuns).values({ companyId: f.company.id, agentId: f.agent.id, status: "running", issueId: f.issue.id, responsibleUserId: "requester" }).returning();
+ const [context] = await db.insert(runIdentityContexts).values({ companyId: f.company.id, runId: next.id, revision: 1, responsibleUserId: "requester", parentContextId: f.context.id, cause: "retry", correlationId: "dispatch" }).returning();
+ const [run] = await db.update(heartbeatRuns).set({ activeIdentityContextId: context.id }).where(eq(heartbeatRuns.id, next.id)).returning();
+ expect(await chatRunSourceMessageId(db, run)).toBe(f.messageId);
+ });
+
+ it("keeps valid channel authority after more than 100 continuations", async () => {
+ const f = await fixture();
+ const runs = Array.from({ length: 120 }, () => ({ id: randomUUID(), companyId: f.company.id, agentId: f.agent.id, status: "succeeded", nativeIssueId: f.issue.id, responsibleUserId: "requester" }));
+ await db.insert(heartbeatRuns).values(runs);
+ const ids = runs.map(() => randomUUID());
+ await db.insert(runIdentityContexts).values(runs.map((run, index) => ({ id: ids[index], companyId: f.company.id, runId: run.id, revision: 1, responsibleUserId: "requester", parentContextId: index ? ids[index - 1] : f.context.id, cause: "monitor", correlationId: "dispatch" })));
+ const [run] = await db.update(heartbeatRuns).set({ activeIdentityContextId: ids.at(-1)! }).where(eq(heartbeatRuns.id, runs.at(-1)!.id)).returning();
+ expect(await chatRunSourceMessageId(db, run)).toBe(f.messageId);
+ });
+
+ it("stops at a new accepted message instead of borrowing an earlier person's origin", async () => {
+ const f = await fixture();
+ const messageId = randomUUID();
+ await db.update(runIdentityContexts).set({ messageId, responsibleUserId: "new-requester" }).where(eq(runIdentityContexts.id, f.context.id));
+ const [run] = await db.update(heartbeatRuns).set({ responsibleUserId: "new-requester", contextSnapshot: { wakeCommentId: f.messageId } }).where(eq(heartbeatRuns.id, f.run.id)).returning();
+ expect(await chatRunSourceMessageId(db, run, { allowLegacyWakeComment: true })).toBe(messageId);
+ });
+
+ it("recovers a legacy wake only through a verified same-requester parent run", async () => {
+ const f = await fixture();
+ await db.update(runIdentityContexts).set({ messageId: null }).where(eq(runIdentityContexts.id, f.origin.id));
+ await db.update(heartbeatRuns).set({ contextSnapshot: { issueId: f.issue.id, wakeCommentId: f.messageId } }).where(eq(heartbeatRuns.id, f.source.id));
+ expect(await chatRunSourceMessageId(db, f.run)).toBeNull();
+ expect(await chatRunSourceMessageId(db, f.run, { allowLegacyWakeComment: true })).toBe(f.messageId);
+ await db.update(heartbeatRuns).set({ responsibleUserId: "another-person" }).where(eq(heartbeatRuns.id, f.source.id));
+ expect(await chatRunSourceMessageId(db, f.run, { allowLegacyWakeComment: true })).toBeNull();
+ });
+
+ it("does not borrow GitHub origin from an earlier requester after a board message", async () => {
+ const f = await fixture();
+ const [message] = await db.insert(issueComments).values({ companyId: f.company.id, issueId: f.issue.id, authorType: "user", authorUserId: "new-requester", body: "Continue" }).returning();
+ await db.update(runIdentityContexts).set({ messageId: message.id, responsibleUserId: "new-requester" }).where(eq(runIdentityContexts.id, f.context.id));
+ const [run] = await db.update(heartbeatRuns).set({ responsibleUserId: "new-requester", contextSnapshot: { wakeCommentId: f.messageId } }).where(eq(heartbeatRuns.id, f.run.id)).returning();
+ expect(await chatRunSourceMessageId(db, run, { provider: "github", allowLegacyWakeComment: true })).toBeNull();
+ });
+
+ it("recovers a legacy GitHub source after a verified same-user board message", async () => {
+ const f = await fixture();
+ const [message] = await db.insert(issueComments).values({ companyId: f.company.id, issueId: f.issue.id, authorType: "user", authorUserId: "requester", body: "Continue" }).returning();
+ await db.update(runIdentityContexts).set({ messageId: null }).where(eq(runIdentityContexts.id, f.origin.id));
+ await db.update(heartbeatRuns).set({ contextSnapshot: { issueId: f.issue.id, wakeCommentId: f.messageId } }).where(eq(heartbeatRuns.id, f.source.id));
+ await db.update(runIdentityContexts).set({ messageId: message.id }).where(eq(runIdentityContexts.id, f.context.id));
+ const [run] = await db.update(heartbeatRuns).set({ contextSnapshot: { wakeCommentId: message.id } }).where(eq(heartbeatRuns.id, f.run.id)).returning();
+ expect(await chatRunSourceMessageId(db, run, { provider: "github", allowLegacyWakeComment: true })).toBe(f.messageId);
+ await db.update(heartbeatRuns).set({ responsibleUserId: "another-person" }).where(eq(heartbeatRuns.id, f.source.id));
+ expect(await chatRunSourceMessageId(db, run, { provider: "github", allowLegacyWakeComment: true })).toBeNull();
+ });
+
+ it.each(["task", "agent", "company", "requester", "missing-parent", "pending-parent", "pending-current", "cycle"])(
+ "rejects a %s break in inherited authority", async fault => {
+ const f = await fixture();
+ if (fault === "task") {
+ const [other] = await db.insert(issues).values({ companyId: f.company.id, title: "Other task" }).returning();
+ const [otherRun] = await db.insert(heartbeatRuns).values({ companyId: f.company.id, agentId: f.agent.id, status: "succeeded", nativeIssueId: other.id }).returning();
+ await db.update(runIdentityContexts).set({ runId: otherRun.id }).where(eq(runIdentityContexts.id, f.origin.id));
+ }
+ if (fault === "agent") {
+ const [other] = await db.insert(agents).values({ companyId: f.company.id, name: "Other agent", role: "general", adapterType: "codex_local" }).returning();
+ await db.update(heartbeatRuns).set({ agentId: other.id }).where(eq(heartbeatRuns.id, f.source.id));
+ }
+ if (fault === "company") {
+ const [other] = await db.insert(companies).values({ name: "Other company", issuePrefix: randomUUID().slice(0, 8) }).returning();
+ await db.update(runIdentityContexts).set({ companyId: other.id }).where(eq(runIdentityContexts.id, f.origin.id));
+ }
+ if (fault === "requester") await db.update(runIdentityContexts).set({ responsibleUserId: "another-person" }).where(eq(runIdentityContexts.id, f.origin.id));
+ if (fault === "missing-parent") await db.update(runIdentityContexts).set({ parentContextId: randomUUID() }).where(eq(runIdentityContexts.id, f.context.id));
+ if (fault === "pending-parent") await db.update(runIdentityContexts).set({ status: "pending" }).where(eq(runIdentityContexts.id, f.origin.id));
+ if (fault === "pending-current") await db.update(runIdentityContexts).set({ status: "pending" }).where(eq(runIdentityContexts.id, f.context.id));
+ if (fault === "cycle") await db.update(runIdentityContexts).set({ messageId: null, parentContextId: f.context.id }).where(eq(runIdentityContexts.id, f.origin.id));
+ await expect(chatRunSourceMessageId(db, f.run)).rejects.toMatchObject({ status: 403 });
+ },
+ );
+
+ it.each(["native", "issue-column", "legacy-issue", "legacy-task"])("uses the same %s task binding in SQL and runtime authority", async source => {
+ const f = await fixture();
+ const values = {
+ nativeIssueId: source === "native" ? f.issue.id : null,
+ issueId: source === "issue-column" ? f.issue.id : null,
+ contextSnapshot: source === "legacy-task" ? { issueId: "", taskId: f.issue.id }
+ : { issueId: source === "native" ? randomUUID() : source === "issue-column" ? [] : f.issue.id },
+ };
+ const [run] = await db.update(heartbeatRuns).set(values).where(eq(heartbeatRuns.id, f.run.id)).returning();
+ const [projection] = await db.select({ issueId: boundRunIssueIdSql() }).from(heartbeatRuns).where(eq(heartbeatRuns.id, run.id));
+ expect(projection.issueId).toBe(f.issue.id);
+ expect(boundRunIssueId(run)).toBe(projection.issueId);
+ });
+});
diff --git a/server/src/services/chat-channels/run-origin.ts b/server/src/services/chat-channels/run-origin.ts
new file mode 100644
index 0000000000..f73f9dca22
--- /dev/null
+++ b/server/src/services/chat-channels/run-origin.ts
@@ -0,0 +1,83 @@
+import { and, eq, isNull, or, sql } from "drizzle-orm";
+import { chatConversations, chatEndpoints, chatMessageLinks, heartbeatRuns, issueComments, runIdentityContexts, type Db } from "@paperclipai/db";
+import type { ChatProvider } from "@paperclipai/shared";
+import { forbidden } from "../../errors.js";
+import { boundRunIssueId, boundRunIssueIdSql } from "../run-task-binding.js";
+
+type Run = Pick<typeof heartbeatRuns.$inferSelect,
+ "id" | "companyId" | "agentId" | "responsibleUserId" | "activeIdentityContextId" | "nativeIssueId" | "issueId" | "contextSnapshot">;
+type Context = typeof runIdentityContexts.$inferSelect;
+
+export async function chatRunSourceMessageId(db: Db, run: Run, options: { context?: Context | null; allowLegacyWakeComment?: boolean; provider?: ChatProvider } = {}): Promise<string | null> {
+ let legacyMessageId = options.allowLegacyWakeComment && typeof run.contextSnapshot?.wakeCommentId === "string"
+ ? run.contextSnapshot.wakeCommentId : null;
+ if (!run.activeIdentityContextId) {
+ return legacyMessageId;
+ }
+ let origin = options.context ?? (await db.select().from(runIdentityContexts).where(and(
+ eq(runIdentityContexts.id, run.activeIdentityContextId),
+ eq(runIdentityContexts.runId, run.id),
+ eq(runIdentityContexts.companyId, run.companyId),
+ eq(runIdentityContexts.status, "accepted"),
+ )).limit(1))[0];
+ if (!origin || origin.id !== run.activeIdentityContextId || origin.runId !== run.id ||
+ origin.companyId !== run.companyId || origin.status !== "accepted" ||
+ origin.responsibleUserId !== run.responsibleUserId) {
+ throw forbidden("Chat requester provenance changed");
+ }
+ const seen = new Set<string>();
+ let acceptedMessageSeen = false;
+ while (true) {
+ if (origin.messageId) {
+ acceptedMessageSeen = true;
+ if (!options.provider) return origin.messageId;
+ const [link] = await db.select({ issueId: chatConversations.issueId, provider: chatEndpoints.provider }).from(chatMessageLinks)
+ .innerJoin(chatConversations, and(eq(chatConversations.id, chatMessageLinks.conversationId), eq(chatConversations.companyId, run.companyId)))
+ .innerJoin(chatEndpoints, and(eq(chatEndpoints.id, chatConversations.endpointId), eq(chatEndpoints.companyId, run.companyId)))
+ .where(and(eq(chatMessageLinks.companyId, run.companyId), eq(chatMessageLinks.commentId, origin.messageId), eq(chatMessageLinks.direction, "inbound"))).limit(1);
+ if (link) {
+ if (link.issueId !== boundRunIssueId(run)) throw forbidden("Chat request belongs to another task");
+ if (link.provider !== options.provider) return null;
+ return origin.messageId;
+ }
+ const [message] = await db.select({ authorUserId: issueComments.authorUserId }).from(issueComments).where(and(
+ eq(issueComments.id, origin.messageId), eq(issueComments.companyId, run.companyId),
+ eq(issueComments.issueId, boundRunIssueId(run) ?? "00000000-0000-0000-0000-000000000000"),
+ or(eq(issueComments.authorType, "user"), and(isNull(issueComments.authorType), isNull(issueComments.authorAgentId))),
+ isNull(issueComments.deletedAt),
+ )).limit(1);
+ if (!run.responsibleUserId || message?.authorUserId !== run.responsibleUserId) throw forbidden("Chat requester provenance changed");
+ // This verified board message may continue its same-user channel history,
+ // but its own wake metadata is not the earlier channel request.
+ legacyMessageId = null;
+ }
+ if (!origin.parentContextId) return legacyMessageId;
+ if (seen.has(origin.id)) throw forbidden("Chat source provenance could not be verified");
+ seen.add(origin.id);
+ const [parent] = await db.select().from(runIdentityContexts).where(and(
+ eq(runIdentityContexts.id, origin.parentContextId),
+ eq(runIdentityContexts.companyId, run.companyId),
+ eq(runIdentityContexts.status, "accepted"),
+ )).limit(1);
+ if (!parent) throw forbidden("Chat requester provenance changed");
+ if (parent.responsibleUserId !== run.responsibleUserId) {
+ if (acceptedMessageSeen) return null;
+ throw forbidden("Chat requester provenance changed");
+ }
+ const [sourceRun] = await db.select({
+ issueId: boundRunIssueIdSql(),
+ responsibleUserId: heartbeatRuns.responsibleUserId,
+ wakeCommentId: sql<unknown>`${heartbeatRuns.contextSnapshot}->'wakeCommentId'`,
+ }).from(heartbeatRuns).where(and(
+ eq(heartbeatRuns.id, parent.runId),
+ eq(heartbeatRuns.companyId, run.companyId),
+ eq(heartbeatRuns.agentId, run.agentId),
+ )).limit(1);
+ if (!sourceRun || !boundRunIssueId(run) || sourceRun.issueId !== boundRunIssueId(run)) {
+ throw forbidden("Chat tools cannot be inherited by another task");
+ }
+ if (options.allowLegacyWakeComment && sourceRun.responsibleUserId === run.responsibleUserId &&
+ typeof sourceRun.wakeCommentId === "string") legacyMessageId ??= sourceRun.wakeCommentId;
+ origin = parent;
+ }
+}
diff --git a/server/src/services/chat-channels/slack/task-authority.ts b/server/src/services/chat-channels/slack/task-authority.ts
index 4b4a086ad1..dab73c8951 100644
--- a/server/src/services/chat-channels/slack/task-authority.ts
+++ b/server/src/services/chat-channels/slack/task-authority.ts
@@ -1,4 +1,5 @@
import type { EndpointRow, DbOrTransaction } from "../runtime-types.js";
+import { boundRunIssueId } from "../../run-task-binding.js";
import type { createChatCredentials } from "../credentials.js";
import { slackSearchActionToken } from "../../connectors/slack-search-context.js";
@@ -58,7 +59,7 @@ export function createSlackTaskAuthorityRegistration(db: Db, options: SlackTaskA
throw forbidden("Chat connectors are disabled");
const identity = await measureRunPhase("connectors.slack.identity", () => slackRunOrigin(db, binding));
const run = identity.run;
- if ((run.contextSnapshot?.issueId ?? run.contextSnapshot?.taskId) !== binding.issueId || !run.responsibleUserId)
+ if (boundRunIssueId(run) !== binding.issueId || !run.responsibleUserId)
throw forbidden("Slack tools require the bound task and an accepted linked user");
const resolved = await measureRunTransaction(db, "connectors.slack.authority", async (tx) => {
const [action] = await tx.select().from(chatActions).where(and(
diff --git a/server/src/services/chat-github-response-comments.ts b/server/src/services/chat-github-response-comments.ts
index a3b97356b8..a20877fe3e 100644
--- a/server/src/services/chat-github-response-comments.ts
+++ b/server/src/services/chat-github-response-comments.ts
@@ -15,6 +15,8 @@ import { projectSafeChatPublicationText } from "./chat-publication-projection.js
import type { GitHubAutomaticEventContext } from "@paperclipai/shared";
import { githubRunReplyState } from "./chat-run-publications.js";
import { logActivity } from "./activity-log.js";
+import { boundRunIssueId } from "./run-task-binding.js";
+import { chatRunSourceMessageId } from "./chat-channels/run-origin.js";
type Transaction = Parameters<Parameters<Db["transaction"]>[0]>[0];
type Api = { request<T>(path: string, options?: { method?: string; body?: unknown }): Promise<T> };
@@ -220,8 +222,9 @@ export function githubResponseCommentService(db: Db, fetchImpl = fetch) {
}
async function requestsForRun(input: { companyId: string; endpointId: string; issueId: string; runId: string }) {
const [run] = await db.select().from(heartbeatRuns).where(and(eq(heartbeatRuns.id, input.runId), eq(heartbeatRuns.companyId, input.companyId)));
- if (!run || (run.nativeIssueId ?? run.contextSnapshot?.issueId) !== input.issueId) throw forbidden("GitHub run has no request binding");
- const ids = [...new Set([run.contextSnapshot?.wakeCommentId, ...(Array.isArray(run.contextSnapshot?.wakeCommentIds) ? run.contextSnapshot.wakeCommentIds : [])].filter((id): id is string => typeof id === "string"))];
+ if (!run || boundRunIssueId(run) !== input.issueId) throw forbidden("GitHub run has no request binding");
+ const originMessageId = await chatRunSourceMessageId(db, run, { allowLegacyWakeComment: true, provider: "github" });
+ const ids = [...new Set([originMessageId, run.contextSnapshot?.wakeCommentId, ...(Array.isArray(run.contextSnapshot?.wakeCommentIds) ? run.contextSnapshot.wakeCommentIds : [])].filter((id): id is string => typeof id === "string"))];
if (!ids.length) throw forbidden("GitHub run has no request binding");
const links = await db.select({ deliveryId: chatMessageLinks.deliveryId }).from(chatMessageLinks)
.innerJoin(chatConversations, and(eq(chatConversations.id, chatMessageLinks.conversationId), eq(chatConversations.companyId, input.companyId),
@@ -274,14 +277,20 @@ export function githubResponseCommentService(db: Db, fetchImpl = fetch) {
let receipt: { id: string; url: string } | undefined;
for (const link of links) {
if (!link.deliveryId) continue;
+ const responseForRequest = async () => (await db.select({ result: chatActions.result }).from(chatActions).where(and(
+ eq(chatActions.companyId, input.companyId), eq(chatActions.endpointId, input.endpointId),
+ eq(chatActions.deliveryId, link.deliveryId!), eq(chatActions.kind, "github_response_comment"),
+ )).limit(1))[0];
+ if ((await responseForRequest())?.result?.final === true) continue;
const assertRun = async () => {
const source = await context(link.deliveryId!);
const [current] = await db.select().from(heartbeatRuns).where(and(eq(heartbeatRuns.id, run.id), eq(heartbeatRuns.companyId, input.companyId)));
if (!current || current.agentId !== source.endpoint.assignedAgentId ||
!["succeeded", "failed", "interrupted", "timed_out", "cancelled"].includes(current.status) ||
source.endpoint.id !== input.endpointId || source.conversation.issueId !== input.issueId ||
- (current.nativeIssueId ?? current.contextSnapshot?.issueId) !== input.issueId)
+ boundRunIssueId(current) !== input.issueId)
throw forbidden("GitHub failure authority changed");
+ if ((await responseForRequest())?.result?.final === true) throw forbidden("GitHub request already has a final response");
if (await githubRunReplyState(db, input) !== "none") throw conflict("GitHub reply is still being resolved");
};
receipt = await acknowledge(link.deliveryId, input.body, assertRun);
diff --git a/server/src/services/chat-github-reviews.ts b/server/src/services/chat-github-reviews.ts
index 9367e02f1b..b187982bf7 100644
--- a/server/src/services/chat-github-reviews.ts
+++ b/server/src/services/chat-github-reviews.ts
@@ -1,5 +1,7 @@
import { githubRunReplyState } from "./chat-run-publications.js";
import { stageReceiptReactionRemovals } from "./chat-receipt-reactions.js";
+import { chatRunSourceMessageId } from "./chat-channels/run-origin.js";
+import { boundRunIssueId } from "./run-task-binding.js";
import {
GitHubPublicationLeaseLost,
withGitHubPublicationLease,
@@ -144,10 +146,7 @@ export function githubChatReviewService(db: Db, fetchImpl = fetch) {
eq(heartbeatRuns.agentId, session.agentId),
),
);
- const taskId =
- run?.nativeIssueId ??
- run?.contextSnapshot?.issueId ??
- run?.contextSnapshot?.taskId;
+ const taskId = run ? boundRunIssueId(run) : null;
if (
!run ||
taskId !== session.issueId ||
@@ -155,7 +154,7 @@ export function githubChatReviewService(db: Db, fetchImpl = fetch) {
(publishing && !["running", "succeeded"].includes(run.status))
)
throw forbidden("This task run is no longer authorized");
- const commentId = run.contextSnapshot?.wakeCommentId;
+ const commentId = await chatRunSourceMessageId(db, run, { allowLegacyWakeComment: true, provider: "github" });
const [source] =
typeof commentId === "string"
? await db
diff --git a/server/src/services/chat-github-tools.ts b/server/src/services/chat-github-tools.ts
index 4c4c8f7358..f87a9f1c66 100644
--- a/server/src/services/chat-github-tools.ts
+++ b/server/src/services/chat-github-tools.ts
@@ -1,7 +1,7 @@
import { createHash } from "node:crypto";
import { z } from "zod";
import { githubReviewAssessmentSchema } from "@paperclipai/shared";
-import { and, eq, isNull } from "drizzle-orm";
+import { and, eq, isNull, sql } from "drizzle-orm";
import {
chatDeliveries,
chatMessageLinks,
@@ -21,7 +21,8 @@ import type {
ToolGatewayDescriptor,
ToolGatewaySession,
} from "./tool-gateway.js";
-import { runContextSnapshotString } from "./tool-access-policy.js";
+import { boundRunIssueIdSql } from "./run-task-binding.js";
+import { chatRunSourceMessageId } from "./chat-channels/run-origin.js";
const objectSchema = (
properties: Record<string, unknown>,
@@ -333,8 +334,7 @@ export async function githubBotConnectionIdsForRun(
): Promise<Set<string>> {
const [run] = await db
.select({
- issueId: heartbeatRuns.nativeIssueId,
- snapshotIssueId: runContextSnapshotString("issueId"),
+ issueId: boundRunIssueIdSql(),
})
.from(heartbeatRuns)
.where(
@@ -344,7 +344,7 @@ export async function githubBotConnectionIdsForRun(
eq(heartbeatRuns.id, runId),
),
);
- const issueId = run?.issueId ?? run?.snapshotIssueId;
+ const issueId = run?.issueId;
if (typeof issueId !== "string") return new Set();
const rows = await db
.select({
@@ -386,7 +386,16 @@ export async function githubGuestBotConnectionForSession(
): Promise<string | null> {
if (!session.runId || !session.agentId || !session.issueId) return null;
const [run] = await db
- .select({ wakeCommentId: runContextSnapshotString("wakeCommentId") })
+ .select({
+ id: heartbeatRuns.id,
+ companyId: heartbeatRuns.companyId,
+ agentId: heartbeatRuns.agentId,
+ responsibleUserId: heartbeatRuns.responsibleUserId,
+ activeIdentityContextId: heartbeatRuns.activeIdentityContextId,
+ nativeIssueId: heartbeatRuns.nativeIssueId,
+ issueId: boundRunIssueIdSql(),
+ contextSnapshot: sql<Record<string, unknown>>`jsonb_build_object('wakeCommentId', ${heartbeatRuns.contextSnapshot}->'wakeCommentId')`,
+ })
.from(heartbeatRuns)
.where(
and(
@@ -395,7 +404,7 @@ export async function githubGuestBotConnectionForSession(
eq(heartbeatRuns.id, session.runId),
),
);
- const commentId = run?.wakeCommentId;
+ const commentId = run ? await chatRunSourceMessageId(db, run, { allowLegacyWakeComment: true, provider: "github" }) : null;
if (typeof commentId !== "string") return null;
const [source] = await db
.select({
diff --git a/server/src/services/connectors/slack-authority.ts b/server/src/services/connectors/slack-authority.ts
index 486b37ab62..06da6455d3 100644
--- a/server/src/services/connectors/slack-authority.ts
+++ b/server/src/services/connectors/slack-authority.ts
@@ -10,6 +10,8 @@ import {
import { and, eq, inArray } from "drizzle-orm";
import { captureRunIdentity } from "../run-identity.js";
import { forbidden } from "../../errors.js";
+import { boundRunIssueId } from "../run-task-binding.js";
+import { chatRunSourceMessageId } from "../chat-channels/run-origin.js";
export interface SlackTaskBinding {
companyId: string;
@@ -149,51 +151,13 @@ export async function slackRunOrigin(db: Db, binding: SlackTaskBinding) {
);
}
if (
- (captured.run.contextSnapshot?.issueId ??
- captured.run.contextSnapshot?.taskId) !== binding.issueId ||
+ boundRunIssueId(captured.run) !== binding.issueId ||
!captured.run.responsibleUserId
)
throw forbidden(
"Slack tools require the bound task and an accepted linked user",
);
- let origin = captured.context;
- const seen = new Set<string>();
- while (origin && !origin.messageId && origin.parentContextId) {
- if (seen.has(origin.id) || seen.size >= 100)
- throw forbidden("Slack source provenance could not be verified");
- seen.add(origin.id);
- const [parent] = await db
- .select()
- .from(runIdentityContexts)
- .where(
- and(
- eq(runIdentityContexts.id, origin.parentContextId),
- eq(runIdentityContexts.companyId, binding.companyId),
- eq(runIdentityContexts.status, "accepted"),
- ),
- );
- if (!parent || parent.responsibleUserId !== captured.run.responsibleUserId)
- throw forbidden("Slack requester provenance changed");
- // Delegation to a different task does not grant that task Slack tools.
- const [sourceRun] = await db
- .select()
- .from(heartbeatRuns)
- .where(
- and(
- eq(heartbeatRuns.id, parent.runId),
- eq(heartbeatRuns.companyId, binding.companyId),
- eq(heartbeatRuns.agentId, binding.agentId),
- ),
- );
- if (
- !sourceRun ||
- (sourceRun.contextSnapshot?.issueId ??
- sourceRun.contextSnapshot?.taskId) !== binding.issueId
- )
- throw forbidden("Slack tools cannot be inherited by another task");
- origin = parent;
- }
- return { ...captured, sourceMessageId: origin?.messageId ?? null };
+ return { ...captured, sourceMessageId: await chatRunSourceMessageId(db, captured.run, { context: captured.context }) };
}
/** Enumerate only this agent's connections; each still needs live run/user authority. */
diff --git a/server/src/services/heartbeat/run-preparation.ts b/server/src/services/heartbeat/run-preparation.ts
index 3a41c987db..374412e127 100644
--- a/server/src/services/heartbeat/run-preparation.ts
+++ b/server/src/services/heartbeat/run-preparation.ts
@@ -6,6 +6,7 @@ import { CONFIGURED_ENVIRONMENT_KEYS } from "../../vendor/paperclip-runner/index
import { ASSIGNED_MCP_SERVER_NAME } from "../mcp-tool-names.js";
import { externalConversationStateSql } from "../slack-conversation-state.js";
import { githubBotConnectionIdsForRun } from "../chat-github-tools.js";
+import { boundRunIssueIdSql } from "../run-task-binding.js";
import { isBrowserUseConnection } from "../browser-use-client.js";
import { explicitOperatorRunIdentity } from "../run-identity.js";
import {
@@ -935,7 +936,7 @@ export async function buildPaperclipRuntimeMcpServers(input: {
);
const [runIdentity] = await input.db
.select({
- contextSnapshot: heartbeatRuns.contextSnapshot,
+ issueId: boundRunIssueIdSql(),
responsibleUserId: heartbeatRuns.responsibleUserId,
activeIdentityContextId: heartbeatRuns.activeIdentityContextId,
})
@@ -998,7 +999,7 @@ export async function buildPaperclipRuntimeMcpServers(input: {
companyId: input.agent.companyId,
agentId: input.agent.id,
runId: input.runId,
- issueId: readNonEmptyString(runIdentity?.contextSnapshot?.issueId ?? runIdentity?.contextSnapshot?.taskId),
+ issueId: runIdentity?.issueId ?? null,
identityContextId: runIdentity?.activeIdentityContextId,
})).map(tool => tool.connectionId))
: new Set<string>();
diff --git a/server/src/services/native-runtime/native-session-resume.ts b/server/src/services/native-runtime/native-session-resume.ts
index c8d8c031d2..3243de9980 100644
--- a/server/src/services/native-runtime/native-session-resume.ts
+++ b/server/src/services/native-runtime/native-session-resume.ts
@@ -33,7 +33,7 @@ export function nativeToolContractFingerprintForTarget(
return `sha256:${createHash("sha256")
.update(
JSON.stringify({
- schema: "paperclip.native-tool-contract.v16",
+ schema: "paperclip.native-tool-contract.v17",
executionTargetKind,
advertisementPolicy: {
// Direct provider threads retain declarations from thread/start.
@@ -48,6 +48,7 @@ export function nativeToolContractFingerprintForTarget(
"always_advertised_run_issue_agent_binding_gated_current_task_description.v2",
semanticCompletion: "finish_accessible_deliverable_evidence.v4",
connectorTools: "assigned_resources_and_pinned_skill_bundle.v1",
+ chatTaskTools: "durable_task_binding_and_accepted_origin.v1",
githubResponses: "bound_working_comment_progress_and_final.v1",
githubInstructionSkills: "trusted_configuration_native_selection.v1",
...(executionTargetKind === "remote"
diff --git a/server/src/services/native-runtime/runtime-context.test.ts b/server/src/services/native-runtime/runtime-context.test.ts
index d0d81c292b..8fd5e101e8 100644
--- a/server/src/services/native-runtime/runtime-context.test.ts
+++ b/server/src/services/native-runtime/runtime-context.test.ts
@@ -428,7 +428,7 @@ it("pins channel tools only when the current task run is bound to that bot", asy
it("pins a voice tool only when the current requester can call through that assigned endpoint", async () => {
serviceMocks.getEffectiveProfilesForAgent.mockResolvedValue({ entries: [{ effect: "include", connectionId: "voice-connection" }], installedConnections: [{ id: "voice-connection", status: "active", enabled: true, healthStatus: "healthy", transport: "voice", config: { provider: "speko" }, transportConfig: {} }], allowedTools: [{ id: "phone-tool", connectionId: "voice-connection" }] });
- const limit = vi.fn().mockResolvedValue([{ contextSnapshot: { issueId: "task-1" }, activeIdentityContextId: "identity-1" }]);
+ const limit = vi.fn().mockResolvedValue([{ issueId: "task-1", activeIdentityContextId: "identity-1" }]);
const db = { select: () => ({ from: () => ({ where: () => ({ limit }) }) }) } as unknown as Db;
const input = { db, agent: { id: "agent-1", companyId: "company-1" }, runId: "run-1" };
expect((await resolveNativeRuntimeMcpSnapshot(input)).bindingId).toBeNull();
diff --git a/server/src/services/native-runtime/runtime-context.ts b/server/src/services/native-runtime/runtime-context.ts
index edbfd89091..8c561aebbf 100644
--- a/server/src/services/native-runtime/runtime-context.ts
+++ b/server/src/services/native-runtime/runtime-context.ts
@@ -1,6 +1,7 @@
import { measureRunPhase } from "../execution-preparation-timing.js";
import { spekoToolsForSession } from "../voice/speko-agent-tools.js";
import { githubBotConnectionIdsForRun } from "../chat-github-tools.js";
+import { boundRunIssueIdSql } from "../run-task-binding.js";
import { isBrowserUseConnection } from "../browser-use-client.js";
import { createHash, randomUUID } from "node:crypto";
import fs from "node:fs/promises";
@@ -205,7 +206,7 @@ export async function resolveNativeRuntimeMcpSnapshot(input: { db: Db; agent: Pi
});
const hasVoiceConnection = effective.installedConnections.some(connection => connection.transport === "voice");
const [runIdentity] = hasGitHubConnection || hasVoiceConnection
- ? await input.db.select({ contextSnapshot: heartbeatRuns.contextSnapshot, responsibleUserId: heartbeatRuns.responsibleUserId, activeIdentityContextId: heartbeatRuns.activeIdentityContextId })
+ ? await input.db.select({ issueId: boundRunIssueIdSql(), responsibleUserId: heartbeatRuns.responsibleUserId, activeIdentityContextId: heartbeatRuns.activeIdentityContextId })
.from(heartbeatRuns)
.where(and(
eq(heartbeatRuns.id, input.runId),
@@ -227,7 +228,7 @@ export async function resolveNativeRuntimeMcpSnapshot(input: { db: Db; agent: Pi
// App access is optional runtime context. Keep usable assignments pinned, but
// do not stop unrelated work because an assigned app needs attention.
const githubBotConnectionIds = await githubBotConnectionIdsForRun(input.db, input.agent.companyId, input.agent.id, input.runId);
- const spekoConnectionIds = hasVoiceConnection ? new Set((await spekoToolsForSession(input.db, { companyId: input.agent.companyId, agentId: input.agent.id, runId: input.runId, issueId: typeof runIdentity?.contextSnapshot?.issueId === "string" ? runIdentity.contextSnapshot.issueId : typeof runIdentity?.contextSnapshot?.taskId === "string" ? runIdentity.contextSnapshot.taskId : null, identityContextId: runIdentity?.activeIdentityContextId })).map(tool => tool.connectionId)) : new Set<string>();
+ const spekoConnectionIds = hasVoiceConnection ? new Set((await spekoToolsForSession(input.db, { companyId: input.agent.companyId, agentId: input.agent.id, runId: input.runId, issueId: runIdentity?.issueId ?? null, identityContextId: runIdentity?.activeIdentityContextId })).map(tool => tool.connectionId)) : new Set<string>();
const availableConnectionIds = new Set(resolvedInstalledConnections.filter((connection) =>
permitted.has(connection.id)
&& connection.status === "active"
diff --git a/server/src/services/run-identity.ts b/server/src/services/run-identity.ts
index 496b58719d..19ac75989c 100644
--- a/server/src/services/run-identity.ts
+++ b/server/src/services/run-identity.ts
@@ -10,6 +10,7 @@ import {
type Db,
} from "@paperclipai/db";
import { conflict, forbidden } from "../errors.js";
+import { boundRunIssueId } from "./run-task-binding.js";
import { isUuidLike } from "@paperclipai/shared";
import { queuedCommentIdsFromRunContext, queuedCommentIdsFromWakePayload } from "./issue-queued-comment-queue.js";
@@ -71,19 +72,18 @@ async function lockIdentityTask(
) {
const [run] = await executor
.select({
- context: heartbeatRuns.contextSnapshot,
- issueId: heartbeatRuns.nativeIssueId,
+ contextSnapshot: heartbeatRuns.contextSnapshot,
+ nativeIssueId: heartbeatRuns.nativeIssueId,
+ issueId: heartbeatRuns.issueId,
})
.from(heartbeatRuns)
.where(
and(eq(heartbeatRuns.id, runId), eq(heartbeatRuns.companyId, companyId)),
);
- const issueId = run?.context?.issueId ?? run?.context?.taskId ?? run?.issueId;
- if (
- issueId !== undefined &&
- issueId !== null &&
- (typeof issueId !== "string" || !isUuidLike(issueId))
- ) {
+ const issueId = run?.nativeIssueId ?? run?.issueId ?? run?.contextSnapshot?.issueId ?? run?.contextSnapshot?.taskId;
+ const legacyIssueId = run?.contextSnapshot?.issueId ?? run?.contextSnapshot?.taskId;
+ if ([issueId, legacyIssueId].some(id => id !== undefined && id !== null &&
+ (typeof id !== "string" || !isUuidLike(id)))) {
throw forbidden("Run task identity is invalid");
}
if (typeof issueId === "string")
@@ -151,7 +151,7 @@ async function activate(executor: Executor, context: RunIdentityContext) {
),
)
.returning();
- const issueId = run?.contextSnapshot?.issueId ?? run?.contextSnapshot?.taskId;
+ const issueId = run ? boundRunIssueId(run) : null;
if (typeof issueId === "string")
await executor
.update(issues)
@@ -319,8 +319,7 @@ export async function prepareSteeredIdentity(
throw forbidden("Steering requires an authenticated message author");
if (
run.status !== "running" ||
- (run.contextSnapshot?.issueId !== input.issueId &&
- run.contextSnapshot?.taskId !== input.issueId)
+ boundRunIssueId(run) !== input.issueId
) {
throw conflict("Steering targets a different or inactive execution");
}
diff --git a/server/src/services/run-task-binding.ts b/server/src/services/run-task-binding.ts
new file mode 100644
index 0000000000..67b89336bd
--- /dev/null
+++ b/server/src/services/run-task-binding.ts
@@ -0,0 +1,21 @@
+import { sql } from "drizzle-orm";
+import { heartbeatRuns } from "@paperclipai/db";
+
+type RunTaskBinding = {
+ nativeIssueId?: string | null;
+ issueId?: string | null;
+ contextSnapshot?: Record<string, unknown> | null;
+};
+
+export function boundRunIssueId(run: RunTaskBinding): string | null {
+ const values = [run.nativeIssueId, run.issueId, run.contextSnapshot?.issueId, run.contextSnapshot?.taskId];
+ return values.find((value): value is string => typeof value === "string" && value.trim().length > 0)?.trim() ?? null;
+}
+
+export function boundRunIssueIdSql() {
+ return sql<string | null>`coalesce(${heartbeatRuns.nativeIssueId}::text, ${heartbeatRuns.issueId}::text,
+ case when jsonb_typeof(${heartbeatRuns.contextSnapshot}->'issueId') = 'string'
+ then nullif(btrim(${heartbeatRuns.contextSnapshot}->>'issueId'), '') end,
+ case when jsonb_typeof(${heartbeatRuns.contextSnapshot}->'taskId') = 'string'
+ then nullif(btrim(${heartbeatRuns.contextSnapshot}->>'taskId'), '') end)`;
+}
diff --git a/server/src/services/tool-access-policy.ts b/server/src/services/tool-access-policy.ts
index 6357c9b5e8..05485b87c1 100644
--- a/server/src/services/tool-access-policy.ts
+++ b/server/src/services/tool-access-policy.ts
@@ -1,4 +1,5 @@
import { createHash } from "node:crypto";
+import { boundRunIssueIdSql } from "./run-task-binding.js";
import { and, asc, desc, eq, gt, inArray, isNull, ne, sql } from "drizzle-orm";
import type { Db } from "@paperclipai/db";
import {
@@ -976,7 +977,7 @@ export function toolAccessPolicyService(db: Db) {
.select({
companyId: heartbeatRuns.companyId,
agentId: heartbeatRuns.agentId,
- issueId: runContextSnapshotString("issueId"),
+ issueId: boundRunIssueIdSql(),
projectId: runContextSnapshotString("projectId"),
routineId: runContextSnapshotString("routineId"),
})
diff --git a/server/src/services/tool-gateway.ts b/server/src/services/tool-gateway.ts
index 393278dd4e..95de0f8c24 100644
--- a/server/src/services/tool-gateway.ts
+++ b/server/src/services/tool-gateway.ts
@@ -12,6 +12,7 @@ import { claimSlackRateLimitRetry } from "./connectors/slack-retry.js";
import { resolveSlackTaskAuthority } from "./connectors/slack-authority.js";
import { SLACK_TOOLS } from "@paperclipai/shared";
import { slackToolsForSession } from "./connectors/slack-catalog.js";
+import { boundRunIssueIdSql } from "./run-task-binding.js";
import { executeSlackTool } from "./connectors/slack.js";
import { githubGuestBotConnectionForSession, githubBotToolsForSession } from "./chat-github-tools.js";
import { githubChatReviewService } from "./chat-github-reviews.js";
@@ -1664,7 +1665,7 @@ export function createToolGatewayService(
companyId: heartbeatRuns.companyId,
agentId: heartbeatRuns.agentId,
status: heartbeatRuns.status,
- issueId: runContextSnapshotString("issueId"),
+ issueId: boundRunIssueIdSql(),
projectId: runContextSnapshotString("projectId"),
})
.from(heartbeatRuns)
diff --git a/server/src/services/voice/speko-agent-tools.ts b/server/src/services/voice/speko-agent-tools.ts
index 669a70a0c5..6332329fe3 100644
--- a/server/src/services/voice/speko-agent-tools.ts
+++ b/server/src/services/voice/speko-agent-tools.ts
@@ -3,6 +3,7 @@ import { and, eq, isNull, sql } from "drizzle-orm";
import { forbidden, HttpError } from "../../errors.js";
import { authorizationService } from "../authorization.js";
import { captureRunIdentity } from "../run-identity.js";
+import { boundRunIssueId } from "../run-task-binding.js";
import { chatVoiceCallbacks, instanceUserRoles, companyMemberships } from "@paperclipai/db";
import type { VoiceCaller } from "./voice-session-store.js";
import { z } from "zod";
@@ -19,7 +20,7 @@ async function resolveAuthority(db: Db, session: SpekoTaskSession, endpointId: s
if (!(await instanceSettingsService(db).getExperimental()).enableChatConnectors) throw forbidden("Voice connections are disabled");
if (!runtimes.has(db) || !session.agentId || !session.runId || !session.issueId) throw forbidden("Speko tools require an active task run");
const { run, context } = await captureRunIdentity(db, { companyId: session.companyId, agentId: session.agentId, runId: session.runId });
- if ((run.contextSnapshot?.issueId ?? run.contextSnapshot?.taskId) !== session.issueId || !run.responsibleUserId || session.identityContextId && session.identityContextId !== context?.id) throw forbidden("The accepted requester or task changed");
+ if (boundRunIssueId(run) !== session.issueId || !run.responsibleUserId || session.identityContextId && session.identityContextId !== context?.id) throw forbidden("The accepted requester or task changed");
const [endpoint] = await db.select().from(chatEndpoints).where(and(eq(chatEndpoints.companyId, session.companyId), eq(chatEndpoints.id, endpointId), eq(chatEndpoints.provider, "speko"), eq(chatEndpoints.assignedAgentId, session.agentId), eq(chatEndpoints.status, "active")));
if (!endpoint) throw forbidden("This agent has no active Speko connection");
const userId = run.responsibleUserId;