@kafca/agentdock 0.1.56 → 0.1.58

package/dist-electron/tests/contracts/agent-message-policy.test.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const agent_message_policy_js_1 = require("../../services/local-ai-core/src/thread/agent-message-policy.js");
+(0, node_test_1.default)('agent message policy is owned by Local Core and includes selected knowledge context', () => {
+    const message = (0, agent_message_policy_js_1.composeAgentMessage)('Summarize the design', [
+        { id: 'kb-1', name: 'Architecture notes' },
+    ]);
+    strict_1.default.match(message, /\[Scheduler Tools\]/);
+    strict_1.default.match(message, /\[Monitor Tools\]/);
+    strict_1.default.match(message, /\[Channel Tools\]/);
+    strict_1.default.match(message, /id: kb-1 \| name: Architecture notes/);
+    strict_1.default.match(message, /\[User Message\]\nSummarize the design\n\[\/User Message\]/);
+});
+(0, node_test_1.default)('agent message policy leaves slash commands untouched', () => {
+    strict_1.default.equal((0, agent_message_policy_js_1.composeAgentMessage)('/agent use pi'), '/agent use pi');
+});

package/dist-electron/tests/contracts/architecture-docs.test.js

@@ -39,33 +39,6 @@ function readSourceFiles(scope) {
         content: (0, node_fs_1.readFileSync)(path, 'utf8'),
     }));
 }
