comisai 1.0.10 → 1.0.12

package/node_modules/@comis/core/dist/event-bus/events-messaging.test.js

@@ -1,433 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { TypedEventBus } from "./bus.js";
-const testSessionKey = { tenantId: "t1", userId: "u1", channelId: "c1" };
-const testMessage = {
-    id: "550e8400-e29b-41d4-a716-446655440000",
-    channelId: "c1",
-    channelType: "telegram",
-    senderId: "u1",
-    text: "hello",
-    timestamp: Date.now(),
-    attachments: [],
-    metadata: {},
-};
-describe("MessagingEvents payload structure", () => {
-    it("message:received delivers NormalizedMessage + SessionKey", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        bus.on("message:received", handler);
-        bus.emit("message:received", { message: testMessage, sessionKey: testSessionKey });
-        expect(handler).toHaveBeenCalledOnce();
-        const payload = handler.mock.calls[0][0];
-        expect(payload.message.id).toBe("550e8400-e29b-41d4-a716-446655440000");
-        expect(payload.message.channelType).toBe("telegram");
-        expect(payload.message.text).toBe("hello");
-        expect(payload.message.attachments).toEqual([]);
-        expect(payload.sessionKey.tenantId).toBe("t1");
-        expect(payload.sessionKey.userId).toBe("u1");
-        expect(payload.sessionKey.channelId).toBe("c1");
-    });
-    it("message:sent delivers channelId, messageId, content", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            channelId: "c1",
-            messageId: "msg-001",
-            content: "Reply text",
-        };
-        bus.on("message:sent", handler);
-        bus.emit("message:sent", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.channelId).toBe("c1");
-        expect(received.messageId).toBe("msg-001");
-        expect(received.content).toBe("Reply text");
-    });
-    it("message:streaming delivers delta + accumulated", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            channelId: "c1",
-            messageId: "msg-002",
-            delta: "world",
-            accumulated: "hello world",
-        };
-        bus.on("message:streaming", handler);
-        bus.emit("message:streaming", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.delta).toBe("world");
-        expect(received.accumulated).toBe("hello world");
-    });
-    it("session:created delivers sessionKey + timestamp", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const now = Date.now();
-        const payload = {
-            sessionKey: testSessionKey,
-            timestamp: now,
-        };
-        bus.on("session:created", handler);
-        bus.emit("session:created", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.sessionKey).toEqual(testSessionKey);
-        expect(received.timestamp).toBe(now);
-    });
-    it("session:expired delivers sessionKey + reason", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            sessionKey: testSessionKey,
-            reason: "idle_timeout",
-        };
-        bus.on("session:expired", handler);
-        bus.emit("session:expired", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.reason).toBe("idle_timeout");
-    });
-    it("session:cross_send delivers mode union type", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const now = Date.now();
-        for (const mode of ["fire-and-forget", "wait", "ping-pong"]) {
-            const payload = {
-                fromSessionKey: "session-a",
-                toSessionKey: "session-b",
-                mode,
-                timestamp: now,
-            };
-            bus.on("session:cross_send", handler);
-            bus.emit("session:cross_send", payload);
-            bus.removeAllListeners("session:cross_send");
-        }
-        expect(handler).toHaveBeenCalledTimes(3);
-        expect(handler.mock.calls[0][0].mode).toBe("fire-and-forget");
-        expect(handler.mock.calls[1][0].mode).toBe("wait");
-        expect(handler.mock.calls[2][0].mode).toBe("ping-pong");
-    });
-    it("session:sub_agent_spawned delivers runId, parentSessionKey, agentId, task", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            runId: "run-001",
-            parentSessionKey: "parent-session",
-            agentId: "sub-agent-1",
-            task: "summarize conversation",
-            timestamp: Date.now(),
-        };
-        bus.on("session:sub_agent_spawned", handler);
-        bus.emit("session:sub_agent_spawned", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.runId).toBe("run-001");
-        expect(received.parentSessionKey).toBe("parent-session");
-        expect(received.agentId).toBe("sub-agent-1");
-        expect(received.task).toBe("summarize conversation");
-    });
-    it("compaction:started delivers agentId, sessionKey, timestamp", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const now = Date.now();
-        const payload = {
-            agentId: "agent-1",
-            sessionKey: testSessionKey,
-            timestamp: now,
-        };
-        bus.on("compaction:started", handler);
-        bus.emit("compaction:started", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.agentId).toBe("agent-1");
-        expect(received.sessionKey).toEqual(testSessionKey);
-    });
-    it("compaction:recommended delivers contextPercent, contextTokens, contextWindow", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            agentId: "agent-1",
-            sessionKey: testSessionKey,
-            contextPercent: 92.5,
-            contextTokens: 185000,
-            contextWindow: 200000,
-            timestamp: Date.now(),
-        };
-        bus.on("compaction:recommended", handler);
-        bus.emit("compaction:recommended", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.contextPercent).toBe(92.5);
-        expect(received.contextTokens).toBe(185000);
-        expect(received.contextWindow).toBe(200000);
-    });
-    it("execution:aborted delivers reason union type", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const reasons = [
-            "user_stop",
-            "budget_exceeded",
-            "circuit_breaker",
-            "max_steps",
-            "context_exhausted",
-            "pipeline_timeout",
-        ];
-        for (const reason of reasons) {
-            const payload = {
-                sessionKey: testSessionKey,
-                reason,
-                agentId: "agent-1",
-                timestamp: Date.now(),
-            };
-            bus.on("execution:aborted", handler);
-            bus.emit("execution:aborted", payload);
-            bus.removeAllListeners("execution:aborted");
-        }
-        expect(handler).toHaveBeenCalledTimes(6);
-        expect(handler.mock.calls[0][0].reason).toBe("user_stop");
-        expect(handler.mock.calls[4][0].reason).toBe("context_exhausted");
-        expect(handler.mock.calls[5][0].reason).toBe("pipeline_timeout");
-    });
-    it("execution:prompt_timeout delivers agentId, sessionKey, timeoutMs", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            agentId: "agent-1",
-            sessionKey: "default:user1:channel1",
-            timeoutMs: 180_000,
-            timestamp: Date.now(),
-        };
-        bus.on("execution:prompt_timeout", handler);
-        bus.emit("execution:prompt_timeout", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.agentId).toBe("agent-1");
-        expect(received.timeoutMs).toBe(180_000);
-    });
-    it("announcement:dead_lettered delivers runId, channelType, reason, timestamp", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const now = Date.now();
-        const payload = {
-            runId: "run-dlq-001",
-            channelType: "telegram",
-            reason: "connection_timeout",
-            timestamp: now,
-        };
-        bus.on("announcement:dead_lettered", handler);
-        bus.emit("announcement:dead_lettered", payload);
-        expect(handler).toHaveBeenCalledOnce();
-        const received = handler.mock.calls[0][0];
-        expect(received.runId).toBe("run-dlq-001");
-        expect(received.channelType).toBe("telegram");
-        expect(received.reason).toBe("connection_timeout");
-        expect(received.timestamp).toBe(now);
-    });
-    it("announcement:dead_letter_delivered delivers runId, channelType, attemptCount, timestamp", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const now = Date.now();
-        const payload = {
-            runId: "run-dlq-002",
-            channelType: "discord",
-            attemptCount: 3,
-            timestamp: now,
-        };
-        bus.on("announcement:dead_letter_delivered", handler);
-        bus.emit("announcement:dead_letter_delivered", payload);
-        expect(handler).toHaveBeenCalledOnce();
-        const received = handler.mock.calls[0][0];
-        expect(received.runId).toBe("run-dlq-002");
-        expect(received.channelType).toBe("discord");
-        expect(typeof received.attemptCount).toBe("number");
-        expect(received.attemptCount).toBe(3);
-        expect(received.timestamp).toBe(now);
-    });
-    it("type safety: @ts-expect-error for missing required fields", () => {
-        const bus = new TypedEventBus();
-        // @ts-expect-error - missing sessionKey in message:received
-        bus.emit("message:received", { message: testMessage });
-        // @ts-expect-error - missing content in message:sent
-        bus.emit("message:sent", { channelId: "c1", messageId: "m1" });
-    });
-});
-// ---------------------------------------------------------------------------
-// Subagent context lifecycle events (Phase 398)
-// ---------------------------------------------------------------------------
-describe("Subagent context lifecycle events (Phase 398)", () => {
-    it("session:sub_agent_spawn_prepared delivers rich payload", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            runId: "run-spawn-001",
-            parentSessionKey: "parent-session",
-            agentId: "sub-agent-1",
-            task: "analyze codebase",
-            depth: 1,
-            maxDepth: 3,
-            artifactCount: 5,
-            timestamp: Date.now(),
-        };
-        bus.on("session:sub_agent_spawn_prepared", handler);
-        bus.emit("session:sub_agent_spawn_prepared", payload);
-        expect(handler).toHaveBeenCalledOnce();
-        const received = handler.mock.calls[0][0];
-        expect(received.runId).toBe("run-spawn-001");
-        expect(received.parentSessionKey).toBe("parent-session");
-        expect(received.agentId).toBe("sub-agent-1");
-        expect(received.task).toBe("analyze codebase");
-        expect(received.depth).toBe(1);
-        expect(received.maxDepth).toBe(3);
-        expect(received.artifactCount).toBe(5);
-    });
-    it("session:sub_agent_result_condensed delivers condensation data", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            runId: "run-cond-001",
-            agentId: "sub-agent-1",
-            level: 2,
-            originalTokens: 8000,
-            condensedTokens: 3500,
-            compressionRatio: 0.4375,
-            taskComplete: true,
-            diskPath: "/tmp/results/run-cond-001.json",
-            timestamp: Date.now(),
-        };
-        bus.on("session:sub_agent_result_condensed", handler);
-        bus.emit("session:sub_agent_result_condensed", payload);
-        expect(handler).toHaveBeenCalledOnce();
-        const received = handler.mock.calls[0][0];
-        expect(received.level).toBe(2);
-        expect(received.compressionRatio).toBe(0.4375);
-        expect(received.originalTokens).toBe(8000);
-        expect(received.condensedTokens).toBe(3500);
-        expect(received.taskComplete).toBe(true);
-        expect(received.diskPath).toBe("/tmp/results/run-cond-001.json");
-    });
-    it("session:sub_agent_lifecycle_ended includes end reason", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            runId: "run-end-001",
-            agentId: "sub-agent-1",
-            parentSessionKey: "parent-session",
-            endReason: "completed",
-            durationMs: 15000,
-            tokensUsed: 12000,
-            cost: 0.036,
-            condensationLevel: 1,
-            timestamp: Date.now(),
-        };
-        bus.on("session:sub_agent_lifecycle_ended", handler);
-        bus.emit("session:sub_agent_lifecycle_ended", payload);
-        expect(handler).toHaveBeenCalledOnce();
-        const received = handler.mock.calls[0][0];
-        expect(received.endReason).toBe("completed");
-        expect(received.durationMs).toBe(15000);
-        expect(received.tokensUsed).toBe(12000);
-        expect(received.cost).toBe(0.036);
-        expect(received.condensationLevel).toBe(1);
-    });
-    it("session:sub_agent_spawn_rejected delivers rejection reason", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            parentSessionKey: "parent-session",
-            agentId: "sub-agent-deep",
-            task: "go deeper",
-            reason: "depth_exceeded",
-            currentDepth: 3,
-            maxDepth: 3,
-            currentChildren: 2,
-            maxChildren: 5,
-            timestamp: Date.now(),
-        };
-        bus.on("session:sub_agent_spawn_rejected", handler);
-        bus.emit("session:sub_agent_spawn_rejected", payload);
-        expect(handler).toHaveBeenCalledOnce();
-        const received = handler.mock.calls[0][0];
-        expect(received.reason).toBe("depth_exceeded");
-        expect(received.currentDepth).toBe(3);
-        expect(received.maxDepth).toBe(3);
-    });
-    it("session:sub_agent_spawn_queued delivers all fields", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            runId: "run-queued-001",
-            parentSessionKey: "parent-session",
-            agentId: "sub-agent-1",
-            task: "queued task",
-            queuePosition: 2,
-            activeChildren: 5,
-            maxChildren: 5,
-            timestamp: Date.now(),
-        };
-        bus.on("session:sub_agent_spawn_queued", handler);
-        bus.emit("session:sub_agent_spawn_queued", payload);
-        expect(handler).toHaveBeenCalledOnce();
-        const received = handler.mock.calls[0][0];
-        expect(received.runId).toBe("run-queued-001");
-        expect(received.parentSessionKey).toBe("parent-session");
-        expect(received.agentId).toBe("sub-agent-1");
-        expect(received.task).toBe("queued task");
-        expect(received.queuePosition).toBe(2);
-        expect(received.activeChildren).toBe(5);
-        expect(received.maxChildren).toBe(5);
-    });
-    it("existing sub_agent_spawned event still works (regression guard)", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            runId: "run-legacy-001",
-            parentSessionKey: "parent-session",
-            agentId: "sub-agent-1",
-            task: "summarize conversation",
-            timestamp: Date.now(),
-        };
-        bus.on("session:sub_agent_spawned", handler);
-        bus.emit("session:sub_agent_spawned", payload);
-        expect(handler).toHaveBeenCalledOnce();
-        const received = handler.mock.calls[0][0];
-        expect(received.runId).toBe("run-legacy-001");
-        expect(received.task).toBe("summarize conversation");
-    });
-});
-// ---------------------------------------------------------------------------
-// Config nesting integration (Phase 398)
-// ---------------------------------------------------------------------------
-import { SecurityConfigSchema } from "../config/schema-security.js";
-describe("Config nesting integration", () => {
-    it("SecurityConfigSchema includes subagentContext with defaults", () => {
-        const config = SecurityConfigSchema.parse({});
-        expect(config.agentToAgent.subagentContext.maxSpawnDepth).toBe(3);
-        expect(config.agentToAgent.subagentContext.maxChildrenPerAgent).toBe(5);
-        expect(config.agentToAgent.subagentContext.maxResultTokens).toBe(4_000);
-        expect(config.agentToAgent.subagentContext.condensationStrategy).toBe("auto");
-        expect(config.agentToAgent.subagentContext.objectiveReinforcement).toBe(true);
-        expect(config.agentToAgent.subagentContext.resultRetentionMs).toBe(86_400_000);
-    });
-    it("existing agentToAgent fields preserved", () => {
-        const config = SecurityConfigSchema.parse({});
-        expect(config.agentToAgent.enabled).toBe(true);
-        expect(config.agentToAgent.maxPingPongTurns).toBe(3);
-        expect(config.agentToAgent.subAgentMaxSteps).toBe(50);
-        expect(config.agentToAgent.subAgentMcpTools).toBe("inherit");
-    });
-    it("subagentContext overrides merge with defaults", () => {
-        const config = SecurityConfigSchema.parse({
-            agentToAgent: {
-                subagentContext: {
-                    maxSpawnDepth: 5,
-                    condensationStrategy: "always",
-                },
-            },
-        });
-        expect(config.agentToAgent.subagentContext.maxSpawnDepth).toBe(5);
-        expect(config.agentToAgent.subagentContext.condensationStrategy).toBe("always");
-        // Other defaults still applied
-        expect(config.agentToAgent.subagentContext.maxChildrenPerAgent).toBe(5);
-        expect(config.agentToAgent.subagentContext.maxResultTokens).toBe(4_000);
-    });
-});

