Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(daemon): resolve task cancellation delay caused by empty agentId (#174)

Gener97e28c0d9cd1
diff --git a/src/cli/daemon/daemon.test.ts b/src/cli/daemon/daemon.test.ts
index 71a16fea0..e803db3fd 100644
--- a/src/cli/daemon/daemon.test.ts
+++ b/src/cli/daemon/daemon.test.ts
@@ -90,18 +90,22 @@ vi.mock("./update-handler.js", () => ({
const mockFindRunningPidByTaskId = vi.fn();
const mockFindRunningEntryByContextKey = vi.fn(() => null);
+const mockUpdateEntry = vi.fn();
vi.mock("./execenv/timeline.js", () => ({
findRunningPidByTaskId: (...args: any[]) => mockFindRunningPidByTaskId(...(args as any[])),
findRunningEntryByContextKey: (...args: any[]) => mockFindRunningEntryByContextKey(...(args as any[])),
+ updateEntry: (...args: any[]) => mockUpdateEntry(...(args as any[])),
}));
const mockWriteKillIntent = vi.fn();
+const mockReadKillIntent = vi.fn(() => null);
const mockClearKillIntent = vi.fn();
const mockAcquireSteeringLock = vi.fn(() => true);
const mockReleaseSteeringLock = vi.fn();
const mockCleanupStaleIntents = vi.fn();
vi.mock("./execenv/steering.js", () => ({
writeKillIntent: (...args: any[]) => mockWriteKillIntent(...(args as any[])),
+ readKillIntent: (...args: any[]) => mockReadKillIntent(...(args as any[])),
clearKillIntent: (...args: any[]) => mockClearKillIntent(...(args as any[])),
acquireSteeringLock: (...args: any[]) => mockAcquireSteeringLock(...(args as any[])),
releaseSteeringLock: (...args: any[]) => mockReleaseSteeringLock(...(args as any[])),
@@ -392,6 +396,40 @@ describe("daemon session runner dispatch", () => {
// We verify the listener was attached — the decrement logic is straightforward
});
+ it("skips failTask when kill intent exists on close", async () => {
+ setupTaskClaim();
+ mockReadKillIntent.mockReturnValue({ reason: "cancelled", targetTaskId: "t1", expectedPid: 50000 });
+
+ await startDaemon();
+ await new Promise((r) => setTimeout(r, 50));
+
+ // Simulate child process exit with non-zero code (killed)
+ spawnedChildren[0].emit("close", 1);
+ await new Promise((r) => setTimeout(r, 10));
+
+ expect(mockClientInstance.failTask).not.toHaveBeenCalled();
+ expect(mockClearKillIntent).toHaveBeenCalled();
+ });
+
+ it("calls failTask when no kill intent exists on close (genuine crash)", async () => {
+ setupTaskClaim();
+ mockReadKillIntent.mockReturnValue(null);
+
+ await startDaemon();
+ await new Promise((r) => setTimeout(r, 50));
+
+ // Simulate child process crash
+ spawnedChildren[0].emit("close", 1);
+
+ await vi.waitFor(() => {
+ expect(mockClientInstance.failTask).toHaveBeenCalledWith(
+ "al_test_token",
+ "t1",
+ expect.stringContaining("session-runner crashed"),
+ );
+ });
+ });
+
it("calls startTask before spawning session runner", async () => {
setupTaskClaim();
@@ -1715,6 +1753,28 @@ describe("daemon kill_task handling", () => {
mockKill.mockRestore();
});
+
+ it("searches correct timeline directory using agentId from task", async () => {
+ setupKillTaskClaim("target_t1");
+ mockFindRunningPidByTaskId.mockReturnValue(77777);
+ const mockKill = vi.spyOn(process, "kill").mockImplementation((() => {}) as any);
+
+ vi.mocked(loadCLIConfigForProfile).mockReturnValue({
+ server_url: "",
+ watched_workspaces: [{ id: "ws1", name: "Test WS", token: "al_test_token" }],
+ });
+ mockClientInstance.register.mockResolvedValue({ runtimes: [{ id: "rt1" }] });
+
+ await startDaemon();
+
+ // The timelineDir should be constructed from workspacesRoot/workspaceId/agentId/workdir/.context_timeline
+ const expectedTimelineDir = path.join("/tmp", "ws", "ws1", "a1", "workdir", ".context_timeline");
+ await vi.waitFor(() => {
+ expect(mockFindRunningPidByTaskId).toHaveBeenCalledWith(expectedTimelineDir, "target_t1");
+ });
+
+ mockKill.mockRestore();
+ });
});
describe("isClientError", () => {
diff --git a/src/cli/daemon/daemon.ts b/src/cli/daemon/daemon.ts
index 8b61c4472..7c57dca19 100644
--- a/src/cli/daemon/daemon.ts
+++ b/src/cli/daemon/daemon.ts
@@ -16,6 +16,8 @@ import { handleCliUpdate, isUpdating, readUpdateMarker, clearUpdateMarker } from
import { findRunningPidByTaskId, findRunningEntryByContextKey, updateEntry } from "./execenv/timeline.js";
import {
writeKillIntent,
+ readKillIntent,
+ clearKillIntent,
acquireSteeringLock,
releaseSteeringLock,
cleanupStaleIntents,
@@ -580,17 +582,17 @@ export async function startDaemon(
case "daemon.kill": {
const ws = workspaceStates.find((w) => w.workspaceId === msg.workspaceId);
- if (ws) {
+ if (ws && !activeTasks.has(msg.taskId)) {
const killTask = fromApiTask({
id: msg.taskId,
- agent_id: "",
+ agent_id: msg.agentId,
runtime_id: "",
conversation_id: "",
workspace_id: ws.workspaceId,
prompt: "",
- status: "queued",
+ status: "dispatched",
priority: 0,
- dispatched_at: null,
+ dispatched_at: new Date().toISOString(),
started_at: null,
completed_at: null,
result: null,
@@ -1032,13 +1034,21 @@ async function handleTask(
child.on("close", async (code) => {
activeTasks.delete(task.id);
if (code !== 0) {
+ const agentBaseDir = join(config.workspacesRoot, task.workspaceId, task.agentId, "workdir");
+ const killIntent = readKillIntent(agentBaseDir, task.id);
+ if (killIntent) {
+ log.info(`Task ${task.id} exited due to kill intent — skipping failTask`);
+ clearKillIntent(agentBaseDir, task.id);
+ return;
+ }
+
const msg = code === null
? `session-runner killed by signal (task ${task.id})`
: `session-runner crashed (exit code ${code}, task ${task.id})`;
log.warn(msg);
// Update timeline JSONL as fallback
- const timelineDir = join(config.workspacesRoot, task.workspaceId, task.agentId, "workdir", ".context_timeline");
+ const timelineDir = join(agentBaseDir, ".context_timeline");
updateEntry(timelineDir, task.id, (entry) => {
entry.pid = null;
entry.status = "failed";
diff --git a/src/shared/src/schemas.ts b/src/shared/src/schemas.ts
index 7020754cf..0342eeb10 100644
--- a/src/shared/src/schemas.ts
+++ b/src/shared/src/schemas.ts
@@ -174,7 +174,7 @@ export const DaemonPushMessageSchema = z.discriminatedUnion("type", [
z.object({ type: z.literal("daemon.evict"), workspaceId: z.string() }),
z.object({ type: z.literal("daemon.update"), version: z.string() }),
z.object({ type: z.literal("daemon.rescan") }),
- z.object({ type: z.literal("daemon.kill"), workspaceId: z.string(), taskId: z.string(), targetTaskId: z.string() }),
+ z.object({ type: z.literal("daemon.kill"), workspaceId: z.string(), agentId: z.string().min(1), taskId: z.string(), targetTaskId: z.string() }),
]);
export type DaemonPushMessageType = z.infer<typeof DaemonPushMessageSchema>;
diff --git a/src/shared/src/types.ts b/src/shared/src/types.ts
index b20f45bf4..b3b9780c6 100644
--- a/src/shared/src/types.ts
+++ b/src/shared/src/types.ts
@@ -304,4 +304,4 @@ export type DaemonPushMessage =
| { type: "daemon.evict"; workspaceId: string }
| { type: "daemon.update"; version: string }
| { type: "daemon.rescan" }
- | { type: "daemon.kill"; workspaceId: string; taskId: string; targetTaskId: string }
+ | { type: "daemon.kill"; workspaceId: string; agentId: string; taskId: string; targetTaskId: string }
diff --git a/src/shared/test/schemas/daemon-push-message.test.ts b/src/shared/test/schemas/daemon-push-message.test.ts
new file mode 100644
index 000000000..b1d5c2efa
--- /dev/null
+++ b/src/shared/test/schemas/daemon-push-message.test.ts
@@ -0,0 +1,51 @@
+import { describe, it, expect } from "vitest";
+import { DaemonPushMessageSchema } from "../../src/schemas";
+
+describe("DaemonPushMessageSchema — daemon.kill", () => {
+ it("accepts valid daemon.kill message with agentId", () => {
+ const msg = {
+ type: "daemon.kill",
+ workspaceId: "ws1",
+ agentId: "ag_abc123",
+ taskId: "kt1",
+ targetTaskId: "t1",
+ };
+ const result = DaemonPushMessageSchema.safeParse(msg);
+ expect(result.success).toBe(true);
+ });
+
+ it("rejects daemon.kill message without agentId", () => {
+ const msg = {
+ type: "daemon.kill",
+ workspaceId: "ws1",
+ taskId: "kt1",
+ targetTaskId: "t1",
+ };
+ const result = DaemonPushMessageSchema.safeParse(msg);
+ expect(result.success).toBe(false);
+ });
+
+ it("rejects daemon.kill message with non-string agentId", () => {
+ const msg = {
+ type: "daemon.kill",
+ workspaceId: "ws1",
+ agentId: 123,
+ taskId: "kt1",
+ targetTaskId: "t1",
+ };
+ const result = DaemonPushMessageSchema.safeParse(msg);
+ expect(result.success).toBe(false);
+ });
+
+ it("rejects daemon.kill message with empty string agentId", () => {
+ const msg = {
+ type: "daemon.kill",
+ workspaceId: "ws1",
+ agentId: "",
+ taskId: "kt1",
+ targetTaskId: "t1",
+ };
+ const result = DaemonPushMessageSchema.safeParse(msg);
+ expect(result.success).toBe(false);
+ });
+});
diff --git a/src/web/src/lib/services/task.test.ts b/src/web/src/lib/services/task.test.ts
index 049d78ee8..b643b7fd5 100644
--- a/src/web/src/lib/services/task.test.ts
+++ b/src/web/src/lib/services/task.test.ts
@@ -28,6 +28,7 @@ vi.mock("@alook/shared", () => ({
claimKillTasks: vi.fn().mockResolvedValue([]),
getActiveTaskByConversation: vi.fn(),
cancelTask: vi.fn(),
+ dispatchTaskById: vi.fn().mockResolvedValue(null),
findSteerableReplacement: vi.fn().mockResolvedValue(null),
},
agent: {
@@ -72,6 +73,7 @@ vi.mock("@/lib/api/responses", () => ({
import { TaskService } from "./task";
import { queries } from "@alook/shared";
import { broadcastToUser, broadcastToDaemon } from "@/lib/broadcast";
+import { log } from "@/lib/logger";
const taskQ = queries.task as {
[K in keyof typeof queries.task]: ReturnType<typeof vi.fn>;
@@ -835,6 +837,7 @@ describe("TaskService", () => {
expect(broadcastToDaemon).toHaveBeenCalledWith("d1", {
type: "daemon.kill",
workspaceId: "w1",
+ agentId: "a1",
taskId: "kt1",
targetTaskId: "t1",
});
@@ -895,6 +898,59 @@ describe("TaskService", () => {
expect(messageQ.activateNextBufferedMessage).toHaveBeenCalledWith({}, "c1");
});
+
+ it("daemon.kill payload includes agentId from active task", async () => {
+ const task = { id: "t1", status: "running", agentId: "agent_xyz", runtimeId: "r1", conversationId: "c1" };
+ taskQ.getActiveTaskByConversation.mockResolvedValue(task);
+ taskQ.cancelTask.mockResolvedValue({ ...task, status: "cancelled" });
+ taskQ.createTask.mockResolvedValue({ id: "kt1" });
+ taskQ.countRunningTasks.mockResolvedValue(0);
+ runtimeQ.getAgentRuntime.mockResolvedValue({ daemonId: "d1" });
+
+ await service.cancelActiveTask("c1", "w1");
+
+ expect(broadcastToDaemon).toHaveBeenCalledWith("d1", expect.objectContaining({
+ agentId: "agent_xyz",
+ }));
+ });
+
+ it("logs warning when daemon.kill broadcast fails", async () => {
+ const task = { id: "t1", status: "running", agentId: "a1", runtimeId: "r1", conversationId: "c1" };
+ taskQ.getActiveTaskByConversation.mockResolvedValue(task);
+ taskQ.cancelTask.mockResolvedValue({ ...task, status: "cancelled" });
+ taskQ.createTask.mockResolvedValue({ id: "kt1" });
+ taskQ.countRunningTasks.mockResolvedValue(0);
+ runtimeQ.getAgentRuntime.mockResolvedValue({ daemonId: "d1" });
+
+ const broadcastError = new Error("connection refused");
+ vi.mocked(broadcastToDaemon).mockRejectedValueOnce(broadcastError);
+
+ await service.cancelActiveTask("c1", "w1");
+
+ await vi.waitFor(() => {
+ expect(log.warn).toHaveBeenCalledWith(
+ "daemon.kill broadcast failed, relying on poll fallback",
+ broadcastError,
+ );
+ });
+ });
+
+ it("dispatches kill task before broadcasting daemon.kill", async () => {
+ const task = { id: "t1", status: "running", agentId: "a1", runtimeId: "r1", conversationId: "c1" };
+ taskQ.getActiveTaskByConversation.mockResolvedValue(task);
+ taskQ.cancelTask.mockResolvedValue({ ...task, status: "cancelled" });
+ taskQ.createTask.mockResolvedValue({ id: "kt1" });
+ taskQ.countRunningTasks.mockResolvedValue(0);
+ runtimeQ.getAgentRuntime.mockResolvedValue({ daemonId: "d1" });
+
+ await service.cancelActiveTask("c1", "w1");
+
+ expect(taskQ.dispatchTaskById).toHaveBeenCalledWith({}, "kt1", "w1");
+ // dispatchTaskById should be called before broadcastToDaemon
+ const dispatchOrder = taskQ.dispatchTaskById.mock.invocationCallOrder[0];
+ const broadcastOrder = vi.mocked(broadcastToDaemon).mock.invocationCallOrder[0];
+ expect(dispatchOrder).toBeLessThan(broadcastOrder);
+ });
});
// ── retryTask ──────────────────────────────────────────────
diff --git a/src/web/src/lib/services/task.ts b/src/web/src/lib/services/task.ts
index 072e06d7b..bbe934fdd 100644
--- a/src/web/src/lib/services/task.ts
+++ b/src/web/src/lib/services/task.ts
@@ -324,14 +324,19 @@ export class TaskService {
context: { target_task_id: activeTask.id },
});
+ // Dispatch (claim) the kill task so it arrives at the daemon in "dispatched" status,
+ // allowing the daemon to call failTask without a status mismatch error.
+ await taskQueries.dispatchTaskById(this.db, killTask.id, workspaceId);
+
const runtime = await queries.runtime.getAgentRuntime(this.db, activeTask.runtimeId);
if (runtime) {
broadcastToDaemon(runtime.daemonId, {
type: "daemon.kill",
workspaceId,
+ agentId: activeTask.agentId,
taskId: killTask.id,
targetTaskId: activeTask.id,
- }).catch(() => {});
+ }).catch((e) => log.warn("daemon.kill broadcast failed, relying on poll fallback", e));
}
}