-const rendererPackageSourceImportAllowlist = new Set([
-    'src/api/cron.ts',
-    'src/api/desktop.ts',
-    'src/api/knowledge.ts',
-    'src/api/monitors.ts',
-    'src/api/runtime-bootstrap.ts',
-    'src/app/runtime.ts',
-    'src/pages/Automation/MonitorList.tsx',
-    'src/pages/Cron/CronList.tsx',
-    'src/pages/Dashboard.tsx',
-    'src/pages/Knowledge/KnowledgeDetail.tsx',
-    'src/pages/Knowledge/KnowledgeHome.tsx',
-    'src/pages/System/Config.tsx',
-    'src/pages/Threads/thread-chat-action-types.ts',
-    'src/pages/Threads/thread-chat-model.ts',
-    'src/pages/Threads/thread-chat-page-state.ts',
-    'src/pages/Threads/thread-chat-permission.test.ts',
-    'src/pages/Threads/thread-chat-permission.ts',
-    'src/pages/Threads/useThreadChatActions.ts',
-    'src/pages/Threads/useThreadChatController.ts',
-    'src/pages/Threads/useThreadChatConversationState.ts',
-    'src/pages/Threads/useThreadChatSendingActions.ts',
-    'src/pages/Threads/useThreadChatSessionBrowser.ts',
-    'src/pages/Threads/ThreadChatComposer.tsx',
-    'src/pages/Threads/useThreadChatThreadActions.ts',
-    'src/types/window.d.ts',
-]);
 (0, node_test_1.default)('state ownership docs identify Local AI Core owners for durable chat and channel state', () => {
     const content = (0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, 'docs', 'architecture', 'state-ownership.md'), 'utf8');
     for (const state of [
@@ -111,12 +84,13 @@ const rendererPackageSourceImportAllowlist = new Set([
     strict_1.default.match(permissionSource, /export type PendingPermissionRequest = ThreadPendingPermissionRequest;/, 'renderer pending permission state must alias the shared thread permission contract');
     strict_1.default.doesNotMatch(permissionSource, /type PermissionTaskState\s*=/, 'permission helpers must not carry a second task-state union');
 });
-(0, node_test_1.default)('renderer does not add new direct imports of package source internals', () => {
-    const offenders = readSourceFiles('src')
-        .filter(({ content }) => /from ['"][^'"]*packages\/(?:contracts|core-sdk|plugin-sdk)\/src/.test(content))
-        .map(({ relativePath }) => relativePath)
-        .filter((relativePath) => !rendererPackageSourceImportAllowlist.has(relativePath));
-    strict_1.default.deepEqual(offenders, [], 'renderer code should import package APIs through stable public entrypoints; add migrations instead of new packages/*/src imports');
+(0, node_test_1.default)('production code imports workspace packages through public package names', () => {
+    const offenders = ['src', 'services', 'packages']
+        .flatMap(readSourceFiles)
+        .filter(({ relativePath }) => !relativePath.startsWith('packages/contracts/src/'))
+        .filter(({ content }) => /(?:packages\/(?:contracts|core-sdk|plugin-sdk|knowledge-api)|(?:contracts|core-sdk|plugin-sdk))\/src/.test(content))
+        .map(({ relativePath }) => relativePath);
+    strict_1.default.deepEqual(offenders, [], 'production code must import workspace dependencies through @cc/* public entrypoints');
 });
 (0, node_test_1.default)('renderer does not import Electron or Local AI Core internals', () => {
     const offenders = readSourceFiles('src')
@@ -137,4 +111,53 @@ const rendererPackageSourceImportAllowlist = new Set([
         const packageJson = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, packagePath), 'utf8'));
         strict_1.default.equal(packageJson.exports?.['.'], './src/index.ts', `${packagePath} must expose its public source entrypoint for workspace consumers`);
     }
+    const contracts = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, 'packages/contracts/package.json'), 'utf8'));
+    const domains = ['runtime', 'threads', 'channels', 'scheduler', 'automation', 'knowledge'];
+    for (const domain of domains) {
+        strict_1.default.ok(contracts.exports?.[`./${domain}`], `contracts must expose the ${domain} domain entrypoint`);
+    }
+    for (const packageName of ['contracts', 'core-sdk', 'plugin-sdk']) {
+        const packageJson = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, `packages/${packageName}/package.json`), 'utf8'));
+        for (const domain of domains) {
+            strict_1.default.equal(packageJson.exports?.[`./${domain}`], `./src/${domain}.ts`, `${packageName} must expose the ${domain} domain through its dedicated entrypoint`);
+        }
+    }
+});
+(0, node_test_1.default)('core sdk domain entrypoints do not re-export the top-level sdk', () => {
+    for (const domain of ['runtime', 'threads', 'channels', 'scheduler', 'automation', 'knowledge']) {
+        const source = (0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, `packages/core-sdk/src/${domain}.ts`), 'utf8');
+        strict_1.default.doesNotMatch(source, /(?:from|import\s*\()\s*['"]\.\/index\.js['"]/, `core-sdk/${domain} must own its implementation without depending on the aggregate entrypoint`);
+        strict_1.default.match(source, /coreRequest|coreClient/, `core-sdk/${domain} must own executable domain behavior`);
+    }
+});
+(0, node_test_1.default)('package domain modules do not depend on aggregate entrypoints', () => {
+    for (const packageName of ['contracts', 'core-sdk', 'plugin-sdk']) {
+        for (const domain of ['runtime', 'threads', 'channels', 'scheduler', 'automation', 'knowledge']) {
+            const source = (0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, `packages/${packageName}/src/${domain}.ts`), 'utf8');
+            strict_1.default.doesNotMatch(source, /(?:from|import\s*\()\s*['"]\.\/index(?:\.js)?['"]/, `${packageName}/${domain} must not reach back through its aggregate entrypoint`);
+        }
+    }
+});
+(0, node_test_1.default)('desktop contracts are consumed through the contracts package outside their owner', () => {
+    const offenders = ['src', 'services', 'packages']
+        .flatMap(readSourceFiles)
+        .filter(({ relativePath }) => !relativePath.startsWith('packages/contracts/src/'))
+        .filter(({ content }) => /shared\/desktop/.test(content))
+        .map(({ relativePath }) => relativePath);
+    strict_1.default.deepEqual(offenders, [], 'business code must consume shared desktop contracts through @cc/superai-contracts');
+});
+(0, node_test_1.default)('renderer does not branch features through the retired runtime provider string', () => {
+    const offenders = readSourceFiles('src')
+        .filter(({ content }) => /RuntimeProvider|getRuntimeProvider|runtimeProvider\s*(?:===|!==)/.test(content))
+        .map(({ relativePath }) => relativePath);
+    strict_1.default.deepEqual(offenders, [], 'renderer features must use capabilities or the Local Core contract directly');
+});
+(0, node_test_1.default)('chat syntax highlighting stays behind a lazy code-block boundary', () => {
+    const markdown = (0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, 'src/components/chat/ChatMarkdown.tsx'), 'utf8');
+    const highlighted = (0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, 'src/components/chat/HighlightedMarkdown.tsx'), 'utf8');
+    strict_1.default.doesNotMatch(markdown, /from ['"]rehype-highlight['"]/, 'base chat markdown must not eagerly load highlighting');
+    strict_1.default.match(markdown, /lazy\(\(\) =>\s*import\('\.\/HighlightedMarkdown'\)/, 'highlighting must use a lazy chunk');
+    for (const language of ['typescript', 'javascript', 'json', 'bash', 'python', 'xml', 'css', 'sql', 'yaml']) {
+        strict_1.default.match(highlighted, new RegExp(`highlight\\.js/lib/languages/${language}`), `${language} must remain in the supported subset`);
+    }
 });

package/dist-electron/tests/contracts/chat-event-gate.test.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const chat_event_gate_js_1 = require("../../src/components/chat/chat-event-gate.js");
+(0, node_test_1.default)('chat event gate rejects duplicate bridge events', () => {
+    const gate = (0, chat_event_gate_js_1.createChatEventGate)();
+    const event = {
+        type: 'update_message',
+        sessionKey: 'workspace:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'preview-1',
+        content: 'working',
+    };
+    strict_1.default.equal(gate.acceptBridgeEvent(event, { activeRunId: 'run-1' }), true);
+    strict_1.default.equal(gate.acceptBridgeEvent(event, { activeRunId: 'run-1' }), false);
+});
+(0, node_test_1.default)('chat event gate rejects late streaming updates after a turn settles', () => {
+    const gate = (0, chat_event_gate_js_1.createChatEventGate)();
+    const context = { activeRunId: 'run-1' };
+    strict_1.default.equal(gate.acceptBridgeEvent({
+        type: 'typing_stop',
+        sessionKey: 'workspace:thread-1',
+        replyCtx: 'run-1',
+    }, context), true);
+    strict_1.default.equal(gate.acceptBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'workspace:thread-1',
+        replyCtx: 'run-1',
+        content: 'late preview',
+    }, context), false);
+});
+(0, node_test_1.default)('chat event gate rejects events from a superseded run', () => {
+    const gate = (0, chat_event_gate_js_1.createChatEventGate)();
+    strict_1.default.equal(gate.acceptBridgeEvent({
+        type: 'reply',
+        sessionKey: 'workspace:thread-1',
+        replyCtx: 'run-old',
+        content: 'late answer',
+    }, {
+        activeRunId: 'run-old',
+        pendingTurn: {
+            sessionKey: 'workspace:thread-1',
+            supersededRunId: 'run-old',
+        },
+    }), false);
+});
+(0, node_test_1.default)('chat event gate deduplicates core refresh events while allowing changed payloads', () => {
+    const gate = (0, chat_event_gate_js_1.createChatEventGate)();
+    const first = {
+        type: 'message.updated',
+        threadId: 'thread-1',
+        message: { id: 'message-1', content: 'one' },
+    };
+    const second = {
+        ...first,
+        message: { id: 'message-1', content: 'two' },
+    };
+    strict_1.default.equal(gate.acceptCoreEvent(first), true);
+    strict_1.default.equal(gate.acceptCoreEvent(first), false);
+    strict_1.default.equal(gate.acceptCoreEvent(second), true);
+});
+(0, node_test_1.default)('chat event gate rejects late Core stream updates after the run settles', () => {
+    const gate = (0, chat_event_gate_js_1.createChatEventGate)();
+    const terminal = {
+        type: 'stream.updated',
+        stream: {
+            type: 'typing_stop',
+            sessionKey: 'workspace:thread-1',
+            replyCtx: 'run-1',
+        },
+    };
+    const lateUpdate = {
+        type: 'presence.updated',
+        live: true,
+        stream: {
+            type: 'update_message',
+            sessionKey: 'workspace:thread-1',
+            replyCtx: 'run-1',
+            content: 'late preview',
+        },
+    };
+    strict_1.default.equal(gate.acceptCoreEvent(terminal), true);
+    strict_1.default.equal(gate.acceptCoreEvent(lateUpdate), false);
+    strict_1.default.equal(gate.acceptCoreEvent({
+        type: 'stream.updated',
+        stream: {
+            type: 'reply',
+            sessionKey: 'workspace:thread-1',
+            replyCtx: 'run-1',
+            content: 'late final',
+        },
+    }), false);
+});
+(0, node_test_1.default)('chat event gate rejects late running state after a Core run completes', () => {
+    const gate = (0, chat_event_gate_js_1.createChatEventGate)();
+    const run = {
+        id: 'run-1',
+        threadId: 'thread-1',
+        startedAt: '',
+        updatedAt: '',
+    };
+    strict_1.default.equal(gate.acceptCoreEvent({
+        type: 'run.updated',
+        run: { ...run, status: 'completed' },
+    }), true);
+    strict_1.default.equal(gate.acceptCoreEvent({
+        type: 'run.updated',
+        run: { ...run, status: 'running' },
+    }), false);
+});

package/dist-electron/tests/contracts/chat-markdown.test.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const markdown_code_block_js_1 = require("../../src/components/chat/markdown-code-block.js");
+(0, node_test_1.default)('markdown code block detection covers fenced and indented code blocks', () => {
+    strict_1.default.equal((0, markdown_code_block_js_1.hasMarkdownCodeBlock)('```ts\nconst value = 1;\n```'), true);
+    strict_1.default.equal((0, markdown_code_block_js_1.hasMarkdownCodeBlock)('~~~python\nprint("hi")\n~~~'), true);
+    strict_1.default.equal((0, markdown_code_block_js_1.hasMarkdownCodeBlock)('  ````ts\nconst value = 1;\n`````'), true);
+    strict_1.default.equal((0, markdown_code_block_js_1.hasMarkdownCodeBlock)('```ts\nconst unfinished = true;'), true);
+    strict_1.default.equal((0, markdown_code_block_js_1.hasMarkdownCodeBlock)('Paragraph\n\n    pnpm test'), true);
+    strict_1.default.equal((0, markdown_code_block_js_1.hasMarkdownCodeBlock)('Use `inline code` only'), false);
+});

package/dist-electron/tests/contracts/thread-task-state.test.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const thread_chat_model_js_1 = require("../../src/pages/Threads/thread-chat-model.js");
+(0, node_test_1.default)('chatControllerActionForTaskState maps each chat task state to a named controller action', () => {
+    strict_1.default.deepEqual((0, thread_chat_model_js_1.chatControllerActionForTaskState)('idle'), { type: 'settled' });
+    strict_1.default.deepEqual((0, thread_chat_model_js_1.chatControllerActionForTaskState)('running'), { type: 'stream_started' });
+    strict_1.default.deepEqual((0, thread_chat_model_js_1.chatControllerActionForTaskState)('awaiting_input'), { type: 'input_requested' });
+    strict_1.default.deepEqual((0, thread_chat_model_js_1.chatControllerActionForTaskState)('awaiting_permission'), { type: 'permission_requested' });
+    strict_1.default.deepEqual((0, thread_chat_model_js_1.chatControllerActionForTaskState)('permission_submitted'), { type: 'permission_submitted' });
+    strict_1.default.deepEqual((0, thread_chat_model_js_1.chatControllerActionForTaskState)('stopping'), { type: 'stop_started' });
+    strict_1.default.deepEqual((0, thread_chat_model_js_1.chatControllerActionForTaskState)('error'), { type: 'failed' });
+});
+(0, node_test_1.default)('taskStateFromControllerStatus narrows the controller status without a cast', () => {
+    strict_1.default.equal((0, thread_chat_model_js_1.taskStateFromControllerStatus)('idle'), 'idle');
+    strict_1.default.equal((0, thread_chat_model_js_1.taskStateFromControllerStatus)('running'), 'running');
+    strict_1.default.equal((0, thread_chat_model_js_1.taskStateFromControllerStatus)('awaiting_input'), 'awaiting_input');
+    strict_1.default.equal((0, thread_chat_model_js_1.taskStateFromControllerStatus)('error'), 'error');
+    strict_1.default.equal((0, thread_chat_model_js_1.taskStateFromControllerStatus)('stopping'), 'stopping');
+    // Terminal controller statuses Threads never dispatches map back to 'error'.
+    strict_1.default.equal((0, thread_chat_model_js_1.taskStateFromControllerStatus)('failed'), 'error');
+    strict_1.default.equal((0, thread_chat_model_js_1.taskStateFromControllerStatus)('timed_out'), 'error');
+    // Session/Web-only statuses map defensively to 'running'.
+    strict_1.default.equal((0, thread_chat_model_js_1.taskStateFromControllerStatus)('sending'), 'running');
+    strict_1.default.equal((0, thread_chat_model_js_1.taskStateFromControllerStatus)('waiting'), 'running');
+    strict_1.default.equal((0, thread_chat_model_js_1.taskStateFromControllerStatus)('polling'), 'running');
+    strict_1.default.equal((0, thread_chat_model_js_1.taskStateFromControllerStatus)('activating'), 'running');
+});

package/dist-electron/tests/contracts/workspace-identity.test.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const workspace_model_js_1 = require("../../src/pages/Desktop/workspace-model.js");
+(0, node_test_1.default)('desktop workspace operations keep using stable identity after a display-name change', () => {
+    strict_1.default.equal((0, workspace_model_js_1.desktopProjectWorkspaceId)({
+        workspace_id: 'workspace-stable',
+        name: 'Renamed workspace',
+        agent: { type: 'pi' },
+        platforms: [],
+    }), 'workspace-stable');
+});
+(0, node_test_1.default)('desktop workspace identity falls back to legacy project names', () => {
+    strict_1.default.equal((0, workspace_model_js_1.desktopProjectWorkspaceId)({
+        name: 'Legacy workspace',
+        agent: { type: 'pi' },
+        platforms: [],
+    }), 'Legacy workspace');
+});

package/dist-electron/tests/electron/core-client.test.js

@@ -0,0 +1,284 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const client_js_1 = require("../../packages/core-sdk/src/client.js");
+class FakeEventSource {
+    listeners = new Map();
+    onerror = null;
+    onopen = null;
+    closed = false;
+    addEventListener(type, listener) {
+        const listeners = this.listeners.get(type) || new Set();
+        listeners.add(listener);
+        this.listeners.set(type, listeners);
+    }
+    emit(type, payload) {
+        for (const listener of this.listeners.get(type) || []) {
+            listener({ data: typeof payload === 'string' ? payload : JSON.stringify(payload) });
+        }
+    }
+    close() {
+        this.closed = true;
+    }
+}
+(0, node_test_1.default)('core client shares one event source across subscribers and closes it after the last unsubscribe', () => {
+    const sources = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1/',
+        eventSourceFactory: () => {
+            const source = new FakeEventSource();
+            sources.push(source);
+            return source;
+        },
+    });
+    const first = client.events.subscribe(() => { });
+    const second = client.events.subscribe(() => { });
+    strict_1.default.equal(sources.length, 1);
+    strict_1.default.equal(client.baseUrl, 'http://127.0.0.1:9831/api/local/v1');
+    first();
+    strict_1.default.equal(sources[0].closed, false);
+    second();
+    strict_1.default.equal(sources[0].closed, true);
+});
+(0, node_test_1.default)('core clients with the same base URL share one event source across instances', () => {
+    const sources = [];
+    const firstClient = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1/',
+        eventSourceFactory: () => {
+            const source = new FakeEventSource();
+            sources.push(source);
+            return source;
+        },
+    });
+    const secondClient = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1',
+        eventSourceFactory: () => {
+            const source = new FakeEventSource();
+            sources.push(source);
+            return source;
+        },
+    });
+    const firstEventTypes = [];
+    const secondEventTypes = [];
+    const stopFirst = firstClient.events.subscribe((event) => firstEventTypes.push(event.type));
+    const stopSecond = secondClient.events.subscribe((event) => secondEventTypes.push(event.type));
+    strict_1.default.equal(sources.length, 1);
+    sources[0].emit('presence.updated', { type: 'presence.updated', live: true });
+    strict_1.default.deepEqual(firstEventTypes, ['presence.updated']);
+    strict_1.default.deepEqual(secondEventTypes, ['presence.updated']);
+    stopFirst();
+    strict_1.default.equal(sources[0].closed, false);
+    stopSecond();
+    strict_1.default.equal(sources[0].closed, true);
+});
+(0, node_test_1.default)('core client ignores malformed events and maps stream events to bridge subscribers', () => {
+    const source = new FakeEventSource();
+    const events = [];
+    const bridgeContents = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1',
+        eventSourceFactory: () => source,
+    });
+    const stopEvents = client.events.subscribe((event) => events.push(event.type));
+    const stopBridge = client.events.subscribeBridge((event) => bridgeContents.push(event.content || ''));
+    source.emit('stream.updated', '{not-json');
+    source.emit('stream.updated', {
+        type: 'stream.updated',
+        stream: { type: 'reply', sessionKey: 'workspace:thread', content: 'done' },
+    });
+    strict_1.default.deepEqual(events, ['stream.updated']);
+    strict_1.default.deepEqual(bridgeContents, ['done']);
+    stopBridge();
+    stopEvents();
+});
+(0, node_test_1.default)('core client ignores valid JSON events that do not match the event contract', () => {
+    const source = new FakeEventSource();
+    const events = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9841/api/local/v1',
+        eventSourceFactory: () => source,
+    });
+    const stop = client.events.subscribe((event) => events.push(event.type));
+    source.emit('runtime.updated', { type: 'runtime.updated' });
+    source.emit('presence.updated', { type: 'presence.updated', live: 'yes' });
+    source.emit('stream.updated', { type: 'stream.updated', stream: { content: 'missing bridge type' } });
+    source.emit('presence.updated', { type: 'presence.updated', live: false });
+    strict_1.default.deepEqual(events, ['presence.updated']);
+    stop();
+});
+(0, node_test_1.default)('core client rejects events whose nested payload misses required contract fields', () => {
+    const source = new FakeEventSource();
+    const events = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1',
+        eventSourceFactory: () => source,
+    });
+    const stop = client.events.subscribe((event) => events.push(event.type));
+    source.emit('run.updated', { type: 'run.updated', run: {} });
+    source.emit('message.created', { type: 'message.created', threadId: 'thread-1', message: {} });
+    source.emit('scheduler.run.updated', { type: 'scheduler.run.updated', run: { id: 'run-1' } });
+    source.emit('run.updated', {
+        type: 'run.updated',
+        run: {
+            id: 'run-1',
+            threadId: 'thread-1',
+            status: 'running',
+            startedAt: '2026-06-21T00:00:00.000Z',
+            updatedAt: '2026-06-21T00:00:01.000Z',
+        },
+    });
+    strict_1.default.deepEqual(events, ['run.updated']);
+    stop();
+});
+(0, node_test_1.default)('identical listener functions retain independent subscriptions', () => {
+    const source = new FakeEventSource();
+    let calls = 0;
+    const listener = () => {
+        calls += 1;
+    };
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1',
+        eventSourceFactory: () => source,
+    });
+    const stopFirst = client.events.subscribe(listener);
+    const stopSecond = client.events.subscribe(listener);
+    stopFirst();
+    strict_1.default.equal(source.closed, false);
+    source.emit('presence.updated', { type: 'presence.updated', live: true });
+    strict_1.default.equal(calls, 1);
+    stopSecond();
+    strict_1.default.equal(source.closed, true);
+});
+(0, node_test_1.default)('one failing event listener does not prevent other subscribers from receiving the event', () => {
+    const source = new FakeEventSource();
+    const events = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9844/api/local/v1',
+        eventSourceFactory: () => source,
+    });
+    const stopFailing = client.events.subscribe(() => {
+        throw new Error('listener failed');
+    });
+    const stopHealthy = client.events.subscribe((event) => events.push(event.type));
+    source.emit('presence.updated', { type: 'presence.updated', live: true });
+    strict_1.default.deepEqual(events, ['presence.updated']);
+    stopFailing();
+    stopHealthy();
+});
+(0, node_test_1.default)('core client schedules only one reconnect while an error is outstanding', () => {
+    const sources = [];
+    const reconnects = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9831/api/local/v1',
+        eventSourceFactory: () => {
+            const source = new FakeEventSource();
+            sources.push(source);
+            return source;
+        },
+        scheduleReconnect: (callback) => {
+            reconnects.push(callback);
+            return reconnects.length;
+        },
+        cancelReconnect: () => { },
+    });
+    const stop = client.events.subscribe(() => { });
+    sources[0].onerror?.();
+    sources[0].onerror?.();
+    strict_1.default.equal(reconnects.length, 1);
+    reconnects[0]();
+    strict_1.default.equal(sources.length, 2);
+    stop();
+});
+(0, node_test_1.default)('an obsolete event source cannot schedule another reconnect after replacement', () => {
+    const sources = [];
+    const reconnects = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9842/api/local/v1',
+        eventSourceFactory: () => {
+            const source = new FakeEventSource();
+            sources.push(source);
+            return source;
+        },
+        scheduleReconnect: (callback) => {
+            reconnects.push(callback);
+            return reconnects.length;
+        },
+        cancelReconnect: () => { },
+    });
+    const stop = client.events.subscribe(() => { });
+    sources[0].onerror?.();
+    reconnects[0]();
+    sources[0].onerror?.();
+    strict_1.default.equal(reconnects.length, 1);
+    stop();
+});
+(0, node_test_1.default)('core client reports reconnect so consumers can recover missed state', () => {
+    const sources = [];
+    const reconnects = [];
+    const states = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9845/api/local/v1',
+        eventSourceFactory: () => {
+            const source = new FakeEventSource();
+            sources.push(source);
+            return source;
+        },
+        scheduleReconnect: (callback) => {
+            reconnects.push(callback);
+            return reconnects.length;
+        },
+        cancelReconnect: () => { },
+    });
+    const stop = client.events.subscribeConnectionState((state) => states.push(state));
+    sources[0].onopen?.();
+    sources[0].onerror?.();
+    reconnects[0]();
+    sources[1].onopen?.();
+    strict_1.default.deepEqual(states, ['connected', 'disconnected', 'connected']);
+    stop();
+    strict_1.default.equal(sources[1].closed, true);
+});
+(0, node_test_1.default)('core client rejects partially populated scheduler and automation payloads', () => {
+    const source = new FakeEventSource();
+    const events = [];
+    const client = (0, client_js_1.createCoreClient)({
+        baseUrl: 'http://127.0.0.1:9843/api/local/v1',
+        eventSourceFactory: () => source,
+    });
+    const stop = client.events.subscribe((event) => events.push(event.type));
+    source.emit('scheduler.job.updated', {
+        type: 'scheduler.job.updated',
+        job: {
+            id: 'job-1',
+            workspaceId: 'workspace-1',
+            platform: 'local',
+            triggerType: 'cron',
+            promptTemplate: 'run',
+            enabled: true,
+            createdAt: '',
+            updatedAt: '',
+        },
+    });
+    source.emit('automation.monitor.updated', {
+        type: 'automation.monitor.updated',
+        monitor: {
+            id: 'monitor-1',
+            workspaceId: 'workspace-1',
+            title: 'price',
+            sourceType: 'stock.quote',
+            sourceConfig: {},
+            condition: {},
+            promptTemplate: 'analyze',
+            enabled: true,
+            cooldownMs: 1000,
+            createdAt: '',
+            updatedAt: '',
+        },
+    });
+    strict_1.default.deepEqual(events, []);
+    stop();
+});