@kafca/agentdock 0.1.23 → 0.1.25

package/dist-electron/electron/plugin-kernel.test.js

@@ -155,6 +155,7 @@ function plugin(id, dependsOn = []) {
             'qoder',
             'iflow',
             'localcore-acp',
+            'pi',
             'opencode',
             'codex',
             'claudecode',
@@ -188,6 +189,7 @@ function plugin(id, dependsOn = []) {
             'qoder',
             'iflow',
             'localcore-acp',
+            'pi',
             'opencode',
             'codex',
             'claudecode',
@@ -243,6 +245,104 @@ type = "codex"
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('pi agent runtime routes projects through bundled pi ACP and coding agent', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-kernel-'));
+    try {
+        const runtime = (0, bootstrap_js_2.bootstrapLocalCoreRuntime)({
+            userDataPath,
+            enableKnowledge: false,
+        });
+        await runtime.state.saveRawConfigFile(`
+[[projects]]
+name = "pi-workspace"
+
+[projects.agent]
+type = "pi"
+
+[[projects.agent.providers]]
+name = "openai"
+api_key = "test-openai-key"
+
+[projects.agent.options.env]
+OPENAI_API_KEY = "override-openai-key"
+`);
+        const configState = await runtime.state.readConfigFile();
+        const project = configState.parsed?.projects?.find((entry) => entry.name === 'pi-workspace');
+        const piRuntime = runtime.agentRuntimes.find((entry) => entry.agentType === 'pi');
+        const route = project ? piRuntime?.createRoute(configState, project) : null;
+        strict_1.default.equal(route?.agentType, 'pi');
+        strict_1.default.equal(route?.config.command, process.execPath);
+        strict_1.default.match(route?.config.args[0] || '', /pi-acp[/\\]dist[/\\]index\.js$/);
+        strict_1.default.match(route?.config.env.PI_ACP_PI_COMMAND || '', /@mariozechner[/\\]pi-coding-agent[/\\]dist[/\\]cli\.js$/);
+        strict_1.default.equal(route?.config.env.OPENAI_API_KEY, 'override-openai-key');
+        strict_1.default.match(route?.config.env.PI_CODING_AGENT_DIR || '', /[\\/]\.pi-agent[\\/]pi-workspace$/);
+        strict_1.default.deepEqual(await runtime.workspaceRouter.listWorkspaces(), [
+            {
+                id: 'pi-workspace',
+                name: 'pi-workspace',
+                agentType: 'pi',
+                platforms: [],
+                sessionsCount: 0,
+                heartbeatEnabled: false,
+            },
+        ]);
+        await runtime.stop();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('pi agent runtime writes provider auth and default model into Pi config dir', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-kernel-'));
+    try {
+        const runtime = (0, bootstrap_js_2.bootstrapLocalCoreRuntime)({
+            userDataPath,
+            enableKnowledge: false,
+        });
+        await runtime.state.saveRawConfigFile(`
+[[projects]]
+name = "deepseek-workspace"
+
+[projects.agent]
+type = "pi"
+
+[[projects.agent.providers]]
+name = "DeepSeek"
+api_key = "test-deepseek-key"
+base_url = "https://api.deepseek.com"
+model = "deepseek-v4-flash"
+`);
+        const configState = await runtime.state.readConfigFile();
+        const project = configState.parsed?.projects?.find((entry) => entry.name === 'deepseek-workspace');
+        const piRuntime = runtime.agentRuntimes.find((entry) => entry.agentType === 'pi');
+        const route = project ? piRuntime?.createRoute(configState, project) : null;
+        const piAgentDir = route?.config.env.PI_CODING_AGENT_DIR || '';
+        strict_1.default.equal(route?.config.model, 'deepseek-v4-flash');
+        strict_1.default.equal(route?.config.env.DEEPSEEK_API_KEY, 'test-deepseek-key');
+        strict_1.default.match(piAgentDir, /[\\/]\.pi-agent[\\/]deepseek-workspace$/);
+        strict_1.default.deepEqual(JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(piAgentDir, 'auth.json'), 'utf8')), {
+            deepseek: { type: 'api_key', key: 'test-deepseek-key' },
+        });
+        strict_1.default.deepEqual(JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(piAgentDir, 'settings.json'), 'utf8')), {
+            defaultProvider: 'deepseek',
+            defaultModel: 'deepseek-v4-flash',
+            quietStartup: true,
+        });
+        strict_1.default.deepEqual(JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(piAgentDir, 'models.json'), 'utf8')), {
+            providers: {
+                deepseek: {
+                    name: 'DeepSeek',
+                    baseUrl: 'https://api.deepseek.com',
+                    apiKey: 'test-deepseek-key',
+                },
+            },
+        });
+        await runtime.stop();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('runtime bootstrap knowledge capabilities come from the selected provider plugin', () => {
     const enabledUserDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-kernel-'));
     const disabledUserDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-kernel-'));
@@ -619,6 +719,7 @@ type = "codex"
                 defaultCollection: 'personal_knowledge',
             },
             plugins: {
+                'builtin.agent-pi': { enabled: false },
                 'builtin.agent-claudecode': { enabled: false },
             },
         }), 'utf8');
