import { afterEach, describe, expect, it, vi } from "vitest";

import { resetAgentEventsForTest, resetAgentRunContextForTest } from "../infra/agent-events.js";

import { resetHeartbeatWakeStateForTests } from "../infra/heartbeat-wake.js";

import { resetSystemEventsForTest } from "../infra/system-events.js";

import { withStateDirEnv } from "../test-helpers/state-dir-env.js";

import {

getDetachedTaskLifecycleRuntime,

resetDetachedTaskLifecycleRuntimeForTests,

setDetachedTaskLifecycleRuntime,

} from "./detached-task-runtime.js";

import {

cancelFlowById,

cancelFlowByIdForOwner,

cancelDetachedTaskRunById,

completeTaskRunByRunId,

createQueuedTaskRun,

createRunningTaskRun,

failTaskRunByRunId,

recordTaskRunProgressByRunId,

retryBlockedFlowAsQueuedTaskRun,

runTaskInFlow,

runTaskInFlowForOwner,

setDetachedTaskDeliveryStatusByRunId,

startTaskRunByRunId,

} from "./task-executor.js";

import {

createManagedTaskFlow,

getTaskFlowById,

listTaskFlowRecords,

resetTaskFlowRegistryForTests,

} from "./task-flow-registry.js";

import {

setTaskRegistryDeliveryRuntimeForTests,

getTaskById,

findLatestTaskForFlowId,

findTaskByRunId,

resetTaskRegistryControlRuntimeForTests,

resetTaskRegistryDeliveryRuntimeForTests,

resetTaskRegistryForTests,

setTaskRegistryControlRuntimeForTests,

} from "./task-registry.js";

const ORIGINAL_STATE_DIR = process.env.OPENCLAW_STATE_DIR;

const hoisted = vi.hoisted(() => {

const sendMessageMock = vi.fn();

const cancelSessionMock = vi.fn();

const killSubagentRunAdminMock = vi.fn();

return {

sendMessageMock,

cancelSessionMock,

killSubagentRunAdminMock,

};

});

vi.mock("../acp/control-plane/manager.js", () => ({

getAcpSessionManager: () => ({

cancelSession: hoisted.cancelSessionMock,

}),

}));

vi.mock("../agents/subagent-control.js", () => ({

killSubagentRunAdmin: (params: unknown) => hoisted.killSubagentRunAdminMock(params),

}));

vi.mock("../utils/message-channel.js", () => ({

isDeliverableMessageChannel: (channel: string) => channel === "notifychat",

}));

async function withTaskExecutorStateDir(run: (stateDir: string) => Promise<void>): Promise<void> {

await withStateDirEnv("openclaw-task-executor-", async ({ stateDir }) => {

resetDetachedTaskLifecycleRuntimeForTests();

resetSystemEventsForTest();

resetHeartbeatWakeStateForTests();

resetAgentEventsForTest();

resetTaskRegistryDeliveryRuntimeForTests();

resetTaskRegistryControlRuntimeForTests();

resetAgentRunContextForTest();

resetTaskRegistryForTests({ persist: false });

resetTaskFlowRegistryForTests({ persist: false });

setTaskRegistryDeliveryRuntimeForTests({

sendMessage: hoisted.sendMessageMock,

});

setTaskRegistryControlRuntimeForTests({

getAcpSessionManager: () => ({

cancelSession: hoisted.cancelSessionMock,

}),

killSubagentRunAdmin: async (params) => hoisted.killSubagentRunAdminMock(params),

});

try {

await run(stateDir);

} finally {

resetSystemEventsForTest();

resetHeartbeatWakeStateForTests();

resetAgentEventsForTest();

resetTaskRegistryDeliveryRuntimeForTests();

resetTaskRegistryControlRuntimeForTests();

resetAgentRunContextForTest();

resetTaskRegistryForTests({ persist: false });

resetTaskFlowRegistryForTests({ persist: false });

}

});

}

function expectParentFlowId(task: { parentFlowId?: string }): string {

expect(task.parentFlowId).toMatch(

/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u,

);

if (task.parentFlowId === undefined) {

throw new Error("Expected task parent flow id");

}

return task.parentFlowId;

}

