Q46: parents wait for their subtasks and cannot close while any are open

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tests/integration/autonomous-run.test.ts

@@ -22,7 +22,7 @@ function call(name: string, args: Record<string, unknown>): ToolCall {
   return { id: `call_${randomUUID()}`, name, arguments: args };
 }
 
-/** Scripts the CEO: staff two reports, delegate work, hand off the file in chat, close the kickoff, then stop. */
+/** Scripts the CEO: staff two reports, delegate work, hand off the file in chat, park the kickoff on its subtask, then stop. */
 function scriptedCeo(): (input: ProviderToolTurnInput) => Promise<AgentTurnResult> {
   const script: Array<{ text: string; toolCalls: ToolCall[] }> = [
     { text: "Staffing.", toolCalls: [
@@ -36,7 +36,7 @@ function scriptedCeo(): (input: ProviderToolTurnInput) => Promise<AgentTurnResul
       call("write_deliverable", { path: "plan/operating-plan.md", content: "# OrbitOps Operating Plan\n\n- Validate demand\n- Launch booking site\n" }),
     ] },
     { text: "Handing off the plan.", toolCalls: [] },
-    { text: "Closing the kickoff.", toolCalls: [] },
+    { text: "Parking the kickoff.", toolCalls: [] },
     { text: "Team staffed, work delegated, plan written.", toolCalls: [] },
   ];
   let index = 0;
@@ -57,13 +57,13 @@ function scriptedCeo(): (input: ProviderToolTurnInput) => Promise<AgentTurnResul
       };
     }
     if (index === 4) {
-      // The prompt carries the task id so the agent can actually close its task.
+      // The prompt carries the task id so the agent can park its task until the delegated work is done.
       const firstUser = input.messages.find((message) => message.role === "user");
       const taskId = firstUser ? /Task id: (\S+)/.exec(firstUser.text)?.[1] : undefined;
       index += 1;
       return {
-        text: "Closing the kickoff.",
-        toolCalls: taskId ? [call("update_task_status", { task_id: taskId, status: "done" })] : [],
+        text: "Parking the kickoff.",
+        toolCalls: taskId ? [call("update_task_status", { task_id: taskId, status: "in_progress" })] : [],
         rawResponseJson: JSON.stringify({ id: `resp_${index}` }),
       };
     }