@@ -631,9 +732,16 @@ name = "claude-workspace"
 
 [projects.agent]
 type = "claudecode"
+
+[[projects]]
+name = "pi-workspace"
+
+[projects.agent]
+type = "pi"
 `);
         strict_1.default.deepEqual(runtime.agentRuntimes.map((entry) => entry.agentType), ['localcore-acp', 'opencode', 'codex']);
         strict_1.default.equal(runtime.kernel.getCapabilitySnapshot().snapshot.agents.some((capability) => capability.agentType === 'claudecode'), false);
+        strict_1.default.equal(runtime.kernel.getCapabilitySnapshot().snapshot.agents.some((capability) => capability.agentType === 'pi'), false);
         strict_1.default.deepEqual(await runtime.workspaceRouter.listWorkspaces(), []);
         await strict_1.default.rejects(() => runtime.workspaceRouter.listThreads('claude-workspace'), /Workspace "claude-workspace" is not configured as a Local AI Core ACP workspace/);
         await runtime.stop();

package/dist-electron/electron/renderer-packaging.test.js

@@ -0,0 +1,77 @@
+"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 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();
+(0, node_test_1.default)('production package config includes renderer build output', () => {
+    const packageJson = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, 'package.json'), 'utf8'));
+    strict_1.default.ok(packageJson.files?.includes('dist/renderer/**'), 'npm package files must include dist/renderer/**');
+    strict_1.default.ok(packageJson.build?.files?.includes('dist/renderer/**'), 'electron-builder files must include dist/renderer/**');
+});
+(0, node_test_1.default)('release validation scripts keep local and candidate gates intact', () => {
+    const packageJson = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, 'package.json'), 'utf8'));
+    const testScript = packageJson.scripts?.test || '';
+    const smokeScript = packageJson.scripts?.['e2e:smoke'] || '';
+    strict_1.default.match(testScript, /\bpnpm build:renderer\b/, 'pnpm test must build renderer assets');
+    strict_1.default.match(testScript, /\bpnpm build:electron\b/, 'pnpm test must compile Electron and Local AI Core tests');
+    strict_1.default.match(testScript, /\bnode --test\b/, 'pnpm test must run the Node test suite');
+    strict_1.default.match(testScript, /dist-electron\/electron\/\*\.test\.js/, 'pnpm test must include Electron tests');
+    strict_1.default.match(testScript, /dist-electron\/packages\/knowledge-api\/test\/\*\.test\.js/, 'pnpm test must include package tests');
+    strict_1.default.match(testScript, /dist-electron\/src\/pages\/Threads\/thread-chat-permission\.test\.js/, 'pnpm test must include renderer state tests');
+    const buildIndex = smokeScript.indexOf('pnpm build');
+    const smokeIndex = smokeScript.indexOf('node scripts/e2e-smoke.mjs');
+    strict_1.default.ok(buildIndex >= 0, 'pnpm e2e:smoke must start from a production build');
+    strict_1.default.ok(smokeIndex > buildIndex, 'pnpm e2e:smoke must run smoke checks after the production build');
+});
+(0, node_test_1.default)('production renderer build has a loadable entry document and assets', () => {
+    const rendererDir = (0, node_path_1.join)(rootDir, 'dist', 'renderer');
+    const indexPath = (0, node_path_1.join)(rendererDir, 'index.html');
+    strict_1.default.ok((0, node_fs_1.existsSync)(indexPath), 'dist/renderer/index.html must exist after production build');
+    const indexHtml = (0, node_fs_1.readFileSync)(indexPath, 'utf8');
+    strict_1.default.match(indexHtml, /<div id="root"><\/div>/, 'renderer entry must mount into #root');
+    const assetReferences = [...indexHtml.matchAll(/(?:src|href)="\.\/(assets\/[^"]+)"/g)].map((match) => match[1]);
+    strict_1.default.ok(assetReferences.some((asset) => asset.endsWith('.js')), 'renderer entry must reference a JS asset');
+    strict_1.default.ok(assetReferences.some((asset) => asset.endsWith('.css')), 'renderer entry must reference a CSS asset');
+    for (const asset of assetReferences) {
+        strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.join)(rendererDir, asset)), `renderer asset must exist: ${asset}`);
+    }
+});
+(0, node_test_1.default)('release workflow keeps validation artifacts separate from formal releases', () => {
+    const ciWorkflow = (0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, '.github', 'workflows', 'ci.yml'), 'utf8');
+    const releaseWorkflow = (0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, '.github', 'workflows', 'release.yml'), 'utf8');
+    const releaseDocs = (0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, 'docs', 'operations', 'release-workflow.md'), 'utf8');
+    strict_1.default.match(ciWorkflow, /pull_request:/, 'CI must run before merge');
+    strict_1.default.match(ciWorkflow, /branches:\s*\n\s*- main/, 'CI must run on main pushes');
+    strict_1.default.match(ciWorkflow, /needs: test/, 'main branch packaging must wait for tests');
+    strict_1.default.match(ciWorkflow, /--publish never/, 'main branch artifacts must not publish formal releases');
+    strict_1.default.match(ciWorkflow, /retention-days: 14/, 'main branch validation artifacts must have bounded retention');
+    strict_1.default.match(releaseWorkflow, /tags:\s*\n\s*- 'v\*'/, 'formal releases must be tied to version tags');
+    strict_1.default.match(releaseWorkflow, /Run tests[\s\S]*?run: pnpm test/, 'release packaging must run the fast gate');
+    strict_1.default.match(releaseWorkflow, /Build app[\s\S]*?run: pnpm build/, 'release packaging must run a production build');
+    strict_1.default.match(releaseWorkflow, /--publish always/, 'release artifacts must publish only from the release workflow');
+    strict_1.default.match(releaseWorkflow, /tag_version.*package_version/s, 'tag releases must verify the package version');
+    strict_1.default.match(releaseDocs, /validation only/i, 'release docs must describe main artifacts as validation only');
+    strict_1.default.match(releaseDocs, /not formal releases/i, 'release docs must separate main artifacts from formal releases');
+});
+(0, node_test_1.default)('production smoke gate launches the built app and checks runtime capabilities', () => {
+    const smokeScript = (0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, 'scripts', 'e2e-smoke.mjs'), 'utf8');
+    const mainSource = (0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, 'electron', 'main.ts'), 'utf8');
+    strict_1.default.match(smokeScript, /scripts\/launch-electron\.mjs/, 'smoke gate must launch the production Electron entry');
+    strict_1.default.match(smokeScript, /AI_WORKSTATION_SMOKE_OUTPUT/, 'smoke gate must wait for an app-written smoke snapshot');
+    strict_1.default.match(smokeScript, /AI_WORKSTATION_USER_DATA_DIR/, 'smoke gate must isolate app data per scenario');
+    strict_1.default.match(smokeScript, /runScenario\('default'\)/, 'smoke gate must cover the default production startup path');
+    strict_1.default.match(smokeScript, /runScenario\('bootstrap-error'/, 'smoke gate must cover degraded bootstrap behavior');
+    strict_1.default.match(smokeScript, /runScenario\('degraded-plugin'/, 'smoke gate must cover plugin diagnostic behavior');
+    strict_1.default.match(smokeScript, /localcore-acp/, 'smoke gate must verify the agent capability snapshot');
+    strict_1.default.match(smokeScript, /pluginDiagnostics/, 'smoke gate must verify plugin diagnostics');
+    strict_1.default.match(mainSource, /appResourcePath\('dist', 'renderer', 'index\.html'\)/, 'production app must load built renderer assets');
+    strict_1.default.match(mainSource, /Renderer build output was not found/, 'production app must fail loudly when renderer assets are missing');
+    strict_1.default.match(mainSource, /\/api\/local\/v1\/capabilities\/snapshot/, 'smoke mode must check runtime capabilities through the app');
+    strict_1.default.match(mainSource, /\/api\/local\/v1\/plugins\/diagnostics/, 'smoke mode must check plugin diagnostics through the app');
+});

package/dist-electron/electron/workspace-task-store.test.js

@@ -9,6 +9,8 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const node_os_1 = require("node:os");
 const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/local-core-acp-store.js");
+const local_core_acp_session_coordinator_js_1 = require("../services/local-ai-core/src/acp/local-core-acp-session-coordinator.js");
+const scheduler_service_js_1 = require("../services/local-ai-core/src/scheduler/scheduler-service.js");
 (0, node_test_1.default)('workspace registry entries persist in LocalCoreAcpStore', () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'workspace-registry-'));
     try {
@@ -34,6 +36,142 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('ACP runtime env includes the current workspace path for file returns', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'workspace-env-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        store.upsertWorkspaceRegistryEntry({
+            workspaceId: 'workspace-a',
+            displayName: 'Workspace A',
+            path: '/tmp/workspace-a',
+            deviceId: 'local',
+            defaultRuntimeId: 'opencode',
+            health: { status: 'healthy', summary: 'ok', issues: [] },
+            git: { isRepo: false },
+        });
+        const thread = store.createThread('workspace-a', 'Thread');
+        let capturedRuntimeEnv;
+        const coordinator = new local_core_acp_session_coordinator_js_1.LocalCoreAcpSessionCoordinator({
+            store,
+            transport: {
+                spawnSession(input) {
+                    capturedRuntimeEnv = input.runtimeEnv;
+                    return {
+                        threadId: input.threadId,
+                        bridgeSessionKey: input.bridgeSessionKey,
+                        closed: false,
+                        sessionId: '',
+                        supportsLoad: false,
+                        pendingPermissionByRun: new Map(),
+                        schedulerJobCreatedByRun: new Map(),
+                    };
+                },
+                initializeSession: async () => { },
+                request: async () => ({ sessionId: 'session-1' }),
+                closeSession: () => { },
+                closeSessionWithError: () => { },
+                sendRaw: () => true,
+            },
+            runThreadMap: new Map(),
+            emitBridge: () => { },
+        });
+        await coordinator.ensureSession(thread.id, 'session:thread-1', {
+            workspaceId: 'workspace-a',
+            agentType: 'opencode',
+            command: 'opencode',
+            args: [],
+            env: {},
+            workDir: '/tmp/workspace-a',
+            model: '',
+        });
+        strict_1.default.equal(capturedRuntimeEnv?.LOCAL_AI_WORKSPACE_ID, 'workspace-a');
+        strict_1.default.equal(capturedRuntimeEnv?.LOCAL_AI_WORKSPACE_PATH, '/tmp/workspace-a');
+        store.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('scheduler uses short ids for new jobs and resolves legacy full ids by short id', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-id-store-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const scheduler = new scheduler_service_js_1.SchedulerService({
+            store,
+            triggers: [],
+            executors: [],
+            eventBus: { emit: () => { }, on: () => () => { } },
+        });
+        const created = scheduler.createJob({
+            workspaceId: 'workspace-a',
+            platform: 'local',
+            route: { type: 'local.thread', channelId: 'workspace-a', threadId: 'thread-1' },
+            executionMode: 'side-thread',
+            triggerType: 'cron',
+            cronExpr: '30 18 * * *',
+            promptTemplate: 'ping',
+            description: 'daily ping',
+            enabled: true,
+        });
+        strict_1.default.match(created.id, /^[0-9a-f]{8}$/);
+        const legacy = store.createScheduledJob({
+            workspaceId: 'workspace-a',
+            platform: 'local',
+            route: { type: 'local.thread', channelId: 'workspace-a', threadId: 'thread-1' },
+            executionMode: 'side-thread',
+            triggerType: 'cron',
+            cronExpr: '0 9 * * *',
+            promptTemplate: 'legacy',
+            description: 'legacy job',
+            enabled: true,
+        });
+        store.db.prepare('UPDATE scheduled_jobs SET id = ? WHERE id = ?').run('job:826aff79-570b-4308-822e-18318e2c96ba', legacy.id);
+        strict_1.default.equal(scheduler.getJob('826aff79')?.id, 'job:826aff79-570b-4308-822e-18318e2c96ba');
+        scheduler.updateJob('826aff79', { description: 'updated legacy job' });
+        strict_1.default.equal(scheduler.getJob('826aff79')?.description, 'updated legacy job');
+        scheduler.deleteJob('826aff79');
+        strict_1.default.equal(scheduler.getJob('826aff79'), undefined);
+        strict_1.default.throws(() => scheduler.deleteJob('826aff79'), /Scheduled job not found: 826aff79/);
+        store.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('scheduled jobs normalize enum-like input before persistence', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-enum-store-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const created = store.createScheduledJob({
+            workspaceId: 'workspace-a',
+            platform: ' Lark ',
+            route: { type: 'channel.chat', channelId: 'chat-1', participantId: 'user-1' },
+            executionMode: 'side_thread',
+            triggerType: 'CRON',
+            cronExpr: '30 18 * * *',
+            promptTemplate: 'ping',
+            description: 'daily ping',
+            enabled: true,
+        });
+        strict_1.default.equal(created.platform, 'lark');
+        strict_1.default.equal(created.executionMode, 'side-thread');
+        strict_1.default.equal(created.triggerType, 'cron');
+        const updated = store.updateScheduledJob(created.id, {
+            executionMode: 'same_thread',
+            triggerType: 'one time',
+            runAt: '2026-05-04T10:00:00.000Z',
+            cronExpr: '',
+        });
+        strict_1.default.equal(updated.executionMode, 'same-thread');
+        strict_1.default.equal(updated.triggerType, 'once');
+        strict_1.default.equal(updated.runAt, '2026-05-04T10:00:00.000Z');
+        strict_1.default.equal(updated.cronExpr, undefined);
+        store.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('agent tasks persist, update status, and can be found by run id', () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agent-task-store-'));
     try {
@@ -64,3 +202,46 @@ const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/loc
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('agent task and run statuses normalize before persistence', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'task-run-status-store-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const task = store.createAgentTask({
+            workspaceId: 'workspace-a',
+            deviceId: 'device-a',
+            runtimeId: 'runtime-a',
+            title: 'Normalize states',
+            status: 'waiting for user',
+        });
+        strict_1.default.equal(task.status, 'waiting_for_user');
+        strict_1.default.equal(store.listAgentTasks({ status: 'waiting for user' }).tasks.length, 1);
+        const updated = store.updateAgentTask(task.taskId, { status: 'canceled' });
+        strict_1.default.equal(updated.status, 'cancelled');
+        strict_1.default.equal(updated.timeline.at(-1)?.status, 'cancelled');
+        const thread = store.createThread('workspace-a', 'Thread');
+        store.updateRun('run-1', thread.id, 'awaiting input');
+        strict_1.default.equal(store.getRun('run-1')?.status, 'awaiting_input');
+        store.updateRun('run-1', thread.id, 'canceled');
+        strict_1.default.equal(store.getRun('run-1')?.status, 'interrupted');
+        const job = store.createScheduledJob({
+            workspaceId: 'workspace-a',
+            platform: 'local',
+            route: { type: 'local.thread', channelId: 'workspace-a', threadId: 'thread-1' },
+            executionMode: 'same-thread',
+            triggerType: 'cron',
+            cronExpr: '0 9 * * *',
+            promptTemplate: 'ping',
+            description: 'daily ping',
+            enabled: true,
+        });
+        const run = store.createScheduledJobRun(job.id, 'complete');
+        strict_1.default.equal(run.status, 'succeeded');
+        const skipped = store.updateScheduledJobRun(run.id, { status: 'cancelled' });
+        strict_1.default.equal(skipped.status, 'skipped');
+        strict_1.default.equal(store.getScheduledJob(job.id)?.lastStatus, 'skipped');
+        store.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});

package/dist-electron/packages/contracts/src/local-core.js

@@ -1,2 +1,112 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeApprovalRequestStatus = normalizeApprovalRequestStatus;
+exports.normalizeAgentTaskStatus = normalizeAgentTaskStatus;
+exports.normalizeChannelContentPartType = normalizeChannelContentPartType;
+exports.normalizeScheduledJobExecutionMode = normalizeScheduledJobExecutionMode;
+exports.normalizeScheduledJobTriggerType = normalizeScheduledJobTriggerType;
+exports.normalizeChannelPlatform = normalizeChannelPlatform;
+exports.normalizeRunStatus = normalizeRunStatus;
+exports.normalizeScheduledJobRunStatus = normalizeScheduledJobRunStatus;
+function normalizeApprovalRequestStatus(value, fallback = 'pending') {
+    const normalized = normalizeContractEnumValue(value || fallback).replace(/-/g, '_');
+    if (normalized === 'pending' ||
+        normalized === 'approved' ||
+        normalized === 'rejected' ||
+        normalized === 'cancelled' ||
+        normalized === 'expired') {
+        return normalized;
+    }
+    if (normalized === 'approve') {
+        return 'approved';
+    }
+    if (normalized === 'reject') {
+        return 'rejected';
+    }
+    if (normalized === 'canceled') {
+        return 'cancelled';
+    }
+    throw new Error('Approval request status must be pending, approved, rejected, cancelled, or expired.');
+}
+function normalizeAgentTaskStatus(value, fallback = 'created') {
+    const normalized = normalizeContractEnumValue(value || fallback).replace(/-/g, '_');
+    if (normalized === 'created' ||
+        normalized === 'queued' ||
+        normalized === 'running' ||
+        normalized === 'waiting_for_user' ||
+        normalized === 'completed' ||
+        normalized === 'failed' ||
+        normalized === 'cancelled') {
+        return normalized;
+    }
+    if (normalized === 'canceled') {
+        return 'cancelled';
+    }
+    throw new Error('Agent task status must be created, queued, running, waiting_for_user, completed, failed, or cancelled.');
+}
+function normalizeChannelContentPartType(value) {
+    const normalized = normalizeContractEnumValue(value).replace(/-/g, '_');
+    if (normalized === 'text' ||
+        normalized === 'image' ||
+        normalized === 'file' ||
+        normalized === 'permission_card') {
+        return normalized;
+    }
+    throw new Error('Channel content part type must be text, image, file, or permission_card.');
+}
+function normalizeContractEnumValue(value) {
+    return String(value || '').trim().toLowerCase().replace(/[\s_]+/g, '-');
+}
+function normalizeScheduledJobExecutionMode(value, fallback = 'same-thread') {
+    const normalized = normalizeContractEnumValue(value || fallback);
+    if (normalized === 'same-thread' || normalized === 'side-thread') {
+        return normalized;
+    }
+    throw new Error('Scheduled job execution mode must be same-thread or side-thread.');
+}
+function normalizeScheduledJobTriggerType(value, fallback = 'cron') {
+    const normalized = normalizeContractEnumValue(value || fallback);
+    if (normalized === 'cron' || normalized === 'once' || normalized === 'one-time') {
+        return normalized === 'one-time' ? 'once' : normalized;
+    }
+    throw new Error('Scheduled job trigger type must be cron or once.');
+}
+function normalizeChannelPlatform(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (!normalized) {
+        throw new Error('Channel platform is required.');
+    }
+    return normalized;
+}
+function normalizeRunStatus(value, fallback = 'queued') {
+    const normalized = normalizeContractEnumValue(value || fallback).replace(/-/g, '_');
+    if (normalized === 'queued' ||
+        normalized === 'running' ||
+        normalized === 'awaiting_input' ||
+        normalized === 'completed' ||
+        normalized === 'failed' ||
+        normalized === 'interrupted') {
+        return normalized;
+    }
+    if (normalized === 'cancelled' || normalized === 'canceled') {
+        return 'interrupted';
+    }
+    throw new Error('Run status must be queued, running, awaiting_input, completed, failed, or interrupted.');
+}
+function normalizeScheduledJobRunStatus(value, fallback = 'queued') {
+    const normalized = normalizeContractEnumValue(value || fallback).replace(/-/g, '_');
+    if (normalized === 'queued' ||
+        normalized === 'running' ||
+        normalized === 'succeeded' ||
+        normalized === 'failed' ||
+        normalized === 'skipped') {
+        return normalized;
+    }
+    if (normalized === 'complete' || normalized === 'completed' || normalized === 'success') {
+        return 'succeeded';
+    }
+    if (normalized === 'cancelled' || normalized === 'canceled') {
+        return 'skipped';
+    }
+    throw new Error('Scheduled job run status must be queued, running, succeeded, failed, or skipped.');
+}

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-backend.js

@@ -9,6 +9,7 @@ const local_core_acp_session_coordinator_js_1 = require("./local-core-acp-sessio
 const local_core_acp_response_processor_js_1 = require("./local-core-acp-response-processor.js");
 const local_core_acp_content_js_1 = require("./local-core-acp-content.js");
 const command_risk_js_1 = require("../security/command-risk.js");
+const local_core_slash_commands_js_1 = require("./local-core-slash-commands.js");
 const ACP_PROMPT_TIMEOUT_MS = 15 * 60 * 1000;
 class LocalCoreAcpBackend {
     options;
@@ -26,11 +27,11 @@ class LocalCoreAcpBackend {
         });
         this.turnCoordinator = new local_core_acp_turn_coordinator_js_1.LocalCoreAcpTurnCoordinator({
             emitBridge: (event) => this.emitBridgeEvent(event),
-            appendMessage: (threadId, role, content, kind) => {
-                this.options.store.appendMessage(threadId, role, content, kind);
+            appendMessage: (threadId, role, content, kind, toolCall) => {
+                this.options.store.appendMessage(threadId, role, content, kind, toolCall);
             },
-            upsertMessage: (threadId, id, role, content, kind) => {
-                this.options.store.upsertMessage(threadId, id, role, content, kind);
+            upsertMessage: (threadId, id, role, content, kind, toolCall) => {
+                this.options.store.upsertMessage(threadId, id, role, content, kind, toolCall);
             },
             updateRunStatus: (runId, threadId, status) => {
                 this.options.store.updateRun(runId, threadId, status);
@@ -71,6 +72,7 @@ class LocalCoreAcpBackend {
                 });
                 return approval.approvalId;
             },
+            getThreadAgentMode: (threadId) => this.options.store.getThreadRow(threadId)?.agent_mode || local_core_slash_commands_js_1.DEFAULT_AGENT_MODE,
             sendRaw: (session, payload) => this.transport.sendRaw(session, payload),
         });
         this.sessionCoordinator = new local_core_acp_session_coordinator_js_1.LocalCoreAcpSessionCoordinator({
@@ -108,8 +110,8 @@ class LocalCoreAcpBackend {
     async listThreads(workspaceId) {
         return this.options.store.listThreadSummaries(workspaceId);
     }
-    async createThread(workspaceId, title, agentType = desktop_js_1.LOCALCORE_ACP_AGENT_TYPE) {
-        return this.options.store.createThread(workspaceId, title, agentType);
+    async createThread(workspaceId, title, agentType = desktop_js_1.LOCALCORE_ACP_AGENT_TYPE, agentMode = local_core_slash_commands_js_1.DEFAULT_AGENT_MODE) {
+        return this.options.store.createThread(workspaceId, title, agentType, agentMode);
     }
     async getThread(threadId) {
         const detail = this.options.store.getThread(threadId, []);
@@ -149,6 +151,31 @@ class LocalCoreAcpBackend {
                 source: 'user',
             },
         });
+        const slashResponse = await this.handleLocalSlashCommand(threadId, row.workspace_id, content);
+        if (slashResponse) {
+            this.options.store.appendMessage(threadId, 'assistant', slashResponse, 'final');
+            this.options.eventBus.emit({
+                type: 'thread.message.accepted',
+                payload: {
+                    threadId,
+                    workspaceId: row.workspace_id,
+                    role: 'assistant',
+                    content: slashResponse,
+                    kind: 'final',
+                    source: 'system',
+                },
+            });
+            this.emitBridgeEvent({
+                type: 'reply',
+                sessionKey: row.bridge_session_key,
+                content: slashResponse,
+            });
+            this.emitBridgeEvent({
+                type: 'typing_stop',
+                sessionKey: row.bridge_session_key,
+            });
+            return { runId: '' };
+        }
         const runId = `run:${threadId}:${Date.now()}`;
         this.options.runThreadMap.set(runId, threadId);
         this.options.store.updateRun(runId, threadId, 'running');
@@ -219,6 +246,40 @@ class LocalCoreAcpBackend {
         });
         return { runId: session.currentRunId };
     }
+    async handleLocalSlashCommand(threadId, workspaceId, content) {
+        const command = (0, local_core_slash_commands_js_1.parseSlashCommand)(content);
+        if (!command || command.name !== 'mode') {
+            return '';
+        }
+        const row = this.options.store.getThreadRow(threadId);
+        const currentMode = row?.agent_mode || local_core_slash_commands_js_1.DEFAULT_AGENT_MODE;
+        const requested = command.args.join(' ').trim();
+        if (!requested) {
+            return (0, local_core_slash_commands_js_1.modeHelpText)(currentMode);
+        }
+        const mode = (0, local_core_slash_commands_js_1.normalizeAgentMode)(requested);
+        if (!mode) {
+            return `未知模式：${requested}\n\n${(0, local_core_slash_commands_js_1.modeHelpText)(currentMode)}`;
+        }
+        this.options.store.updateThreadAgentMode(threadId, mode);
+        try {
+            await this.sessionCoordinator.setThreadMode(threadId, mode);
+        }
+        catch (error) {
+            this.options.log?.(`localcore-acp mode sync failed for ${threadId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        this.options.store.createAuditEvent({
+            type: 'permission.changed',
+            workspaceId,
+            actor: 'local',
+            summary: `Thread agent mode changed to ${mode}.`,
+            metadata: { threadId, mode },
+        });
+        if (mode === 'bypassPermissions') {
+            return '已切换到 yolo 模式：后续工具调用会跳过权限申请。使用 `/mode default` 可恢复默认权限。';
+        }
+        return `已切换到 ${(0, local_core_slash_commands_js_1.formatAgentMode)(mode)} 模式。`;
+    }
     async interruptRun(runId) {
         return this.sessionCoordinator.interruptRun(runId);
     }