@kafca/agentdock 0.1.14 → 0.1.16

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

@@ -166,8 +166,8 @@ function plugin(id, dependsOn = []) {
         strict_1.default.deepEqual(runtime.kernel.getCapabilitySnapshot().scheduler, {
             enabled: true,
             triggerTypes: ['cron', 'once'],
-            deliveryTargets: ['lark', 'weixin'],
-            platforms: ['lark', 'weixin'],
+            deliveryTargets: ['local', 'lark', 'weixin'],
+            platforms: ['local', 'lark', 'weixin'],
         });
         await runtime.start();
         await runtime.stop();
@@ -199,8 +199,8 @@ function plugin(id, dependsOn = []) {
         strict_1.default.deepEqual(runtime.kernel.getCapabilitySnapshot().scheduler, {
             enabled: true,
             triggerTypes: ['cron', 'once'],
-            deliveryTargets: ['lark', 'weixin'],
-            platforms: ['lark', 'weixin'],
+            deliveryTargets: ['local', 'lark', 'weixin'],
+            platforms: ['local', 'lark', 'weixin'],
         });
     }
     finally {
@@ -265,8 +265,8 @@ function plugin(id, dependsOn = []) {
         strict_1.default.deepEqual(runtime.kernel.getCapabilitySnapshot().scheduler, {
             enabled: true,
             triggerTypes: ['cron', 'once'],
-            deliveryTargets: ['weixin'],
-            platforms: ['weixin'],
+            deliveryTargets: ['local', 'weixin'],
+            platforms: ['local', 'weixin'],
         });
     }
     finally {

package/dist-electron/electron/runtime-detection-service.test.js

@@ -0,0 +1,116 @@
+"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_os_1 = require("node:os");
+const runtime_detection_service_js_1 = require("../services/local-ai-core/src/runtime/runtime-detection-service.js");
+(0, node_test_1.default)('runtime detection service returns unknown results before first detection', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-detection-service-'));
+    try {
+        const service = new runtime_detection_service_js_1.RuntimeDetectionService({
+            userDataPath,
+            readConfig: async () => null,
+            detect: () => [],
+        });
+        const runtimes = service.list();
+        const opencode = runtimes.find((runtime) => runtime.runtimeId === 'opencode');
+        strict_1.default.equal(opencode?.status, 'unknown');
+        strict_1.default.equal(opencode?.installed, false);
+        strict_1.default.equal(runtimes.find((runtime) => runtime.runtimeId === 'localcore-acp')?.status, 'installed');
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('runtime detection service refresh persists latest results', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-detection-service-persist-'));
+    try {
+        const detectedAt = '2026-04-27T00:00:00.000Z';
+        const result = runtimeResult({ detectedAt, version: '1.2.3' });
+        const service = new runtime_detection_service_js_1.RuntimeDetectionService({
+            userDataPath,
+            readConfig: async () => null,
+            detect: () => [result],
+        });
+        strict_1.default.deepEqual(await service.refresh(), [result]);
+        const nextService = new runtime_detection_service_js_1.RuntimeDetectionService({
+            userDataPath,
+            readConfig: async () => null,
+            detect: () => [],
+        });
+        strict_1.default.equal(nextService.list()[0]?.version, '1.2.3');
+        strict_1.default.match((0, node_fs_1.readFileSync)((0, node_path_1.join)(userDataPath, 'runtime', 'runtime-detection.json'), 'utf8'), /"version": "1.2.3"/);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('runtime detection service ignores corrupted persisted state', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-detection-service-corrupt-'));
+    try {
+        const statePath = (0, node_path_1.join)(userDataPath, 'runtime', 'runtime-detection.json');
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(userDataPath, 'runtime'), { recursive: true });
+        (0, node_fs_1.writeFileSync)(statePath, '{not-json', 'utf8');
+        const service = new runtime_detection_service_js_1.RuntimeDetectionService({
+            userDataPath,
+            readConfig: async () => null,
+            detect: () => [],
+        });
+        strict_1.default.equal(service.list().find((runtime) => runtime.runtimeId === 'opencode')?.status, 'unknown');
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('runtime detection service emits detection events and filters single runtime refresh response', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-detection-service-events-'));
+    try {
+        const events = [];
+        const service = new runtime_detection_service_js_1.RuntimeDetectionService({
+            userDataPath,
+            readConfig: async () => null,
+            detect: () => [
+                runtimeResult({ runtimeId: 'opencode', agentType: 'opencode' }),
+                runtimeResult({ runtimeId: 'codex', agentType: 'codex' }),
+            ],
+            emit: (event) => {
+                events.push(event.type);
+            },
+        });
+        const refreshed = await service.refresh('codex');
+        strict_1.default.deepEqual(refreshed.map((runtime) => runtime.runtimeId), ['codex']);
+        strict_1.default.deepEqual(events, [
+            'runtime.detect.started',
+            'runtime.detect.completed',
+            'runtime.status.changed',
+            'runtime.status.changed',
+        ]);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+function runtimeResult(input = {}) {
+    return {
+        agentType: input.agentType || 'opencode',
+        runtimeId: input.runtimeId || input.agentType || 'opencode',
+        displayName: input.displayName || 'OpenCode',
+        status: input.status || 'installed',
+        installed: input.installed ?? true,
+        command: input.command || '/tmp/opencode',
+        binaryPath: input.binaryPath || input.command || '/tmp/opencode',
+        version: input.version,
+        detectedAt: input.detectedAt || '2026-04-27T00:00:00.000Z',
+        summary: input.summary || 'OpenCode is installed.',
+        details: input.details,
+        issues: input.issues || [],
+        recommendedActions: input.recommendedActions || [],
+        source: input.source || 'path',
+        error: input.error,
+    };
+}

package/dist-electron/electron/security-approval-store.test.js

@@ -0,0 +1,89 @@
+"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_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/local-core-acp-store.js");
+const command_risk_js_1 = require("../services/local-ai-core/src/security/command-risk.js");
+(0, node_test_1.default)('workspace security settings persist and create audit events', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'security-settings-'));
+    const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+    const settings = store.updateWorkspaceSecuritySettings('workspace-a', {
+        permissions: {
+            'command.execute': 'deny',
+            'network.access': 'allow',
+        },
+        allowPaths: ['/tmp/project'],
+        denyPaths: ['/tmp/project/.env'],
+        updatedBy: 'tester',
+    });
+    strict_1.default.equal(settings.permissions['command.execute'], 'deny');
+    strict_1.default.equal(settings.permissions['workspace.read'], 'allow');
+    strict_1.default.deepEqual(settings.allowPaths, ['/tmp/project']);
+    strict_1.default.deepEqual(settings.denyPaths, ['/tmp/project/.env']);
+    const audit = store.listAuditEvents({ workspaceId: 'workspace-a', type: 'permission.changed' });
+    strict_1.default.equal(audit.events.length, 1);
+    strict_1.default.equal(audit.events[0].actor, 'tester');
+    store.close();
+    const reopened = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+    strict_1.default.equal(reopened.getWorkspaceSecuritySettings('workspace-a').permissions['command.execute'], 'deny');
+    reopened.close();
+});
+(0, node_test_1.default)('approval requests persist, resolve, attach to tasks, and audit lifecycle', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'approval-requests-'));
+    const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+    const task = store.createAgentTask({
+        workspaceId: 'workspace-a',
+        deviceId: 'local',
+        runtimeId: 'codex',
+        threadId: 'thread-a',
+        runId: 'run-a',
+        title: 'Dangerous command',
+        status: 'waiting_for_user',
+    });
+    const approval = store.createApprovalRequest({
+        workspaceId: 'workspace-a',
+        taskId: task.taskId,
+        threadId: 'thread-a',
+        runId: 'run-a',
+        kind: 'command',
+        riskLevel: 'high',
+        title: 'Approve rm',
+        description: 'rm -rf /tmp/project TOKEN=secret-value',
+        requestedAction: 'rm -rf /tmp/project',
+        command: 'rm -rf /tmp/project',
+        scopes: ['command.execute', 'workspace.write'],
+        requestedBy: 'agent',
+    });
+    strict_1.default.equal(approval.status, 'pending');
+    strict_1.default.match(approval.description, /\[REDACTED_SECRET\]/);
+    strict_1.default.ok(store.getAgentTask(task.taskId)?.approvalIds.includes(approval.approvalId));
+    const resolved = store.resolveApprovalRequest(approval.approvalId, {
+        status: 'approved',
+        resolvedBy: 'tester',
+        resolution: 'allow once',
+    });
+    strict_1.default.equal(resolved.status, 'approved');
+    strict_1.default.equal(resolved.resolvedBy, 'tester');
+    strict_1.default.equal(store.listApprovalRequests({ status: 'approved' }).approvals.length, 1);
+    strict_1.default.equal(store.listAuditEvents({ approvalId: approval.approvalId }).events.length, 2);
+    store.close();
+});
+(0, node_test_1.default)('command risk classification and secret redaction cover baseline rules', () => {
+    const high = (0, command_risk_js_1.classifyCommandRisk)('git reset --hard HEAD');
+    strict_1.default.equal(high.riskLevel, 'high');
+    strict_1.default.equal(high.requiresApproval, true);
+    strict_1.default.ok(high.scopes.includes('git.modify'));
+    const medium = (0, command_risk_js_1.classifyCommandRisk)('pnpm install');
+    strict_1.default.equal(medium.riskLevel, 'medium');
+    strict_1.default.ok(medium.scopes.includes('network.access'));
+    const low = (0, command_risk_js_1.classifyCommandRisk)('ls src');
+    strict_1.default.equal(low.riskLevel, 'low');
+    strict_1.default.equal(low.requiresApproval, false);
+    strict_1.default.equal((0, local_core_acp_store_js_1.redactSecrets)('OPENAI_API_KEY=sk-test1234567890 Bearer abc.def'), 'OPENAI_API_KEY=[REDACTED_SECRET] Bearer [REDACTED_SECRET]');
+});

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

@@ -0,0 +1,66 @@
+"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_os_1 = require("node:os");
+const local_core_acp_store_js_1 = require("../services/local-ai-core/src/acp/local-core-acp-store.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 {
+        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 },
+        });
+        store.close();
+        const nextStore = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const workspace = nextStore.getWorkspaceRegistryEntry('workspace-a');
+        strict_1.default.equal(workspace?.displayName, 'Workspace A');
+        strict_1.default.equal(workspace?.defaultRuntimeId, 'opencode');
+        strict_1.default.equal(workspace?.health.status, 'healthy');
+        nextStore.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 {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const task = store.createAgentTask({
+            workspaceId: 'workspace-a',
+            deviceId: 'local',
+            runtimeId: 'opencode',
+            threadId: 'thread-1',
+            runId: 'run-1',
+            title: 'Implement feature',
+            prompt: 'Please implement feature',
+            status: 'running',
+        });
+        const updated = store.updateAgentTask(task.taskId, {
+            status: 'completed',
+            summary: 'done',
+            log: { level: 'info', message: 'finished' },
+        });
+        strict_1.default.equal(updated.status, 'completed');
+        strict_1.default.equal(updated.summary, 'done');
+        strict_1.default.equal(updated.logs[0]?.message, 'finished');
+        strict_1.default.equal(store.getAgentTaskByRunId('run-1')?.taskId, task.taskId);
+        strict_1.default.equal(store.listAgentTasks({ status: 'completed' }).tasks.length, 1);
+        store.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});

