@kafca/agentdock 0.1.56 → 0.1.57

package/dist-electron/src/pages/Threads/thread-chat-model.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.upsertSessionGroup = exports.ASSISTANT_REPLY_TIMEOUT_MS = void 0;
+exports.chatControllerActionForTaskState = chatControllerActionForTaskState;
+exports.taskStateFromControllerStatus = taskStateFromControllerStatus;
 exports.isInternalProgressBridgeKind = isInternalProgressBridgeKind;
 exports.isAwaitingInputBridgeStatus = isAwaitingInputBridgeStatus;
 exports.findStreamingPreviewMessage = findStreamingPreviewMessage;
@@ -9,10 +11,7 @@ exports.shouldAcceptLiveBridgeEvent = shouldAcceptLiveBridgeEvent;
 exports.settlePreviewMessages = settlePreviewMessages;
 exports.finalizeTurnMessageKinds = finalizeTurnMessageKinds;
 exports.extractVisibleMessageContent = extractVisibleMessageContent;
-exports.sessionMatchesDesktop = sessionMatchesDesktop;
-exports.toMessages = toMessages;
 exports.toMessagesFromThread = toMessagesFromThread;
-exports.toChatThreadSummary = toChatThreadSummary;
 exports.toCoreChatThreadSummary = toCoreChatThreadSummary;
 exports.sortChatThreadsByLiveAndUpdated = sortChatThreadsByLiveAndUpdated;
 exports.chatThreadMatchesSearch = chatThreadMatchesSearch;
@@ -28,9 +27,49 @@ exports.formatTaskHint = formatTaskHint;
 exports.isTaskRunningState = isTaskRunningState;
 exports.isTaskInputLocked = isTaskInputLocked;
 exports.canStreamingPromoteTaskState = canStreamingPromoteTaskState;
-const desktop_1 = require("../../../shared/desktop");
-const session_utils_1 = require("../../lib/session-utils");
+const chat_event_gate_1 = require("../../components/chat/chat-event-gate");
+const superai_contracts_1 = require("../../../packages/contracts/src/index.js");
 exports.ASSISTANT_REPLY_TIMEOUT_MS = 90000;
+// Threads drives the shared chat controller through these mappers instead of the
+// reducer's `transition` escape hatch so its task state stays inside ChatTaskState
+// and the reducer's named-action guards remain meaningful.
+function chatControllerActionForTaskState(next) {
+    switch (next) {
+        case 'idle':
+            return { type: 'settled' };
+        case 'running':
+            return { type: 'stream_started' };
+        case 'awaiting_input':
+            return { type: 'input_requested' };
+        case 'awaiting_permission':
+            return { type: 'permission_requested' };
+        case 'permission_submitted':
+            return { type: 'permission_submitted' };
+        case 'stopping':
+            return { type: 'stop_started' };
+        case 'error':
+            return { type: 'failed' };
+    }
+}
+function taskStateFromControllerStatus(status) {
+    switch (status) {
+        case 'idle':
+        case 'running':
+        case 'awaiting_input':
+        case 'awaiting_permission':
+        case 'permission_submitted':
+        case 'error':
+        case 'stopping':
+            return status;
+        case 'failed':
+        case 'timed_out':
+            return 'error';
+        default:
+            // sending/waiting/polling/activating are Session/Web-only statuses the
+            // Threads surface never holds; map them defensively to 'running'.
+            return 'running';
+    }
+}
 function isInternalProgressBridgeKind(bridgeKind) {
     return bridgeKind === 'thought' ||
         bridgeKind === 'plan' ||
@@ -64,23 +103,10 @@ function shouldReplacePreviewWithReply(message, replyContent, replyCtx, replyBri
         message.bridgeKind === 'assistant'));
 }
 function shouldAcceptLiveBridgeEvent(input) {
-    const replyCtx = String(input.event.replyCtx || '').trim();
-    if (!replyCtx) {
-        return true;
-    }
-    const activeRunId = String(input.activeRunId || '').trim();
-    const pendingTurn = input.pendingTurn;
-    if (pendingTurn && pendingTurn.sessionKey === input.event.sessionKey) {
-        const pendingRunId = String(pendingTurn.runId || '').trim();
-        if (pendingRunId) {
-            return replyCtx === pendingRunId;
-        }
-        const supersededRunId = String(pendingTurn.supersededRunId || '').trim();
-        if (supersededRunId && replyCtx === supersededRunId) {
-            return false;
-        }
-    }
-    return !activeRunId || replyCtx === activeRunId;
+    return (0, chat_event_gate_1.shouldAcceptRunScopedEvent)(input.event, {
+        activeRunId: input.activeRunId,
+        pendingTurn: input.pendingTurn,
+    });
 }
 function settlePreviewMessages(messages, turnKey) {
     let changed = false;
@@ -130,19 +156,6 @@ function extractVisibleMessageContent(content) {
     }
     return match[1] || '';
 }
-function sessionMatchesDesktop(session) {
-    return session.platform === 'desktop' || session.session_key.startsWith('desktop:');
-}
-function toMessages(history) {
-    return history.map((message, index) => ({
-        id: `${index}-${message.timestamp || message.role}`,
-        role: message.role === 'user' ? 'user' : message.role === 'system' ? 'system' : 'assistant',
-        content: message.role === 'user' ? extractVisibleMessageContent(message.content) : message.content,
-        kind: message.kind === 'progress' ? 'progress' : 'final',
-        order: index,
-        timestamp: message.timestamp,
-    }));
-}
 function toMessagesFromThread(history) {
     return history.map((message, index) => ({
         id: message.id || `${index}-${message.timestamp || message.role}`,
@@ -160,20 +173,6 @@ function toMessagesFromThread(history) {
         timestamp: message.timestamp,
     }));
 }
-function toChatThreadSummary(project, session) {
-    return {
-        id: session.id,
-        project,
-        name: (0, session_utils_1.sessionLabel)(session),
-        live: session.live,
-        createdAt: session.created_at,
-        updatedAt: session.updated_at,
-        excerpt: extractVisibleMessageContent(session.last_message?.content || ''),
-        agentType: session.agent_type,
-        agentMode: undefined,
-        bridgeSessionKey: session.session_key,
-    };
-}
 function toCoreChatThreadSummary(thread) {
     return {
         id: thread.id,
@@ -261,7 +260,7 @@ function normalizeBridgeActionRows(input) {
             return [];
         }
         return row
-            .map((button) => (0, desktop_1.normalizeDesktopBridgeButtonOption)(button))
+            .map((button) => (0, superai_contracts_1.normalizeDesktopBridgeButtonOption)(button))
             .filter((button) => Boolean(button));
     })
         .filter((row) => row.length > 0);
@@ -281,7 +280,7 @@ function upsertThreadInGroup(groups, project, thread) {
     return upsertThreadGroup(groups, project, nextSessions);
 }
 function isPermissionActionRow(rows) {
-    return rows.some((row) => row.some((action) => (0, desktop_1.isPermissionButtonOption)(action)));
+    return rows.some((row) => row.some((action) => (0, superai_contracts_1.isPermissionButtonOption)(action)));
 }
 function formatTaskHint(taskState, typing) {
     if (taskState === 'stopping') {

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');
+});