function requireCreatedFlowTask(

result: ReturnType<typeof runTaskInFlow>,

): NonNullable<ReturnType<typeof runTaskInFlow>["task"]> {

if (!result.task) {

throw new Error("Expected TaskFlow child task to be created");

}

return result.task;

}

function expectCancelRequestedAt(value: unknown): number {

expect(typeof value).toBe("number");

if (typeof value !== "number") {

throw new Error("Expected numeric cancelRequestedAt");

}

expect(Number.isInteger(value)).toBe(true);

expect(value).toBeGreaterThan(0);

return value;

}

function createRunningAcpChildTaskRun(

overrides: Partial<Parameters<typeof createRunningTaskRun>[0]> = {},

) {

return createRunningTaskRun({

runtime: "acp",

ownerKey: "agent:main:main",

scopeKind: "session",

childSessionKey: "agent:codex:acp:child",

runId: "run-acp-child",

task: "Inspect a PR",

startedAt: 10,

deliveryStatus: "pending",

...overrides,

});

}

function spyOnRuntimeCancel() {

const defaultRuntime = getDetachedTaskLifecycleRuntime();

const cancelDetachedTaskRunByIdSpy = vi.fn(

(...args: Parameters<typeof defaultRuntime.cancelDetachedTaskRunById>) =>

defaultRuntime.cancelDetachedTaskRunById(...args),

);

setDetachedTaskLifecycleRuntime({

...defaultRuntime,

cancelDetachedTaskRunById: cancelDetachedTaskRunByIdSpy,

});

return cancelDetachedTaskRunByIdSpy;

}

function expectCancelledAcpChildTask(

child: ReturnType<typeof createRunningTaskRun>,

cancelled: { found?: boolean; cancelled?: boolean },

) {

expect(cancelled.found).toBe(true);

expect(cancelled.cancelled).toBe(true);

const task = getTaskById(child.taskId);

expect(task?.taskId).toBe(child.taskId);

expect(task?.status).toBe("cancelled");

expect(hoisted.cancelSessionMock).toHaveBeenCalledWith({

cfg: {} as never,

sessionKey: "agent:codex:acp:child",

reason: "task-cancel",

});

}