package/dist-electron/packages/core-sdk/src/index.js

@@ -8,6 +8,11 @@ exports.startCoreService = startCoreService;
 exports.stopCoreService = stopCoreService;
 exports.restartCoreService = restartCoreService;
 exports.getCoreLogs = getCoreLogs;
+exports.listInstalledAgentRuntimes = listInstalledAgentRuntimes;
+exports.listRuntimeDetections = listRuntimeDetections;
+exports.getRuntimeDetection = getRuntimeDetection;
+exports.refreshRuntimeDetections = refreshRuntimeDetections;
+exports.refreshRuntimeDetection = refreshRuntimeDetection;
 exports.readCoreConfigFile = readCoreConfigFile;
 exports.saveCoreRawConfigFile = saveCoreRawConfigFile;
 exports.saveCoreStructuredConfigFile = saveCoreStructuredConfigFile;
@@ -33,6 +38,23 @@ exports.listLarkAuthorizedUsers = listLarkAuthorizedUsers;
 exports.getWeixinQrCode = getWeixinQrCode;
 exports.checkWeixinQrCodeStatus = checkWeixinQrCodeStatus;
 exports.listWorkspaces = listWorkspaces;
+exports.listWorkspaceRegistry = listWorkspaceRegistry;
+exports.getWorkspaceRegistryEntry = getWorkspaceRegistryEntry;
+exports.createWorkspaceRegistryEntry = createWorkspaceRegistryEntry;
+exports.updateWorkspaceRegistryEntry = updateWorkspaceRegistryEntry;
+exports.deleteWorkspaceRegistryEntry = deleteWorkspaceRegistryEntry;
+exports.listAgentTasks = listAgentTasks;
+exports.getAgentTask = getAgentTask;
+exports.createAgentTask = createAgentTask;
+exports.updateAgentTask = updateAgentTask;
+exports.getWorkspaceSecuritySettings = getWorkspaceSecuritySettings;
+exports.updateWorkspaceSecuritySettings = updateWorkspaceSecuritySettings;
+exports.classifyCommand = classifyCommand;
+exports.listApprovalRequests = listApprovalRequests;
+exports.getApprovalRequest = getApprovalRequest;
+exports.createApprovalRequest = createApprovalRequest;
+exports.resolveApprovalRequest = resolveApprovalRequest;
+exports.listAuditEvents = listAuditEvents;
 exports.listScheduledJobs = listScheduledJobs;
 exports.getScheduledJob = getScheduledJob;
 exports.createScheduledJob = createScheduledJob;
