The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
fix(auth): derive low-trust human direction from existing execution records (#14775)
Dotta0829d94af2a2
diff --git a/doc/LOW-TRUST-PRESETS.md b/doc/LOW-TRUST-PRESETS.mdindex 9581e7cfa3..3000719216 100644--- a/doc/LOW-TRUST-PRESETS.md+++ b/doc/LOW-TRUST-PRESETS.md@@ -41,6 +41,35 @@ Low-trust agents cannot read or mutate agent configuration, instruction bundles,or company skill configuration through direct grants. Configuration changes fromlow-trust work must go through higher-trust review and promotion paths instead.+## Human-directed work++An authenticated board user can talk to a low-trust agent in their own Agent+Chat or assign it a task outside its default intake boundary. Existing conversation+identity authorizes owner chat. Ordinary tasks use the human requester already+recorded on the run's wakeup requests, including coalesced requests. Each request+retains its server-owned origin; plugin-attributed users do not count as board+instructions. Legacy board assignment requests remain valid through their existing+assignment source, reason, and human requester, without trusting old plugin human+attribution. A board backlog assignment is retained as a completed assignment+request with no run, so it authorizes the later system launch without starting+work prematurely. No separate permission table or client-supplied human identity is needed. Responsible-user+attribution, external connector sender attribution, and agent claims do not qualify.++At dispatch and API authorization, Paperclip checks the live run and current+assignment in one database snapshot. The exception permits reading, commenting+on, and updating only that run's exact task. It does not extend to another task,+a child, a whole project, configuration, instructions, secrets, or runtime+management. Normal responsible-user checks still apply. The exception is never+stored in the inherited trust boundary.++Automatic retries and continuations follow the existing `retryOfRunId` database+links, checking the same company, agent, and task at every step. Cancelled runs+cannot authorize a retry. The common assignment transaction cancels prior human+requests, including plugin and service reassignments. Assigning the task back+cannot revive those requests, and late run settlement cannot undo cancellation. Sandbox and+isolated workspace requirements still apply, as do malformed-policy and+company-boundary checks.+## Child→Parent Reporting Under ContainmentThe direct-parent report comment (`doc/execution-semantics.md` §6, "Child→Parent@@ -59,7 +88,8 @@ runtime boundary:- the selected execution environment must use the `sandbox` driver- the effective execution workspace mode must be `isolated_workspace`-- the issue being run must be inside the resolved low-trust boundary+- the issue being run must be inside the resolved low-trust boundary or be the+ exact human-directed task described above- secret references must use binding ids explicitly allowed by the boundary- inline sensitive environment values such as API keys and tokens are rejected- workspace runtime-service mutations are denied unless the boundary explicitlydiff --git a/doc/SPEC-implementation.md b/doc/SPEC-implementation.mdindex 782f4c08b6..580aa360aa 100644--- a/doc/SPEC-implementation.md+++ b/doc/SPEC-implementation.md@@ -626,6 +626,15 @@ budget gates, and pause gates remain independently enforced. Comment access isstructurally downstream of issue read access (`issue:comment` is a subset of`issue:read`).+Authenticated board direction permits a low-trust agent to execute its own+human conversation or the exact task explicitly assigned or addressed by a human.+This server-owned exception is bound to the current assignee and the run's task;+it uses existing conversation identity and authenticated execution-request records,+including same-task retry ancestry. It does not expand inherited boundaries or+grant privileged tools. Backlog assignments retain the existing human requester+without starting a run. Reassignment transactionally cancels prior human requests,+including service/plugin writes; cancelled runs cannot authorize later retries. See `doc/LOW-TRUST-PRESETS.md` for containment details.+Cross-issue writes are contained per heartbeat run. An agent-authored commentmay wake the target assignee, including an explicit `resume: true` comment on a`done` or `cancelled` issue, but the wake remains agent-class and is subject todiff --git a/server/src/__tests__/human-directed-work.test.ts b/server/src/__tests__/human-directed-work.test.tsnew file mode 100644index 0000000000..b76e28677c--- /dev/null+++ b/server/src/__tests__/human-directed-work.test.ts@@ -0,0 +1,268 @@+import { randomUUID } from "node:crypto";+import { eq } from "drizzle-orm";+import { afterAll, beforeAll, describe, expect, it } from "vitest";+import { agents, companies, createDb, heartbeatRuns, agentWakeupRequests, issues, projects } from "@paperclipai/db";+import { LOW_TRUST_REVIEW_PRESET } from "@paperclipai/shared";+import { getEmbeddedPostgresTestSupport, startEmbeddedPostgresTestDatabase } from "./helpers/embedded-postgres.js";+import { createPostgresWatchdogAdapter } from "../modules/active-run-watchdog/adapters/postgres.js";+import { issueService } from "../services/issues.js";+import { authorizationService } from "../services/authorization.js";+import { resolveAndRetainRunTrustPreset } from "../services/run-trust-preset.js";+import { assertLowTrustWorkspaceIsolation } from "../services/low-trust-runtime-containment.js";+import { retainBacklogHumanAssignment, withHumanDirectedWork } from "../services/human-directed-work.js";+import { resolveCoreTrustPreset } from "../services/trust-preset-resolver.js";++const support = await getEmbeddedPostgresTestSupport();+(support.supported ? describe : describe.skip)("human-directed low-trust work", () => {+ let database: Awaited<ReturnType<typeof startEmbeddedPostgresTestDatabase>>;+ let db: ReturnType<typeof createDb>;+ beforeAll(async () => {+ database = await startEmbeddedPostgresTestDatabase("paperclip-human-work-");+ db = createDb(database.connectionString, { maxConnections: 2 });+ }, 30_000);+ afterAll(async () => { await database?.cleanup(); }, 60_000);++ async function seed() {+ const companyId = randomUUID();+ await db.insert(companies).values({ id: companyId, name: companyId, issuePrefix: companyId.slice(0, 8) });+ const [project] = await db.insert(projects).values({ companyId, name: "Contained intake" }).returning();+ const [agent] = await db.insert(agents).values({+ companyId, name: "Contained agent", role: "engineer", adapterType: "paperclip_runner",+ permissions: { authorizationPolicy: { trustPreset: LOW_TRUST_REVIEW_PRESET,+ trustBoundary: { mode: LOW_TRUST_REVIEW_PRESET, companyId, projectIds: [project.id] } } },+ }).returning();+ const [other] = await db.insert(agents).values({ companyId, name: "Other", role: "engineer" }).returning();+ return { companyId, agent, other };+ }+ async function task(f: Awaited<ReturnType<typeof seed>>) {+ return issueService(db).create(f.companyId, {+ title: `Direct task ${randomUUID()}`, assigneeAgentId: f.agent.id,+ createdByUserId: "owner", responsibleUserId: "owner",+ });+ }+ async function execution(f: Awaited<ReturnType<typeof seed>>, issue: Awaited<ReturnType<typeof task>>,+ options: { human?: boolean; context?: Record<string, unknown>; retryOfRunId?: string; status?: string } = {}) {+ const [wake] = await db.insert(agentWakeupRequests).values({ companyId: f.companyId, agentId: f.agent.id,+ source: options.human ? "assignment" : "automation", status: "claimed",+ requestedByActorType: options.human ? "user" : "system", requestedByActorId: options.human ? "owner" : null,+ payload: { issueId: issue.id, _paperclipWakeContext: { source: "issue.update" } } }).returning();+ const [run] = await db.insert(heartbeatRuns).values({ companyId: f.companyId, agentId: f.agent.id,+ status: options.status ?? "running", responsibleUserId: "owner", wakeupRequestId: wake.id,+ retryOfRunId: options.retryOfRunId, contextSnapshot: { issueId: issue.id, ...options.context } }).returning();+ await db.update(agentWakeupRequests).set({ runId: run.id }).where(eq(agentWakeupRequests.id, wake.id));+ return { run, wake, actor: { type: "agent" as const, companyId: f.companyId,+ agentId: f.agent.id, source: "agent_key" as const, runId: run.id } };+ }+ async function launch(f: Awaited<ReturnType<typeof seed>>, issue: Awaited<ReturnType<typeof task>>,+ options: Parameters<typeof execution>[2] = {}) {+ const current = await execution(f, issue, options);+ return { ...current, ...await resolveAndRetainRunTrustPreset(db, {+ companyId: f.companyId, agentId: f.agent.id, runId: current.run.id, agent: f.agent, issue,+ }) };+ }+ async function resolve(f: Awaited<ReturnType<typeof seed>>, issue: Awaited<ReturnType<typeof task>>, runId: string) {+ return withHumanDirectedWork(db, resolveCoreTrustPreset({ companyId: f.companyId, agent: f.agent, issue }),+ { companyId: f.companyId, agentId: f.agent.id, runId });+ }+ const resource = (issue: Awaited<ReturnType<typeof task>>) => ({ type: "issue" as const,+ companyId: issue.companyId, issueId: issue.id, projectId: issue.projectId,+ parentIssueId: issue.parentId, assigneeAgentId: issue.assigneeAgentId, status: issue.status });++ it("allows the exact human-assigned task at dispatch and tool access; retains containment on retries", async () => {+ const f = await seed(); const issue = await task(f);+ const first = await launch(f, issue, { human: true });+ expect(first.trustPreset).toMatchObject({ kind: "low_trust_review", humanDirectedIssueId: issue.id });+ expect(JSON.stringify(first.executionPolicy)).not.toContain("humanDirectedIssueId");+ const retried = await resolveAndRetainRunTrustPreset(db, { companyId: f.companyId,+ agentId: f.agent.id, runId: first.run.id, agent: f.agent, issue });+ expect(retried.trustPreset).toMatchObject(first.trustPreset);+ await expect(assertLowTrustWorkspaceIsolation({ db, resolution: first.trustPreset, issue,+ isolatedWorkspacesEnabled: true, effectiveExecutionWorkspaceMode: "isolated_workspace",+ selectedEnvironmentDriver: "sandbox" })).resolves.toBeUndefined();+ for (const action of ["issue:read", "issue:comment", "issue:mutate"] as const) {+ expect(await authorizationService(db).decide({ actor: first.actor, action, resource: resource(issue) })).toMatchObject({ allowed: true });+ }+ const unrelated = await task(f);+ expect(await authorizationService(db).decide({ actor: first.actor, action: "issue:read", resource: resource(unrelated) })).toMatchObject({ allowed: false });+ expect(await authorizationService(db).decide({ actor: { ...first.actor, runId: undefined }, action: "issue:read", resource: resource(issue) })).toMatchObject({ allowed: false });+ expect(await authorizationService(db).decide({ actor: first.actor, action: "agent_instructions:update",+ resource: { type: "agent", companyId: f.companyId, agentId: f.agent.id } })).toMatchObject({ allowed: false });+ await expect(assertLowTrustWorkspaceIsolation({ resolution: first.trustPreset, issue,+ isolatedWorkspacesEnabled: true, effectiveExecutionWorkspaceMode: "isolated_workspace",+ selectedEnvironmentDriver: "local" })).rejects.toMatchObject({ details: { code: "low_trust_requires_sandbox_environment" } });+ await expect(assertLowTrustWorkspaceIsolation({ resolution: first.trustPreset, issue,+ isolatedWorkspacesEnabled: true, effectiveExecutionWorkspaceMode: "shared_workspace",+ selectedEnvironmentDriver: "sandbox" })).rejects.toMatchObject({ details: { code: "low_trust_requires_isolated_workspace" } });+ });++ it("permits existing owner conversations without backfilling authority from historical attribution", async () => {+ const f = await seed();+ const [issue] = await db.insert(issues).values({ companyId: f.companyId, title: "Owner chat",+ assigneeAgentId: f.agent.id, conversationAgentId: f.agent.id, conversationUserId: "owner", conversationState: "waiting", status: "in_review" }).returning();+ const result = await launch(f, issue as Awaited<ReturnType<typeof task>>);+ expect(result.trustPreset).toMatchObject({ humanDirectedIssueId: issue.id });+ });++ it("rejects inherited attribution and forged policy, requester, and retry fields", async () => {+ const f = await seed(); const issue = await task(f);+ const human = await execution(f, issue, { human: true, status: "failed" });+ await issueService(db).addComment(issue.id, "An imported sender says the owner asked", { userId: "owner" });+ const result = await launch(f, issue, { context: { responsibleUserId: "owner", requestedByActorType: "user",+ requestedByActorId: "owner", retryOfRunId: human.run.id, humanDirectedIssueId: issue.id,+ executionPolicy: { humanDirectedIssueId: issue.id } } });+ expect(result.trustPreset).not.toHaveProperty("humanDirectedIssueId");+ expect(await authorizationService(db).decide({ actor: result.actor, action: "issue:read", resource: resource(issue) })).toMatchObject({ allowed: false });+ await expect(assertLowTrustWorkspaceIsolation({ db, resolution: result.trustPreset, issue,+ isolatedWorkspacesEnabled: true, effectiveExecutionWorkspaceMode: "isolated_workspace",+ selectedEnvironmentDriver: "sandbox" })).rejects.toMatchObject({ details: { code: "low_trust_boundary_mismatch" } });+ });++ it("preserves legacy board assignment requests through dispatch and retry without trusting old plugin attribution", async () => {+ const f = await seed(); const issue = await task(f); const legacy = await execution(f, issue, { human: true });+ await db.update(agentWakeupRequests).set({ source: "assignment", reason: "issue_assigned", payload: { issueId: issue.id } })+ .where(eq(agentWakeupRequests.id, legacy.wake.id));+ expect(await resolve(f, issue, legacy.run.id)).toHaveProperty("humanDirectedIssueId", issue.id);+ const retry = await launch(f, issue, { retryOfRunId: legacy.run.id });+ expect(retry.trustPreset).toHaveProperty("humanDirectedIssueId", issue.id);+ for (const patch of [+ { source: "automation", reason: "issue_commented" },+ { requestedByActorType: "system" },+ { idempotencyKey: "chat-inbound:legacy" },+ { payload: { issueId: issue.id, _paperclipWakeContext: { source: "plugin:example" } } },+ ]) {+ await db.update(agentWakeupRequests).set(patch).where(eq(agentWakeupRequests.id, legacy.wake.id));+ expect(await resolve(f, issue, legacy.run.id)).not.toHaveProperty("humanDirectedIssueId");+ expect(await resolve(f, issue, retry.run.id)).not.toHaveProperty("humanDirectedIssueId");+ await db.update(agentWakeupRequests).set({ source: "assignment", reason: "issue_assigned", requestedByActorType: "user",+ idempotencyKey: null, payload: { issueId: issue.id } }).where(eq(agentWakeupRequests.id, legacy.wake.id));+ }+ });++ it("recognizes a coalesced human request for the same run and exact task", async () => {+ const f = await seed(); const issue = await task(f); const current = await execution(f, issue);+ expect(await resolve(f, issue, current.run.id)).not.toHaveProperty("humanDirectedIssueId");+ const [coalesced] = await db.insert(agentWakeupRequests).values({ companyId: f.companyId, agentId: f.agent.id,+ runId: current.run.id, source: "assignment", status: "coalesced", requestedByActorType: "user",+ requestedByActorId: "owner", payload: { issueId: issue.id, _paperclipWakeContext: { source: "issue.update" } } }).returning();+ expect(await resolve(f, issue, current.run.id)).toHaveProperty("humanDirectedIssueId", issue.id);+ for (const patch of [+ { status: "cancelled" }, { status: "skipped" }, { requestedByActorId: " " },+ { requestedByActorType: "agent" }, { idempotencyKey: "chat-inbound:external-sender" },+ { payload: { issueId: randomUUID() } },+ { payload: { issueId: issue.id, _paperclipWakeContext: { source: "plugin:untrusted" } } },+ { payload: { issueId: issue.id } }, { companyId: randomUUID() }, { agentId: f.other.id },+ ]) {+ // Existing foreign keys require a real company for the cross-company case.+ const badCompany = patch.companyId;+ if (badCompany) await db.insert(companies).values({ id: badCompany, name: badCompany });+ await db.update(agentWakeupRequests).set(patch).where(eq(agentWakeupRequests.id, coalesced.id));+ expect(await resolve(f, issue, current.run.id)).not.toHaveProperty("humanDirectedIssueId");+ await db.update(agentWakeupRequests).set({ status: "coalesced", requestedByActorType: "user",+ requestedByActorId: "owner", idempotencyKey: null, payload: { issueId: issue.id, _paperclipWakeContext: { source: "issue.update" } },+ companyId: f.companyId, agentId: f.agent.id }).where(eq(agentWakeupRequests.id, coalesced.id));+ }+ });++ it("preserves human authority through durable retry and continuation ancestry", async () => {+ const f = await seed(); const issue = await task(f);+ const root = await execution(f, issue, { human: true, status: "failed" });+ const middle = await execution(f, issue, { retryOfRunId: root.run.id, status: "succeeded" });+ const last = await launch(f, issue, { retryOfRunId: middle.run.id });+ expect(last.trustPreset).toHaveProperty("humanDirectedIssueId", issue.id);+ expect(await authorizationService(db).decide({ actor: last.actor, action: "issue:comment", resource: resource(issue) })).toMatchObject({ allowed: true });+ await db.update(heartbeatRuns).set({ status: "cancelled", errorCode: "issue_reassigned" }).where(eq(heartbeatRuns.id, middle.run.id));+ expect(await resolve(f, issue, last.run.id)).not.toHaveProperty("humanDirectedIssueId");+ });++ it("never borrows retry authority from another task, agent, or company and terminates cycles", async () => {+ const f = await seed(); const issue = await task(f); const otherIssue = await task(f);+ const otherCompany = await seed();+ for (const scope of [+ { fixture: f, issue: otherIssue },+ { fixture: { ...f, agent: { ...f.agent, id: f.other.id } }, issue },+ { fixture: otherCompany, issue: await task(otherCompany) },+ ]) {+ const parent = await execution(scope.fixture, scope.issue, { human: true, status: "failed" });+ const child = await launch(f, issue, { retryOfRunId: parent.run.id });+ expect(child.trustPreset).not.toHaveProperty("humanDirectedIssueId");+ }+ const a = await execution(f, issue); const b = await execution(f, issue, { retryOfRunId: a.run.id });+ await db.update(heartbeatRuns).set({ retryOfRunId: b.run.id }).where(eq(heartbeatRuns.id, a.run.id));+ expect(await resolve(f, issue, a.run.id)).not.toHaveProperty("humanDirectedIssueId");+ });++ it("revokes direction in service/plugin assignment transactions even while the old run remains running", async () => {+ const f = await seed(); const issue = await task(f); const first = await execution(f, issue, { human: true });+ let release!: () => void; let ready!: () => void;+ const held = new Promise<void>((resolve) => { release = resolve; });+ const changed = new Promise<void>((resolve) => { ready = resolve; });+ const reassignment = db.transaction(async (tx) => {+ await issueService(db).update(issue.id, { assigneeAgentId: f.other.id }, tx);+ ready(); await held;+ });+ try {+ await Promise.race([changed, reassignment]);+ // With the reassignment deliberately held open, reads see the old committed+ // assignment and live run together. After commit the wake is revoked even+ // without route-level cancellation of the run.+ expect(await resolve(f, issue, first.run.id)).toHaveProperty("humanDirectedIssueId", issue.id);+ } finally { release(); await reassignment; }+ expect(await resolve(f, issue, first.run.id)).not.toHaveProperty("humanDirectedIssueId");+ await issueService(db).update(issue.id, { assigneeAgentId: f.agent.id });+ expect((await db.select().from(heartbeatRuns).where(eq(heartbeatRuns.id, first.run.id)))[0].status).toBe("running");+ expect((await db.select().from(agentWakeupRequests).where(eq(agentWakeupRequests.id, first.wake.id)))[0].status).toBe("cancelled");+ expect(await resolve(f, issue, first.run.id)).not.toHaveProperty("humanDirectedIssueId");+ const oldRetry = await launch(f, issue, { retryOfRunId: first.run.id });+ expect(oldRetry.trustPreset).not.toHaveProperty("humanDirectedIssueId");+ const automatic = await launch(f, issue);+ expect(automatic.trustPreset).not.toHaveProperty("humanDirectedIssueId");+ const human = await launch(f, issue, { human: true });+ expect(human.trustPreset).toHaveProperty("humanDirectedIssueId", issue.id);+ });++ it("a late watchdog success cannot restore a request revoked by reassignment", async () => {+ const f = await seed(); const issue = await task(f); const first = await execution(f, issue, { human: true });+ await issueService(db).update(issue.id, { assigneeAgentId: f.other.id });+ const completed = (await issueService(db).update(issue.id, { assigneeAgentId: f.agent.id, status: "done" }))!;+ const watchdog = createPostgresWatchdogAdapter(db);+ expect(await watchdog.foldSourceResolvedRun(f.companyId, {+ run: { ...first.run, sourceIssueId: issue.id },+ sourceIssue: { ...completed, isRecoveryOriginKind: false },+ evidence: { kind: "activity", id: randomUUID(), createdAt: new Date(), action: "issue.updated" },+ existingEvaluation: null, silenceStartedAt: null, silenceAgeMs: null,+ cleanup: { attempted: false, outcome: "no_process_metadata", adapterType: "paperclip_runner" }, now: new Date(),+ })).toMatchObject({ kind: "folded" });+ expect((await db.select().from(agentWakeupRequests).where(eq(agentWakeupRequests.id, first.wake.id)))[0].status).toBe("cancelled");+ const retry = await launch(f, issue, { retryOfRunId: first.run.id });+ expect(retry.trustPreset).not.toHaveProperty("humanDirectedIssueId");+ });++ it("retains backlog direction for a later system run and rejects stale or nonhuman assignment callbacks", async () => {+ const f = await seed(); const issue = await task(f);+ await retainBacklogHumanAssignment(db, issue, { actorType: "agent", actorId: "owner" });+ const automatic = await execution(f, issue);+ expect(await resolve(f, issue, automatic.run.id)).not.toHaveProperty("humanDirectedIssueId");+ await retainBacklogHumanAssignment(db, issue, { actorType: "user", actorId: "owner" });+ const promoted = (await issueService(db).update(issue.id, { status: "todo" }))!;+ expect(await resolve(f, promoted, automatic.run.id)).toHaveProperty("humanDirectedIssueId", issue.id);+ await issueService(db).update(issue.id, { assigneeAgentId: f.other.id });+ await issueService(db).update(issue.id, { assigneeAgentId: f.agent.id, status: "backlog" });+ // A delayed callback holding the original issue snapshot cannot regrant.+ await retainBacklogHumanAssignment(db, issue, { actorType: "user", actorId: "owner" });+ expect(await resolve(f, issue, automatic.run.id)).not.toHaveProperty("humanDirectedIssueId");+ });++ it("does not authorize a cancelled chat or an uncommitted human request", async () => {+ const f = await seed(); const issue = await task(f); const current = await execution(f, issue);+ await expect(db.transaction(async (tx) => {+ await tx.update(agentWakeupRequests).set({ requestedByActorType: "user", requestedByActorId: "owner" }).where(eq(agentWakeupRequests.id, current.wake.id));+ expect(await resolve(f, issue, current.run.id)).not.toHaveProperty("humanDirectedIssueId");+ throw new Error("rollback sentinel");+ })).rejects.toThrow("rollback sentinel");+ expect(await resolve(f, issue, current.run.id)).not.toHaveProperty("humanDirectedIssueId");+ await db.update(issues).set({ conversationAgentId: f.agent.id, conversationUserId: "owner", conversationState: "active" }).where(eq(issues.id, issue.id));+ expect(await resolve(f, issue, current.run.id)).toHaveProperty("humanDirectedIssueId", issue.id);+ await db.update(heartbeatRuns).set({ status: "cancelled" }).where(eq(heartbeatRuns.id, current.run.id));+ expect(await resolve(f, issue, current.run.id)).not.toHaveProperty("humanDirectedIssueId");+ });+});diff --git a/server/src/__tests__/issue-assigned-backlog-contract-routes.test.ts b/server/src/__tests__/issue-assigned-backlog-contract-routes.test.tsindex c98b523720..3df28bdcc1 100644--- a/server/src/__tests__/issue-assigned-backlog-contract-routes.test.ts+++ b/server/src/__tests__/issue-assigned-backlog-contract-routes.test.ts@@ -4,6 +4,9 @@ import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";const assigneeAgentId = "22222222-2222-4222-8222-222222222222";+const mockRetainBacklogAssignment = vi.hoisted(() => vi.fn(async () => undefined));+vi.mock("../services/human-directed-work.js", () => ({ retainBacklogHumanAssignment: mockRetainBacklogAssignment }));+const mockWakeup = vi.hoisted(() => vi.fn(async () => undefined));const mockLogActivity = vi.hoisted(() => vi.fn(async () => undefined));const mockIssueService = vi.hoisted(() => ({@@ -331,6 +334,10 @@ describe("assigned backlog creation contract", () => {assigneeAgentId,status: "backlog",}));+ expect(mockRetainBacklogAssignment).toHaveBeenCalledWith(+ expect.anything(), expect.objectContaining({ assigneeAgentId, status: "backlog" }),+ expect.objectContaining({ actorType: "user", actorId: "local-board" }),+ );expect(mockLogActivity).toHaveBeenCalledWith(expect.anything(),expect.objectContaining({diff --git a/server/src/__tests__/issue-thread-interactions-service.test.ts b/server/src/__tests__/issue-thread-interactions-service.test.tsindex 707612762e..8af1e9b98f 100644--- a/server/src/__tests__/issue-thread-interactions-service.test.ts+++ b/server/src/__tests__/issue-thread-interactions-service.test.ts@@ -257,10 +257,25 @@ describeEmbeddedPostgres("issueThreadInteractionService", () => {const scope = { id: fixture.issueId, companyId: fixture.companyId };const input = { ...questionCreateInput(fixture.runId), idempotencyKey: "chat-question" };const actor = { agentId: fixture.agentId };- const [omitted, explicit] = await Promise.all([- interactionsSvc.create(scope, input, actor),- interactionsSvc.create(scope, { ...input, addresseeUserId: fixture.userId }, actor),- ]);+ // Both callers must finish their optimistic lookup before either transaction+ // inserts, forcing the unique-conflict recovery path instead of relying on timing.+ const transaction = db.transaction.bind(db);+ let arrivals = 0;+ let release!: () => void;+ const ready = new Promise<void>(resolve => { release = resolve; });+ const gate = vi.spyOn(db, "transaction").mockImplementation(async (callback, config) => {+ if (++arrivals === 2) release();+ await ready;+ return transaction(callback, config);+ });+ let omitted!: Awaited<ReturnType<typeof interactionsSvc.create>>;+ let explicit!: Awaited<ReturnType<typeof interactionsSvc.create>>;+ try {+ [omitted, explicit] = await Promise.all([+ interactionsSvc.create(scope, input, actor),+ interactionsSvc.create(scope, { ...input, addresseeUserId: fixture.userId }, actor),+ ]);+ } finally { gate.mockRestore(); }expect(explicit.id).toBe(omitted.id);expect(explicit.addresseeUserId).toBe(fixture.userId);expect(await db.select().from(issueThreadInteractions)).toHaveLength(1);diff --git a/server/src/__tests__/low-trust-red-team-routes.test.ts b/server/src/__tests__/low-trust-red-team-routes.test.tsindex 5fb90ce480..b565f4a6eb 100644--- a/server/src/__tests__/low-trust-red-team-routes.test.ts+++ b/server/src/__tests__/low-trust-red-team-routes.test.ts@@ -7,6 +7,7 @@ import { and, eq } from "drizzle-orm";import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";import {activityLog,+ authUsers,agentWakeupRequests,agentRuntimeState,agents,@@ -49,6 +50,7 @@ import { drainHeartbeatRunsToQuiescence } from "./helpers/drain-heartbeat-runs.jimport { errorHandler } from "../middleware/index.js";import { agentRoutes } from "../routes/agents.js";import { issueRoutes } from "../routes/issues.js";+import { issueService } from "../services/issues.js";import { heartbeatService } from "../services/heartbeat.js";import { LOW_TRUST_QUARANTINED_BODY } from "../services/source-trust.js";@@ -914,6 +916,7 @@ describeEmbeddedPostgres(await db.delete(agentRuntimeState);await db.delete(principalPermissionGrants);await db.delete(companyMemberships);+ await db.delete(authUsers);await db.delete(agents);await db.delete(projects);await deleteCompanySkillsAfterLateHeartbeatWritesDrain(db);@@ -923,6 +926,113 @@ describeEmbeddedPostgres(await tempDb?.cleanup();});+ it("allows the human-requested run through HTTP while rejecting attribution-only authority", async () => {+ const fixture = await seedLowTrustFixture(db);+ await db.insert(authUsers).values({ id: "board-user", name: "Owner", email: "[email protected]", createdAt: new Date(), updatedAt: new Date() });+ await db.insert(companyMemberships).values({ companyId: fixture.company.id, principalType: "user", principalId: "board-user", membershipRole: "owner", status: "active" });+ // The fixture already occupies the agent's sole execution slot. Let the+ // real board route enqueue work, then bind its queued run for HTTP checks.+ await db.update(agents).set({ runtimeConfig: { heartbeat: { wakeOnDemand: true, maxConcurrentRuns: 1 } } })+ .where(eq(agents.id, fixture.agents.lowTrust.id));+ const board = createApp(db, boardActor(fixture));+ const created = await request(board).post(`/api/companies/${fixture.company.id}/issues`)+ .send({ title: "Human assigned outside intake", status: "todo", assigneeAgentId: fixture.agents.lowTrust.id });+ expect(created.status, JSON.stringify(created.body)).toBe(201);+ const queued = () => db.select().from(agentWakeupRequests).where(and(+ eq(agentWakeupRequests.companyId, fixture.company.id),+ eq(agentWakeupRequests.agentId, fixture.agents.lowTrust.id),+ )).then(rows => rows.find(row => row.payload?.issueId === created.body.id && row.runId));+ await waitFor(async () => Boolean(await queued()));+ const wake = (await queued())!;+ expect(wake).toMatchObject({ requestedByActorType: "user", requestedByActorId: "board-user" });+ const [directRun] = await db.update(heartbeatRuns).set({ status: "running" })+ .where(eq(heartbeatRuns.id, wake.runId!)).returning();+ await db.update(issues).set({ status: "in_progress", checkoutRunId: directRun.id, executionRunId: directRun.id })+ .where(eq(issues.id, created.body.id));+ const directedAgent = createApp(db, { ...agentActor(fixture), runId: directRun.id });+ const read = await request(directedAgent).get(`/api/issues/${created.body.id}`);+ expect(read.status, JSON.stringify(read.body)).toBe(200);+ const reply = await request(directedAgent).post(`/api/issues/${created.body.id}/comments`)+ .send({ body: "I can work on this human-directed task" });+ expect(reply.status, JSON.stringify(reply.body)).toBe(201);+ expect(reply.body.sourceTrust).toMatchObject({ preset: LOW_TRUST_REVIEW_PRESET, disposition: "quarantined" });+ const updated = await request(directedAgent).patch(`/api/issues/${created.body.id}`)+ .send({ description: "Completed the requested analysis" });+ expect(updated.status, JSON.stringify(updated.body)).toBe(200);+ expect(updated.body.description).toBe("Completed the requested analysis");+ // The human requester does not authorize reads outside this run's task.+ const foreignRead = await request(directedAgent).get(`/api/issues/${fixture.issues.siblingOutOfScope.id}`);+ expect([403, 404]).toContain(foreignRead.status);+ expectNoCanary(foreignRead.body, fixture.canaries.issueSibling);++ await db.update(agentWakeupRequests).set({ requestedByActorType: "agent", requestedByActorId: fixture.agents.collaborator.id })+ .where(eq(agentWakeupRequests.id, wake.id));+ const forgedRead = await request(directedAgent).get(`/api/issues/${created.body.id}`);+ expect([403, 404]).toContain(forgedRead.status);++ await db.update(agentWakeupRequests).set({ requestedByActorType: "user", requestedByActorId: "board-user" })+ .where(eq(agentWakeupRequests.id, wake.id));+ const handoff = await request(directedAgent).patch(`/api/issues/${created.body.id}`)+ .send({ status: "in_review", assigneeAgentId: null, assigneeUserId: "board-user", comment: "Ready for human review" });+ expect(handoff.status, JSON.stringify(handoff.body)).toBe(200);+ const [stopped] = await db.select().from(heartbeatRuns).where(eq(heartbeatRuns.id, directRun.id));+ expect(stopped).toMatchObject({ status: "cancelled", errorCode: "issue_reassigned" });+ const returned = await request(board).patch(`/api/issues/${created.body.id}`)+ .send({ status: "backlog", assigneeAgentId: fixture.agents.lowTrust.id, assigneeUserId: null });+ expect(returned.status, JSON.stringify(returned.body)).toBe(200);+ // Reassignment back does not revive the cancelled run's human request.+ const staleRead = await request(directedAgent).get(`/api/issues/${created.body.id}`);+ expect([403, 404]).toContain(staleRead.status);++ });++ it("retains a board backlog assignment and rejects plugin-attributed wakes with forged board payloads", async () => {+ const fixture = await seedLowTrustFixture(db);+ await db.insert(authUsers).values({ id: "board-user", name: "Owner", email: "[email protected]", createdAt: new Date(), updatedAt: new Date() });+ await db.insert(companyMemberships).values({ companyId: fixture.company.id, principalType: "user", principalId: "board-user", membershipRole: "owner", status: "active" });+ await db.update(agents).set({ runtimeConfig: { heartbeat: { wakeOnDemand: true, maxConcurrentRuns: 1 } } })+ .where(eq(agents.id, fixture.agents.lowTrust.id));+ const board = createApp(db, boardActor(fixture));+ const created = await request(board).post(`/api/companies/${fixture.company.id}/issues`)+ .send({ title: "Human backlog assignment", status: "backlog", assigneeAgentId: fixture.agents.lowTrust.id });+ expect(created.status, JSON.stringify(created.body)).toBe(201);+ const receipts = await db.select().from(agentWakeupRequests).where(eq(agentWakeupRequests.companyId, fixture.company.id));+ expect(receipts.filter(w => w.payload?.issueId === created.body.id)).toEqual([expect.objectContaining({+ reason: "issue_human_assignment", status: "completed", runId: null, requestedByActorId: "board-user",+ })]);+ await issueService(db).update(created.body.id, { status: "todo" });+ const systemRun = await heartbeatService(db).wakeup(fixture.agents.lowTrust.id, {+ source: "automation", reason: "issue_ready", requestedByActorType: "system",+ payload: { issueId: created.body.id }, contextSnapshot: { issueId: created.body.id, source: "automatic_promotion" },+ });+ expect(systemRun).toBeTruthy();+ await db.update(heartbeatRuns).set({ status: "running" }).where(eq(heartbeatRuns.id, systemRun!.id));+ const worker = createApp(db, { ...agentActor(fixture), runId: systemRun!.id });+ expect((await request(worker).get(`/api/issues/${created.body.id}`)).status).toBe(200);+ // These are the same service calls used by plugin issues.update; no HTTP+ // cancellation is involved, and the run is deliberately left running.+ await issueService(db).update(created.body.id, { assigneeAgentId: fixture.agents.collaborator.id });+ await issueService(db).update(created.body.id, { assigneeAgentId: fixture.agents.lowTrust.id });+ expect([403, 404]).toContain((await request(worker).get(`/api/issues/${created.body.id}`)).status);+ const pluginRun = await heartbeatService(db).wakeup(fixture.agents.lowTrust.id, {+ source: "automation", reason: "issue_commented", requestedByActorType: "user", requestedByActorId: "board-user",+ payload: { issueId: created.body.id, _paperclipWakeContext: { source: "issue.comment" } },+ contextSnapshot: { issueId: created.body.id, source: "plugin:example" },+ });+ expect(pluginRun).toBeTruthy();+ const pluginWake = (await db.select().from(agentWakeupRequests).where(eq(agentWakeupRequests.runId, pluginRun!.id)))+ .find(w => w.requestedByActorType === "user")!;+ expect(pluginWake.payload?._paperclipWakeContext).toMatchObject({ source: "plugin:example" });+ await db.update(heartbeatRuns).set({ status: "running" }).where(eq(heartbeatRuns.id, pluginRun!.id));+ const pluginWorker = createApp(db, { ...agentActor(fixture), runId: pluginRun!.id });+ expect([403, 404]).toContain((await request(pluginWorker).get(`/api/issues/${created.body.id}`)).status);+ // Authenticated reassignment while still in backlog also retains direction.+ const assigned = await request(board).patch(`/api/issues/${created.body.id}`)+ .send({ status: "backlog", assigneeAgentId: fixture.agents.lowTrust.id });+ expect(assigned.status, JSON.stringify(assigned.body)).toBe(200);+ expect((await request(pluginWorker).get(`/api/issues/${created.body.id}`)).status).toBe(200);+ });+it("allows bounded same-issue reads and writes while quarantining low-trust output", async () => {const fixture = await seedLowTrustFixture(db);const app = createApp(db, agentActor(fixture));diff --git a/server/src/modules/active-run-watchdog/adapters/postgres.ts b/server/src/modules/active-run-watchdog/adapters/postgres.tsindex 126bd70a39..ac46b6c095 100644--- a/server/src/modules/active-run-watchdog/adapters/postgres.ts+++ b/server/src/modules/active-run-watchdog/adapters/postgres.ts@@ -1,4 +1,4 @@-import { and, asc, desc, eq, gt, gte, inArray, notInArray, sql } from "drizzle-orm";+import { and, asc, desc, eq, gt, gte, inArray, ne, notInArray, sql } from "drizzle-orm";import type { Db } from "@paperclipai/db";import {agents,@@ -337,6 +337,8 @@ export function createPostgresWatchdogAdapter(db: Db): WatchdogRunReader & Watch.where(and(eq(agentWakeupRequests.id, input.run.wakeupRequestId),eq(agentWakeupRequests.companyId, companyId),+ // A late success fold cannot restore cancelled assignment authority.+ ne(agentWakeupRequests.status, "cancelled"),));}diff --git a/server/src/routes/issues.ts b/server/src/routes/issues.tsindex 2b00cc1b0d..35c467d91e 100644--- a/server/src/routes/issues.ts+++ b/server/src/routes/issues.ts@@ -252,6 +252,7 @@ import {normalizeUploadAttachmentContentType,SVG_CONTENT_TYPE,} from "../attachment-types.js";+import { retainBacklogHumanAssignment } from "../services/human-directed-work.js";import { queueIssueAssignmentWakeup } from "../services/issue-assignment-wakeup.js";import { shouldWakeAssigneeForIssueComment } from "../services/issue-comment-wakeup.js";import { createSecretProposalsService } from "../services/secret-proposals.js";@@ -11816,6 +11817,7 @@ export function issueRoutes(});return;}+ await retainBacklogHumanAssignment(db, issue, actor);await issueReferencesSvc.syncIssue(issue.id);await externalObjectsSvc.syncIssueSafely(issue.id);const referenceSummary =@@ -12215,6 +12217,7 @@ export function issueRoutes(});}+ await retainBacklogHumanAssignment(db, issue, actor);if (!serializationContext || !currentSerializedChild) {void queueIssueAssignmentWakeup({heartbeat,@@ -12474,6 +12477,7 @@ export function issueRoutes(});}+ await retainBacklogHumanAssignment(db, issue, actor);if (!serializedBlockedChildIds.has(issue.id)) {void queueIssueAssignmentWakeup({heartbeat,@@ -13818,6 +13822,10 @@ export function issueRoutes(}}+ if (req.body.assigneeAgentId !== undefined) {+ await retainBacklogHumanAssignment(db, issue, actor);+ }+if (titleOrDescriptionChanged) {await issueReferencesSvc.syncIssue(issue.id);await externalObjectsSvc.syncIssueSafely(issue.id);diff --git a/server/src/services/authorization.ts b/server/src/services/authorization.tsindex ed1719e028..c3362a2002 100644--- a/server/src/services/authorization.ts+++ b/server/src/services/authorization.ts@@ -1,5 +1,6 @@import { and, eq, inArray, isNull, sql } from "drizzle-orm";import type { Db } from "@paperclipai/db";+import { withHumanDirectedWork } from "./human-directed-work.js";import {agents,authUsers,@@ -873,13 +874,17 @@ export function authorizationService(db: Db | DbTransaction) {}): Promise<TrustPresetResolution> {const { issue, project } = await loadResourceContext(input.resource);const run = await loadRunPolicy(input.actor.runId, input.companyId, input.actorAgent.id);- return resolveCoreTrustPreset({+ const resolution = resolveCoreTrustPreset({companyId: input.companyId,agent: input.actorAgent,project,issue,run,});+ if (!input.actor.runId || resolution.kind !== "low_trust_review") return resolution;+ return withHumanDirectedWork(db, resolution, {+ companyId: input.companyId, agentId: input.actorAgent.id, runId: input.actor.runId,+ });}async function issueIdIsDescendantOf(issueId: string, rootIssueId: string, companyId: string) {@@ -1036,6 +1041,10 @@ export function authorizationService(db: Db | DbTransaction) {if (input.resource.type !== "issue") {return lowTrustDeny("Low-trust issue access is missing an issue resource.");}+ if (input.resolution.humanDirectedIssueId && input.resource.companyId === boundary.companyId &&+ input.resource.issueId === input.resolution.humanDirectedIssueId) {+ return lowTrustAllow("Allowed on the exact task directed by an authenticated human.");+ }if (input.action === "issue:comment" && input.directParentReportTarget) {if (input.resource.issueId &&diff --git a/server/src/services/heartbeat.ts b/server/src/services/heartbeat.tsindex 6cce1f365e..57f0c5fa5b 100644--- a/server/src/services/heartbeat.ts+++ b/server/src/services/heartbeat.ts@@ -13126,7 +13126,9 @@ export function heartbeatService(await db.update(agentWakeupRequests).set({ status, ...patch, updatedAt: new Date() })- .where(eq(agentWakeupRequests.id, wakeupRequestId));+ // Reassignment revokes requests transactionally. Late execution settlement+ // must not turn a revoked request back into authority for a later retry.+ .where(and(eq(agentWakeupRequests.id, wakeupRequestId), ne(agentWakeupRequests.status, "cancelled")));}async function addContinuationExhaustedCommentOnce(input: {@@ -17191,6 +17193,7 @@ export function heartbeatService(eq(agentWakeupRequests.companyId, current.companyId),eq(agentWakeupRequests.agentId, current.agentId),eq(agentWakeupRequests.runId, current.id),+ ne(agentWakeupRequests.status, "cancelled"),),);await tx@@ -17929,7 +17932,7 @@ export function heartbeatService(await tx.update(agentWakeupRequests).set({ status: "queued", claimedAt: null, updatedAt: now })- .where(eq(agentWakeupRequests.id, released.wakeupRequestId));+ .where(and(eq(agentWakeupRequests.id, released.wakeupRequestId), ne(agentWakeupRequests.status, "cancelled")));}const context = parseObject(released.contextSnapshot);@@ -26700,6 +26703,10 @@ export function heartbeatService(triggerDetail,payload,});+ // Keep each request's own server-derived origin, including coalesced wakes.+ // A run's merged context cannot establish which caller authored one receipt.+ // Overwrite caller-supplied nested context rather than trusting it.+ payload = { ...payload, [DEFERRED_WAKE_CONTEXT_KEY]: { ...enrichedContextSnapshot } };let issueId =readNonEmptyString(enrichedContextSnapshot.issueId) ?? issueIdFromPayload;if (executionReconciliationWake && !issueId) return null;diff --git a/server/src/services/human-directed-work.ts b/server/src/services/human-directed-work.tsnew file mode 100644index 0000000000..477aaaad20--- /dev/null+++ b/server/src/services/human-directed-work.ts@@ -0,0 +1,94 @@+import { and, eq, sql } from "drizzle-orm";+import { agentWakeupRequests, issues } from "@paperclipai/db";+import type { Db } from "@paperclipai/db";+import type { TrustPresetResolution } from "./trust-preset-resolver.js";++/**+ * Derive exact-task authority from existing server-owned execution records.+ * Responsible-user attribution alone is insufficient: it is also inherited by+ * agent-created work. Never read authority or retry ancestry from tool payloads.+ */+export async function withHumanDirectedWork(+ db: Pick<Db, "execute">,+ resolution: TrustPresetResolution,+ input: { companyId: string; agentId: string; runId: string },+): Promise<TrustPresetResolution> {+ if (resolution.kind !== "low_trust_review" ||+ resolution.boundary.companyId !== input.companyId) return resolution;++ // One snapshot binds the live run, current assignee, and authenticated wake.+ // Reassignment cancels the old request records in the assignment transaction.+ // Neither those records nor cancelled executions can lend authority to retries.+ // UNION deduplicates rows so a malformed retry cycle terminates without a cap.+ const [issue] = await db.execute<{ id: string }>(sql`+ WITH RECURSIVE current_task AS (+ SELECT i.id, i.conversation_agent_id, i.conversation_user_id, r.id AS run_id+ FROM heartbeat_runs r+ JOIN issues i ON i.id::text = coalesce(r.context_snapshot->>'issueId', r.context_snapshot->>'taskId')+ AND i.company_id = r.company_id AND i.assignee_agent_id = r.agent_id+ WHERE r.id = ${input.runId}::uuid AND r.company_id = ${input.companyId}::uuid+ AND r.agent_id = ${input.agentId}::uuid AND r.status = 'running'+ ), task_runs AS (+ SELECT r.id, r.retry_of_run_id+ FROM heartbeat_runs r JOIN current_task t ON t.run_id = r.id+ UNION+ SELECT parent.id, parent.retry_of_run_id+ FROM heartbeat_runs parent JOIN task_runs child ON parent.id = child.retry_of_run_id+ JOIN current_task t ON t.id::text = coalesce(parent.context_snapshot->>'issueId', parent.context_snapshot->>'taskId')+ WHERE parent.company_id = ${input.companyId}::uuid AND parent.agent_id = ${input.agentId}::uuid+ AND parent.status <> 'cancelled'+ )+ SELECT t.id FROM current_task t+ WHERE (t.conversation_agent_id = ${input.agentId}::uuid AND t.conversation_user_id IS NOT NULL)+ OR EXISTS (+ SELECT 1 FROM agent_wakeup_requests w+ WHERE (w.run_id IN (SELECT id FROM task_runs) OR+ (w.run_id IS NULL AND w.reason = 'issue_human_assignment' AND w.status = 'completed'))+ AND w.company_id = ${input.companyId}::uuid AND w.agent_id = ${input.agentId}::uuid+ AND w.requested_by_actor_type = 'user' AND nullif(trim(w.requested_by_actor_id), '') IS NOT NULL+ AND w.status NOT IN ('skipped', 'cancelled')+ -- The source is copied from server-owned context at admission, never+ -- from caller payloads. Plugins can attribute a user but use plugin: sources.+ AND (w.payload->'_paperclipWakeContext'->>'source' LIKE 'issue.%'+ -- Before origin snapshots were retained, board assignment requests+ -- already had this closed source/reason/actor combination. Plugin+ -- assignment wakes are system-attributed; plugin human comments are+ -- automation wakes. External connector receipts are excluded below.+ OR (NOT (w.payload ? '_paperclipWakeContext')+ AND w.source = 'assignment' AND w.reason = 'issue_assigned'))+ AND coalesce(w.payload->>'issueId', w.payload->>'taskId',+ w.payload->'_paperclipWakeContext'->>'issueId', w.payload->'_paperclipWakeContext'->>'taskId') = t.id::text+ -- Connector sender attribution can also use a user id. Its durable+ -- inbound receipts are not authenticated board instructions.+ AND (w.idempotency_key IS NULL OR w.idempotency_key NOT LIKE 'chat-inbound:%')+ )+ `);+ return issue ? { ...resolution, humanDirectedIssueId: issue.id } : resolution;+}++/** Preserve a board assignment made before a task is runnable, without starting it.+ * Uses the existing requester columns, not another user identity or grant table.+ * Call only with the authenticated HTTP actor and the committed write result.+ */+export async function retainBacklogHumanAssignment(+ db: Db,+ issue: { id: string; companyId: string; assigneeAgentId: string | null; status: string; statusVersion: number },+ actor: { actorType: string; actorId: string },+) {+ if (actor.actorType !== "user" || !actor.actorId.trim() || issue.status !== "backlog" || !issue.assigneeAgentId) return;+ await db.transaction(async (tx) => {+ // An assignment that changed (even A -> B -> A) before this callback cannot+ // revive stale direction. Reassignment and this receipt share the issue lock.+ const [current] = await tx.select({ id: issues.id }).from(issues).where(and(+ eq(issues.id, issue.id), eq(issues.companyId, issue.companyId),+ eq(issues.assigneeAgentId, issue.assigneeAgentId!), eq(issues.statusVersion, issue.statusVersion),+ )).for("update");+ if (!current) return;+ await tx.insert(agentWakeupRequests).values({+ companyId: issue.companyId, agentId: issue.assigneeAgentId!, source: "assignment",+ reason: "issue_human_assignment", status: "completed", finishedAt: new Date(),+ requestedByActorType: "user", requestedByActorId: actor.actorId,+ payload: { issueId: issue.id, _paperclipWakeContext: { source: "issue.backlog_assignment" } },+ });+ });+}diff --git a/server/src/services/issue-thread-interactions.ts b/server/src/services/issue-thread-interactions.tsindex 4e5a9e7154..7ff415d525 100644--- a/server/src/services/issue-thread-interactions.ts+++ b/server/src/services/issue-thread-interactions.ts@@ -2,6 +2,7 @@ import {currentContinuationOrigins,deliveredContinuationCommentIds,} from "./execution-continuation.js";+import { isUniqueViolation } from "../db-errors.js";import { assertAgentRunWriteAllowed } from "../agent-run-cancellation.js";import { connectionIntentDeliveries } from "@paperclipai/db";import { isDeepStrictEqual } from "node:util";@@ -583,20 +584,6 @@ function isUserCommentSupersedableKind().includes(kind);}-function isIssueThreadInteractionIdempotencyConflict(error: unknown): boolean {- if (typeof error !== "object" || error === null) return false;- const err = error as {- code?: string;- constraint?: string;- constraint_name?: string;- };- const constraint = err.constraint ?? err.constraint_name;- return (- err.code === "23505" &&- constraint === ISSUE_THREAD_INTERACTION_IDEMPOTENCY_CONSTRAINT- );-}-function isEquivalentCreateRequest(row: IssueThreadInteractionRow,input: CreateIssueThreadInteraction,@@ -3730,7 +3717,7 @@ export function issueThreadInteractionService(} catch (error) {if (!normalizedData.idempotencyKey ||- !isIssueThreadInteractionIdempotencyConflict(error)+ !isUniqueViolation(error, ISSUE_THREAD_INTERACTION_IDEMPOTENCY_CONSTRAINT)) {throw error;}diff --git a/server/src/services/issues.ts b/server/src/services/issues.tsindex 18585836a4..0e6c861193 100644--- a/server/src/services/issues.ts+++ b/server/src/services/issues.ts@@ -10950,6 +10950,15 @@ export function issueService(db: Db) {if ((issueData.assigneeAgentId !== undefined && issueData.assigneeAgentId !== receiptExisting.assigneeAgentId)|| (issueData.assigneeUserId !== undefined && issueData.assigneeUserId !== receiptExisting.assigneeUserId)) {patch.statusVersion = sql`${issues.statusVersion} + 1` as unknown as number;+ // Invalidate human direction at the common assignment boundary, including+ // plugin/service writes that do not go through HTTP run cancellation.+ // Keep the requester attribution for audit; cancellation revokes its use.+ await tx.update(agentWakeupRequests).set({ status: "cancelled", finishedAt: new Date(), updatedAt: new Date() })+ .where(and(eq(agentWakeupRequests.companyId, receiptExisting.companyId),+ eq(agentWakeupRequests.requestedByActorType, "user"),+ sql`coalesce(${agentWakeupRequests.payload}->>'issueId', ${agentWakeupRequests.payload}->>'taskId',+ ${agentWakeupRequests.payload}->'_paperclipWakeContext'->>'issueId',+ ${agentWakeupRequests.payload}->'_paperclipWakeContext'->>'taskId') = ${id}`));}// Reasserting Blocked or changing its blockers is a fresh decision even// when the status string stays the same. Invalidate recovery's priordiff --git a/server/src/services/low-trust-runtime-containment.ts b/server/src/services/low-trust-runtime-containment.tsindex 22ce04d6d9..613123f562 100644--- a/server/src/services/low-trust-runtime-containment.ts+++ b/server/src/services/low-trust-runtime-containment.ts@@ -69,6 +69,8 @@ export async function assertLowTrustWorkspaceIsolation(input: {}if (!input.issue ||+ !(input.resolution.humanDirectedIssueId && input.issue.companyId === input.resolution.boundary.companyId &&+ input.issue.id === input.resolution.humanDirectedIssueId) &&!(await workspaceIssueWithinLowTrustBoundary({db: input.db,boundary: input.resolution.boundary,diff --git a/server/src/services/run-trust-preset.ts b/server/src/services/run-trust-preset.tsindex 20cf0da92b..b02094114c 100644--- a/server/src/services/run-trust-preset.ts+++ b/server/src/services/run-trust-preset.ts@@ -1,6 +1,7 @@import { and, eq, sql } from "drizzle-orm";import { heartbeatRuns, type Db } from "@paperclipai/db";import { conflict } from "../errors.js";+import { withHumanDirectedWork } from "./human-directed-work.js";import {resolveCoreTrustPreset,type ResolveCoreTrustPresetInput,@@ -61,6 +62,9 @@ export async function resolveAndRetainRunTrustPreset(updatedAt: new Date(),}).where(scope);- return { trustPreset, executionPolicy };+ return { trustPreset: await withHumanDirectedWork(tx, trustPreset, {+ companyId: input.companyId, agentId: input.agentId,+ runId: input.runId,+ }), executionPolicy };});}diff --git a/server/src/services/trust-preset-resolver.ts b/server/src/services/trust-preset-resolver.tsindex 97529840bc..7b0ab3b7f6 100644--- a/server/src/services/trust-preset-resolver.ts+++ b/server/src/services/trust-preset-resolver.ts@@ -53,6 +53,8 @@ export type TrustPresetResolution =| {kind: "low_trust_review";preset: typeof LOW_TRUST_REVIEW_PRESET;+ /** Server-derived authority for this run's exact task; never a policy input. */+ humanDirectedIssueId?: string;boundary: LowTrustBoundary & { companyId: string };sourcePresets: Partial<Record<TrustPresetPolicySource, TrustPreset>>;}