daycare-cli 0.0.0-canary.00a24ac

package/dist/engine/engine.spec.js

@@ -0,0 +1,736 @@
+import { promises as fs } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { configResolve } from "../config/configResolve.js";
+import * as dockerContainersStaleRemoveModule from "../sandbox/docker/dockerContainersStaleRemove.js";
+import { storageOpen } from "../storage/storageOpen.js";
+import { userConnectorKeyCreate } from "../storage/userConnectorKeyCreate.js";
+import { agentPathConnector } from "./agents/ops/agentPathBuild.js";
+import { Engine } from "./engine.js";
+import { EngineEventBus } from "./ipc/events.js";
+describe("Engine reset command", () => {
+    it("posts reset with message context for user commands", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            const postSpy = vi.spyOn(engine.agentSystem, "post").mockResolvedValue(undefined);
+            const agentIdForTargetSpy = vi.spyOn(engine.agentSystem, "agentIdForTarget").mockResolvedValue("agent-1");
+            const sendMessage = vi.fn(async () => undefined);
+            const commandState = {};
+            const connector = {
+                capabilities: { sendText: true },
+                onMessage: () => () => undefined,
+                onCommand: (handler) => {
+                    commandState.handler = handler;
+                    return () => undefined;
+                },
+                sendMessage
+            };
+            const registerResult = engine.modules.connectors.register("telegram", connector);
+            expect(registerResult).toEqual({ ok: true, status: "loaded" });
+            const commandHandler = commandState.handler;
+            if (!commandHandler) {
+                throw new Error("Expected command handler to be registered");
+            }
+            const target = agentPathConnector("123", "telegram");
+            const context = { messageId: "55" };
+            await commandHandler("/reset", context, target);
+            expect(postSpy).toHaveBeenCalledTimes(1);
+            const postCall = postSpy.mock.calls[0];
+            if (!postCall) {
+                throw new Error("Expected reset post call");
+            }
+            const ctx = postCall[0];
+            const postTarget = postCall[1];
+            const payload = postCall[2];
+            expect(agentIdForTargetSpy).toHaveBeenCalledWith(ctx, {
+                path: expect.stringMatching(/^\/[^/]+\/telegram$/)
+            });
+            expect(postTarget.agentId).toBe("agent-1");
+            expect(payload).toEqual({
+                type: "reset",
+                message: "Manual reset requested by the user.",
+                context: expect.objectContaining(context)
+            });
+            expect(sendMessage).not.toHaveBeenCalled();
+            await engine.modules.connectors.unregisterAll("test");
+            await engine.shutdown();
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("drops pending debounced messages for descriptor before reset", async () => {
+        vi.useFakeTimers();
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            const postSpy = vi.spyOn(engine.agentSystem, "post").mockResolvedValue(undefined);
+            const agentIdForTargetSpy = vi.spyOn(engine.agentSystem, "agentIdForTarget").mockResolvedValue("agent-1");
+            const state = {};
+            const connector = {
+                capabilities: { sendText: true },
+                onMessage: (handler) => {
+                    state.messageHandler = handler;
+                    return () => undefined;
+                },
+                onCommand: (handler) => {
+                    state.commandHandler = handler;
+                    return () => undefined;
+                },
+                sendMessage: async () => undefined
+            };
+            const registerResult = engine.modules.connectors.register("telegram", connector);
+            expect(registerResult).toEqual({ ok: true, status: "loaded" });
+            const target = agentPathConnector("123", "telegram");
+            const messageHandler = state.messageHandler;
+            const commandHandler = state.commandHandler;
+            if (!messageHandler || !commandHandler) {
+                throw new Error("Expected handlers to be registered");
+            }
+            await messageHandler({ text: "can you check downloads?" }, { messageId: "1" }, target);
+            await commandHandler("/reset", { messageId: "2" }, target);
+            await vi.advanceTimersByTimeAsync(100);
+            expect(postSpy).toHaveBeenCalledTimes(1);
+            const postCall = postSpy.mock.calls[0];
+            if (!postCall) {
+                throw new Error("Expected reset post call");
+            }
+            const ctx = postCall[0];
+            const postTarget = postCall[1];
+            const payload = postCall[2];
+            expect(agentIdForTargetSpy).toHaveBeenCalledWith(ctx, {
+                path: expect.stringMatching(/^\/[^/]+\/telegram$/)
+            });
+            expect(postTarget.agentId).toBe("agent-1");
+            expect(payload).toEqual({
+                type: "reset",
+                message: "Manual reset requested by the user.",
+                context: expect.objectContaining({ messageId: "2" })
+            });
+            await engine.modules.connectors.unregisterAll("test");
+            await engine.shutdown();
+        }
+        finally {
+            vi.useRealTimers();
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("Engine context tool list", () => {
+    it("exposes no classical tools in model context", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            await engine.start();
+            const status = engine.getStatus();
+            expect(status.tools).toEqual([]);
+            await engine.shutdown();
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("Engine app costs wiring", () => {
+    it("scopes token stats fetch to ctx user", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            const findManySpy = vi.spyOn(engine.storage.tokenStats, "findMany").mockResolvedValue([]);
+            const findAllSpy = vi.spyOn(engine.storage.tokenStats, "findAll").mockResolvedValue([]);
+            const appServer = engine.appServer;
+            const ctx = { userId: "user-1" };
+            const options = { from: 100, to: 200 };
+            await appServer.tokenStatsFetch(ctx, options);
+            expect(findManySpy).toHaveBeenCalledWith(ctx, options);
+            expect(findAllSpy).not.toHaveBeenCalled();
+            await engine.shutdown();
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("Engine timezone mismatch handling", () => {
+    it("emits timezone update guidance enrichments when context timezone differs", async () => {
+        vi.useFakeTimers();
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            const postSpy = vi.spyOn(engine.agentSystem, "post").mockResolvedValue(undefined);
+            const state = {};
+            const connector = {
+                capabilities: { sendText: true },
+                onMessage: (handler) => {
+                    state.messageHandler = handler;
+                    return () => undefined;
+                },
+                onCommand: () => () => undefined,
+                sendMessage: async () => undefined
+            };
+            const registerResult = engine.modules.connectors.register("telegram", connector);
+            expect(registerResult).toEqual({ ok: true, status: "loaded" });
+            const target = agentPathConnector("123", "telegram");
+            const messageHandler = state.messageHandler;
+            if (!messageHandler) {
+                throw new Error("Expected message handler to be registered");
+            }
+            await messageHandler({ text: "seed" }, { messageId: "seed-1" }, target);
+            await vi.advanceTimersByTimeAsync(100);
+            postSpy.mockClear();
+            const user = await engine.storage.resolveUserByConnectorKey(userConnectorKeyCreate("telegram", "123"));
+            await engine.storage.users.update(user.id, {
+                timezone: "UTC",
+                updatedAt: Date.now()
+            });
+            await messageHandler({ text: "hello" }, { messageId: "msg-1", timezone: "America/New_York" }, target);
+            await vi.advanceTimersByTimeAsync(100);
+            expect(postSpy).toHaveBeenCalledTimes(1);
+            const call = postSpy.mock.calls[0];
+            if (!call) {
+                throw new Error("Expected agent post call");
+            }
+            const postedMessage = call[2];
+            expect(postedMessage.type).toBe("message");
+            expect(postedMessage.context.timezone).toBe("America/New_York");
+            expect(postedMessage.context.enrichments).toEqual(expect.arrayContaining([
+                {
+                    key: "timezone_change_notice",
+                    value: "Message context timezone changed from profile timezone UTC to America/New_York. Update profile timezone with user_profile_update."
+                },
+                {
+                    key: "profile_name_notice",
+                    value: "User first/last name are not set. If the name is visible from the context (e.g. connector profile, message signature), set it via user_profile_update. Otherwise, ask the user for their name."
+                }
+            ]));
+            const updatedUser = await engine.storage.users.findById(user.id);
+            expect(updatedUser?.timezone).toBe("UTC");
+            await engine.modules.connectors.unregisterAll("test");
+            await engine.shutdown();
+        }
+        finally {
+            vi.useRealTimers();
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("Engine startup plugin hooks", () => {
+    it("runs preStart hooks before systems and postStart hooks after systems", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            const order = [];
+            vi.spyOn(engine.pluginManager, "preStartAll").mockImplementation(async () => {
+                order.push("preStart");
+            });
+            vi.spyOn(engine.agentSystem, "start").mockImplementation(async () => {
+                order.push("agentSystem.start");
+            });
+            vi.spyOn(engine.crons, "start").mockImplementation(async () => {
+                order.push("crons.start");
+            });
+            vi.spyOn(engine.delayedSignals, "start").mockImplementation(async () => {
+                order.push("delayedSignals.start");
+            });
+            vi.spyOn(engine.pluginManager, "postStartAll").mockImplementation(async () => {
+                order.push("postStart");
+            });
+            await engine.start();
+            expect(order).toEqual([
+                "preStart",
+                "agentSystem.start",
+                "crons.start",
+                "delayedSignals.start",
+                "postStart"
+            ]);
+            await engine.shutdown();
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("discovers swarms before loading agents so restored sandboxes include swarm mounts", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            const discoverSpy = vi.spyOn(engine.swarms, "discover").mockResolvedValue([]);
+            const loadSpy = vi.spyOn(engine.agentSystem, "load").mockResolvedValue();
+            vi.spyOn(engine.providerManager, "reload").mockResolvedValue();
+            vi.spyOn(engine.processes, "load").mockResolvedValue();
+            vi.spyOn(engine.pluginManager, "reload").mockResolvedValue();
+            vi.spyOn(engine.appServer, "start").mockResolvedValue();
+            vi.spyOn(engine.channels, "load").mockResolvedValue();
+            vi.spyOn(engine.exposes, "start").mockResolvedValue();
+            vi.spyOn(engine.pluginManager, "preStartAll").mockResolvedValue();
+            vi.spyOn(engine.agentSystem, "start").mockResolvedValue();
+            vi.spyOn(engine.crons, "start").mockResolvedValue();
+            vi.spyOn(engine.delayedSignals, "start").mockResolvedValue();
+            vi.spyOn(engine.pluginManager, "postStartAll").mockResolvedValue();
+            vi.spyOn(engine.appServer, "stop").mockResolvedValue();
+            vi.spyOn(engine.modules.connectors, "unregisterAll").mockResolvedValue();
+            vi.spyOn(engine.exposes, "stop").mockResolvedValue();
+            vi.spyOn(engine.pluginManager, "unloadAll").mockResolvedValue();
+            await engine.start();
+            const discoverOrder = discoverSpy.mock.invocationCallOrder[0] ?? 0;
+            const loadOrder = loadSpy.mock.invocationCallOrder[0] ?? Number.MAX_SAFE_INTEGER;
+            expect(discoverOrder).toBeGreaterThan(0);
+            expect(discoverOrder).toBeLessThan(loadOrder);
+            await engine.shutdown();
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("Engine Docker stale container cleanup", () => {
+    it("runs startup stale scan when docker is enabled", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        const staleRemoveSpy = vi
+            .spyOn(dockerContainersStaleRemoveModule, "dockerContainersStaleRemove")
+            .mockResolvedValue(undefined);
+        try {
+            const config = configResolve({
+                engine: { dataDir: dir },
+                docker: { enabled: true, image: "daycare-sandbox", tag: "latest" }
+            }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            await engine.start();
+            expect(staleRemoveSpy).toHaveBeenCalledTimes(1);
+            expect(staleRemoveSpy).toHaveBeenCalledWith(expect.anything(), "daycare-sandbox:latest");
+            await engine.shutdown();
+        }
+        finally {
+            staleRemoveSpy.mockRestore();
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("skips startup stale scan when docker is disabled", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        const staleRemoveSpy = vi
+            .spyOn(dockerContainersStaleRemoveModule, "dockerContainersStaleRemove")
+            .mockResolvedValue(undefined);
+        try {
+            const config = configResolve({ engine: { dataDir: dir }, docker: { enabled: false } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            await engine.start();
+            expect(staleRemoveSpy).not.toHaveBeenCalled();
+            await engine.shutdown();
+        }
+        finally {
+            staleRemoveSpy.mockRestore();
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("Engine expose lifecycle", () => {
+    it("starts and stops expose module with engine lifecycle", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            const startSpy = vi.spyOn(engine.exposes, "start").mockResolvedValue(undefined);
+            const stopSpy = vi.spyOn(engine.exposes, "stop").mockResolvedValue(undefined);
+            await engine.start();
+            await engine.shutdown();
+            expect(startSpy).toHaveBeenCalledTimes(1);
+            expect(stopSpy).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("Engine tool registration", () => {
+    it("registers the skill tool in normal mode", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            await engine.start();
+            const toolNames = engine.modules.tools.listTools().map((tool) => tool.name);
+            expect(toolNames).toContain("skill");
+            expect(toolNames).toContain("agent_reset");
+            expect(toolNames).toContain("agent_compact");
+            expect(toolNames).toContain("user_profile_update");
+            await engine.shutdown();
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("Engine swarm registration", () => {
+    it("discovers swarms on startup and exposes swarm_create", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const seedStorage = await storageOpen(config.db.path, {
+                url: config.db.url,
+                autoMigrate: true
+            });
+            try {
+                const owner = (await seedStorage.users.findOwner()) ??
+                    (await seedStorage.users.create({
+                        id: "sy45wijd1hmr03ef2wu7busv",
+                        isOwner: true,
+                        createdAt: 0,
+                        updatedAt: 0,
+                        nametag: "owner"
+                    }));
+                await seedStorage.users.create({
+                    id: "swarm-user-1",
+                    parentUserId: owner.id,
+                    isSwarm: true,
+                    nametag: "github-reviewer",
+                    firstName: "GitHub",
+                    lastName: "Reviewer",
+                    bio: "Reviews pull requests",
+                    about: "PR-focused assistant",
+                    systemPrompt: "You are a focused PR review assistant.",
+                    memory: false
+                });
+            }
+            finally {
+                seedStorage.connection.close();
+            }
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            await engine.start();
+            const toolNames = engine.modules.tools.listTools().map((tool) => tool.name);
+            expect(toolNames).toContain("swarm_create");
+            await engine.shutdown();
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("Engine abort command", () => {
+    it("aborts active inference for user commands and confirms in channel", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            vi.spyOn(engine.agentSystem, "abortInferenceForTarget").mockReturnValue(true);
+            const postSpy = vi.spyOn(engine.agentSystem, "post").mockResolvedValue(undefined);
+            const sendMessage = vi.fn(async () => undefined);
+            const commandState = {};
+            const connector = {
+                capabilities: { sendText: true },
+                onMessage: () => () => undefined,
+                onCommand: (handler) => {
+                    commandState.handler = handler;
+                    return () => undefined;
+                },
+                sendMessage
+            };
+            const registerResult = engine.modules.connectors.register("telegram", connector);
+            expect(registerResult).toEqual({ ok: true, status: "loaded" });
+            const commandHandler = commandState.handler;
+            if (!commandHandler) {
+                throw new Error("Expected command handler to be registered");
+            }
+            const target = agentPathConnector("123", "telegram");
+            const context = { messageId: "56" };
+            await commandHandler("/abort", context, target);
+            expect(engine.agentSystem.abortInferenceForTarget).toHaveBeenCalledWith({
+                path: expect.stringMatching(/^\/[^/]+\/telegram$/)
+            });
+            expect(sendMessage).toHaveBeenCalledWith("123", {
+                text: "Stopped current inference.",
+                replyToMessageId: "56"
+            });
+            expect(postSpy).not.toHaveBeenCalled();
+            await engine.modules.connectors.unregisterAll("test");
+            await engine.shutdown();
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("Engine compact command", () => {
+    it("posts compact work for user commands", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            const postSpy = vi.spyOn(engine.agentSystem, "post").mockResolvedValue(undefined);
+            const agentIdForTargetSpy = vi.spyOn(engine.agentSystem, "agentIdForTarget").mockResolvedValue("agent-1");
+            const sendMessage = vi.fn(async () => undefined);
+            const commandState = {};
+            const connector = {
+                capabilities: { sendText: true },
+                onMessage: () => () => undefined,
+                onCommand: (handler) => {
+                    commandState.handler = handler;
+                    return () => undefined;
+                },
+                sendMessage
+            };
+            const registerResult = engine.modules.connectors.register("telegram", connector);
+            expect(registerResult).toEqual({ ok: true, status: "loaded" });
+            const commandHandler = commandState.handler;
+            if (!commandHandler) {
+                throw new Error("Expected command handler to be registered");
+            }
+            const target = agentPathConnector("123", "telegram");
+            const context = { messageId: "57" };
+            await commandHandler("/compact", context, target);
+            expect(postSpy).toHaveBeenCalledTimes(1);
+            const postCall = postSpy.mock.calls[0];
+            if (!postCall) {
+                throw new Error("Expected compact post call");
+            }
+            const ctx = postCall[0];
+            const postTarget = postCall[1];
+            const payload = postCall[2];
+            expect(agentIdForTargetSpy).toHaveBeenCalledWith(ctx, {
+                path: expect.stringMatching(/^\/[^/]+\/telegram$/)
+            });
+            expect(postTarget.agentId).toBe("agent-1");
+            expect(payload).toEqual({ type: "compact", context: expect.objectContaining(context) });
+            expect(sendMessage).not.toHaveBeenCalled();
+            await engine.modules.connectors.unregisterAll("test");
+            await engine.shutdown();
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("Engine plugin commands", () => {
+    it("dispatches unknown slash commands to the plugin command registry", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            const pluginHandler = vi.fn(async () => undefined);
+            engine.modules.commands.register("upgrade-plugin", {
+                command: "upgrade",
+                description: "Upgrade daycare to latest version",
+                handler: pluginHandler
+            });
+            const commandState = {};
+            const connector = {
+                capabilities: { sendText: true },
+                onMessage: () => () => undefined,
+                onCommand: (handler) => {
+                    commandState.handler = handler;
+                    return () => undefined;
+                },
+                sendMessage: async () => undefined
+            };
+            const registerResult = engine.modules.connectors.register("telegram", connector);
+            expect(registerResult).toEqual({ ok: true, status: "loaded" });
+            const commandHandler = commandState.handler;
+            if (!commandHandler) {
+                throw new Error("Expected command handler to be registered");
+            }
+            const target = agentPathConnector("123", "telegram");
+            const context = { messageId: "56" };
+            await commandHandler("/upgrade now", context, target);
+            expect(pluginHandler).toHaveBeenCalledWith("/upgrade now", expect.objectContaining(context), expect.stringMatching(/^\/[^/]+\/telegram$/));
+            await engine.modules.connectors.unregisterAll("test");
+            await engine.shutdown();
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("Engine message batching", () => {
+    it("debounces and combines connector messages per descriptor", async () => {
+        vi.useFakeTimers();
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            const postSpy = vi.spyOn(engine.agentSystem, "post").mockResolvedValue(undefined);
+            const messageState = {};
+            const connector = {
+                capabilities: { sendText: true },
+                onMessage: (handler) => {
+                    messageState.handler = handler;
+                    return () => undefined;
+                },
+                sendMessage: async () => undefined
+            };
+            const registerResult = engine.modules.connectors.register("telegram", connector);
+            expect(registerResult).toEqual({ ok: true, status: "loaded" });
+            const handler = messageState.handler;
+            if (!handler) {
+                throw new Error("Expected message handler to be registered");
+            }
+            const target = agentPathConnector("123", "telegram");
+            await handler({ text: "first" }, { messageId: "1" }, target);
+            await vi.advanceTimersByTimeAsync(50);
+            await handler({ text: "second" }, { messageId: "2" }, target);
+            await vi.advanceTimersByTimeAsync(99);
+            expect(postSpy).not.toHaveBeenCalled();
+            await vi.advanceTimersByTimeAsync(1);
+            expect(postSpy).toHaveBeenCalledTimes(1);
+            const postCall = postSpy.mock.calls[0];
+            if (!postCall) {
+                throw new Error("Expected batched post call");
+            }
+            const ctx = postCall[0];
+            const postTarget = postCall[1];
+            const payload = postCall[2];
+            expect(postTarget.path).toMatch(/^\/[^/]+\/telegram$/);
+            expect(postTarget.path.split("/")[1]).toBe(ctx.userId);
+            expect(payload).toEqual({
+                type: "message",
+                message: { text: "first\nsecond", rawText: "first\nsecond" },
+                context: expect.objectContaining({ messageId: "2" })
+            });
+            await engine.modules.connectors.unregisterAll("test");
+            await engine.shutdown();
+        }
+        finally {
+            vi.useRealTimers();
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("canonicalizes connector path with channel/user suffix", async () => {
+        vi.useFakeTimers();
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            const postSpy = vi.spyOn(engine.agentSystem, "post").mockResolvedValue(undefined);
+            const messageState = {};
+            const connector = {
+                capabilities: { sendText: true },
+                onMessage: (handler) => {
+                    messageState.handler = handler;
+                    return () => undefined;
+                },
+                sendMessage: async () => undefined
+            };
+            const registerResult = engine.modules.connectors.register("telegram", connector);
+            expect(registerResult).toEqual({ ok: true, status: "loaded" });
+            const handler = messageState.handler;
+            if (!handler) {
+                throw new Error("Expected message handler to be registered");
+            }
+            await handler({ text: "hello" }, { messageId: "1" }, "/user-7/telegram/channel-1/user-7");
+            await vi.advanceTimersByTimeAsync(100);
+            expect(postSpy).toHaveBeenCalledTimes(1);
+            const call = postSpy.mock.calls[0];
+            if (!call) {
+                throw new Error("Expected post call");
+            }
+            const ctx = call[0];
+            const target = call[1];
+            expect(target.path).toBe(`/${ctx.userId}/telegram/channel-1/user-7`);
+            const user = await engine.storage.resolveUserByConnectorKey(userConnectorKeyCreate("telegram", "channel-1/user-7"));
+            expect(user.id).toBe(ctx.userId);
+            await engine.modules.connectors.unregisterAll("test");
+            await engine.shutdown();
+        }
+        finally {
+            vi.useRealTimers();
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("ignores empty connector messages", async () => {
+        vi.useFakeTimers();
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            const postSpy = vi.spyOn(engine.agentSystem, "post").mockResolvedValue(undefined);
+            const messageState = {};
+            const connector = {
+                capabilities: { sendText: true },
+                onMessage: (handler) => {
+                    messageState.handler = handler;
+                    return () => undefined;
+                },
+                sendMessage: async () => undefined
+            };
+            const registerResult = engine.modules.connectors.register("telegram", connector);
+            expect(registerResult).toEqual({ ok: true, status: "loaded" });
+            const handler = messageState.handler;
+            if (!handler) {
+                throw new Error("Expected message handler to be registered");
+            }
+            const target = agentPathConnector("123", "telegram");
+            await handler({ text: "   " }, { messageId: "1" }, target);
+            await vi.advanceTimersByTimeAsync(100);
+            expect(postSpy).not.toHaveBeenCalled();
+            await engine.modules.connectors.unregisterAll("test");
+            await engine.shutdown();
+        }
+        finally {
+            vi.useRealTimers();
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it("routes incoming connector files from staging to user downloads before posting", async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), "daycare-engine-"));
+        try {
+            const config = configResolve({ engine: { dataDir: dir } }, path.join(dir, "settings.json"));
+            const engine = new Engine({ config, eventBus: new EngineEventBus() });
+            const postSpy = vi.spyOn(engine.agentSystem, "post").mockResolvedValue(undefined);
+            const messageState = {};
+            const connector = {
+                capabilities: { sendText: true },
+                onMessage: (handler) => {
+                    messageState.handler = handler;
+                    return () => undefined;
+                },
+                sendMessage: async () => undefined
+            };
+            const registerResult = engine.modules.connectors.register("telegram", connector);
+            expect(registerResult).toEqual({ ok: true, status: "loaded" });
+            const handler = messageState.handler;
+            if (!handler) {
+                throw new Error("Expected message handler to be registered");
+            }
+            const target = agentPathConnector("123", "telegram");
+            const stagedDir = path.join(config.dataDir, "tmp", "staging");
+            const stagedPath = path.join(stagedDir, "photo.jpg");
+            await fs.mkdir(stagedDir, { recursive: true });
+            await fs.writeFile(stagedPath, Buffer.from("image-bytes"));
+            await handler({
+                text: "photo",
+                files: [
+                    {
+                        id: "file-1",
+                        name: "photo.jpg",
+                        mimeType: "image/jpeg",
+                        size: 11,
+                        path: stagedPath
+                    }
+                ]
+            }, { messageId: "1" }, target);
+            await new Promise((resolve) => setTimeout(resolve, 120));
+            const user = await engine.storage.resolveUserByConnectorKey(userConnectorKeyCreate("telegram", "123"));
+            const postPayload = postSpy.mock.calls[0]?.[2];
+            const postedPath = postPayload.message.files?.[0]?.path ?? "";
+            const expectedDownloadsDir = path.join(config.usersDir, user.id, "home", "downloads");
+            expect(postSpy).toHaveBeenCalledTimes(1);
+            expect(postPayload.type).toBe("message");
+            expect(postedPath.startsWith(`${path.resolve(expectedDownloadsDir)}${path.sep}`)).toBe(true);
+            expect(postedPath).not.toContain(`${path.sep}tmp${path.sep}staging${path.sep}`);
+            await expect(fs.access(stagedPath)).rejects.toThrow();
+            await engine.modules.connectors.unregisterAll("test");
+            await engine.shutdown();
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+//# sourceMappingURL=engine.spec.js.map