package/node_modules/@comis/core/dist/event-bus/events.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@comis/core/dist/event-bus/events.test.js

@@ -1,93 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { TypedEventBus } from "./bus.js";
-describe("EventMap composition", () => {
-    it("EventMap extends all 4 sub-interfaces", () => {
-        // Runtime: verify representative keys exist
-        const bus = new TypedEventBus();
-        const keys = [
-            "message:received",
-            "skill:loaded",
-            "channel:registered",
-            "config:patched",
-            "graph:started",
-        ];
-        expect(keys).toHaveLength(5);
-    });
-    it("round-trips one event from each domain group through TypedEventBus", () => {
-        const bus = new TypedEventBus();
-        // MessagingEvents: message:received
-        const msgHandler = vi.fn();
-        const sessionKey = { tenantId: "t1", userId: "u1", channelId: "c1" };
-        const message = {
-            id: "550e8400-e29b-41d4-a716-446655440000",
-            channelId: "c1",
-            channelType: "telegram",
-            senderId: "u1",
-            text: "hello",
-            timestamp: Date.now(),
-            attachments: [],
-            metadata: {},
-        };
-        bus.on("message:received", msgHandler);
-        bus.emit("message:received", { message, sessionKey });
-        expect(msgHandler).toHaveBeenCalledOnce();
-        expect(msgHandler.mock.calls[0][0].message.text).toBe("hello");
-        expect(msgHandler.mock.calls[0][0].sessionKey.tenantId).toBe("t1");
-        // AgentEvents: skill:loaded
-        const skillHandler = vi.fn();
-        const skillPayload = { skillName: "greet", source: "/skills/greet.md", timestamp: Date.now() };
-        bus.on("skill:loaded", skillHandler);
-        bus.emit("skill:loaded", skillPayload);
-        expect(skillHandler).toHaveBeenCalledWith(skillPayload);
-        // ChannelEvents: channel:registered
-        const chanHandler = vi.fn();
-        const chanPayload = {
-            channelType: "discord",
-            pluginId: "discord-01",
-            capabilities: {
-                chatTypes: ["dm", "group"],
-                features: {
-                    reactions: true,
-                    editMessages: true,
-                    deleteMessages: true,
-                    fetchHistory: false,
-                    attachments: true,
-                    threads: false,
-                    mentions: true,
-                    formatting: ["markdown"],
-                    buttons: false,
-                    cards: false,
-                    effects: false,
-                },
-                limits: { maxMessageChars: 2000 },
-                streaming: { supported: false, throttleMs: 300, method: "none" },
-                threading: { supported: false, threadType: "none" },
-            },
-            timestamp: Date.now(),
-        };
-        bus.on("channel:registered", chanHandler);
-        bus.emit("channel:registered", chanPayload);
-        expect(chanHandler).toHaveBeenCalledWith(chanPayload);
-        // InfraEvents: config:patched
-        const cfgHandler = vi.fn();
-        const cfgPayload = { section: "agent", key: "model", patchedBy: "admin", timestamp: Date.now() };
-        bus.on("config:patched", cfgHandler);
-        bus.emit("config:patched", cfgPayload);
-        expect(cfgHandler).toHaveBeenCalledWith(cfgPayload);
-    });
-    it("keyof EventMap includes events from all 4 sub-interfaces", () => {
-        // Type-level: satisfies checks that specific event names are valid EventMap keys
-        const _msgKey = "message:received";
-        const _agentKey = "tool:executed";
-        const _chanKey = "queue:enqueued";
-        const _infraKey = "system:shutdown";
-        expect(true).toBe(true); // type-level test passes if it compiles
-    });
-    it("type safety: @ts-expect-error for nonexistent event names on EventMap-typed bus", () => {
-        const bus = new TypedEventBus();
-        // @ts-expect-error - nonexistent event name
-        bus.on("does:not:exist", vi.fn());
-        // @ts-expect-error - close but wrong event name
-        bus.on("message:receivd", vi.fn());
-    });
-});

