codeep 2.13.2 → 2.15.0

package/dist/acp/server.js

@@ -8,7 +8,7 @@ import { StdioTransport } from './transport.js';
 import { runAgentSession } from './session.js';
 import { loadCustomCommands } from '../utils/customCommands.js';
 import { registerSessionServers, disposeAllSessions as disposeAllMcpSessions } from '../utils/mcpRegistry.js';
-import { loadMcpServerConfig, mergeMcpServers } from '../utils/mcpConfig.js';
+import { loadMcpServerConfigSplit, isWorkspaceMcpTrusted, mergeMcpServers } from '../utils/mcpConfig.js';
 import { handleMcpSamplingRequest } from '../utils/mcpSamplingBridge.js';
 import { executeCommandAsync } from '../utils/shell.js';
 import { initWorkspace, loadWorkspace, handleCommand } from './commands.js';
@@ -18,7 +18,7 @@ import { ApiError } from '../api/index.js';
 import { PROVIDERS } from '../config/providers.js';
 import { getCurrentVersion } from '../utils/update.js';
 import { reportStats, syncSession, generateProjectId } from '../utils/codeepCloud.js';
-import { getCostBreakdown, resetTokenTracking } from '../utils/tokenTracker.js';
+import { getCostBreakdown, getRecordCount, createTokenScope, runWithTokenScope } from '../utils/tokenTracker.js';
 import { isGitRepository } from '../utils/git.js';
 import { getProjectContext } from '../utils/project.js';
 // ─── Slash commands advertised to Zed ────────────────────────────────────────
@@ -141,10 +141,18 @@ export function formatToolInputForPermission(tool, params) {
                     ? lines.slice(0, MAX_CONTENT_LINES).join('\n') + `\n… (${lines.length - MAX_CONTENT_LINES} more lines)`
                     : params.content;
             }
-            if (typeof params.old_string === 'string' && typeof params.new_string === 'string') {
-                out.changes = `replace ${params.old_string.split('\n').length} line(s)`;
-                out.old_string = truncateDiff(params.old_string);
-                out.new_string = truncateDiff(params.new_string);
+            // The built-in edit_file tool schema emits old_text / new_text (see
+            // utils/tools.ts); accept the old_string/new_string spelling too for
+            // robustness. Without this the permission dialog dropped the diff and
+            // showed only { file, path } — the user approved edits blind.
+            const oldText = typeof params.old_text === 'string' ? params.old_text
+                : (typeof params.old_string === 'string' ? params.old_string : undefined);
+            const newText = typeof params.new_text === 'string' ? params.new_text
+                : (typeof params.new_string === 'string' ? params.new_string : undefined);
+            if (oldText !== undefined && newText !== undefined) {
+                out.changes = `replace ${oldText.split('\n').length} line(s)`;
+                out.old_string = truncateDiff(oldText);
+                out.new_string = truncateDiff(newText);
             }
             return out;
         }
@@ -531,7 +539,18 @@ export function startAcpServer() {
      * in-flight registration so tool calls don't race the startup.
      */
     function spawnMcpServersForSession(acpSessionId, cwd, acpServers, label) {
-        const fromConfig = loadMcpServerConfig(cwd);
+        // Workspace-sourced servers (.codeep/mcp_servers.json, .mcp.json) travel
+        // with the repo, so they spawn only for workspaces the user has trusted
+        // (same gate the TUI prompts for at startup). ACP-provided servers are
+        // the editor's own config and global ~/.codeep entries are the user's —
+        // both spawn unconditionally.
+        const { global: globalServers, workspace: workspaceServers } = loadMcpServerConfigSplit(cwd);
+        const workspaceTrusted = isWorkspaceMcpTrusted(cwd);
+        if (workspaceServers.length > 0 && !workspaceTrusted) {
+            process.stderr.write(`[codeep-acp] MCP (${label}): skipped ${workspaceServers.length} workspace server(s) — untrusted workspace. ` +
+                `Run /mcp trust (or \`codeep\` in the repo once) to enable.\n`);
+        }
+        const fromConfig = workspaceTrusted ? [...globalServers, ...workspaceServers] : globalServers;
         const merged = mergeMcpServers(fromConfig, acpServers);
         if (merged.length === 0)
             return;
@@ -860,7 +879,6 @@ export function startAcpServer() {
                 },
             });
         };