@@ -116,6 +138,10 @@ function ensureEventSource() {
     };
     [
         'runtime.updated',
+        'runtime.detect.started',
+        'runtime.detect.completed',
+        'runtime.detect.failed',
+        'runtime.status.changed',
         'thread.updated',
         'message.created',
         'message.updated',
@@ -180,6 +206,21 @@ async function getCoreLogs(limit) {
     const suffix = typeof limit === 'number' ? `?limit=${encodeURIComponent(String(limit))}` : '';
     return coreRequest('GET', `/runtime/logs${suffix}`);
 }
+async function listInstalledAgentRuntimes() {
+    return coreRequest('GET', '/runtime/agent-runtimes');
+}
+async function listRuntimeDetections() {
+    return coreRequest('GET', '/runtimes');
+}
+async function getRuntimeDetection(runtimeId) {
+    return coreRequest('GET', `/runtimes/${encodeURIComponent(runtimeId)}`);
+}
+async function refreshRuntimeDetections() {
+    return coreRequest('POST', '/runtimes/refresh');
+}
+async function refreshRuntimeDetection(runtimeId) {
+    return coreRequest('POST', `/runtimes/${encodeURIComponent(runtimeId)}/refresh`);
+}
 async function readCoreConfigFile() {
     return coreRequest('GET', '/runtime/config');
 }
@@ -257,6 +298,89 @@ async function checkWeixinQrCodeStatus(workspaceId, ticket) {
 async function listWorkspaces() {
     return coreRequest('GET', '/workspaces');
 }
+async function listWorkspaceRegistry() {
+    return coreRequest('GET', '/workspace-registry');
+}
+async function getWorkspaceRegistryEntry(workspaceId) {
+    return coreRequest('GET', `/workspace-registry/${encodeURIComponent(workspaceId)}`);
+}
+async function createWorkspaceRegistryEntry(input) {
+    return coreRequest('POST', '/workspace-registry', input);
+}
+async function updateWorkspaceRegistryEntry(workspaceId, input) {
+    return coreRequest('PATCH', `/workspace-registry/${encodeURIComponent(workspaceId)}`, input);
+}
+async function deleteWorkspaceRegistryEntry(workspaceId) {
+    return coreRequest('DELETE', `/workspace-registry/${encodeURIComponent(workspaceId)}`);
+}
+async function listAgentTasks(query = {}) {
+    const params = new URLSearchParams();
+    if (query.workspaceId)
+        params.set('workspace_id', query.workspaceId);
+    if (query.runtimeId)
+        params.set('runtime_id', query.runtimeId);
+    if (query.status)
+        params.set('status', Array.isArray(query.status) ? query.status.join(',') : query.status);
+    if (query.limit)
+        params.set('limit', String(query.limit));
+    const suffix = params.toString() ? `?${params.toString()}` : '';
+    return coreRequest('GET', `/tasks${suffix}`);
+}
+async function getAgentTask(taskId) {
+    return coreRequest('GET', `/tasks/${encodeURIComponent(taskId)}`);
+}
+async function createAgentTask(input) {
+    return coreRequest('POST', '/tasks', input);
+}
+async function updateAgentTask(taskId, input) {
+    return coreRequest('PATCH', `/tasks/${encodeURIComponent(taskId)}`, input);
+}
+async function getWorkspaceSecuritySettings(workspaceId) {
+    return coreRequest('GET', `/workspace-security/${encodeURIComponent(workspaceId)}`);
+}
+async function updateWorkspaceSecuritySettings(workspaceId, input) {
+    return coreRequest('PATCH', `/workspace-security/${encodeURIComponent(workspaceId)}`, input);
+}
+async function classifyCommand(command, workspaceId) {
+    return coreRequest('POST', '/security/command-risk', { command, workspaceId });
+}
+async function listApprovalRequests(query = {}) {
+    const params = new URLSearchParams();
+    if (query.workspaceId)
+        params.set('workspace_id', query.workspaceId);
+    if (query.taskId)
+        params.set('task_id', query.taskId);
+    if (query.status)
+        params.set('status', Array.isArray(query.status) ? query.status.join(',') : query.status);
+    if (query.limit)
+        params.set('limit', String(query.limit));
+    const suffix = params.toString() ? `?${params.toString()}` : '';
+    return coreRequest('GET', `/approvals${suffix}`);
+}
+async function getApprovalRequest(approvalId) {
+    return coreRequest('GET', `/approvals/${encodeURIComponent(approvalId)}`);
+}
+async function createApprovalRequest(input) {
+    return coreRequest('POST', '/approvals', input);
+}
+async function resolveApprovalRequest(approvalId, input) {
+    return coreRequest('POST', `/approvals/${encodeURIComponent(approvalId)}/resolve`, input);
+}
+async function listAuditEvents(query = {}) {
+    const params = new URLSearchParams();
+    if (query.workspaceId)
+        params.set('workspace_id', query.workspaceId);
+    if (query.taskId)
+        params.set('task_id', query.taskId);
+    if (query.approvalId)
+        params.set('approval_id', query.approvalId);
+    if (query.type)
+        params.set('type', Array.isArray(query.type) ? query.type.join(',') : query.type);
+    if (query.limit)
+        params.set('limit', String(query.limit));
+    const suffix = params.toString() ? `?${params.toString()}` : '';
+    return coreRequest('GET', `/audit-events${suffix}`);
+}
 async function listScheduledJobs(workspaceId) {
     const suffix = workspaceId ? `?workspace_id=${encodeURIComponent(workspaceId)}` : '';
     return coreRequest('GET', `/scheduler/jobs${suffix}`);

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

@@ -7,6 +7,7 @@ const local_core_acp_transport_js_1 = require("./local-core-acp-transport.js");
 const local_core_acp_turn_coordinator_js_1 = require("./local-core-acp-turn-coordinator.js");
 const local_core_acp_session_coordinator_js_1 = require("./local-core-acp-session-coordinator.js");
 const local_core_acp_response_processor_js_1 = require("./local-core-acp-response-processor.js");
+const command_risk_js_1 = require("../security/command-risk.js");
 const ACP_PROMPT_TIMEOUT_MS = 15 * 60 * 1000;
 class LocalCoreAcpBackend {
     options;
@@ -32,6 +33,42 @@ class LocalCoreAcpBackend {
             },
             updateRunStatus: (runId, threadId, status) => {
                 this.options.store.updateRun(runId, threadId, status);
+                const task = this.options.store.getAgentTaskByRunId(runId);
+                if (task) {
+                    this.options.store.updateAgentTask(task.taskId, {
+                        status: status === 'awaiting_input' ? 'waiting_for_user' : 'running',
+                    });
+                }
+            },
+            createApprovalRequest: ({ threadId, runId, title, description, command, options }) => {
+                const row = this.options.store.getThreadRow(threadId);
+                if (!row) {
+                    return undefined;
+                }
+                const task = this.options.store.getAgentTaskByRunId(runId);
+                const classification = (0, command_risk_js_1.classifyCommandRisk)(command || description || title);
+                const approval = this.options.store.createApprovalRequest({
+                    workspaceId: row.workspace_id,
+                    taskId: task?.taskId,
+                    threadId,
+                    runId,
+                    deviceId: 'local',
+                    kind: classification.scopes.includes('git.modify') ? 'git' : 'command',
+                    riskLevel: classification.riskLevel,
+                    title,
+                    description,
+                    requestedAction: command || description || title,
+                    command,
+                    scopes: classification.scopes,
+                    options: options.map((option) => ({
+                        optionId: option.optionId,
+                        label: option.name || option.optionId,
+                        action: option.normalizedAction === 'deny' ? 'reject' : 'approve',
+                    })),
+                    requestedBy: 'agent',
+                    metadata: { classification },
+                });
+                return approval.approvalId;
             },
             sendRaw: (session, payload) => this.transport.sendRaw(session, payload),
         });
@@ -112,6 +149,16 @@ class LocalCoreAcpBackend {
         const runId = `run:${threadId}:${Date.now()}`;
         this.options.runThreadMap.set(runId, threadId);
         this.options.store.updateRun(runId, threadId, 'running');
+        this.options.store.createAgentTask({
+            workspaceId: row.workspace_id,
+            deviceId: 'local',
+            runtimeId: row.agent_type,
+            threadId,
+            runId,
+            title: content.trim().slice(0, 80) || row.title || 'Agent task',
+            prompt: content,
+            status: 'running',
+        });
         this.options.eventBus.emit({
             type: 'run.started',
             payload: {
@@ -154,6 +201,13 @@ class LocalCoreAcpBackend {
         if (!accepted) {
             throw new Error(session.closeReason || 'ACP session is not writable');
         }
+        if (pendingPermission.approvalId) {
+            this.options.store.resolveApprovalRequest(pendingPermission.approvalId, {
+                status: matched.normalizedAction === 'deny' ? 'rejected' : 'approved',
+                resolvedBy: 'local',
+                resolution: matched.name || matched.optionId,
+            });
+        }
         session.pendingPermissionByRun.delete(session.currentRunId);
         this.emitBridgeEvent({
             type: 'typing_start',
@@ -280,6 +334,13 @@ class LocalCoreAcpBackend {
             }
             const nextStatus = result?.stopReason === 'cancelled' ? 'interrupted' : 'completed';
             this.options.store.updateRun(runId, threadId, nextStatus);
+            const task = this.options.store.getAgentTaskByRunId(runId);
+            if (task) {
+                this.options.store.updateAgentTask(task.taskId, {
+                    status: nextStatus === 'interrupted' ? 'cancelled' : 'completed',
+                    summary: result?.stopReason === 'cancelled' ? 'Request cancelled.' : 'Task completed.',
+                });
+            }
             this.options.eventBus.emit({
                 type: 'run.completed',
                 payload: {
@@ -298,6 +359,13 @@ class LocalCoreAcpBackend {
         catch (error) {
             const errorContent = `Agent error: ${error instanceof Error ? error.message : String(error)}`;
             this.options.store.updateRun(runId, threadId, 'failed');
+            const task = this.options.store.getAgentTaskByRunId(runId);
+            if (task) {
+                this.options.store.updateAgentTask(task.taskId, {
+                    status: 'failed',
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
             this.options.store.appendMessage(threadId, 'assistant', errorContent, 'final');
             this.options.eventBus.emit({
                 type: 'thread.message.accepted',