package/node_modules/@comis/core/dist/hooks/hook-runner-global.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@comis/core/dist/hooks/hook-runner-global.test.js

@@ -1,29 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import { setGlobalHookRunner, getGlobalHookRunner, clearGlobalHookRunner, } from "./hook-runner-global.js";
-describe("hook-runner-global", () => {
-    afterEach(() => {
-        clearGlobalHookRunner();
-    });
-    it("returns null before any runner is set", () => {
-        expect(getGlobalHookRunner()).toBeNull();
-    });
-    it("returns the runner after setGlobalHookRunner", () => {
-        const runner = {};
-        setGlobalHookRunner(runner);
-        expect(getGlobalHookRunner()).toBe(runner);
-    });
-    it("returns null after clearGlobalHookRunner", () => {
-        const runner = {};
-        setGlobalHookRunner(runner);
-        clearGlobalHookRunner();
-        expect(getGlobalHookRunner()).toBeNull();
-    });
-    it("replaces the previous runner when set again", () => {
-        const first = {};
-        const second = {};
-        setGlobalHookRunner(first);
-        setGlobalHookRunner(second);
-        expect(getGlobalHookRunner()).toBe(second);
-        expect(getGlobalHookRunner()).not.toBe(first);
-    });
-});

package/node_modules/@comis/core/dist/hooks/hook-runner.test.d.ts

@@ -1 +0,0 @@
-export {};