-        resetTokenTracking();
         // Manual mode gates write/edit for THIS run via a per-call option passed to
         // runAgentSession (extraDangerousTools, below) — NOT by mutating the global
         // `agentConfirmWriteFile` config, which leaked the session's mode into the
@@ -876,257 +894,283 @@ export function startAcpServer() {
                 },
             });
         };
-        // Try slash commands first
-        handleCommand(prompt, session, sendChunk, abortController.signal)
-            .then((cmd) => {
-            if (cmd.handled) {
-                if (cmd.response)
-                    sendChunk(cmd.response);
-                // If provider or model changed, push updated config options to Zed
-                if (cmd.configOptionsChanged) {
-                    transport.notify('session/update', {
-                        sessionId: params.sessionId,
-                        update: {
-                            sessionUpdate: 'config_option_update',
-                            configOptions: buildConfigOptions(),
-                        },
-                    });
-                }
-                // Update title with first real prompt if session had no history
-                if (!session.titleSent && !session.hadHistory) {
-                    session.titleSent = true;
-                    sendSessionTitle(params.sessionId, [{ role: 'user', content: prompt }]);
-                }
-                transport.respond(msg.id, { stopReason: 'end_turn' });
-                return;
-            }
-            // Not a command — run agent loop
-            let enrichedPrompt = prompt;
-            if (session.addedFiles.size > 0) {
-                const parts = ['[Attached files]'];
-                for (const [, f] of session.addedFiles) {
-                    parts.push(`\nFile: ${f.relativePath}\n\`\`\`\n${f.content}\n\`\`\``);
-                }
-                enrichedPrompt = parts.join('\n') + '\n\n' + prompt;
-            }
-            runAgentSession({
-                prompt: enrichedPrompt,
-                workspaceRoot: session.workspaceRoot,
-                conversationId: params.sessionId,
-                abortSignal: abortController.signal,
-                onChunk: sendChunk,
-                onThought: (text) => {
-                    transport.notify('session/update', {
-                        sessionId: params.sessionId,
-                        update: {
-                            sessionUpdate: 'agent_thought_chunk',
-                            content: { type: 'text', text },
-                        },
-                    });
-                },
-                onToolCall: (toolCallId, toolName, kind, title, status, locations, rawOutput) => {
-                    if (status === 'running') {
-                        // Initial tool_call notification: spec ToolCall shape
+        // Try slash commands first.
+        // Run the whole prompt lifecycle inside THIS ACP session's token scope so
+        // (a) concurrent sessions on one process can't mix usage totals, and
+        // (b) usage accumulates into the session's own buffer across prompts, so
+        // `/cost` stays session-cumulative. `tokenReportStart` marks the pre-prompt
+        // count so we report only this prompt's delta to cloud telemetry.
+        session.tokenRecords ??= createTokenScope();
+        runWithTokenScope(session.tokenRecords, () => {
+            const tokenReportStart = getRecordCount();
+            return handleCommand(prompt, session, sendChunk, abortController.signal)
+                .then((cmd) => {
+                if (cmd.handled) {
+                    if (cmd.response)
+                        sendChunk(cmd.response);
+                    // If provider or model changed, push updated config options to Zed
+                    if (cmd.configOptionsChanged) {
                         transport.notify('session/update', {
                             sessionId: params.sessionId,
                             update: {
-                                sessionUpdate: 'tool_call',
-                                toolCallId,
-                                title: title || toolName,
-                                kind: kind || 'other',
-                                status: 'in_progress',
-                                ...(locations && locations.length > 0
-                                    ? { locations: locations.map(path => ({ path })) }
-                                    : {}),
+                                sessionUpdate: 'config_option_update',
+                                configOptions: buildConfigOptions(),
                             },
                         });
-                        // Add to plan as in_progress — only meaningful actions (not reads)
-                        if (kind === 'edit' || kind === 'execute' || kind === 'delete') {
-                            planEntries.set(toolCallId, {
-                                id: toolCallId,
-                                content: title || toolName,
-                                priority: kind === 'execute' ? 'high' : 'medium',
-                                status: 'in_progress',
-                            });
-                            sendPlan();
-                        }
                     }
-                    else {
-                        // tool_call_update: update status to completed/failed, with optional content
+                    // Update title with first real prompt if session had no history
+                    if (!session.titleSent && !session.hadHistory) {
+                        session.titleSent = true;
+                        sendSessionTitle(params.sessionId, [{ role: 'user', content: prompt }]);
+                    }
+                    transport.respond(msg.id, { stopReason: 'end_turn' });
+                    return;
+                }
+                // Not a command — run agent loop
+                let enrichedPrompt = prompt;
+                if (session.addedFiles.size > 0) {
+                    const parts = ['[Attached files]'];
+                    for (const [, f] of session.addedFiles) {
+                        parts.push(`\nFile: ${f.relativePath}\n\`\`\`\n${f.content}\n\`\`\``);
+                    }
+                    enrichedPrompt = parts.join('\n') + '\n\n' + prompt;
+                }
+                runAgentSession({
+                    prompt: enrichedPrompt,
+                    workspaceRoot: session.workspaceRoot,
+                    conversationId: params.sessionId,
+                    abortSignal: abortController.signal,
+                    onChunk: sendChunk,
+                    onThought: (text) => {
                         transport.notify('session/update', {
                             sessionId: params.sessionId,
                             update: {
-                                sessionUpdate: 'tool_call_update',
-                                toolCallId,
-                                status: status === 'finished' ? 'completed' : 'failed',
-                                ...(rawOutput !== undefined ? { rawOutput } : {}),
+                                sessionUpdate: 'agent_thought_chunk',
+                                content: { type: 'text', text },
                             },
                         });
-                        // Mark plan entry as completed
-                        const entry = planEntries.get(toolCallId);
-                        if (entry) {
-                            entry.status = 'completed';
-                            sendPlan();
+                    },
+                    onToolCall: (toolCallId, toolName, kind, title, status, locations, rawOutput) => {
+                        if (status === 'running') {
+                            // Initial tool_call notification: spec ToolCall shape
+                            transport.notify('session/update', {
+                                sessionId: params.sessionId,
+                                update: {
+                                    sessionUpdate: 'tool_call',
+                                    toolCallId,
+                                    title: title || toolName,
+                                    kind: kind || 'other',
+                                    status: 'in_progress',
+                                    ...(locations && locations.length > 0
+                                        ? { locations: locations.map(path => ({ path })) }
+                                        : {}),
+                                },
+                            });
+                            // Add to plan as in_progress — only meaningful actions (not reads)
+                            if (kind === 'edit' || kind === 'execute' || kind === 'delete') {
+                                planEntries.set(toolCallId, {
+                                    id: toolCallId,
+                                    content: title || toolName,
+                                    priority: kind === 'execute' ? 'high' : 'medium',
+                                    status: 'in_progress',
+                                });
+                                sendPlan();
+                            }
                         }
-                    }
-                },
-                // Manual mode gates write_file/edit_file for this run only (per-call,
-                // no global config mutation).
-                extraDangerousTools: session.currentModeId === 'manual' ? ['write_file', 'edit_file'] : undefined,
-                // Only request permission in Manual mode
-                onRequestPermission: session.currentModeId === 'manual'
-                    ? async (toolCall) => {
-                        const permToolCallId = `perm_${randomUUID()}`;
-                        const result = await transport.request('session/request_permission', {
-                            sessionId: params.sessionId,
-                            toolCall: {
-                                toolCallId: permToolCallId,
-                                toolName: toolCall.tool,
-                                toolInput: formatToolInputForPermission(toolCall.tool, toolCall.parameters),
-                                status: 'pending',
-                                content: [],
-                            },
-                            options: [
-                                { optionId: 'allow_once', name: 'Allow once', kind: 'allow_once' },
-                                { optionId: 'allow_always', name: 'Allow always', kind: 'allow_always' },
-                                { optionId: 'reject_once', name: 'Reject once', kind: 'reject_once' },
-                                { optionId: 'reject_always', name: 'Reject always', kind: 'reject_always' },
-                            ],
-                        });
-                        // Map ACP outcome back to PermissionOutcome
-                        if (!result || result.outcome.type === 'cancelled')
-                            return 'reject_once';
-                        return result.outcome.optionId;
-                    }
-                    : undefined,
-                // Per ACP spec, `fs/read_text_file` and `fs/write_text_file` are
-                // CLIENT methods — only safe to call when the client advertised
-                // the capability in `initialize`. Routing through the client
-                // means the editor's dirty buffers + undo history stay correct
-                // (otherwise an in-editor unsaved change would be invisible to
-                // the agent, or worse, silently overwritten).
-                fs: {
-                    readTextFile: clientSupportsFsRead
-                        ? async (absolutePath) => {
-                            const result = await transport.request('fs/read_text_file', {
+                        else {
+                            // tool_call_update: update status to completed/failed, with optional content
+                            transport.notify('session/update', {
                                 sessionId: params.sessionId,
-                                path: absolutePath,
+                                update: {
+                                    sessionUpdate: 'tool_call_update',
+                                    toolCallId,
+                                    status: status === 'finished' ? 'completed' : 'failed',
+                                    ...(rawOutput !== undefined ? { rawOutput } : {}),
+                                },
                             });
-                            if (!result || typeof result.content !== 'string') {
-                                throw new Error('fs/read_text_file returned no content');
+                            // Mark plan entry as completed
+                            const entry = planEntries.get(toolCallId);
+                            if (entry) {
+                                entry.status = 'completed';
+                                sendPlan();
                             }
-                            return result.content;
                         }
-                        : undefined,
-                    writeTextFile: clientSupportsFsWrite
-                        ? async (absolutePath, content) => {
-                            await transport.request('fs/write_text_file', {
+                    },
+                    // Manual mode gates write_file/edit_file for this run only (per-call,
+                    // no global config mutation).
+                    extraDangerousTools: session.currentModeId === 'manual' ? ['write_file', 'edit_file'] : undefined,
+                    // Only request permission in Manual mode
+                    onRequestPermission: session.currentModeId === 'manual'
+                        ? async (toolCall) => {
+                            const permToolCallId = `perm_${randomUUID()}`;
+                            const result = await transport.request('session/request_permission', {
                                 sessionId: params.sessionId,
-                                path: absolutePath,
-                                content,
+                                toolCall: {
+                                    toolCallId: permToolCallId,
+                                    toolName: toolCall.tool,
+                                    toolInput: formatToolInputForPermission(toolCall.tool, toolCall.parameters),
+                                    status: 'pending',
+                                    content: [],
+                                },
+                                options: [
+                                    { optionId: 'allow_once', name: 'Allow once', kind: 'allow_once' },
+                                    { optionId: 'allow_always', name: 'Allow always', kind: 'allow_always' },
+                                    { optionId: 'reject_once', name: 'Reject once', kind: 'reject_once' },
+                                    { optionId: 'reject_always', name: 'Reject always', kind: 'reject_always' },
+                                ],
                             });
+                            // Map ACP outcome back to PermissionOutcome
+                            if (!result || result.outcome.type === 'cancelled')
+                                return 'reject_once';
+                            return result.outcome.optionId;
                         }
                         : undefined,
-                },
-                onExecuteCommand: async (command, args, cwd) => {
-                    // Per ACP spec, only call terminal/* if the client advertised the
-                    // capability in initialize. Otherwise execute locally.
-                    if (!clientSupportsTerminal) {
-                        const r = await executeCommandAsync(command, args, { cwd, projectRoot: cwd, timeout: 120000 });
-                        return { stdout: r.stdout ?? '', stderr: r.stderr ?? '', exitCode: r.exitCode ?? 0 };
+                    // Per ACP spec, `fs/read_text_file` and `fs/write_text_file` are
+                    // CLIENT methods — only safe to call when the client advertised
+                    // the capability in `initialize`. Routing through the client
+                    // means the editor's dirty buffers + undo history stay correct
+                    // (otherwise an in-editor unsaved change would be invisible to
+                    // the agent, or worse, silently overwritten).
+                    fs: {
+                        readTextFile: clientSupportsFsRead
+                            ? async (absolutePath) => {
+                                const result = await transport.request('fs/read_text_file', {
+                                    sessionId: params.sessionId,
+                                    path: absolutePath,
+                                });
+                                if (!result || typeof result.content !== 'string') {
+                                    throw new Error('fs/read_text_file returned no content');
+                                }
+                                return result.content;
+                            }
+                            : undefined,
+                        writeTextFile: clientSupportsFsWrite
+                            ? async (absolutePath, content) => {
+                                await transport.request('fs/write_text_file', {
+                                    sessionId: params.sessionId,
+                                    path: absolutePath,
+                                    content,
+                                });
+                            }
+                            : undefined,
+                    },
+                    onExecuteCommand: async (command, args, cwd) => {
+                        // Per ACP spec, only call terminal/* if the client advertised the
+                        // capability in initialize. Otherwise execute locally.
+                        if (!clientSupportsTerminal) {
+                            const r = await executeCommandAsync(command, args, { cwd, projectRoot: cwd, timeout: 120000 });
+                            return { stdout: r.stdout ?? '', stderr: r.stderr ?? '', exitCode: r.exitCode ?? 0 };
+                        }
+                        try {
+                            const createResult = await transport.request('terminal/create', {
+                                sessionId: params.sessionId,
+                                command,
+                                args,
+                                cwd,
+                                outputByteLimit: 1_000_000,
+                            });
+                            const { terminalId } = createResult;
+                            // Spec method is snake_case `terminal/wait_for_exit` and takes
+                            // only { sessionId, terminalId } — no timeoutMs.
+                            const waitResult = await transport.request('terminal/wait_for_exit', {
+                                sessionId: params.sessionId,
+                                terminalId,
+                            });
+                            const outputResult = await transport.request('terminal/output', {
+                                sessionId: params.sessionId,
+                                terminalId,
+                            });
+                            await transport.request('terminal/release', {
+                                sessionId: params.sessionId,
+                                terminalId,
+                            });
+                            const exitCode = waitResult.exitStatus.type === 'exited' ? waitResult.exitStatus.code : 1;
+                            return { stdout: outputResult.output ?? '', stderr: '', exitCode };
+                        }
+                        catch (err) {
+                            // Client terminal failed — fall back to local execution
+                            const r = await executeCommandAsync(command, args, { cwd, projectRoot: cwd, timeout: 120000 });
+                            return { stdout: r.stdout ?? '', stderr: r.stderr ?? '', exitCode: r.exitCode ?? 0 };
+                        }
+                    },
+                }).then(() => {
+                    session.history.push({ role: 'user', content: prompt });
+                    const agentResponse = agentResponseChunks.join('');
+                    if (agentResponse) {
+                        session.history.push({ role: 'assistant', content: agentResponse });
                     }
-                    try {
-                        const createResult = await transport.request('terminal/create', {
-                            sessionId: params.sessionId,
-                            command,
-                            args,
-                            cwd,
-                            outputByteLimit: 1_000_000,
-                        });
-                        const { terminalId } = createResult;
-                        // Spec method is snake_case `terminal/wait_for_exit` and takes
-                        // only { sessionId, terminalId } — no timeoutMs.
-                        const waitResult = await transport.request('terminal/wait_for_exit', {
-                            sessionId: params.sessionId,
-                            terminalId,
-                        });
-                        const outputResult = await transport.request('terminal/output', {
-                            sessionId: params.sessionId,
-                            terminalId,
-                        });
-                        await transport.request('terminal/release', {
-                            sessionId: params.sessionId,
-                            terminalId,
-                        });
-                        const exitCode = waitResult.exitStatus.type === 'exited' ? waitResult.exitStatus.code : 1;
-                        return { stdout: outputResult.output ?? '', stderr: '', exitCode };
+                    autoSaveSession(session.history, session.workspaceRoot);
+                    // Report token usage to dashboard
+                    const projectCtx = getProjectContext(session.workspaceRoot);
+                    const sharedFields = {
+                        sessionId: session.codeepSessionId,
+                        sessionName: session.codeepSessionId,
+                        messageCount: session.history.length,
+                        cliVersion: getCurrentVersion(),
+                        projectName: projectCtx?.name,
+                        projectId: generateProjectId(session.workspaceRoot),
+                        language: projectCtx?.type,
+                        isGit: isGitRepository(session.workspaceRoot),
+                    };
+                    const costBreakdown = getCostBreakdown(tokenReportStart);
+                    if (costBreakdown.length > 0) {
+                        for (const entry of costBreakdown) {
+                            reportStats({
+                                ...sharedFields,
+                                model: entry.model,
+                                provider: entry.provider,
+                                inputTokens: entry.promptTokens || undefined,
+                                outputTokens: entry.completionTokens || undefined,
+                                cacheCreationTokens: entry.cacheCreationTokens || undefined,
+                                cacheReadTokens: entry.cacheReadTokens || undefined,
+                                estimatedCost: entry.estimatedCost || undefined,
+                            });
+                        }
                     }
-                    catch (err) {
-                        // Client terminal failed — fall back to local execution
-                        const r = await executeCommandAsync(command, args, { cwd, projectRoot: cwd, timeout: 120000 });
-                        return { stdout: r.stdout ?? '', stderr: r.stderr ?? '', exitCode: r.exitCode ?? 0 };
+                    else {
+                        reportStats({ ...sharedFields, model: config.get('model'), provider: config.get('provider') });
                     }
-                },
-            }).then(() => {
-                session.history.push({ role: 'user', content: prompt });
-                const agentResponse = agentResponseChunks.join('');
-                if (agentResponse) {
-                    session.history.push({ role: 'assistant', content: agentResponse });
-                }
-                autoSaveSession(session.history, session.workspaceRoot);
-                // Report token usage to dashboard
-                const projectCtx = getProjectContext(session.workspaceRoot);
-                const sharedFields = {
-                    sessionId: session.codeepSessionId,
-                    sessionName: session.codeepSessionId,
-                    messageCount: session.history.length,
-                    cliVersion: getCurrentVersion(),
-                    projectName: projectCtx?.name,
-                    projectId: generateProjectId(session.workspaceRoot),
-                    language: projectCtx?.type,
-                    isGit: isGitRepository(session.workspaceRoot),
-                };
-                const costBreakdown = getCostBreakdown();
-                if (costBreakdown.length > 0) {
-                    for (const entry of costBreakdown) {
-                        reportStats({
-                            ...sharedFields,
-                            model: entry.model,
-                            provider: entry.provider,
-                            inputTokens: entry.promptTokens || undefined,
-                            outputTokens: entry.completionTokens || undefined,
-                            cacheCreationTokens: entry.cacheCreationTokens || undefined,
-                            cacheReadTokens: entry.cacheReadTokens || undefined,
-                            estimatedCost: entry.estimatedCost || undefined,
-                        });
+                    // Sync session history to dashboard
+                    syncSession({
+                        sessionId: session.codeepSessionId,
+                        projectName: projectCtx?.name,
+                        projectId: generateProjectId(session.workspaceRoot),
+                        messages: session.history,
+                    });
+                    // Update title with first real prompt if session had no history
+                    if (!session.titleSent && !session.hadHistory) {
+                        session.titleSent = true;
+                        sendSessionTitle(params.sessionId, [{ role: 'user', content: prompt }]);
                     }
-                }
-                else {
-                    reportStats({ ...sharedFields, model: config.get('model'), provider: config.get('provider') });
-                }
-                // Sync session history to dashboard
-                syncSession({
-                    sessionId: session.codeepSessionId,
-                    projectName: projectCtx?.name,
-                    projectId: generateProjectId(session.workspaceRoot),
-                    messages: session.history,
-                });
-                // Update title with first real prompt if session had no history
-                if (!session.titleSent && !session.hadHistory) {
-                    session.titleSent = true;
-                    sendSessionTitle(params.sessionId, [{ role: 'user', content: prompt }]);
-                }
-                transport.respond(msg.id, { stopReason: 'end_turn' });
-            }).catch((err) => {
-                if (err.name === 'AbortError') {
-                    // Clear plan UI on the client side when session is cancelled
-                    if (planEntries.size > 0) {
-                        planEntries.clear();
-                        sendPlan();
+                    transport.respond(msg.id, { stopReason: 'end_turn' });
+                }).catch((err) => {
+                    if (err.name === 'AbortError') {
+                        // Clear plan UI on the client side when session is cancelled
+                        if (planEntries.size > 0) {
+                            planEntries.clear();
+                            sendPlan();
+                        }
+                        transport.respond(msg.id, { stopReason: 'cancelled' });
                     }
-                    transport.respond(msg.id, { stopReason: 'cancelled' });
-                }
-                else if (err.message?.includes('API key not configured') || err.message?.includes('API key') || (err instanceof ApiError && err.status === 401)) {
+                    else if (err.message?.includes('API key not configured') || err.message?.includes('API key') || (err instanceof ApiError && err.status === 401)) {
+                        sendChunk(`❌ No API key configured. Use /login <provider> <key> or set the environment variable (e.g. ZAI_API_KEY, ANTHROPIC_API_KEY).`);
+                        transport.respond(msg.id, { stopReason: 'end_turn' });
+                    }
+                    else if (err instanceof ApiError && err.status >= 500) {
+                        sendChunk(`⚠️ API server error (${err.status}). Please try again.`);
+                        transport.respond(msg.id, { stopReason: 'end_turn' });
+                    }
+                    else {
+                        transport.error(msg.id, -32000, err.message);
+                    }
+                }).finally(() => {
+                    if (session)
+                        session.abortController = null;
+                    planEntries.clear();
+                });
+            })
+                .catch((err) => {
+                if (err.message?.includes('API key not configured') || err.message?.includes('API key') || (err instanceof ApiError && err.status === 401)) {
                     sendChunk(`❌ No API key configured. Use /login <provider> <key> or set the environment variable (e.g. ZAI_API_KEY, ANTHROPIC_API_KEY).`);
                     transport.respond(msg.id, { stopReason: 'end_turn' });
                 }
@@ -1137,26 +1181,9 @@ export function startAcpServer() {
                 else {
                     transport.error(msg.id, -32000, err.message);
                 }
-            }).finally(() => {
                 if (session)
                     session.abortController = null;
-                planEntries.clear();
             });
-        })
-            .catch((err) => {
-            if (err.message?.includes('API key not configured') || err.message?.includes('API key') || (err instanceof ApiError && err.status === 401)) {
-                sendChunk(`❌ No API key configured. Use /login <provider> <key> or set the environment variable (e.g. ZAI_API_KEY, ANTHROPIC_API_KEY).`);
-                transport.respond(msg.id, { stopReason: 'end_turn' });
-            }
-            else if (err instanceof ApiError && err.status >= 500) {
-                sendChunk(`⚠️ API server error (${err.status}). Please try again.`);
-                transport.respond(msg.id, { stopReason: 'end_turn' });
-            }
-            else {
-                transport.error(msg.id, -32000, err.message);
-            }
-            if (session)
-                session.abortController = null;
         });
     }
     // Keep process alive until stdin closes (Zed terminates us)

package/dist/config/index.d.ts

@@ -140,6 +140,16 @@ export interface ConfigSchema {
 }
 export type { AgentMode };
 export type { LanguageCode };
+/**
+ * Get sessions directory - local .codeep/sessions/ if in project, otherwise global
+ */
+export declare function getSessionsDir(projectPath?: string): string;
+/**
+ * Check if directory is a project
+ * Looks for common project indicators: package.json, pyproject.toml, Cargo.toml, go.mod, composer.json, etc.
+ * Also checks if user has manually initialized this folder as a project (.codeep/project.json)
+ */
+export declare function isProjectDirectory(path: string): boolean;
 /**
  * Check if directory has standard project markers (not manually initialized)
  */