daycare-cli 0.0.0-canary.f57680e

package/dist/engine/agents/agent.spec.js

@@ -0,0 +1,622 @@
+import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { createId } from "@paralleldrive/cuid2";
+import { Agent } from "./agent.js";
+import { AgentInbox } from "./ops/agentInbox.js";
+import { AgentSystem } from "./agentSystem.js";
+import { ConnectorRegistry } from "../modules/connectorRegistry.js";
+import { ImageGenerationRegistry } from "../modules/imageGenerationRegistry.js";
+import { ToolResolver } from "../modules/toolResolver.js";
+import { EngineEventBus } from "../ipc/events.js";
+import { AuthStore } from "../../auth/store.js";
+import { FileStore } from "../../files/store.js";
+import { configResolve } from "../../config/configResolve.js";
+import { ConfigModule } from "../config/configModule.js";
+import { Signals } from "../signals/signals.js";
+import { DelayedSignals } from "../signals/delayedSignals.js";
+import { agentStateRead } from "./ops/agentStateRead.js";
+describe("Agent", () => {
+    it("persists descriptor, state, and history on create", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-agent-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir }, assistant: { workspaceDir: dir } }, path.join(dir, "settings.json"));
+            const agentSystem = new AgentSystem({
+                config: new ConfigModule(config),
+                eventBus: new EngineEventBus(),
+                connectorRegistry: new ConnectorRegistry({
+                    onMessage: async () => undefined
+                }),
+                imageRegistry: new ImageGenerationRegistry(),
+                toolResolver: new ToolResolver(),
+                pluginManager: {},
+                inferenceRouter: {},
+                fileStore: new FileStore(config),
+                authStore: new AuthStore(config)
+            });
+            agentSystem.setCrons({});
+            const agentId = createId();
+            const descriptor = {
+                type: "user",
+                connector: "slack",
+                channelId: "channel-1",
+                userId: "user-1"
+            };
+            await Agent.create(agentId, descriptor, new AgentInbox(agentId), agentSystem);
+            const descriptorPath = path.join(config.agentsDir, agentId, "descriptor.json");
+            const statePath = path.join(config.agentsDir, agentId, "state.json");
+            const historyPath = path.join(config.agentsDir, agentId, "history.jsonl");
+            const descriptorRaw = await readFile(descriptorPath, "utf8");
+            expect(JSON.parse(descriptorRaw)).toEqual(descriptor);
+            const stateRaw = await readFile(statePath, "utf8");
+            const state = JSON.parse(stateRaw);
+            expect(state.permissions.workingDir).toBe(config.defaultPermissions.workingDir);
+            const historyRaw = await readFile(historyPath, "utf8");
+            expect(historyRaw).toContain("\"type\":\"start\"");
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("sends reset confirmation from agent for user resets with context", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-agent-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir }, assistant: { workspaceDir: dir } }, path.join(dir, "settings.json"));
+            const connectorRegistry = new ConnectorRegistry({
+                onMessage: async () => undefined
+            });
+            const sendMessage = vi.fn(async () => undefined);
+            const connector = {
+                capabilities: { sendText: true },
+                onMessage: () => () => undefined,
+                sendMessage
+            };
+            const registerResult = connectorRegistry.register("telegram", connector);
+            expect(registerResult).toEqual({ ok: true, status: "loaded" });
+            const agentSystem = new AgentSystem({
+                config: new ConfigModule(config),
+                eventBus: new EngineEventBus(),
+                connectorRegistry,
+                imageRegistry: new ImageGenerationRegistry(),
+                toolResolver: new ToolResolver(),
+                pluginManager: {},
+                inferenceRouter: {},
+                fileStore: new FileStore(config),
+                authStore: new AuthStore(config)
+            });
+            agentSystem.setCrons({});
+            await agentSystem.load();
+            await agentSystem.start();
+            const descriptor = {
+                type: "user",
+                connector: "telegram",
+                channelId: "channel-1",
+                userId: "user-1"
+            };
+            const result = await agentSystem.postAndAwait({ descriptor }, {
+                type: "reset",
+                message: "Manual reset requested by the user.",
+                context: { messageId: "42" }
+            });
+            expect(result).toEqual({ type: "reset", ok: true });
+            expect(sendMessage).toHaveBeenCalledWith("channel-1", {
+                text: "🔄 Session reset.",
+                replyToMessageId: "42"
+            });
+            await connectorRegistry.unregisterAll("test");
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("rotates inference session id on reset", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-agent-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir }, assistant: { workspaceDir: dir } }, path.join(dir, "settings.json"));
+            const agentSystem = new AgentSystem({
+                config: new ConfigModule(config),
+                eventBus: new EngineEventBus(),
+                connectorRegistry: new ConnectorRegistry({
+                    onMessage: async () => undefined
+                }),
+                imageRegistry: new ImageGenerationRegistry(),
+                toolResolver: new ToolResolver(),
+                pluginManager: {},
+                inferenceRouter: {},
+                fileStore: new FileStore(config),
+                authStore: new AuthStore(config)
+            });
+            agentSystem.setCrons({});
+            await agentSystem.load();
+            await agentSystem.start();
+            const descriptor = {
+                type: "cron",
+                id: createId(),
+                name: "Reset Session Agent"
+            };
+            await agentSystem.postAndAwait({ descriptor }, { type: "reset", message: "first reset" });
+            const agentId = await agentSystem.agentIdForTarget({ descriptor });
+            const firstState = await agentStateRead(config, agentId);
+            expect(firstState?.inferenceSessionId).toBeTruthy();
+            await agentSystem.postAndAwait({ agentId }, { type: "reset", message: "second reset" });
+            const secondState = await agentStateRead(config, agentId);
+            expect(secondState?.inferenceSessionId).toBeTruthy();
+            expect(secondState?.inferenceSessionId).not.toBe(firstState?.inferenceSessionId);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("shows typing and writes compaction logs for manual compaction", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-agent-"));
+        try {
+            const config = configResolve({
+                engine: { dataDir: dir },
+                assistant: { workspaceDir: dir },
+                providers: [{ id: "openai", model: "gpt-4.1" }]
+            }, path.join(dir, "settings.json"));
+            const connectorRegistry = new ConnectorRegistry({
+                onMessage: async () => undefined
+            });
+            const sendMessage = vi.fn(async () => undefined);
+            const stopTyping = vi.fn(() => undefined);
+            const startTyping = vi.fn(() => stopTyping);
+            const connector = {
+                capabilities: { sendText: true, typing: true },
+                onMessage: () => () => undefined,
+                sendMessage,
+                startTyping
+            };
+            const registerResult = connectorRegistry.register("telegram", connector);
+            expect(registerResult).toEqual({ ok: true, status: "loaded" });
+            let receivedSessionId;
+            const complete = vi.fn(async (_context, sessionId) => {
+                receivedSessionId = sessionId;
+                return {
+                    providerId: "openai",
+                    modelId: "gpt-4.1",
+                    message: {
+                        role: "assistant",
+                        content: [{ type: "text", text: "Compacted summary" }],
+                        api: "openai-responses",
+                        provider: "openai",
+                        model: "gpt-4.1",
+                        usage: {
+                            input: 10,
+                            output: 5,
+                            cacheRead: 0,
+                            cacheWrite: 0,
+                            totalTokens: 15,
+                            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+                        },
+                        stopReason: "stop",
+                        timestamp: Date.now()
+                    }
+                };
+            });
+            const inferenceRouter = {
+                complete
+            };
+            const agentSystem = new AgentSystem({
+                config: new ConfigModule(config),
+                eventBus: new EngineEventBus(),
+                connectorRegistry,
+                imageRegistry: new ImageGenerationRegistry(),
+                toolResolver: new ToolResolver(),
+                pluginManager: {},
+                inferenceRouter,
+                fileStore: new FileStore(config),
+                authStore: new AuthStore(config)
+            });
+            agentSystem.setCrons({});
+            await agentSystem.load();
+            await agentSystem.start();
+            const descriptor = {
+                type: "user",
+                connector: "telegram",
+                channelId: "channel-1",
+                userId: "user-1"
+            };
+            await agentSystem.postAndAwait({ descriptor }, { type: "reset", message: "seed context" });
+            const agentId = await agentSystem.agentIdForTarget({ descriptor });
+            const beforeCompaction = await agentStateRead(config, agentId);
+            expect(beforeCompaction?.inferenceSessionId).toBeTruthy();
+            const result = await agentSystem.postAndAwait({ descriptor }, { type: "compact", context: { messageId: "88" } });
+            expect(result).toEqual({ type: "compact", ok: true });
+            expect(complete).toHaveBeenCalledTimes(1);
+            expect(receivedSessionId).toBe(beforeCompaction?.inferenceSessionId);
+            expect(startTyping).toHaveBeenCalledWith("channel-1");
+            expect(stopTyping).toHaveBeenCalledTimes(1);
+            expect(sendMessage).toHaveBeenLastCalledWith("channel-1", {
+                text: "Session compacted.",
+                replyToMessageId: "88"
+            });
+            const state = await agentStateRead(config, agentId);
+            const firstContextMessage = state?.context.messages?.[0];
+            expect(firstContextMessage?.role).toBe("user");
+            expect(typeof firstContextMessage?.content).toBe("string");
+            expect(String(firstContextMessage?.content)).toContain("Session context compacted.");
+            const files = await readdir(path.join(config.agentsDir, agentId));
+            expect(files.some((file) => file.startsWith("compaction_") && file.endsWith(".md"))).toBe(true);
+            await connectorRegistry.unregisterAll("test");
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("reports empty compaction summaries without changing context", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-agent-"));
+        try {
+            const config = configResolve({
+                engine: { dataDir: dir },
+                assistant: { workspaceDir: dir },
+                providers: [{ id: "openai", model: "gpt-4.1" }]
+            }, path.join(dir, "settings.json"));
+            const connectorRegistry = new ConnectorRegistry({
+                onMessage: async () => undefined
+            });
+            const sendMessage = vi.fn(async () => undefined);
+            const connector = {
+                capabilities: { sendText: true, typing: true },
+                onMessage: () => () => undefined,
+                sendMessage,
+                startTyping: () => () => undefined
+            };
+            const registerResult = connectorRegistry.register("telegram", connector);
+            expect(registerResult).toEqual({ ok: true, status: "loaded" });
+            const inferenceRouter = {
+                complete: vi.fn(async () => ({
+                    providerId: "openai",
+                    modelId: "gpt-4.1",
+                    message: {
+                        role: "assistant",
+                        content: [{ type: "text", text: "   " }],
+                        api: "openai-responses",
+                        provider: "openai",
+                        model: "gpt-4.1",
+                        usage: {
+                            input: 10,
+                            output: 5,
+                            cacheRead: 0,
+                            cacheWrite: 0,
+                            totalTokens: 15,
+                            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+                        },
+                        stopReason: "stop",
+                        timestamp: Date.now()
+                    }
+                }))
+            };
+            const agentSystem = new AgentSystem({
+                config: new ConfigModule(config),
+                eventBus: new EngineEventBus(),
+                connectorRegistry,
+                imageRegistry: new ImageGenerationRegistry(),
+                toolResolver: new ToolResolver(),
+                pluginManager: {},
+                inferenceRouter,
+                fileStore: new FileStore(config),
+                authStore: new AuthStore(config)
+            });
+            agentSystem.setCrons({});
+            await agentSystem.load();
+            await agentSystem.start();
+            const descriptor = {
+                type: "user",
+                connector: "telegram",
+                channelId: "channel-1",
+                userId: "user-1"
+            };
+            await agentSystem.postAndAwait({ descriptor }, { type: "reset", message: "seed context" });
+            const result = await agentSystem.postAndAwait({ descriptor }, { type: "compact", context: { messageId: "89" } });
+            expect(result).toEqual({ type: "compact", ok: false });
+            expect(sendMessage).toHaveBeenLastCalledWith("channel-1", {
+                text: "Compaction produced an empty summary; context unchanged.",
+                replyToMessageId: "89"
+            });
+            await connectorRegistry.unregisterAll("test");
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("drops queued signals after unsubscribe before agent handles inbox", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-agent-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir }, assistant: { workspaceDir: dir } }, path.join(dir, "settings.json"));
+            const eventBus = new EngineEventBus();
+            const agentSystem = new AgentSystem({
+                config: new ConfigModule(config),
+                eventBus,
+                connectorRegistry: new ConnectorRegistry({
+                    onMessage: async () => undefined
+                }),
+                imageRegistry: new ImageGenerationRegistry(),
+                toolResolver: new ToolResolver(),
+                pluginManager: {},
+                inferenceRouter: {},
+                fileStore: new FileStore(config),
+                authStore: new AuthStore(config)
+            });
+            agentSystem.setCrons({});
+            const signals = new Signals({
+                eventBus,
+                configDir: config.configDir,
+                onDeliver: async (signal, subscriptions) => {
+                    await agentSystem.signalDeliver(signal, subscriptions);
+                }
+            });
+            agentSystem.setSignals(signals);
+            await agentSystem.load();
+            const agentId = createId();
+            const descriptor = { type: "cron", id: agentId, name: "Signal agent" };
+            await agentSystem.post({ descriptor }, { type: "reset", message: "init" });
+            signals.subscribe({ agentId, pattern: "build:*:done", silent: true });
+            await signals.generate({ type: "build:alpha:done", source: { type: "system" } });
+            signals.unsubscribe({ agentId, pattern: "build:*:done" });
+            await agentSystem.start();
+            await agentSystem.postAndAwait({ agentId }, { type: "reset", message: "flush queue" });
+            const historyPath = path.join(config.agentsDir, agentId, "history.jsonl");
+            const historyRaw = await readFile(historyPath, "utf8");
+            expect(historyRaw.includes("[signal]")).toBe(false);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("delivers queued signal when subscribed at handling time", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-agent-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir }, assistant: { workspaceDir: dir } }, path.join(dir, "settings.json"));
+            const eventBus = new EngineEventBus();
+            const agentSystem = new AgentSystem({
+                config: new ConfigModule(config),
+                eventBus,
+                connectorRegistry: new ConnectorRegistry({
+                    onMessage: async () => undefined
+                }),
+                imageRegistry: new ImageGenerationRegistry(),
+                toolResolver: new ToolResolver(),
+                pluginManager: {},
+                inferenceRouter: {},
+                fileStore: new FileStore(config),
+                authStore: new AuthStore(config)
+            });
+            agentSystem.setCrons({});
+            const signals = new Signals({
+                eventBus,
+                configDir: config.configDir,
+                onDeliver: async (signal, subscriptions) => {
+                    await agentSystem.signalDeliver(signal, subscriptions);
+                }
+            });
+            agentSystem.setSignals(signals);
+            await agentSystem.load();
+            const agentId = createId();
+            const descriptor = { type: "cron", id: agentId, name: "Signal agent" };
+            await agentSystem.post({ descriptor }, { type: "reset", message: "init" });
+            signals.subscribe({ agentId, pattern: "build:*:done", silent: true });
+            await signals.generate({ type: "build:alpha:done", source: { type: "system" } });
+            signals.unsubscribe({ agentId, pattern: "build:*:done" });
+            signals.subscribe({ agentId, pattern: "build:*:done", silent: true });
+            await agentSystem.start();
+            await agentSystem.postAndAwait({ agentId }, { type: "reset", message: "flush queue" });
+            const historyPath = path.join(config.agentsDir, agentId, "history.jsonl");
+            const historyRaw = await readFile(historyPath, "utf8");
+            expect(historyRaw.includes("[signal]")).toBe(true);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("does not deliver agent-sourced signals back to the same agent", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-agent-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir }, assistant: { workspaceDir: dir } }, path.join(dir, "settings.json"));
+            const eventBus = new EngineEventBus();
+            const agentSystem = new AgentSystem({
+                config: new ConfigModule(config),
+                eventBus,
+                connectorRegistry: new ConnectorRegistry({
+                    onMessage: async () => undefined
+                }),
+                imageRegistry: new ImageGenerationRegistry(),
+                toolResolver: new ToolResolver(),
+                pluginManager: {},
+                inferenceRouter: {},
+                fileStore: new FileStore(config),
+                authStore: new AuthStore(config)
+            });
+            agentSystem.setCrons({});
+            const signals = new Signals({
+                eventBus,
+                configDir: config.configDir,
+                onDeliver: async (signal, subscriptions) => {
+                    await agentSystem.signalDeliver(signal, subscriptions);
+                }
+            });
+            agentSystem.setSignals(signals);
+            await agentSystem.load();
+            const sourceAgentId = createId();
+            const peerAgentId = createId();
+            await agentSystem.post({ descriptor: { type: "cron", id: sourceAgentId, name: "Source agent" } }, { type: "reset", message: "init source" });
+            await agentSystem.post({ descriptor: { type: "cron", id: peerAgentId, name: "Peer agent" } }, { type: "reset", message: "init peer" });
+            signals.subscribe({ agentId: sourceAgentId, pattern: "build:*:done", silent: true });
+            signals.subscribe({ agentId: peerAgentId, pattern: "build:*:done", silent: true });
+            await signals.generate({
+                type: "build:alpha:done",
+                source: { type: "agent", id: sourceAgentId }
+            });
+            await agentSystem.start();
+            await agentSystem.postAndAwait({ agentId: sourceAgentId }, { type: "reset", message: "flush source queue" });
+            await agentSystem.postAndAwait({ agentId: peerAgentId }, { type: "reset", message: "flush peer queue" });
+            const sourceHistoryPath = path.join(config.agentsDir, sourceAgentId, "history.jsonl");
+            const sourceHistoryRaw = await readFile(sourceHistoryPath, "utf8");
+            expect(sourceHistoryRaw.includes("[signal]")).toBe(false);
+            const peerHistoryPath = path.join(config.agentsDir, peerAgentId, "history.jsonl");
+            const peerHistoryRaw = await readFile(peerHistoryPath, "utf8");
+            expect(peerHistoryRaw.includes("[signal]")).toBe(true);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("emits wake and sleep lifecycle signals", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-agent-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir }, assistant: { workspaceDir: dir } }, path.join(dir, "settings.json"));
+            const eventBus = new EngineEventBus();
+            const agentSystem = new AgentSystem({
+                config: new ConfigModule(config),
+                eventBus,
+                connectorRegistry: new ConnectorRegistry({
+                    onMessage: async () => undefined
+                }),
+                imageRegistry: new ImageGenerationRegistry(),
+                toolResolver: new ToolResolver(),
+                pluginManager: {},
+                inferenceRouter: {},
+                fileStore: new FileStore(config),
+                authStore: new AuthStore(config)
+            });
+            agentSystem.setCrons({});
+            const signals = new Signals({ eventBus, configDir: config.configDir });
+            agentSystem.setSignals(signals);
+            await agentSystem.load();
+            await agentSystem.start();
+            const lifecycleTypes = [];
+            const unsubscribe = eventBus.onEvent((event) => {
+                if (event.type !== "signal.generated") {
+                    return;
+                }
+                const payload = event.payload;
+                if (!payload.type.startsWith("agent:")) {
+                    return;
+                }
+                lifecycleTypes.push(payload.type);
+            });
+            const agentId = createId();
+            const descriptor = { type: "cron", id: agentId, name: "Lifecycle agent" };
+            await agentSystem.postAndAwait({ descriptor }, { type: "reset", message: "init lifecycle" });
+            await agentSystem.postAndAwait({ agentId }, { type: "reset", message: "wake lifecycle" });
+            unsubscribe();
+            expect(lifecycleTypes).toContain(`agent:${agentId}:sleep`);
+            expect(lifecycleTypes).toContain(`agent:${agentId}:wake`);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("emits idle lifecycle signal one minute after sleeping", async () => {
+        vi.useFakeTimers();
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-agent-"));
+        let delayedSignals = null;
+        try {
+            const config = configResolve({ engine: { dataDir: dir }, assistant: { workspaceDir: dir } }, path.join(dir, "settings.json"));
+            const eventBus = new EngineEventBus();
+            const configModule = new ConfigModule(config);
+            const signals = new Signals({ eventBus, configDir: config.configDir });
+            delayedSignals = new DelayedSignals({ config: configModule, eventBus, signals });
+            const agentSystem = new AgentSystem({
+                config: configModule,
+                eventBus,
+                connectorRegistry: new ConnectorRegistry({
+                    onMessage: async () => undefined
+                }),
+                imageRegistry: new ImageGenerationRegistry(),
+                toolResolver: new ToolResolver(),
+                pluginManager: {},
+                inferenceRouter: {},
+                fileStore: new FileStore(config),
+                authStore: new AuthStore(config),
+                delayedSignals
+            });
+            agentSystem.setCrons({});
+            agentSystem.setSignals(signals);
+            await delayedSignals.start();
+            await agentSystem.load();
+            await agentSystem.start();
+            const lifecycleTypes = [];
+            const unsubscribe = eventBus.onEvent((event) => {
+                if (event.type !== "signal.generated") {
+                    return;
+                }
+                const payload = event.payload;
+                lifecycleTypes.push(payload.type);
+            });
+            const agentId = createId();
+            const descriptor = { type: "cron", id: agentId, name: "Idle agent" };
+            await agentSystem.postAndAwait({ descriptor }, { type: "reset", message: "init idle lifecycle" });
+            await vi.advanceTimersByTimeAsync(59_000);
+            expect(lifecycleTypes).not.toContain(`agent:${agentId}:idle`);
+            await vi.advanceTimersByTimeAsync(1_000);
+            await vi.waitFor(() => {
+                expect(lifecycleTypes).toContain(`agent:${agentId}:idle`);
+            });
+            unsubscribe();
+        }
+        finally {
+            delayedSignals?.stop();
+            vi.useRealTimers();
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("cancels pending idle lifecycle signal when agent wakes", async () => {
+        vi.useFakeTimers();
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-agent-"));
+        let delayedSignals = null;
+        try {
+            const config = configResolve({ engine: { dataDir: dir }, assistant: { workspaceDir: dir } }, path.join(dir, "settings.json"));
+            const eventBus = new EngineEventBus();
+            const configModule = new ConfigModule(config);
+            const signals = new Signals({ eventBus, configDir: config.configDir });
+            delayedSignals = new DelayedSignals({ config: configModule, eventBus, signals });
+            const agentSystem = new AgentSystem({
+                config: configModule,
+                eventBus,
+                connectorRegistry: new ConnectorRegistry({
+                    onMessage: async () => undefined
+                }),
+                imageRegistry: new ImageGenerationRegistry(),
+                toolResolver: new ToolResolver(),
+                pluginManager: {},
+                inferenceRouter: {},
+                fileStore: new FileStore(config),
+                authStore: new AuthStore(config),
+                delayedSignals
+            });
+            agentSystem.setCrons({});
+            agentSystem.setSignals(signals);
+            await delayedSignals.start();
+            await agentSystem.load();
+            await agentSystem.start();
+            const lifecycleTypes = [];
+            const unsubscribe = eventBus.onEvent((event) => {
+                if (event.type !== "signal.generated") {
+                    return;
+                }
+                const payload = event.payload;
+                lifecycleTypes.push(payload.type);
+            });
+            const agentId = createId();
+            const descriptor = { type: "cron", id: agentId, name: "Wake cancel agent" };
+            await agentSystem.postAndAwait({ descriptor }, { type: "reset", message: "initial sleep" });
+            await vi.advanceTimersByTimeAsync(30_000);
+            await agentSystem.postAndAwait({ agentId }, { type: "reset", message: "wake before idle deadline" });
+            await vi.advanceTimersByTimeAsync(30_000);
+            expect(lifecycleTypes).not.toContain(`agent:${agentId}:idle`);
+            await vi.advanceTimersByTimeAsync(30_000);
+            await vi.waitFor(() => {
+                expect(lifecycleTypes).toContain(`agent:${agentId}:idle`);
+            });
+            unsubscribe();
+        }
+        finally {
+            delayedSignals?.stop();
+            vi.useRealTimers();
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+//# sourceMappingURL=agent.spec.js.map