describe("task-executor", () => {

afterEach(() => {

if (ORIGINAL_STATE_DIR === undefined) {

delete process.env.OPENCLAW_STATE_DIR;

} else {

process.env.OPENCLAW_STATE_DIR = ORIGINAL_STATE_DIR;

}

resetSystemEventsForTest();

resetHeartbeatWakeStateForTests();

resetAgentEventsForTest();

resetTaskRegistryDeliveryRuntimeForTests();

resetTaskRegistryControlRuntimeForTests();

resetAgentRunContextForTest();

resetTaskRegistryForTests({ persist: false });

resetTaskFlowRegistryForTests({ persist: false });

hoisted.sendMessageMock.mockReset();

hoisted.cancelSessionMock.mockReset();

hoisted.killSubagentRunAdminMock.mockReset();

});

it("advances a queued run through start and completion", async () => {

await withTaskExecutorStateDir(async () => {

const created = createQueuedTaskRun({

runtime: "acp",

ownerKey: "agent:main:main",

scopeKind: "session",

childSessionKey: "agent:codex:acp:child",

runId: "run-executor-queued",

task: "Investigate issue",

});

expect(created.status).toBe("queued");

startTaskRunByRunId({

runId: "run-executor-queued",

startedAt: 100,

lastEventAt: 100,

eventSummary: "Started.",

});

completeTaskRunByRunId({

runId: "run-executor-queued",

endedAt: 250,

lastEventAt: 250,

terminalSummary: "Done.",

});

const task = getTaskById(created.taskId);

expect(task?.taskId).toBe(created.taskId);

expect(task?.status).toBe("succeeded");

expect(task?.startedAt).toBe(100);

expect(task?.endedAt).toBe(250);

expect(task?.terminalSummary).toBe("Done.");

});

});

it("records progress, failure, and delivery status through the executor", async () => {

await withTaskExecutorStateDir(async () => {

const created = createRunningTaskRun({

runtime: "subagent",

ownerKey: "agent:main:main",

scopeKind: "session",

childSessionKey: "agent:codex:subagent:child",

runId: "run-executor-fail",

task: "Write summary",

startedAt: 10,

});

recordTaskRunProgressByRunId({

runId: "run-executor-fail",

lastEventAt: 20,

progressSummary: "Collecting results",

eventSummary: "Collecting results",

});

failTaskRunByRunId({

runId: "run-executor-fail",

endedAt: 40,

lastEventAt: 40,

error: "tool failed",

});

setDetachedTaskDeliveryStatusByRunId({

runId: "run-executor-fail",

deliveryStatus: "failed",

});

const task = getTaskById(created.taskId);

expect(task?.taskId).toBe(created.taskId);

expect(task?.status).toBe("failed");

expect(task?.progressSummary).toBe("Collecting results");

expect(task?.error).toBe("tool failed");

expect(task?.deliveryStatus).toBe("failed");

});

});

it("persists explicit task kind metadata on created runs", async () => {

await withTaskExecutorStateDir(async () => {

const created = createRunningTaskRun({

runtime: "cli",

taskKind: "video_generation",

sourceId: "video_generate:openai",

ownerKey: "agent:main:main",

scopeKind: "session",

childSessionKey: "agent:main:main",

runId: "run-executor-kind",

task: "Generate lobster video",

startedAt: 10,

deliveryStatus: "not_applicable",

});

const task = getTaskById(created.taskId);

expect(task?.taskId).toBe(created.taskId);

expect(task?.taskKind).toBe("video_generation");

expect(task?.sourceId).toBe("video_generate:openai");

const found = findTaskByRunId("run-executor-kind");

expect(found?.taskId).toBe(created.taskId);

expect(found?.taskKind).toBe("video_generation");

});

});

it("auto-creates a one-task flow and keeps it synced with task status", async () => {

await withTaskExecutorStateDir(async () => {

const created = createRunningTaskRun({

runtime: "subagent",

ownerKey: "agent:main:main",

scopeKind: "session",

childSessionKey: "agent:codex:subagent:child",

runId: "run-executor-flow",

task: "Write summary",

startedAt: 10,

deliveryStatus: "pending",

});

const parentFlowId = expectParentFlowId(created);

const runningFlow = getTaskFlowById(parentFlowId);

expect(runningFlow?.flowId).toBe(parentFlowId);

expect(runningFlow?.ownerKey).toBe("agent:main:main");

expect(runningFlow?.status).toBe("running");

expect(runningFlow?.goal).toBe("Write summary");

expect(runningFlow?.notifyPolicy).toBe("done_only");

completeTaskRunByRunId({

runId: "run-executor-flow",

endedAt: 40,

lastEventAt: 40,

terminalSummary: "Done.",

});

const succeededFlow = getTaskFlowById(parentFlowId);

expect(succeededFlow?.flowId).toBe(parentFlowId);

expect(succeededFlow?.status).toBe("succeeded");

expect(succeededFlow?.endedAt).toBe(40);

expect(succeededFlow?.goal).toBe("Write summary");

expect(succeededFlow?.notifyPolicy).toBe("done_only");

});

});

it("does not auto-create one-task flows for non-returning bookkeeping runs", async () => {

await withTaskExecutorStateDir(async () => {

const created = createRunningTaskRun({

runtime: "cli",

ownerKey: "agent:main:main",

scopeKind: "session",

childSessionKey: "agent:main:main",

runId: "run-executor-cli",

task: "Foreground gateway run",

deliveryStatus: "not_applicable",

startedAt: 10,

});

expect(created.parentFlowId).toBeUndefined();

expect(listTaskFlowRecords()).toStrictEqual([]);

});

});

it("records blocked metadata on one-task flows and reuses the same flow for queued retries", async () => {

await withTaskExecutorStateDir(async () => {

const created = createRunningTaskRun({

runtime: "acp",

ownerKey: "agent:main:main",

scopeKind: "session",

requesterOrigin: {

channel: "notifychat",

to: "notifychat:123",

},

childSessionKey: "agent:codex:acp:child",

runId: "run-executor-blocked",

task: "Patch file",

startedAt: 10,

deliveryStatus: "pending",

});

completeTaskRunByRunId({

runId: "run-executor-blocked",

endedAt: 40,

lastEventAt: 40,

terminalOutcome: "blocked",

terminalSummary: "Writable session required.",

});

const blockedTask = getTaskById(created.taskId);

expect(blockedTask?.taskId).toBe(created.taskId);

expect(blockedTask?.status).toBe("succeeded");

expect(blockedTask?.terminalOutcome).toBe("blocked");

expect(blockedTask?.terminalSummary).toBe("Writable session required.");

const parentFlowId = expectParentFlowId(created);

const blockedFlow = getTaskFlowById(parentFlowId);

expect(blockedFlow?.flowId).toBe(parentFlowId);

expect(blockedFlow?.status).toBe("blocked");

expect(blockedFlow?.blockedTaskId).toBe(created.taskId);

expect(blockedFlow?.blockedSummary).toBe("Writable session required.");

expect(blockedFlow?.endedAt).toBe(40);

const retried = retryBlockedFlowAsQueuedTaskRun({

flowId: parentFlowId,

runId: "run-executor-retry",

childSessionKey: "agent:codex:acp:retry-child",

});

expect(retried.found).toBe(true);

expect(retried.retried).toBe(true);

if (!retried.retried) {

throw new Error("Expected blocked flow retry");

}

if (!retried.previousTask || !retried.task) {

throw new Error("Expected retry result payload");

}

expect(retried.previousTask.taskId).toBe(created.taskId);

expect(retried.task.parentFlowId).toBe(parentFlowId);

expect(retried.task.parentTaskId).toBe(created.taskId);

expect(retried.task.status).toBe("queued");

expect(retried.task.runId).toBe("run-executor-retry");

const queuedFlow = getTaskFlowById(parentFlowId);

expect(queuedFlow?.flowId).toBe(parentFlowId);

expect(queuedFlow?.status).toBe("queued");

expect(findLatestTaskForFlowId(parentFlowId)?.runId).toBe("run-executor-retry");

const original = findTaskByRunId("run-executor-blocked");

expect(original?.taskId).toBe(created.taskId);

expect(original?.status).toBe("succeeded");

expect(original?.terminalOutcome).toBe("blocked");

expect(original?.terminalSummary).toBe("Writable session required.");

});

});

it("cancels active tasks linked to a managed TaskFlow", async () => {

await withTaskExecutorStateDir(async () => {

hoisted.cancelSessionMock.mockResolvedValue(undefined);

const flow = createManagedTaskFlow({

ownerKey: "agent:main:main",

controllerId: "tests/managed-flow",

goal: "Inspect PR batch",

requesterOrigin: {

channel: "notifychat",

to: "notifychat:123",

},

});

const child = createRunningTaskRun({

runtime: "acp",

ownerKey: "agent:main:main",

scopeKind: "session",

parentFlowId: flow.flowId,

childSessionKey: "agent:codex:acp:child",

runId: "run-linear-cancel",

task: "Inspect a PR",

startedAt: 10,

deliveryStatus: "pending",

});

const cancelled = await cancelFlowById({

cfg: {} as never,

flowId: flow.flowId,

});

expect(cancelled.found).toBe(true);

expect(cancelled.cancelled).toBe(true);

const task = findTaskByRunId("run-linear-cancel");

expect(task?.taskId).toBe(child.taskId);

expect(task?.status).toBe("cancelled");

const cancelledFlow = getTaskFlowById(flow.flowId);

expect(cancelledFlow?.flowId).toBe(flow.flowId);

expect(cancelledFlow?.status).toBe("cancelled");

});

});

it("runs child tasks under managed TaskFlows", async () => {

await withTaskExecutorStateDir(async () => {

const flow = createManagedTaskFlow({

ownerKey: "agent:main:main",

controllerId: "tests/managed-flow",

goal: "Inspect PR batch",

requesterOrigin: {

channel: "notifychat",

to: "notifychat:123",

},

});

const created = runTaskInFlow({

flowId: flow.flowId,

runtime: "acp",

childSessionKey: "agent:codex:acp:child",

runId: "run-flow-child",

label: "Inspect a PR",

task: "Inspect a PR",

status: "running",

startedAt: 10,

lastEventAt: 10,

});

expect(created.found).toBe(true);

expect(created.created).toBe(true);

if (!created.created) {

throw new Error("Expected managed flow child task creation");

}

if (!created.task) {

throw new Error("Expected managed flow child task payload");

}

expect(created.task.parentFlowId).toBe(flow.flowId);

expect(created.task.ownerKey).toBe("agent:main:main");

expect(created.task.status).toBe("running");

expect(created.task.runId).toBe("run-flow-child");

const createdTask = requireCreatedFlowTask(created);

const task = getTaskById(createdTask.taskId);

expect(task?.parentFlowId).toBe(flow.flowId);

expect(task?.ownerKey).toBe("agent:main:main");

expect(task?.childSessionKey).toBe("agent:codex:acp:child");

});

});

it("refuses to add child tasks once cancellation is requested on a managed TaskFlow", async () => {

await withTaskExecutorStateDir(async () => {

const flow = createManagedTaskFlow({

ownerKey: "agent:main:main",

controllerId: "tests/managed-flow",

goal: "Protected flow",

});

const cancelled = await cancelFlowById({

cfg: {} as never,

flowId: flow.flowId,

});

expect(cancelled.found).toBe(true);

expect(cancelled.cancelled).toBe(true);

const created = runTaskInFlow({

flowId: flow.flowId,

runtime: "acp",

childSessionKey: "agent:codex:acp:child",

runId: "run-flow-after-cancel",

task: "Should be denied",

});

expect(created.found).toBe(true);

expect(created.created).toBe(false);

expect(created.reason).toBe("Flow cancellation has already been requested.");

});

});

it("sets cancel intent before child tasks settle and finalizes later", async () => {

await withTaskExecutorStateDir(async () => {

hoisted.cancelSessionMock.mockRejectedValue(new Error("still shutting down"));

const flow = createManagedTaskFlow({

ownerKey: "agent:main:main",

controllerId: "tests/managed-flow",

goal: "Long running batch",

});

const created = runTaskInFlow({

flowId: flow.flowId,

runtime: "acp",

childSessionKey: "agent:codex:acp:child",

runId: "run-flow-sticky-cancel",

task: "Inspect a PR",

status: "running",

startedAt: 10,

lastEventAt: 10,

});

const child = requireCreatedFlowTask(created);

const cancelled = await cancelFlowById({

cfg: {} as never,

flowId: flow.flowId,

});

expect(cancelled.found).toBe(true);

expect(cancelled.cancelled).toBe(false);

expect(cancelled.reason).toBe("One or more child tasks are still active.");

expect(cancelled.flow?.flowId).toBe(flow.flowId);

expect(cancelled.flow?.status).toBe("queued");

const cancelRequestedAt = expectCancelRequestedAt(cancelled.flow?.cancelRequestedAt);

failTaskRunByRunId({

runId: "run-flow-sticky-cancel",

endedAt: 50,

lastEventAt: 50,

error: "cancel completed later",

status: "cancelled",

});

const task = getTaskById(child.taskId);

expect(task?.taskId).toBe(child.taskId);

expect(task?.status).toBe("cancelled");

const cancelledFlow = getTaskFlowById(flow.flowId);

expect(cancelledFlow?.flowId).toBe(flow.flowId);

expect(cancelledFlow?.cancelRequestedAt).toBe(cancelRequestedAt);

expect(cancelledFlow?.status).toBe("cancelled");

expect(cancelledFlow?.endedAt).toBe(50);

});

});

it("denies cross-owner flow cancellation through the owner-scoped wrapper", async () => {

await withTaskExecutorStateDir(async () => {

const flow = createManagedTaskFlow({

ownerKey: "agent:main:main",

controllerId: "tests/managed-flow",

goal: "Protected flow",

});

const cancelled = await cancelFlowByIdForOwner({

cfg: {} as never,

flowId: flow.flowId,

callerOwnerKey: "agent:main:other",

});

expect(cancelled.found).toBe(false);

expect(cancelled.cancelled).toBe(false);

expect(cancelled.reason).toBe("Flow not found.");

const storedFlow = getTaskFlowById(flow.flowId);

expect(storedFlow?.flowId).toBe(flow.flowId);

expect(storedFlow?.status).toBe("queued");

});

});

it("denies cross-owner managed TaskFlow child spawning through the owner-scoped wrapper", async () => {

await withTaskExecutorStateDir(async () => {

const flow = createManagedTaskFlow({

ownerKey: "agent:main:main",

controllerId: "tests/managed-flow",

goal: "Protected flow",

});

const created = runTaskInFlowForOwner({

flowId: flow.flowId,

callerOwnerKey: "agent:main:other",

runtime: "acp",

childSessionKey: "agent:codex:acp:child",

runId: "run-flow-cross-owner",

task: "Should be denied",

});

expect(created.found).toBe(false);

expect(created.created).toBe(false);

expect(created.reason).toBe("Flow not found.");

expect(findLatestTaskForFlowId(flow.flowId)).toBeUndefined();

});

});

it("cancels active ACP child tasks", async () => {

await withTaskExecutorStateDir(async () => {

hoisted.cancelSessionMock.mockResolvedValue(undefined);

const child = createRunningAcpChildTaskRun({

runId: "run-linear-cancel",

});

const cancelled = await cancelDetachedTaskRunById({

cfg: {} as never,

taskId: child.taskId,

});

expectCancelledAcpChildTask(child, cancelled);

});

});

it("dispatches detached task cancellation through the registered runtime", async () => {

await withTaskExecutorStateDir(async () => {

hoisted.cancelSessionMock.mockResolvedValue(undefined);

const child = createRunningAcpChildTaskRun({

runId: "run-external-cancel",

});

const cancelDetachedTaskRunByIdSpy = spyOnRuntimeCancel();

const cancelled = await cancelDetachedTaskRunById({

cfg: {} as never,

taskId: child.taskId,

});

expect(cancelDetachedTaskRunByIdSpy).toHaveBeenCalledWith({

cfg: {} as never,

taskId: child.taskId,

});

expect(cancelled.found).toBe(true);

expect(cancelled.cancelled).toBe(true);

});

});

it("falls back to the legacy canceller when the registered runtime declines task ownership", async () => {

await withTaskExecutorStateDir(async () => {

hoisted.cancelSessionMock.mockResolvedValue(undefined);

const child = createRunningAcpChildTaskRun({

runId: "run-runtime-decline-cancel",

});

const cancelDetachedTaskRunByIdSpy = vi.fn(async () => ({

found: false,

cancelled: false,

reason: "not owned by runtime",

}));

setDetachedTaskLifecycleRuntime({

...getDetachedTaskLifecycleRuntime(),

cancelDetachedTaskRunById: cancelDetachedTaskRunByIdSpy,

});

const cancelled = await cancelDetachedTaskRunById({

cfg: {} as never,

taskId: child.taskId,

});

expect(cancelDetachedTaskRunByIdSpy).toHaveBeenCalledWith({

cfg: {} as never,

taskId: child.taskId,

});

expectCancelledAcpChildTask(child, cancelled);

});

});

it("does not fall back when the registered runtime claims task ownership", async () => {

await withTaskExecutorStateDir(async () => {

hoisted.cancelSessionMock.mockResolvedValue(undefined);

const child = createRunningAcpChildTaskRun({

runId: "run-runtime-owned-cancel",

});

const cancelDetachedTaskRunByIdSpy = vi.fn(async () => ({

found: true,

cancelled: false,

reason: "runtime refused cancel",

}));

setDetachedTaskLifecycleRuntime({

...getDetachedTaskLifecycleRuntime(),

cancelDetachedTaskRunById: cancelDetachedTaskRunByIdSpy,

});

const cancelled = await cancelDetachedTaskRunById({

cfg: {} as never,

taskId: child.taskId,

});

expect(cancelled.found).toBe(true);

expect(cancelled.cancelled).toBe(false);

expect(cancelled.reason).toBe("runtime refused cancel");

expect(cancelDetachedTaskRunByIdSpy).toHaveBeenCalledWith({

cfg: {} as never,

taskId: child.taskId,

});

const task = getTaskById(child.taskId);

expect(task?.taskId).toBe(child.taskId);

expect(task?.status).toBe("running");

expect(hoisted.cancelSessionMock).not.toHaveBeenCalled();

});

});

it("cancels active subagent child tasks", async () => {

await withTaskExecutorStateDir(async () => {

hoisted.killSubagentRunAdminMock.mockResolvedValue({

found: true,

killed: true,

});

const child = createRunningTaskRun({

runtime: "subagent",

ownerKey: "agent:main:main",

scopeKind: "session",

childSessionKey: "agent:codex:subagent:child",

runId: "run-subagent-cancel",

task: "Inspect a PR",

startedAt: 10,

deliveryStatus: "pending",

});

const cancelled = await cancelDetachedTaskRunById({

cfg: {} as never,

taskId: child.taskId,

});

expect(cancelled.found).toBe(true);

expect(cancelled.cancelled).toBe(true);

const task = getTaskById(child.taskId);

expect(task?.taskId).toBe(child.taskId);

expect(task?.status).toBe("cancelled");

expect(hoisted.killSubagentRunAdminMock).toHaveBeenCalledWith({

cfg: {} as never,

sessionKey: "agent:codex:subagent:child",

});

});

});

it("routes TaskFlow cancellation through the registered detached runtime", async () => {

await withTaskExecutorStateDir(async () => {

hoisted.cancelSessionMock.mockResolvedValue(undefined);

const flow = createManagedTaskFlow({

ownerKey: "agent:main:main",

controllerId: "tests/cancel-flow",

goal: "Cancel linked tasks",

});

const child = runTaskInFlow({

flowId: flow.flowId,

runtime: "acp",

childSessionKey: "agent:codex:acp:child",

runId: "run-flow-cancel-via-runtime",

task: "Cancel flow child",

status: "running",

startedAt: 10,

});

if (!child.created) {

throw new Error("expected child task creation to succeed");

}

const childTask = child.task;

if (!childTask) {

throw new Error("expected child task payload");

}

const cancelDetachedTaskRunByIdSpy = spyOnRuntimeCancel();

const cancelled = await cancelFlowById({

cfg: {} as never,

flowId: flow.flowId,

});

expect(cancelDetachedTaskRunByIdSpy).toHaveBeenCalledWith({

cfg: {} as never,

taskId: childTask.taskId,

});

expect(cancelled.found).toBe(true);

expect(cancelled.cancelled).toBe(true);

expect(cancelled.flow?.flowId).toBe(flow.flowId);

expect(cancelled.flow?.status).toBe("cancelled");

});

});

it("scopes run-id updates to the matching runtime and session", async () => {

await withTaskExecutorStateDir(async () => {

const victim = createRunningTaskRun({

runtime: "acp",

ownerKey: "agent:victim:main",

scopeKind: "session",

childSessionKey: "agent:victim:acp:child",

runId: "run-shared-executor-scope",

task: "Victim ACP task",

deliveryStatus: "pending",

});

const attacker = createRunningTaskRun({

runtime: "cli",

ownerKey: "agent:attacker:main",

scopeKind: "session",

childSessionKey: "agent:attacker:main",

runId: "run-shared-executor-scope",

task: "Attacker CLI task",

deliveryStatus: "not_applicable",

});

failTaskRunByRunId({

runId: "run-shared-executor-scope",

runtime: "cli",

sessionKey: "agent:attacker:main",

endedAt: 40,

lastEventAt: 40,

error: "attacker controlled error",

});

const attackerTask = getTaskById(attacker.taskId);

expect(attackerTask?.status).toBe("failed");

expect(attackerTask?.error).toBe("attacker controlled error");

expect(getTaskById(victim.taskId)?.status).toBe("running");

});

});

});