@kafca/agentdock 0.1.28 → 0.1.30

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

@@ -11,6 +11,8 @@ 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");
+const bootstrap_js_1 = require("../services/local-ai-core/src/kernel/bootstrap.js");
+const local_core_controller_js_1 = require("../services/local-ai-core/src/runtime/local-core-controller.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 {
@@ -36,6 +38,50 @@ const scheduler_service_js_1 = require("../services/local-ai-core/src/scheduler/
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('scheduler create resolves a Lark route from the current thread binding', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-binding-route-'));
+    try {
+        const runtime = (0, bootstrap_js_1.bootstrapLocalCoreRuntime)({
+            userDataPath,
+            enableKnowledge: false,
+            log: () => { },
+        });
+        const controller = new local_core_controller_js_1.LocalCoreController(userDataPath, runtime);
+        const thread = runtime.store.createThread('workspace-a', 'Lark thread');
+        const now = new Date().toISOString();
+        runtime.store.upsertPlatformThreadBinding({
+            workspace_id: 'workspace-a',
+            platform: 'lark',
+            chat_id: 'chat-1',
+            platform_user_id: 'user-1',
+            thread_id: thread.id,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        const job = await controller.createScheduledJob({
+            workspaceId: 'workspace-a',
+            threadId: thread.id,
+            executionMode: 'side-thread',
+            triggerType: 'cron',
+            cronExpr: '30 18 * * *',
+            promptTemplate: 'ping',
+            description: 'bound lark task',
+            enabled: true,
+        });
+        strict_1.default.equal(job.platform, 'lark');
+        strict_1.default.deepEqual(job.route, {
+            type: 'channel.chat',
+            channelId: 'chat-1',
+            participantId: 'user-1',
+            threadId: thread.id,
+        });
+        await controller.close();
+    }
+    finally {
+        (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 {
@@ -92,6 +138,78 @@ const scheduler_service_js_1 = require("../services/local-ai-core/src/scheduler/
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('ACP scheduled session can override permission mode without changing thread mode', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-permission-mode-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const thread = store.createThread('workspace-a', 'Thread');
+        const capturedSessionNewParams = [];
+        let closeCount = 0;
+        const coordinator = new local_core_acp_session_coordinator_js_1.LocalCoreAcpSessionCoordinator({
+            store,
+            transport: {
+                spawnSession(input) {
+                    return {
+                        threadId: input.threadId,
+                        bridgeSessionKey: input.bridgeSessionKey,
+                        closed: false,
+                        sessionId: '',
+                        supportsLoad: false,
+                        pendingPermissionByRun: new Map(),
+                        schedulerJobCreatedByRun: new Map(),
+                        launchPermissionMode: '',
+                    };
+                },
+                initializeSession: async () => { },
+                request: async (_session, method, params) => {
+                    if (method === 'session/new') {
+                        capturedSessionNewParams.push(params);
+                        return { sessionId: 'session-1' };
+                    }
+                    return {};
+                },
+                closeSession: () => {
+                    closeCount += 1;
+                },
+                closeSessionWithError: () => { },
+                sendRaw: () => true,
+            },
+            runThreadMap: new Map(),
+            emitBridge: () => { },
+        });
+        await coordinator.ensureSession(thread.id, 'session:thread-1', {
+            workspaceId: 'workspace-a',
+            agentType: 'claudecode',
+            command: 'claude',
+            args: [],
+            env: {},
+            workDir: '/tmp/workspace-a',
+            model: '',
+        }, { permissionMode: 'bypassPermissions' });
+        strict_1.default.equal(capturedSessionNewParams[0]?._meta?.claudeCode?.options?.permissionMode, 'bypassPermissions');
+        strict_1.default.equal(store.getThreadRow(thread.id)?.agent_mode, 'default');
+        await coordinator.ensureSession(thread.id, 'session:thread-1', {
+            workspaceId: 'workspace-a',
+            agentType: 'claudecode',
+            command: 'claude',
+            args: [],
+            env: {},
+            workDir: '/tmp/workspace-a',
+            model: '',
+        });
+        strict_1.default.equal(closeCount, 1);
+        strict_1.default.deepEqual(capturedSessionNewParams[1]?._meta, {
+            claudeCode: {
+                emitRawSDKMessages: [
+                    { type: 'system', subtype: 'local_command_output' },
+                ],
+            },
+        });
+    }
+    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 {

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

@@ -10,6 +10,7 @@ const local_core_acp_response_processor_js_1 = require("./local-core-acp-respons
 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 local_core_acp_progress_js_1 = require("./local-core-acp-progress.js");
 const ACP_PROMPT_TIMEOUT_MS = 15 * 60 * 1000;
 class LocalCoreAcpBackend {
     options;
@@ -27,11 +28,11 @@ class LocalCoreAcpBackend {
         });
         this.turnCoordinator = new local_core_acp_turn_coordinator_js_1.LocalCoreAcpTurnCoordinator({
             emitBridge: (event) => this.emitBridgeEvent(event),
-            appendMessage: (threadId, role, content, kind, toolCall) => {
-                this.options.store.appendMessage(threadId, role, content, kind, toolCall);
+            appendMessage: (threadId, role, content, kind, toolCall, bridgeKind, bridgeStatus) => {
+                this.options.store.appendMessage(threadId, role, content, kind, toolCall, bridgeKind, bridgeStatus);
             },
-            upsertMessage: (threadId, id, role, content, kind, toolCall) => {
-                this.options.store.upsertMessage(threadId, id, role, content, kind, toolCall);
+            upsertMessage: (threadId, id, role, content, kind, toolCall, bridgeKind, bridgeStatus) => {
+                this.options.store.upsertMessage(threadId, id, role, content, kind, toolCall, bridgeKind, bridgeStatus);
             },
             updateRunStatus: (runId, threadId, status) => {
                 this.options.store.updateRun(runId, threadId, status);
@@ -129,7 +130,7 @@ class LocalCoreAcpBackend {
         this.options.store.deleteThread(threadId);
         return { deleted: true };
     }
-    async sendThreadMessage(threadId, input, config) {
+    async sendThreadMessage(threadId, input, config, options = {}) {
         if (!config) {
             throw new Error('localcore-acp message send requires a workspace config.');
         }
@@ -199,7 +200,7 @@ class LocalCoreAcpBackend {
                 sessionKey: row.bridge_session_key,
             },
         });
-        void this.runPrompt(threadId, runId, row.bridge_session_key, config, message).catch((error) => {
+        void this.runPrompt(threadId, runId, row.bridge_session_key, config, message, options).catch((error) => {
             this.options.log?.(`localcore-acp prompt failed for ${threadId}: ${error instanceof Error ? error.message : String(error)}`);
         });
         return { runId };
@@ -283,7 +284,7 @@ class LocalCoreAcpBackend {
     async interruptRun(runId) {
         return this.sessionCoordinator.interruptRun(runId);
     }
-    async runPrompt(threadId, runId, bridgeSessionKey, config, input) {
+    async runPrompt(threadId, runId, bridgeSessionKey, config, input, options = {}) {
         const row = this.options.store.getThreadRow(threadId);
         if (!row) {
             throw new Error(`Thread not found: ${threadId}`);
@@ -297,16 +298,19 @@ class LocalCoreAcpBackend {
         const content = message.displayText;
         let session = null;
         try {
-            session = await this.sessionCoordinator.ensureSession(threadId, bridgeSessionKey, config);
+            session = await this.sessionCoordinator.ensureSession(threadId, bridgeSessionKey, config, {
+                permissionMode: options.permissionMode,
+            });
             session.currentRunId = runId;
             session.currentTurn = {
                 runId,
                 replyCtx: runId,
                 previewHandle: (0, node_crypto_1.randomUUID)(),
                 thoughtPreviewHandle: (0, node_crypto_1.randomUUID)(),
-                thoughtMessageId: `${runId}-thought`,
+                thoughtMessageId: `${runId}-thought-1`,
                 assistantText: '',
                 thoughtText: '',
+                thoughtSequence: 1,
                 typingStarted: true,
                 previewStarted: false,
                 thoughtPreviewStarted: false,
@@ -317,6 +321,7 @@ class LocalCoreAcpBackend {
                 pendingToolCalls: {},
                 pendingToolCallOrder: [],
                 toolCallSequence: 0,
+                toolObservations: [],
                 permission: null,
             };
             const promptPromise = this.transport.request(session, 'session/prompt', {
@@ -330,9 +335,11 @@ class LocalCoreAcpBackend {
             if (!currentTurn || currentTurn.runId !== runId) {
                 return;
             }
+            this.turnCoordinator.closePendingThoughtSegment(session);
             this.turnCoordinator.flushPendingToolCall(session);
             if (currentTurn.assistantText) {
-                const processed = await this.responseProcessor.processAssistantResponse(threadId, currentTurn.assistantText);
+                const assistantText = (0, local_core_acp_progress_js_1.stripObservedToolTranscriptsFromAssistantText)(currentTurn.assistantText, currentTurn.toolObservations);
+                const processed = await this.responseProcessor.processAssistantResponse(threadId, assistantText);
                 if (processed.displayContent) {
                     this.options.store.appendMessage(threadId, 'assistant', processed.displayContent, 'final');
                     this.options.eventBus.emit({

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyAssistantMessageChunk = applyAssistantMessageChunk;
 exports.applyThoughtChunk = applyThoughtChunk;
+exports.closeThoughtSegment = closeThoughtSegment;
 exports.registerPendingToolCall = registerPendingToolCall;
 exports.resolveToolCallForUpdate = resolveToolCallForUpdate;
 exports.resolveFallbackToolCall = resolveFallbackToolCall;
@@ -16,6 +17,8 @@ exports.isTerminalToolStatus = isTerminalToolStatus;
 exports.formatPlanProgress = formatPlanProgress;
 exports.extractToolCallKey = extractToolCallKey;
 exports.extractToolCallInput = extractToolCallInput;
+exports.recordToolObservation = recordToolObservation;
+exports.stripObservedToolTranscriptsFromAssistantText = stripObservedToolTranscriptsFromAssistantText;
 function applyAssistantMessageChunk(currentTurn, text) {
     if (!text) {
         return null;
@@ -27,20 +30,26 @@ function applyAssistantMessageChunk(currentTurn, text) {
             bridgeType: 'preview_start',
             previewHandle: currentTurn.previewHandle,
             content: currentTurn.assistantText,
+            bridgeKind: 'assistant',
         };
     }
     return {
         bridgeType: 'update_message',
         previewHandle: currentTurn.previewHandle,
         content: currentTurn.assistantText,
+        bridgeKind: 'assistant',
     };
 }
 function applyThoughtChunk(currentTurn, text) {
     if (!text) {
         return null;
     }
-    currentTurn.thoughtText = mergeStreamingText(currentTurn.thoughtText, text);
-    const content = `💭 ${currentTurn.thoughtText.trim()}`;
+    const projection = mergeThoughtSegment(currentTurn.thoughtText, text);
+    currentTurn.thoughtText = projection.fullText;
+    const content = currentTurn.thoughtText.trim();
+    if (!content) {
+        return null;
+    }
     if (!currentTurn.thoughtPreviewStarted) {
         currentTurn.thoughtPreviewStarted = true;
         return {
@@ -48,6 +57,7 @@ function applyThoughtChunk(currentTurn, text) {
             previewHandle: currentTurn.thoughtPreviewHandle,
             messageId: currentTurn.thoughtMessageId,
             content,
+            bridgeKind: 'thought',
         };
     }
     return {
@@ -55,25 +65,70 @@ function applyThoughtChunk(currentTurn, text) {
         previewHandle: currentTurn.thoughtPreviewHandle,
         messageId: currentTurn.thoughtMessageId,
         content,
+        bridgeKind: 'thought',
     };
 }
-function mergeStreamingText(current, next) {
+function closeThoughtSegment(currentTurn) {
+    const thoughtText = currentTurn.thoughtText || '';
+    if (!thoughtText.trim()) {
+        return;
+    }
+    const nextSequence = (currentTurn.thoughtSequence || 1) + 1;
+    const runId = currentTurn.runId || 'thought';
+    currentTurn.thoughtSequence = nextSequence;
+    currentTurn.thoughtText = '';
+    currentTurn.thoughtPreviewStarted = false;
+    currentTurn.thoughtMessageId = `${runId}-thought-${nextSequence}`;
+    currentTurn.thoughtPreviewHandle = `${runId}-thought-preview-${nextSequence}`;
+}
+function mergeThoughtSegment(current, next) {
     if (!current) {
-        return next;
+        return { fullText: next, segmentText: next };
     }
     if (next.startsWith(current)) {
-        return next;
+        return {
+            fullText: next,
+            segmentText: next.slice(current.length),
+        };
     }
     if (current.endsWith(next)) {
-        return current;
+        return {
+            fullText: current,
+            segmentText: '',
+        };
     }
     const maxOverlap = Math.min(current.length, next.length);
     for (let size = maxOverlap; size > 0; size -= 1) {
         if (current.endsWith(next.slice(0, size))) {
-            return current + next.slice(size);
+            const suffix = next.slice(size);
+            return {
+                fullText: current + suffix,
+                segmentText: suffix,
+            };
         }
     }
-    return current + next;
+    return {
+        fullText: appendThoughtPiece(current, next),
+        segmentText: next,
+    };
+}
+function appendThoughtPiece(current, next) {
+    if (!current.trim()) {
+        return next;
+    }
+    if (!next.trim()) {
+        return current;
+    }
+    if (/^[,.;:!?，。；：！？、）】》]/.test(next.trimStart())) {
+        return current.trimEnd() + next.trimStart();
+    }
+    if (/^[-/]/.test(next.trimStart()) || /[-/][A-Za-z0-9]*$/.test(current.trimEnd())) {
+        return current.trimEnd() + next.trimStart();
+    }
+    if (/\s$/.test(current) || /^\s/.test(next)) {
+        return current + next;
+    }
+    return `${current.trimEnd()} ${next.trimStart()}`;
 }
 function registerPendingToolCall(input) {
     const title = String(input.update.title || 'Running tool').trim();
@@ -177,7 +232,7 @@ function formatPlanProgress(entries) {
         .map((entry) => String(entry?.content || '').trim())
         .filter(Boolean)
         .join(' | ');
-    return summary ? `💭 ${summary}` : '';
+    return summary;
 }
 function extractToolCallKey(update) {
     for (const key of ['toolCallId', 'tool_call_id', 'callId', 'call_id', 'invocationId', 'invocation_id', 'id']) {
@@ -199,3 +254,184 @@ function extractToolCallInput(update) {
     }
     return undefined;
 }
+function recordToolObservation(currentTurn, observation) {
+    const normalized = {
+        ...observation,
+        name: observation.name?.trim() || undefined,
+        title: observation.title?.trim() || undefined,
+        status: observation.status?.trim() || undefined,
+        outputText: observation.outputText?.trim() || undefined,
+    };
+    if (!normalized.name && !normalized.title && normalized.input === undefined && !normalized.outputText) {
+        return;
+    }
+    currentTurn.toolObservations = [
+        ...(currentTurn.toolObservations || []),
+        normalized,
+    ];
+}
+function stripObservedToolTranscriptsFromAssistantText(text, observations) {
+    let remaining = String(text || '');
+    const knownObservations = observations || [];
+    for (let guard = 0; guard < knownObservations.length; guard += 1) {
+        const stripped = stripOneObservedToolTranscriptPrefix(remaining, knownObservations);
+        if (stripped === remaining) {
+            break;
+        }
+        remaining = stripped;
+    }
+    return remaining.trim();
+}
+function stripOneObservedToolTranscriptPrefix(text, observations) {
+    const trimmedStart = text.replace(/^\s+/, '');
+    if (!trimmedStart) {
+        return text;
+    }
+    const matchingEvidence = observations
+        .map((observation) => createToolObservationEvidence(observation))
+        .find((evidence) => matchesObservedToolTranscriptPrefix(trimmedStart, evidence));
+    if (!matchingEvidence) {
+        return text;
+    }
+    const boundary = findToolTranscriptPrefixBoundary(trimmedStart, matchingEvidence);
+    if (boundary <= 0) {
+        return text;
+    }
+    return trimmedStart.slice(boundary);
+}
+function createToolObservationEvidence(observation) {
+    const serializedInput = serializeObservationValue(observation.input);
+    const serializedOutput = observation.outputText || '';
+    const structuredValues = collectStructuredStringValues(serializedOutput);
+    return {
+        toolNames: uniqueNonEmpty([
+            observation.name,
+            observation.title,
+        ].map((value) => normalizeEvidencePhrase(value || ''))),
+        urls: uniqueNonEmpty([
+            ...extractUrls(serializedInput),
+            ...extractUrls(serializedOutput),
+        ]),
+        phrases: uniqueNonEmpty([
+            ...structuredValues,
+            observation.title,
+            serializedInput.length <= 300 ? serializedInput : '',
+        ].map((value) => normalizeEvidencePhrase(value || '')).filter((value) => value.length >= 12)),
+    };
+}
+function matchesObservedToolTranscriptPrefix(text, evidence) {
+    const prefix = text.slice(0, 3000);
+    const normalizedPrefix = normalizeEvidencePhrase(prefix);
+    const hasToolName = evidence.toolNames.some((name) => name && normalizedPrefix.includes(name));
+    const urlMatches = evidence.urls.filter((url) => prefix.includes(url)).length;
+    const phraseMatches = evidence.phrases.filter((phrase) => normalizedPrefix.includes(phrase)).length;
+    if (hasToolName && (urlMatches > 0 || phraseMatches > 0)) {
+        return true;
+    }
+    return urlMatches > 0 && phraseMatches > 0;
+}
+function findToolTranscriptPrefixBoundary(text, evidence) {
+    const lines = text.split(/\n/);
+    const firstContentLine = lines.find((line) => line.trim());
+    if (!firstContentLine || !isTranscriptStartLine(firstContentLine, evidence)) {
+        return 0;
+    }
+    let offset = 0;
+    let seenEvidence = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] || '';
+        const lineWithNewlineLength = line.length + (index < lines.length - 1 ? 1 : 0);
+        if (lineContainsObservationEvidence(line, evidence)) {
+            seenEvidence = true;
+        }
+        if (seenEvidence && index > 0 && line.trim() && !isStructuredTranscriptLine(line, evidence)) {
+            return offset;
+        }
+        offset += lineWithNewlineLength;
+    }
+    return 0;
+}
+function isTranscriptStartLine(line, evidence) {
+    const trimmed = line.trim();
+    return lineContainsObservationEvidence(line, evidence) &&
+        (/^(```|\{|\[|\*\*[^*]+\*\*|#+\s)/.test(trimmed) || /^[A-Za-z0-9_.-]+:/.test(trimmed));
+}
+function isStructuredTranscriptLine(line, evidence) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return true;
+    }
+    if (lineContainsObservationEvidence(line, evidence)) {
+        return true;
+    }
+    return /^(```|\{|\}|\[|\]|".+":|\*\*[^*]+:\*\*|\*[^*]+\*|#+\s)/.test(trimmed) ||
+        /[:：]\s*$/.test(trimmed) ||
+        /[{}\[\]"]/g.test(trimmed) ||
+        /^[A-Za-z0-9_.-]+:/.test(trimmed);
+}
+function lineContainsObservationEvidence(line, evidence) {
+    const normalizedLine = normalizeEvidencePhrase(line);
+    return evidence.toolNames.some((name) => name && normalizedLine.includes(name)) ||
+        evidence.urls.some((url) => line.includes(url)) ||
+        evidence.phrases.some((phrase) => phrase && normalizedLine.includes(phrase));
+}
+function serializeObservationValue(value) {
+    if (value == null) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function collectStructuredStringValues(text) {
+    const values = [];
+    try {
+        collectStringValues(JSON.parse(text), values);
+    }
+    catch {
+        const matches = text.matchAll(/"(title|description|url|name|summary)"\s*:\s*"([^"]{12,})"/gi);
+        for (const match of matches) {
+            values.push(match[2] || '');
+        }
+    }
+    return values;
+}
+function collectStringValues(value, values) {
+    if (typeof value === 'string') {
+        values.push(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectStringValues(item, values);
+        }
+        return;
+    }
+    if (!value || typeof value !== 'object') {
+        return;
+    }
+    for (const entry of Object.values(value)) {
+        collectStringValues(entry, values);
+    }
+}
+function extractUrls(text) {
+    return [...text.matchAll(/https?:\/\/[^\s"'`<>),\]}]+/g)]
+        .map((match) => match[0])
+        .filter(Boolean);
+}
+function normalizeEvidencePhrase(value) {
+    return String(value || '')
+        .replace(/\\[nrt]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+function uniqueNonEmpty(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}

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

@@ -25,9 +25,13 @@ class LocalCoreAcpSessionCoordinator {
         this.options.transport.closeSession(session);
         this.sessions.delete(threadId);
     }
-    async ensureSession(threadId, bridgeSessionKey, config) {
+    async ensureSession(threadId, bridgeSessionKey, config, options = {}) {
         const existing = this.sessions.get(threadId);
-        if (existing && !existing.closed && existing.sessionId) {
+        const permissionMode = this.resolveLaunchPermissionMode(threadId, options.permissionMode);
+        if (existing
+            && !existing.closed
+            && existing.sessionId
+            && existing.launchPermissionMode === permissionMode) {
             return existing;
         }
         if (existing) {
@@ -43,6 +47,7 @@ class LocalCoreAcpSessionCoordinator {
             config,
             runtimeEnv: this.buildAgentRuntimeEnv(threadId, String(baseEnv.PATH || '')),
         });
+        session.launchPermissionMode = permissionMode;
         this.sessions.set(threadId, session);
         await this.options.transport.initializeSession(session);
         const row = this.options.store.getThreadRow(threadId);
@@ -68,7 +73,7 @@ class LocalCoreAcpSessionCoordinator {
                 const created = await this.options.transport.request(session, 'session/new', {
                     cwd: config.workDir,
                     mcpServers: [],
-                    _meta: this.buildSessionMeta(threadId),
+                    _meta: this.buildSessionMeta(threadId, permissionMode),
                 }, 30000);
                 session.sessionId = String(created.sessionId || created.session_id || created.id || created.session?.sessionId || created.session?.session_id || created.session?.id || '').trim();
                 if (!session.sessionId) {
@@ -182,17 +187,25 @@ class LocalCoreAcpSessionCoordinator {
         }
         return env;
     }
-    buildSessionMeta(threadId) {
+    resolveLaunchPermissionMode(threadId, permissionModeOverride = '') {
         const row = this.options.store.getThreadRow(threadId);
-        const mode = String(row?.agent_mode || '').trim();
-        if (!mode || mode === 'default') {
-            return undefined;
-        }
+        const mode = String(permissionModeOverride || row?.agent_mode || '').trim();
+        return !mode || mode === 'default' ? '' : mode;
+    }
+    buildSessionMeta(threadId, permissionModeOverride = '') {
+        const mode = this.resolveLaunchPermissionMode(threadId, permissionModeOverride);
         return {
             claudeCode: {
-                options: {
-                    permissionMode: mode,
-                },
+                emitRawSDKMessages: [
+                    { type: 'system', subtype: 'local_command_output' },
+                ],
+                ...(mode
+                    ? {
+                        options: {
+                            permissionMode: mode,
+                        },
+                    }
+                    : {}),
             },
         };
     }