@kafca/agentdock 0.1.43 → 0.1.45

package/dist-electron/services/local-ai-core/src/sandbox/sandbox-stdio-proxy.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_process_1 = __importDefault(require("node:process"));
+const node_readline_1 = __importDefault(require("node:readline"));
+const sandbox_manager_js_1 = require("./sandbox-manager.js");
+async function main() {
+    const config = parseConfig();
+    const manager = new sandbox_manager_js_1.SandboxManager({
+        config,
+        env: node_process_1.default.env,
+        log: (message) => {
+            node_process_1.default.stderr.write(`[agentdock-sandbox] ${message}\n`);
+        },
+    });
+    let run;
+    let abortController;
+    let closed = false;
+    const cleanup = async () => {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        abortController?.abort();
+        await manager.cleanup(run);
+    };
+    const signalHandler = () => {
+        void cleanup().finally(() => node_process_1.default.exit(0));
+    };
+    node_process_1.default.once('SIGTERM', signalHandler);
+    node_process_1.default.once('SIGINT', signalHandler);
+    node_process_1.default.once('disconnect', signalHandler);
+    try {
+        run = await manager.start();
+        abortController = new AbortController();
+        node_process_1.default.stderr.write(`[agentdock-sandbox] HTTP ACP bridge endpoint: ${run.endpoint}\n`);
+        await pipeHttpNdjson(run.endpoint, abortController, cleanup);
+    }
+    catch (error) {
+        node_process_1.default.stderr.write(`[agentdock-sandbox] ${error instanceof Error ? error.message : String(error)}\n`);
+        await cleanup();
+        node_process_1.default.exit(1);
+    }
+}
+async function pipeHttpNdjson(endpoint, abortController, cleanup) {
+    await waitForHttpReady(endpoint, abortController.signal);
+    void readHttpOutput(endpoint, abortController.signal)
+        .then(() => cleanup().finally(() => node_process_1.default.exit(0)))
+        .catch((error) => {
+        if (abortController.signal.aborted) {
+            return;
+        }
+        node_process_1.default.stderr.write(`[agentdock-sandbox] ACP bridge output error: ${error instanceof Error ? error.message : String(error)}\n`);
+        void cleanup().finally(() => node_process_1.default.exit(1));
+    });
+    let inputQueue = Promise.resolve();
+    const rl = node_readline_1.default.createInterface({
+        input: node_process_1.default.stdin,
+        crlfDelay: Infinity,
+    });
+    rl.on('line', (line) => {
+        if (!line.trim()) {
+            return;
+        }
+        inputQueue = inputQueue
+            .then(() => postHttpInput(endpoint, line, abortController.signal))
+            .catch((error) => {
+            if (abortController.signal.aborted) {
+                return;
+            }
+            node_process_1.default.stderr.write(`[agentdock-sandbox] ACP bridge input error: ${error instanceof Error ? error.message : String(error)}\n`);
+            void cleanup().finally(() => node_process_1.default.exit(1));
+        });
+    });
+    node_process_1.default.stdin.on('end', () => {
+        inputQueue
+            .then(() => closeHttpRuntime(endpoint, abortController.signal))
+            .catch(() => undefined)
+            .finally(() => cleanup().finally(() => node_process_1.default.exit(0)));
+    });
+}
+function parseConfig() {
+    const raw = node_process_1.default.env.AGENTDOCK_SANDBOX_CONFIG || '';
+    if (!raw) {
+        throw new Error('AGENTDOCK_SANDBOX_CONFIG is required.');
+    }
+    return JSON.parse(raw);
+}
+async function waitForHttpReady(endpoint, signal) {
+    const deadline = Date.now() + 30000;
+    let lastError;
+    while (Date.now() < deadline && !signal.aborted) {
+        try {
+            const response = await fetchWithTimeout(joinEndpointPath(endpoint, '/healthz'), {
+                method: 'GET',
+                signal,
+            }, Math.min(3000, Math.max(1000, deadline - Date.now())));
+            const payload = await response.json().catch(() => ({}));
+            if (response.ok && payload?.runtimeRunning !== false) {
+                return;
+            }
+            lastError = new Error(`Health check failed with ${response.status}${payload?.runtimeRunning === false ? ' runtime not running' : ''}`);
+        }
+        catch (error) {
+            lastError = error;
+        }
+        await delay(200);
+    }
+    throw lastError instanceof Error ? lastError : new Error(`Timed out connecting to sandbox ACP bridge: ${endpoint}`);
+}
+async function readHttpOutput(endpoint, signal) {
+    const response = await fetch(joinEndpointPath(endpoint, '/v1/acp/output'), { signal });
+    if (!response.ok || !response.body) {
+        throw new Error(`Output stream failed with ${response.status}`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (!signal.aborted) {
+        const { value, done } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lastNewline = Math.max(buffer.lastIndexOf('\n'), buffer.lastIndexOf('\r'));
+        if (lastNewline >= 0) {
+            writeOutputLines(buffer.slice(0, lastNewline + 1));
+            buffer = buffer.slice(lastNewline + 1);
+        }
+    }
+    buffer += decoder.decode();
+    writeOutputLines(buffer);
+}
+async function postHttpInput(endpoint, line, signal) {
+    const response = await fetchWithTimeout(joinEndpointPath(endpoint, '/v1/acp/input'), {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/x-ndjson',
+        },
+        body: `${line.replace(/\r?\n$/, '')}\n`,
+        signal,
+    }, 30000);
+    if (!response.ok) {
+        throw new Error(`Input write failed with ${response.status}`);
+    }
+}
+async function closeHttpRuntime(endpoint, signal) {
+    if (signal.aborted) {
+        return;
+    }
+    await fetchWithTimeout(joinEndpointPath(endpoint, '/v1/acp/close'), {
+        method: 'POST',
+        signal,
+    }, 3000);
+}
+async function fetchWithTimeout(input, init, timeoutMs) {
+    const timeoutController = new AbortController();
+    const timeout = setTimeout(() => timeoutController.abort(), timeoutMs);
+    const abort = () => timeoutController.abort();
+    init.signal?.addEventListener('abort', abort, { once: true });
+    try {
+        return await fetch(input, {
+            ...init,
+            signal: timeoutController.signal,
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+        init.signal?.removeEventListener('abort', abort);
+    }
+}
+function writeOutputLines(text) {
+    for (const line of text.split(/\r?\n/)) {
+        if (line.trim()) {
+            node_process_1.default.stdout.write(`${line}\n`);
+        }
+    }
+}
+function joinEndpointPath(endpoint, path) {
+    return `${endpoint.replace(/\/+$/, '')}${path}`;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+void main();

package/dist-electron/services/local-ai-core/src/thread/slash-command-registry.js

@@ -12,6 +12,9 @@ class SlashCommandRegistry {
             }
         }
     }
+    list() {
+        return [...new Set(this.handlers.values())];
+    }
     async execute(text, context) {
         const command = (0, local_core_slash_commands_js_1.parseSlashCommand)(text);
         if (!command) {

package/dist-electron/services/local-ai-core/src/thread/thread-command-service.js

@@ -9,6 +9,13 @@ class ThreadCommandService {
     registry = new slash_command_registry_js_1.SlashCommandRegistry();
     constructor(options) {
         this.options = options;
+        this.registry.register({
+            names: ['stop'],
+            execute: async (_command, input) => ({
+                handled: true,
+                displayText: await this.executeStopCommand(input.threadId, input.workspaceId),
+            }),
+        });
         this.registry.register({
             names: ['mode'],
             execute: async (command, input) => ({
@@ -126,6 +133,31 @@ class ThreadCommandService {
         });
         return `已将当前线程 Agent 切换为 ${canonicalAgent}。\n后续消息将使用 ${canonicalAgent} 处理。${runningNote}`;
     }
+    async executeStopCommand(threadId, workspaceId) {
+        const latestRun = this.options.getLatestRunForThread(threadId);
+        if (!latestRun || !['queued', 'running', 'awaiting_input'].includes(latestRun.status)) {
+            return '当前没有正在运行的任务。';
+        }
+        if (!this.options.interruptRun) {
+            return '当前运行时不支持通过 `/stop` 停止任务。';
+        }
+        try {
+            const result = await this.options.interruptRun(latestRun.id);
+            this.options.createAuditEvent({
+                type: 'task.updated',
+                workspaceId,
+                actor: 'local',
+                summary: `Stop requested for run ${latestRun.id}.`,
+                metadata: { threadId, runId: latestRun.id, interrupted: result.interrupted },
+            });
+            return result.interrupted
+                ? '已请求停止当前任务。'
+                : '已将当前任务标记为停止；运行时可能已经结束或无法接收取消信号。';
+        }
+        catch (error) {
+            return `停止任务失败：${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
     hasActiveRun(threadId) {
         const latestRun = this.options.getLatestRunForThread(threadId);
         return Boolean(latestRun && ['queued', 'running', 'awaiting_input'].includes(latestRun.status));

package/dist-electron/services/local-ai-core/src/thread/thread-slash-command-dispatcher.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadSlashCommandDispatcher = exports.LOCAL_SLASH_COMMANDS = void 0;
+exports.slashHelpText = slashHelpText;
+const local_core_slash_commands_js_1 = require("../acp/local-core-slash-commands.js");
+const session_command_service_js_1 = require("./session-command-service.js");
+const thread_command_service_js_1 = require("./thread-command-service.js");
+exports.LOCAL_SLASH_COMMANDS = [
+    { names: ['help'], usage: '/help', summary: '查看这份帮助。', group: 'thread' },
+    { names: ['stop'], usage: '/stop', summary: '停止当前正在运行的任务。', group: 'thread' },
+    { names: ['mode'], usage: '/mode [default|auto|acceptEdits|dontAsk|plan|yolo]', summary: '查看或切换当前线程权限模式。', group: 'thread' },
+    { names: ['agent'], usage: '/agent [list|current|use <agent-id>|reset]', summary: '查看或切换当前线程 Agent。', group: 'thread' },
+    { names: ['new'], usage: '/new [标题]', summary: '新建会话。', group: 'session' },
+    { names: ['list', 'sessions'], usage: '/list', summary: '查看会话列表。', group: 'session' },
+    { names: ['switch', 'sw'], usage: '/switch <编号 | id前缀 | 标题>', summary: '切换会话。', group: 'session' },
+    { names: ['history', 'his'], usage: '/history [条数]', summary: '查看当前会话最近消息。', group: 'session' },
+    { names: ['name'], usage: '/name <标题>', summary: '重命名当前会话。', group: 'session' },
+    { names: ['search'], usage: '/search <关键词>', summary: '搜索会话。', group: 'session' },
+    { names: ['del', 'delete', 'rm'], usage: '/del <编号 | id前缀 | 标题> [--confirm]', summary: '删除会话。', group: 'session' },
+];
+const SESSION_COMMAND_NAMES = namesForGroup('session');
+const THREAD_COMMAND_NAMES = namesForGroup('thread');
+class ThreadSlashCommandDispatcher {
+    sessionService;
+    threadService;
+    constructor(options) {
+        this.sessionService = new session_command_service_js_1.SessionCommandService(options.session);
+        this.threadService = new thread_command_service_js_1.ThreadCommandService(options.thread);
+    }
+    async execute(context) {
+        const command = (0, local_core_slash_commands_js_1.parseSlashCommand)(context.content);
+        if (!command) {
+            return { handled: false, displayText: '' };
+        }
+        if (command.name === 'help') {
+            return { handled: true, displayText: slashHelpText() };
+        }
+        if (SESSION_COMMAND_NAMES.has(command.name)) {
+            return this.sessionService.execute(context.content, {
+                workspaceId: context.workspaceId,
+                currentThreadId: context.threadId,
+                defaultTitle: context.defaultTitle,
+            });
+        }
+        if (THREAD_COMMAND_NAMES.has(command.name)) {
+            return this.threadService.execute({
+                threadId: context.threadId,
+                workspaceId: context.workspaceId,
+                content: context.content,
+                defaultAgentType: context.defaultAgentType,
+            });
+        }
+        return { handled: false, displayText: '' };
+    }
+}
+exports.ThreadSlashCommandDispatcher = ThreadSlashCommandDispatcher;
+function slashHelpText(definitions = exports.LOCAL_SLASH_COMMANDS) {
+    return [
+        '可用命令：',
+        ...definitions.map((definition) => {
+            const aliases = definition.names.slice(1).map((name) => `/${name}`).join('、');
+            const aliasText = aliases ? `（别名：${aliases}）` : '';
+            return `\`${definition.usage}\`${aliasText} ${definition.summary}`;
+        }),
+    ].join('\n');
+}
+function namesForGroup(group) {
+    return new Set(exports.LOCAL_SLASH_COMMANDS
+        .filter((definition) => definition.group === group)
+        .flatMap((definition) => definition.names));
+}

package/dist-electron/shared/desktop.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CHANNEL_PROTOCOL_INSTRUCTION = exports.MONITOR_PROTOCOL_INSTRUCTION = exports.SCHEDULER_PROTOCOL_INSTRUCTION = exports.LOCALCORE_ACP_AGENT_TYPE = exports.DESKTOP_INTERACTIVE_PERMISSION_AGENT_TYPES = exports.DESKTOP_PROVIDER_THINKING_OPTIONS = exports.DESKTOP_PROVIDER_PRESET_OPTIONS = exports.DESKTOP_PLATFORM_TYPE_OPTIONS = exports.DESKTOP_AGENT_TYPE_OPTIONS = exports.DESKTOP_LARK_SDK_PACKAGE = exports.DESKTOP_CLAUDECODE_ACP_PACKAGE = exports.DESKTOP_CODEX_ACP_PACKAGE = exports.DESKTOP_PI_CODING_AGENT_PACKAGE = exports.DESKTOP_PI_ACP_PACKAGE = exports.DEFAULT_DESKTOP_CLAUDECODE_MODEL = exports.DEFAULT_DESKTOP_OPENCODE_MODEL = exports.DEFAULT_DESKTOP_AGENT_TYPE = void 0;
+exports.DEFAULT_SANDBOX_RUNTIME_IMAGES = exports.DESKTOP_DEPLOYMENT_PROFILES = exports.DEFAULT_SANDBOX_STATE_MOUNT_PATH = exports.DEFAULT_SANDBOX_WORKSPACE_MOUNT_PATH = exports.DEFAULT_SANDBOX_RUNTIME_IMAGE_ID = exports.DEFAULT_SANDBOX_PROVIDER_ID = exports.CHANNEL_PROTOCOL_INSTRUCTION = exports.MONITOR_PROTOCOL_INSTRUCTION = exports.SCHEDULER_PROTOCOL_INSTRUCTION = exports.LOCALCORE_ACP_AGENT_TYPE = exports.DESKTOP_INTERACTIVE_PERMISSION_AGENT_TYPES = exports.DESKTOP_PROVIDER_THINKING_OPTIONS = exports.DESKTOP_PROVIDER_PRESET_OPTIONS = exports.DESKTOP_PLATFORM_TYPE_OPTIONS = exports.DESKTOP_AGENT_TYPE_OPTIONS = exports.DESKTOP_LARK_SDK_PACKAGE = exports.DESKTOP_CLAUDECODE_ACP_PACKAGE = exports.DESKTOP_CODEX_ACP_PACKAGE = exports.DESKTOP_PI_CODING_AGENT_PACKAGE = exports.DESKTOP_PI_ACP_PACKAGE = exports.DEFAULT_DESKTOP_CLAUDECODE_MODEL = exports.DEFAULT_DESKTOP_OPENCODE_MODEL = exports.DEFAULT_DESKTOP_AGENT_TYPE = void 0;
 exports.deriveDesktopRuntimePhase = deriveDesktopRuntimePhase;
 exports.deriveDesktopRuntimeRoles = deriveDesktopRuntimeRoles;
 exports.normalizeDesktopPlatformType = normalizeDesktopPlatformType;
@@ -12,6 +12,9 @@ exports.isPermissionButtonOption = isPermissionButtonOption;
 exports.normalizeDesktopBridgeButtonOption = normalizeDesktopBridgeButtonOption;
 exports.supportsInteractivePermission = supportsInteractivePermission;
 exports.isAcpAgentType = isAcpAgentType;
+exports.getDesktopDeploymentProfile = getDesktopDeploymentProfile;
+exports.defaultSandboxProviderForProfile = defaultSandboxProviderForProfile;
+exports.defaultSandboxRuntimeImage = defaultSandboxRuntimeImage;
 exports.DEFAULT_DESKTOP_AGENT_TYPE = 'pi';
 exports.DEFAULT_DESKTOP_OPENCODE_MODEL = 'opencode/minimax-m2.5-free';
 exports.DEFAULT_DESKTOP_CLAUDECODE_MODEL = '';
@@ -266,3 +269,84 @@ function isAcpAgentType(agentType) {
         || normalized === 'hermes'
         || normalized === exports.LOCALCORE_ACP_AGENT_TYPE;
 }
+exports.DEFAULT_SANDBOX_PROVIDER_ID = 'opensandbox-default';
+exports.DEFAULT_SANDBOX_RUNTIME_IMAGE_ID = 'pi-acp-local';
+exports.DEFAULT_SANDBOX_WORKSPACE_MOUNT_PATH = '/workspace';
+exports.DEFAULT_SANDBOX_STATE_MOUNT_PATH = '/agent-state';
+exports.DESKTOP_DEPLOYMENT_PROFILES = [
+    {
+        id: 'local-desktop',
+        label: 'Local Desktop',
+        corePublicOrigin: 'http://127.0.0.1:9831',
+        coreBindHost: '127.0.0.1',
+        openSandboxServerUrl: 'http://127.0.0.1:8080',
+        defaultWorkspaceRoot: '',
+        sandboxImagePrefix: 'agentdock',
+        workspaceMountPath: exports.DEFAULT_SANDBOX_WORKSPACE_MOUNT_PATH,
+        stateMountPath: exports.DEFAULT_SANDBOX_STATE_MOUNT_PATH,
+        defaultSandboxProviderId: exports.DEFAULT_SANDBOX_PROVIDER_ID,
+    },
+    {
+        id: 'docker-compose',
+        label: 'Docker Compose',
+        corePublicOrigin: 'http://127.0.0.1:9831',
+        coreBindHost: '0.0.0.0',
+        openSandboxServerUrl: 'http://opensandbox-server:8080',
+        defaultWorkspaceRoot: '/workspace',
+        sandboxImagePrefix: 'agentdock',
+        workspaceMountPath: exports.DEFAULT_SANDBOX_WORKSPACE_MOUNT_PATH,
+        stateMountPath: exports.DEFAULT_SANDBOX_STATE_MOUNT_PATH,
+        defaultSandboxProviderId: exports.DEFAULT_SANDBOX_PROVIDER_ID,
+    },
+    {
+        id: 'remote-cloud',
+        label: 'Remote Cloud',
+        corePublicOrigin: '',
+        coreBindHost: '0.0.0.0',
+        openSandboxServerUrl: '',
+        defaultWorkspaceRoot: '/workspace',
+        sandboxImagePrefix: 'agentdock',
+        workspaceMountPath: exports.DEFAULT_SANDBOX_WORKSPACE_MOUNT_PATH,
+        stateMountPath: exports.DEFAULT_SANDBOX_STATE_MOUNT_PATH,
+        defaultSandboxProviderId: exports.DEFAULT_SANDBOX_PROVIDER_ID,
+    },
+];
+exports.DEFAULT_SANDBOX_RUNTIME_IMAGES = [
+    {
+        id: exports.DEFAULT_SANDBOX_RUNTIME_IMAGE_ID,
+        agent_type: 'pi',
+        image: 'agentdock/pi-acp:local',
+        transport: 'http-ndjson',
+        acp_port: 8080,
+        entrypoint: ['node', '/opt/agentdock/acp-bridge.mjs'],
+        workspace_mount_path: exports.DEFAULT_SANDBOX_WORKSPACE_MOUNT_PATH,
+        state_mount_path: exports.DEFAULT_SANDBOX_STATE_MOUNT_PATH,
+    },
+];
+function getDesktopDeploymentProfile(profileId) {
+    const normalized = String(profileId || '').trim();
+    return exports.DESKTOP_DEPLOYMENT_PROFILES.find((profile) => profile.id === normalized) || exports.DESKTOP_DEPLOYMENT_PROFILES[0];
+}
+function defaultSandboxProviderForProfile(profileId) {
+    const profile = getDesktopDeploymentProfile(profileId);
+    return {
+        id: profile.defaultSandboxProviderId,
+        type: 'opensandbox',
+        name: 'OpenSandbox',
+        server_url: profile.openSandboxServerUrl,
+        api_key_env: 'OPEN_SANDBOX_API_KEY',
+    };
+}
+function defaultSandboxRuntimeImage(agentType) {
+    const normalized = String(agentType || '').trim().toLowerCase() || 'pi';
+    return exports.DEFAULT_SANDBOX_RUNTIME_IMAGES.find((image) => image.agent_type === normalized) || {
+        id: `${normalized}-acp-local`,
+        agent_type: normalized,
+        image: `agentdock/${normalized}-acp:local`,
+        transport: 'http-ndjson',
+        acp_port: 8080,
+        entrypoint: ['node', '/opt/agentdock/acp-bridge.mjs'],
+        workspace_mount_path: exports.DEFAULT_SANDBOX_WORKSPACE_MOUNT_PATH,
+        state_mount_path: exports.DEFAULT_SANDBOX_STATE_MOUNT_PATH,
+    };
+}

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

@@ -9,6 +9,62 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const node_process_1 = __importDefault(require("node:process"));
 const rootDir = node_process_1.default.cwd();
+const sourceFileExtensions = new Set(['.ts', '.tsx', '.mts', '.mjs']);
+function listSourceFiles(dir) {
+    const entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const path = (0, node_path_1.join)(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (['dist', 'dist-electron', 'node_modules', 'release'].includes(entry.name)) {
+                continue;
+            }
+            files.push(...listSourceFiles(path));
+            continue;
+        }
+        if (entry.isFile() && sourceFileExtensions.has(path.slice(path.lastIndexOf('.')))) {
+            files.push(path);
+        }
+    }
+    return files;
+}
+function readSourceFiles(scope) {
+    const dir = (0, node_path_1.join)(rootDir, scope);
+    if (!(0, node_fs_1.statSync)(dir, { throwIfNoEntry: false })?.isDirectory()) {
+        return [];
+    }
+    return listSourceFiles(dir).map((path) => ({
+        path,
+        relativePath: (0, node_path_1.relative)(rootDir, path),
+        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/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 [
@@ -54,3 +110,30 @@ const rootDir = node_process_1.default.cwd();
     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)('renderer does not import Electron or Local AI Core internals', () => {
+    const offenders = readSourceFiles('src')
+        .filter(({ content }) => {
+        return (/from ['"]electron(?:\/[^'"]*)?['"]/.test(content) ||
+            /from ['"][^'"]*\/electron(?:\/[^'"]*)?['"]/.test(content) ||
+            /from ['"][^'"]*services\/local-ai-core\/src/.test(content));
+    })
+        .map(({ relativePath }) => relativePath);
+    strict_1.default.deepEqual(offenders, [], 'renderer code must communicate with Electron and Local AI Core through shared contracts and API adapters');
+});
+(0, node_test_1.default)('workspace packages declare public package entrypoints', () => {
+    for (const packagePath of [
+        'packages/contracts/package.json',
+        'packages/core-sdk/package.json',
+        'packages/plugin-sdk/package.json',
+    ]) {
+        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`);
+    }
+});