fix(approvals): make revision requests checkoutable

tests/unit/approval-review-feedback-writeback.test.ts

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { AppDatabase } from "../../src/main/database";
 import { handleApprovalResolved } from "../../src/main/automation/automation-approval-handler";
+import { createHeartbeat } from "../../src/main/orchestration/heartbeat";
 
 const tempDirs: string[] = [];
 
@@ -18,7 +19,9 @@ afterEach(async () => {
 });
 
 describe("deliverable review feedback writeback", () => {
-  it("persists high-importance knowledge when the board requests revisions on a deliverable", async () => {
+  it.each(["rejected", "revision_requested"] as const)(
+    "persists high-importance knowledge when the board returns %s on a deliverable",
+    async (decision) => {
     const profileDir = await createTempDir("agentcompany-review-feedback-");
     const db = new AppDatabase(profileDir);
     db.init();
@@ -87,7 +90,7 @@ describe("deliverable review feedback writeback", () => {
 
     db.core.approvals.decideApproval({
       approvalId,
-      state: "revision_requested",
+      state: decision,
       decisionNote: "Add stronger competitor evidence and a clearer recommendation.",
     });
 
@@ -105,7 +108,7 @@ describe("deliverable review feedback writeback", () => {
       handleTaskStatusChange: vi.fn(),
       runWorkflowPipeline: async () => {},
       trackTimer: vi.fn(),
-    }, approvalId, companyId, "revision_requested");
+    }, approvalId, companyId, decision);
 
     const knowledgeEntries = db.projection.snapshot.listSnapshot().knowledgeBase.filter((entry) => entry.companyId === companyId);
     expect(knowledgeEntries).toHaveLength(1);
@@ -113,13 +116,147 @@ describe("deliverable review feedback writeback", () => {
     expect(knowledgeEntries[0]?.importance).toBe("high");
     expect(knowledgeEntries[0]?.referencedEntityType).toBe("task");
     expect(knowledgeEntries[0]?.referencedEntityId).toBe(taskId);
-    expect(knowledgeEntries[0]?.content).toContain("revision_requested");
+    expect(knowledgeEntries[0]?.content).toContain(decision);
     expect(knowledgeEntries[0]?.content).toContain("stronger competitor evidence");
     expect(wakeAgentIfPossible).toHaveBeenCalledWith(agentId, companyId, "revision_needed");
-    expect(db.core.entity.getTask(taskId).status).toBe("in_progress");
+    expect(wakeAgentIfPossible).toHaveBeenCalledTimes(1);
+    expect(db.core.entity.getTask(taskId).status).toBe("todo");
     const document = db.projection.snapshot.listSnapshot().documents.find((entry) => entry.id === documentId);
     expect(document?.status).toBe("draft");
 
+    db.close();
+    },
+  );
+
+  it("makes a revision request immediately checkoutable by the assignee heartbeat", async () => {
+    const profileDir = await createTempDir("agentcompany-review-checkout-");
+    const db = new AppDatabase(profileDir);
+    db.init();
+
+    db.core.connectors.saveConnector({
+      id: "openai-codex",
+      model: "gpt-5.4",
+      envBindingText: "",
+      notes: "Test connector",
+    });
+
+    const companyId = db.core.company.saveCompany({
+      name: "Review Checkout Co",
+      description: "Tests review revision checkout",
+      status: "active",
+    });
+    const workspaceId = db.core.workspaces.saveWorkspace({
+      companyId,
+      name: "Primary",
+      localPath: profileDir,
+      repoUrl: "",
+      repoRef: "",
+      isPrimary: true,
+    });
+    const agentId = db.core.agents.saveAgent({
+      companyId,
+      name: "Research Lead",
+      role: "Researcher",
+      title: "Research Lead",
+      status: "active",
+      reportsTo: null,
+      connectorId: "openai-codex",
+      workspaceId,
+      model: "gpt-5.4",
+      capabilities: "Research and synthesis",
+      budgetMonthlyUsd: 180,
+      department: "research",
+    });
+    const taskId = db.core.tasks.saveTask({
+      companyId,
+      title: "Draft market report",
+      description: "Produce a market report with concrete evidence and business insight.",
+      assigneeAgentId: agentId,
+      workspaceId,
+      priority: "high",
+      status: "in_review",
+    });
+    const documentId = db.core.documents.saveDocument({
+      companyId,
+      type: "knowledge_article",
+      title: "Market report",
+      content: "Draft report body",
+      authorAgentId: agentId,
+      status: "in_review",
+    });
+    const approvalId = db.core.approvals.requestApproval({
+      companyId,
+      relatedTaskId: taskId,
+      requestedByAgentId: agentId,
+      type: "deliverable_review",
+      payloadSummary: "Review market report deliverable",
+      impactSummary: "Board review required before the report is finalized.",
+      payloadJson: JSON.stringify({ documentIds: [documentId] }),
+    });
+
+    db.core.approvals.decideApproval({
+      approvalId,
+      state: "revision_requested",
+      decisionNote: "Add stronger competitor evidence and a clearer recommendation.",
+    });
+
+    const dispatchRunToWorker = vi.fn();
+    const heartbeat = createHeartbeat(
+      {
+        db,
+        logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+        publishDomainChanged: vi.fn(),
+        emitEvent: vi.fn(),
+        notify: vi.fn(),
+        createRunToken: () => "test-token",
+        getApiPort: () => 3210,
+        dispatchAutomation: vi.fn(),
+        hasWorkerReady: () => true,
+        enqueueWorkerRun: vi.fn(),
+        isQuitting: () => false,
+        listRuntimeSkillEntries: () => [],
+        budgetService: {
+          autoCloseExpiredIncidents: vi.fn(() => 0),
+          evaluateBudgetGate: vi.fn(() => ({ allowed: true, blockedBy: [] })),
+        } as never,
+        checkpointEngine: { shouldPauseHeartbeat: () => false },
+      },
+      () => ({
+        workspace: null,
+        lockMode: "none",
+        source: "none",
+        observationPath: profileDir,
+      }),
+      () => null,
+      dispatchRunToWorker,
+      (filter) => db.core.runs.hasActiveRun(filter),
+    );
+
+    handleApprovalResolved({
+      db,
+      logger: { info: () => {}, warn: () => {}, error: () => {} },
+      publishDomainChanged: () => {},
+      notify: vi.fn(),
+      wakeAgentIfPossible: heartbeat.wakeAgentIfPossible,
+      queueBrowserActionExecution: () => {},
+      isQuitting: () => false,
+    }, {
+      dispatchAutomation: vi.fn(),
+      handleTaskStatusChange: vi.fn(),
+      runWorkflowPipeline: async () => {},
+      trackTimer: vi.fn(),
+    }, approvalId, companyId, "revision_requested");
+
+    const task = db.core.entity.getTask(taskId);
+    expect(task.status).toBe("in_progress");
+    expect(db.core.runs.hasActiveRun({ companyId, taskId, agentId })).toBe(true);
+    expect(dispatchRunToWorker).toHaveBeenCalledTimes(1);
+    expect(dispatchRunToWorker).toHaveBeenCalledWith(expect.objectContaining({
+      companyId,
+      task: expect.objectContaining({ id: taskId }),
+      trigger: "revision_needed",
+    }));
+
     db.close();
   });
 });