@@ -162,13 +162,12 @@ describe("autonomous bootstrap run", () => {
     const run = state.taskRuns.find((r) => r.id === claimed!.id);
     expect(run?.state).toBe("completed");
 
-    // The CEO closed the kickoff task using the task id the prompt carries.
+    // The CEO parked the kickoff using the task id the prompt carries; it waits on its subtask.
     const kickoffTask = connection.db.prepare("select status from tasks where id = (select task_id from task_runs where id = ?)")
       .get(claimed!.id) as { status: string };
-    expect(kickoffTask).toEqual({ status: "done" });
+    expect(kickoffTask).toEqual({ status: "in_progress" });
 
-    // Stage 4 heartbeat: the CEO-delegated task (assigned to a hired, heartbeat-enabled
-    // agent, with no run yet) is enqueued exactly once for autonomous execution.
+    // Stage 4 heartbeat: only the delegated task is enqueued; the kickoff waits for it.
     const enqueued = taskExecution.enqueueHeartbeatRuns();
     expect(enqueued).toHaveLength(1);
     const queued = connection.db.prepare("select task_id, state, trigger from task_runs where id = ?").get(enqueued[0]) as { task_id: string; state: string; trigger: string };

tests/integration/task-dependencies.test.ts

@@ -0,0 +1,94 @@
+import { randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import { DatabaseConnection } from "../../src/main/database/connection";
+import { OnboardingService } from "../../src/main/services/onboarding-service";
+import { OrganizationService } from "../../src/main/services/organization-service";
+import { ProviderService } from "../../src/main/services/provider-service";
+import { providerAdapters } from "../../src/main/services/provider-adapters";
+import { TaskExecutionService } from "../../src/main/services/task-execution-service";
+import { ChatService } from "../../src/main/services/chat-service";
+import { dispatchAgentTool } from "../../src/main/services/agent-tools";
+import { claimNextQueuedRun } from "../../src/main/app/task-queue-worker";
+import { RISK_LEVEL, TASK_PRIORITY, TASK_STATUS } from "../../src/shared/domain";
+import type { AgentTurnResult, ProviderToolTurnInput } from "../../src/main/services/provider-tool-turn";
+
+const testVault = {
+  encryptSecret: (secret: string) => Buffer.from(secret, "utf8"),
+  decryptSecret: (ciphertext: Buffer) => ciphertext.toString("utf8"),
+};
+
+function company() {
+  const connection = new DatabaseConnection(join(tmpdir(), `ac-deps-${randomUUID()}.db`));
+  const prompts: string[] = [];
+  const turn = async (input: ProviderToolTurnInput): Promise<AgentTurnResult> => {
+    const first = input.messages[0];
+    if (first?.role !== "user") throw new Error("The run must open with the task prompt.");
+    prompts.push(first.text);
+    return { text: "done", toolCalls: [], rawResponseJson: "{}" };
+  };
+  const providers = new ProviderService(connection.db, providerAdapters, testVault, undefined, turn);
+  const onboarding = new OnboardingService({ db: connection.db, saveProviderCredential: (input) => providers.saveCredential(input) });
+  const execution = new TaskExecutionService(connection.db, providers);
+  const organization = new OrganizationService(connection.db);
+  let orgId = "";
+  let ceoId = "";
+  connection.transaction(() => {
+    const summary = onboarding.bootstrap({
+      companyName: "FlowPilot", companyDescription: "CSM analytics.", employeeName: "Yang", workspacePath: "",
+      executionMode: "ai_ceo", autoApproveHires: true, reviewDeliverables: false,
+      goalTitle: "Ship the MVP.", goalDescription: "A working product.",
+      providerKey: "openai", providerSecret: "sk-test-key", providerModel: "gpt-5.4",
+    });
+    orgId = summary.orgId;
+    ceoId = summary.ceoAgentId;
+  });
+  return { connection, execution, organization, orgId, ceoId, prompts };
+}
+
+describe("task dependencies", () => {
+  test("a parent cannot close while subtasks are open, and waits for them before running again", async () => {
+    const h = company();
+    const { prompts } = h;
+    const kickoff = claimNextQueuedRun(h.connection)!;
+    const parentId = (h.connection.db.prepare("select task_id from task_runs where id = ?").get(kickoff.id) as { task_id: string }).task_id;
+    await h.execution.executeRun(h.orgId, kickoff.id);
+    const childId = h.organization.createTask({
+      orgId: h.orgId, title: "Hire the CTO", description: "d", status: TASK_STATUS.BACKLOG, assigneeAgentId: h.ceoId,
+      risk: RISK_LEVEL.LOW, projectId: null, goalId: null, workspaceId: null, priority: TASK_PRIORITY.NORMAL, requiresFilesystem: false,
+    });
+    h.connection.db.prepare("update tasks set parent_task_id = ? where id = ?").run(parentId, childId);
+
+    const parentTitle = (h.connection.db.prepare("select title from tasks where id = ?").get(parentId) as { title: string }).title;
+    expect(() => h.organization.updateTaskStatus(h.orgId, parentId, TASK_STATUS.DONE))
+      .toThrow(`"${parentTitle}" has open subtasks: Hire the CTO. It can close once they are done.`);
+    const ctx = { orgId: h.orgId, agent: { id: h.ceoId, modelProviderId: null, modelId: null }, taskProjectId: null, taskGoalId: null, taskId: null, sourceThreadId: null, workspace: null };
+    const deps = { db: h.connection.db, organization: h.organization, chat: new ChatService(h.connection.db) };
+    expect(dispatchAgentTool(deps, ctx, { id: "c1", name: "update_task_status", arguments: { task_id: parentId, status: "done" } }))
+      .toBe(`ERROR: "${parentTitle}" has open subtasks: Hire the CTO. It can close once they are done.`);
+
+    // A run queued before the subtask existed is superseded instead of running ahead of it.
+    h.connection.db.prepare("insert into task_runs(id, org_id, task_id, agent_id, provider_id, execution_context_id, service_identity_id, workspace_mount_json, secret_scope_json, trigger, state, created_at) select 'run_early', org_id, task_id, agent_id, provider_id, 'ctx_early', service_identity_id, workspace_mount_json, secret_scope_json, 'heartbeat', 'running', created_at from task_runs where id = ?").run(kickoff.id);
+    await h.execution.executeRun(h.orgId, "run_early");
+    expect(h.connection.db.prepare("select state, error_message from task_runs where id = 'run_early'").get())
+      .toEqual({ state: "superseded", error_message: 'Superseded: the task has open subtasks ("Hire the CTO"); it runs again once they are done.' });
+
+    const waiting = h.connection.transaction(() => h.execution.enqueueHeartbeatRuns());
+    const queuedTasks = () => (h.connection.db.prepare("select task_id from task_runs where state = 'queued'").all() as Array<{ task_id: string }>).map((row) => row.task_id);
+    expect(waiting).toHaveLength(1);
+    expect(queuedTasks()).toEqual([childId]);
+
+    h.connection.db.prepare("update task_runs set state = 'completed' where state = 'queued'").run();
+    h.organization.updateTaskStatus(h.orgId, childId, TASK_STATUS.DONE);
+    h.connection.transaction(() => h.execution.enqueueHeartbeatRuns());
+    expect(queuedTasks()).toEqual([parentId]);
+    const resumed = claimNextQueuedRun(h.connection)!;
+    await h.execution.executeRun(h.orgId, resumed.id);
+    expect(prompts.at(-1)).toContain("The subtasks you delegated from this task are all done: Hire the CTO.");
+    expect(prompts[0]).toContain('move it to "in_progress"');
+    expect(prompts[0]).not.toContain(`update_task_status(task_id="${parentId}", status="done") and summarize`);
+    h.organization.updateTaskStatus(h.orgId, parentId, TASK_STATUS.DONE);
+    h.connection.close();
+  });
+});