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(server): refuse agent delegation cycles back to an open ancestor's creator (#10658)
Devin Foleyddbcf53e312d
diff --git a/server/src/__tests__/issue-assignee-invokability-routes.test.ts b/server/src/__tests__/issue-assignee-invokability-routes.test.tsindex 8fff514a23..a52310427d 100644--- a/server/src/__tests__/issue-assignee-invokability-routes.test.ts+++ b/server/src/__tests__/issue-assignee-invokability-routes.test.ts@@ -14,6 +14,7 @@ const agentStatusById: Record<string, string> = {const mockIssueService = vi.hoisted(() => ({getById: vi.fn(),+ findOpenAncestorCreatedByAgent: vi.fn(),update: vi.fn(),create: vi.fn(),createChild: vi.fn(),@@ -148,6 +149,18 @@ function agentActor(): Actor {};}+// Minimal chainable/thenable db stub: any query resolves to an empty row set.+// Needed because some route paths (e.g. source-trust resolution for agent+// actors) query the db directly rather than through the mocked services.+function stubDb(): any {+ const query: any = {};+ for (const method of ["select", "from", "where", "innerJoin", "leftJoin", "orderBy", "limit", "groupBy", "for"]) {+ query[method] = () => query;+ }+ query.then = (resolve: (rows: unknown[]) => unknown) => Promise.resolve(resolve([]));+ return { select: () => query };+}+function createApp(actor: Actor) {const app = express();app.use(express.json());@@ -155,7 +168,7 @@ function createApp(actor: Actor) {(req as any).actor = actor;next();});- app.use("/api", issueRoutes({} as any, {} as any));+ app.use("/api", issueRoutes(stubDb() as any, {} as any));app.use(errorHandler);return app;}@@ -184,6 +197,8 @@ function makeIssue(overrides: Record<string, unknown> = {}) {describe("issue assignee invokability guard", () => {beforeEach(() => {mockIssueService.getById.mockReset();+ mockIssueService.findOpenAncestorCreatedByAgent.mockReset();+ mockIssueService.findOpenAncestorCreatedByAgent.mockResolvedValue(null);mockIssueService.update.mockReset();mockIssueService.create.mockReset();mockIssueService.createChild.mockReset();@@ -250,3 +265,79 @@ describe("issue assignee invokability guard", () => {expect(mockIssueService.update).toHaveBeenCalled();});});++describe("agent delegation cycle guard", () => {+ beforeEach(() => {+ mockIssueService.getById.mockReset();+ mockIssueService.findOpenAncestorCreatedByAgent.mockReset();+ mockIssueService.findOpenAncestorCreatedByAgent.mockResolvedValue(null);+ mockIssueService.create.mockReset();+ mockIssueService.createChild.mockReset();+ });++ it("refuses an agent child assigned to the creator of an open ancestor", async () => {+ const parent = makeIssue();+ mockIssueService.getById.mockResolvedValue(parent);+ mockIssueService.findOpenAncestorCreatedByAgent.mockResolvedValue({+ id: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",+ identifier: "PAP-100",+ parentId: null,+ createdByAgentId: IDLE_AGENT_ID,+ status: "in_progress",+ });++ const res = await request(createApp(agentActor()))+ .post(`/api/issues/${parent.id}/children`)+ .send({+ title: "Hand it back",+ description: "Bounce",+ assigneeAgentId: IDLE_AGENT_ID,+ });++ expect(res.status).toBe(409);+ expect(res.body.error).toContain("Delegation cycle");+ expect(res.body.details).toMatchObject({ code: "delegation_cycle" });+ expect(mockIssueService.createChild).not.toHaveBeenCalled();+ expect(mockIssueService.findOpenAncestorCreatedByAgent).toHaveBeenCalledWith(parent.id, IDLE_AGENT_ID);+ });++ it("allows the same child when no open ancestor was created by the assignee", async () => {+ const parent = makeIssue();+ mockIssueService.getById.mockResolvedValue(parent);+ mockIssueService.createChild.mockResolvedValue({+ issue: makeIssue({ id: "cccccccc-cccc-4ccc-8ccc-cccccccccccc", parentId: parent.id, assigneeAgentId: IDLE_AGENT_ID }),+ parentBlockerAdded: false,+ });++ const res = await request(createApp(agentActor()))+ .post(`/api/issues/${parent.id}/children`)+ .send({+ title: "Legit subtask",+ description: "Fine",+ assigneeAgentId: IDLE_AGENT_ID,+ });++ expect(res.status).toBe(201);+ expect(mockIssueService.createChild).toHaveBeenCalled();+ });++ it("does not consult the guard for board actors", async () => {+ const parent = makeIssue({ assigneeAgentId: null });+ mockIssueService.getById.mockResolvedValue(parent);+ mockIssueService.createChild.mockResolvedValue({+ issue: makeIssue({ id: "dddddddd-dddd-4ddd-8ddd-dddddddddddd", parentId: parent.id, assigneeAgentId: IDLE_AGENT_ID }),+ parentBlockerAdded: false,+ });++ const res = await request(createApp(boardActor()))+ .post(`/api/issues/${parent.id}/children`)+ .send({+ title: "Human-created child",+ description: "Deliberate",+ assigneeAgentId: IDLE_AGENT_ID,+ });++ expect(res.status).toBe(201);+ expect(mockIssueService.findOpenAncestorCreatedByAgent).not.toHaveBeenCalled();+ });+});diff --git a/server/src/__tests__/issue-execution-policy-routes.test.ts b/server/src/__tests__/issue-execution-policy-routes.test.tsindex 7302f13264..214f231c93 100644--- a/server/src/__tests__/issue-execution-policy-routes.test.ts+++ b/server/src/__tests__/issue-execution-policy-routes.test.ts@@ -5,6 +5,7 @@ import { normalizeIssueExecutionPolicy } from "../services/issue-execution-policconst mockIssueService = vi.hoisted(() => ({getById: vi.fn(),+ findOpenAncestorCreatedByAgent: vi.fn(async () => null),assertCheckoutOwner: vi.fn(),update: vi.fn(),createChild: vi.fn(),diff --git a/server/src/__tests__/issues-service.test.ts b/server/src/__tests__/issues-service.test.tsindex e3069cdb6a..fe97cc4b75 100644--- a/server/src/__tests__/issues-service.test.ts+++ b/server/src/__tests__/issues-service.test.ts@@ -2451,6 +2451,127 @@ describeEmbeddedPostgres("issueService.list participantAgentId", () => {});});+describeEmbeddedPostgres("issueService.findOpenAncestorCreatedByAgent", () => {+ let db!: ReturnType<typeof createDb>;+ let svc!: ReturnType<typeof issueService>;+ let tempDb: Awaited<ReturnType<typeof startEmbeddedPostgresTestDatabase>> | null = null;++ beforeAll(async () => {+ tempDb = await startEmbeddedPostgresTestDatabase("paperclip-issues-ancestor-");+ db = createDb(tempDb.connectionString);+ svc = issueService(db);+ await ensureIssueRelationsTable(db);+ }, 20_000);++ afterEach(async () => {+ await db.delete(issues);+ await db.delete(agents);+ await db.delete(companies);+ });++ afterAll(async () => {+ await tempDb?.cleanup();+ });++ async function seedChain() {+ const companyId = randomUUID();+ const delegatorId = randomUUID();+ await db.insert(companies).values({+ id: companyId,+ name: "Chain Co",+ issuePrefix: `C${companyId.replace(/-/g, "").slice(0, 6).toUpperCase()}`,+ requireBoardApprovalForNewAgents: false,+ });+ await db.insert(agents).values({+ id: delegatorId,+ companyId,+ name: "Delegator",+ role: "engineer",+ status: "idle",+ adapterType: "codex_local",+ adapterConfig: {},+ runtimeConfig: {},+ permissions: {},+ });+ const rootId = randomUUID();+ const midId = randomUUID();+ await db.insert(issues).values([+ {+ id: rootId,+ companyId,+ title: "Root task",+ status: "in_progress",+ priority: "medium",+ issueNumber: 1,+ identifier: "CHAIN-1",+ },+ {+ id: midId,+ companyId,+ title: "Delegated review",+ status: "in_progress",+ priority: "medium",+ parentId: rootId,+ createdByAgentId: delegatorId,+ issueNumber: 2,+ identifier: "CHAIN-2",+ },+ ]);+ return { companyId, delegatorId, rootId, midId };+ }++ it("finds an open ancestor created by the agent, at any depth", async () => {+ const { delegatorId, midId } = await seedChain();++ const direct = await svc.findOpenAncestorCreatedByAgent(midId, delegatorId);+ expect(direct?.id).toBe(midId);++ const other = await svc.findOpenAncestorCreatedByAgent(midId, randomUUID());+ expect(other).toBeNull();+ });++ it("ignores closed ancestors created by the agent", async () => {+ const { delegatorId, midId } = await seedChain();+ await db.update(issues).set({ status: "done" }).where(eq(issues.id, midId));++ expect(await svc.findOpenAncestorCreatedByAgent(midId, delegatorId)).toBeNull();+ });++ it("finds the ancestor through an arbitrarily deep chain", async () => {+ const { companyId, delegatorId, midId } = await seedChain();+ // Extend the chain 60 levels below the delegator-created ancestor so the+ // match sits far above the new child's parent.+ let parentId = midId;+ for (let index = 0; index < 60; index += 1) {+ const childId = randomUUID();+ await db.insert(issues).values({+ id: childId,+ companyId,+ title: `Deep child ${index}`,+ status: "in_progress",+ priority: "medium",+ parentId,+ issueNumber: index + 10,+ identifier: `CHAIN-${index + 10}`,+ });+ parentId = childId;+ }++ const found = await svc.findOpenAncestorCreatedByAgent(parentId, delegatorId);+ expect(found?.id).toBe(midId);+ });++ it("terminates on a corrupted parent-graph cycle", async () => {+ const { delegatorId, rootId, midId } = await seedChain();+ // Corrupt the graph: root's parent points back at mid.+ await db.update(issues).set({ parentId: midId }).where(eq(issues.id, rootId));++ const found = await svc.findOpenAncestorCreatedByAgent(midId, delegatorId);+ expect(found?.id).toBe(midId);+ expect(await svc.findOpenAncestorCreatedByAgent(midId, randomUUID())).toBeNull();+ });+});+describeEmbeddedPostgres("issueService.create workspace inheritance", () => {let db!: ReturnType<typeof createDb>;let svc!: ReturnType<typeof issueService>;diff --git a/server/src/routes/issues.ts b/server/src/routes/issues.tsindex e314a6d42f..64ec351386 100644--- a/server/src/routes/issues.ts+++ b/server/src/routes/issues.ts@@ -4396,6 +4396,34 @@ export function issueRoutes(};}+ /**+ * Refuse an agent creating a child issue assigned to the agent that created+ * a still-open ancestor in the same chain. That shape is a delegation cycle+ * (A delegates to B, B delegates the same work back to A): each agent lacks+ * something the other assumed it had, the chain of blocked issues grows,+ * and no one tells the human. Humans are unaffected, and closed ancestors+ * do not count — re-engaging the creator of finished work is normal.+ */+ async function assertNoAgentDelegationCycle(input: {+ actorType: string;+ parentIssueId: string | null | undefined;+ assigneeAgentId: string | null | undefined;+ }) {+ if (input.actorType !== "agent") return;+ if (!input.parentIssueId || !input.assigneeAgentId) return;+ const ancestor = await svc.findOpenAncestorCreatedByAgent(input.parentIssueId, input.assigneeAgentId);+ if (!ancestor) return;+ throw conflict(+ `Delegation cycle: ${ancestor.identifier ?? "an ancestor issue"} in this chain was created by the agent this child would be assigned to. ` ++ "Complete the remaining work in your own issue, leave the child unassigned, or escalate to a board operator — do not delegate the work back to the agent that delegated it to you.",+ {+ code: "delegation_cycle",+ ancestorIssueId: ancestor.id,+ assigneeAgentId: input.assigneeAgentId,+ },+ );+ }+async function normalizeIssueAssigneeAgentReference(companyId: string,rawAssigneeAgentId: string | null | undefined,@@ -7143,6 +7171,11 @@ export function issueRoutes(rawCreateBody.assigneeAgentId as string | null | undefined,{ actorType: req.actor.type },);+ await assertNoAgentDelegationCycle({+ actorType: req.actor.type,+ parentIssueId: typeof effectiveParentId === "string" ? effectiveParentId : null,+ assigneeAgentId: normalizedAssigneeAgentId ?? null,+ });const actor = getActorInfo(req);const runWorkspaceInheritanceSourceIssueId = hasExplicitIssueWorkspaceCreateSelection(rawCreateBody)? null@@ -7359,6 +7392,11 @@ export function issueRoutes(sanitizedBody.assigneeAgentId as string | null | undefined,{ actorType: req.actor.type },);+ await assertNoAgentDelegationCycle({+ actorType: req.actor.type,+ parentIssueId: parent.id,+ assigneeAgentId: normalizedAssigneeAgentId ?? null,+ });const createBody = {...sanitizedBody,...(normalizedAssigneeAgentId !== undefined ? { assigneeAgentId: normalizedAssigneeAgentId } : {}),diff --git a/server/src/services/issues.ts b/server/src/services/issues.tsindex 4acf9bec04..34b1e594b8 100644--- a/server/src/services/issues.ts+++ b/server/src/services/issues.ts@@ -5340,6 +5340,52 @@ export function issueService(db: Db) {return activeInboxArchiveFields(archive, lastActivityAt);},+ /**+ * Walk the full parent chain from `parentIssueId` (inclusive) looking for+ * a still-open ancestor created by `agentId`. Used to refuse agent+ * delegation cycles: an agent assigning a new child to the agent that+ * created an open ancestor is handing the same work back to its own+ * delegator (A→B→A hot-potato). One recursive query covers the entire+ * chain regardless of depth; `UNION` (not `UNION ALL`) deduplicates+ * revisited rows, so a parent graph corrupted into a loop terminates+ * instead of recursing forever.+ */+ findOpenAncestorCreatedByAgent: async (+ parentIssueId: string,+ agentId: string,+ ): Promise<{+ id: string;+ identifier: string | null;+ parentId: string | null;+ createdByAgentId: string | null;+ status: string;+ } | null> => {+ const rows = await db.execute(sql`+ WITH RECURSIVE ancestors(id, parent_id) AS (+ SELECT id, parent_id FROM issues WHERE id = ${parentIssueId}+ UNION+ SELECT parent.id, parent.parent_id+ FROM issues parent+ JOIN ancestors ON parent.id = ancestors.parent_id+ )+ SELECT i.id, i.identifier, i.parent_id, i.created_by_agent_id, i.status+ FROM issues i+ JOIN ancestors a ON a.id = i.id+ WHERE i.created_by_agent_id = ${agentId}+ AND i.status NOT IN ('done', 'cancelled')+ LIMIT 1+ `);+ const first = (Array.isArray(rows) ? rows[0] : null) as Record<string, unknown> | null;+ if (!first) return null;+ return {+ id: String(first.id),+ identifier: typeof first.identifier === "string" ? first.identifier : null,+ parentId: typeof first.parent_id === "string" ? first.parent_id : null,+ createdByAgentId: typeof first.created_by_agent_id === "string" ? first.created_by_agent_id : null,+ status: String(first.status),+ };+ },+getById: async (raw: string) => {const id = raw.trim();const identifier = normalizeIssueReferenceIdentifier(id);