codeep 3.3.3 → 3.4.1

package/dist/renderer/commands.js

@@ -5,16 +5,16 @@
  * decoupled from global state. Import-heavy commands use dynamic imports
  * to keep startup time low.
  */
-import { config, getCurrentProvider, getModelsForCurrentProvider, PROTOCOLS, LANGUAGES, setProvider, setApiKey, clearApiKey, getApiKey, saveSession, startNewSession, loadSession, listSessionsWithInfo, deleteSession, renameSession, setProjectPermission, saveProfile, loadProfile, applyProfile, listProfiles, deleteProfile, initializeAsProject, isManuallyInitializedProject, } from '../config/index.js';
+import { config, getCurrentProvider, getModelsForCurrentProvider, PROTOCOLS, LANGUAGES, setProvider, setApiKey, clearApiKey, getApiKey, saveSession, startNewSession, loadSession, listSessionsWithInfo, deleteSession, renameSession, sessionNameProblem, setProjectPermission, saveProfile, loadProfile, applyProfile, listProfiles, deleteProfile, initializeAsProject, isManuallyInitializedProject, } from '../config/index.js';
 import { setTelegramToken, clearTelegramToken, hasTelegramToken } from '../utils/telegramCredentials.js';
 import { getProjectContext } from '../utils/project.js';
 import { getCurrentVersion } from '../utils/update.js';
 import { getProviderList, getProvider, modelSupportsReasoningEffort, reasoningParamsFor, availableReasoningTiers, resolveReasoningTier, REASONING_TIERS } from '../config/providers.js';
 import { setProjectContext } from '../api/index.js';
 import { runSkill, runCommandChain } from './agentExecution.js';
-import { loadProjectIntelligence, saveProjectIntelligence } from '../utils/projectIntelligence.js';
+import { loadProjectIntelligence, saveProjectIntelligence, INTELLIGENCE_NOT_SAVED } from '../utils/projectIntelligence.js';
 import { ollamaModelHint } from './ollamaHint.js';
-import { buildSearchSnippets, parseKeepRecent, joinSessionName, parseTaskAddArgs, formatTaskList, formatProfileList, formatMemoryList, formatStatsReport, extractCodeBlocks, resolveBlockIndex, extractFileChanges, formatApplyDiffLine, parsePromptArgs, formatMcpReloadReport, formatMcpResourcesList, formatMcpResourceRead, formatMcpPromptsList, formatMcpPromptResult, formatMcpServerList, parseInsightsDays, formatCloudSessionLabel, formatMeSyncReport, formatMeLearnResult, formatMeInitResult, formatSkillsShow, formatSkillsBrowseEmpty, formatSkillsPublishResult } from './commands/helpers.js';
+import { buildSearchSnippets, parseKeepRecent, joinSessionName, parseTaskAddArgs, formatTaskList, formatProfileList, formatMemoryList, formatStatsReport, extractCodeBlocks, resolveBlockIndex, extractFileChanges, formatApplyDiffLine, parsePromptArgs, formatMcpReloadReport, formatMcpResourcesList, formatMcpResourceRead, formatMcpPromptsList, formatMcpPromptResult, formatMcpServerList, parseInsightsDays, formatCloudSessionLabel, formatMeSyncReport, formatUndoAllReport, formatMeLearnResult, formatMeInitResult, formatSkillsShow, formatSkillsBrowseEmpty, formatSkillsPublishResult } from './commands/helpers.js';
 import { resolveCommand } from './commands/registry.js';
 import { telemetryCommand } from '../commands/core/telemetry.js';
 import { keysyncCommand } from '../commands/core/keysync.js';
@@ -523,11 +523,13 @@ export async function handleCommand(command, args, ctx) {
                     ctx.app.notify('Not linked to codeep.dev. Run: codeep account');
                     break;
                 }
-                const { pushUserProfile, pullUserProfile } = await import('../utils/codeepCloud.js');
+                const { pushUserProfileResult, pullUserProfileResult, describeSyncFailure } = await import('../utils/codeepCloud.js');
                 ctx.app.notify('Syncing your profile with codeep.dev…');
-                const pushed = await pushUserProfile();
-                const pulled = await pullUserProfile();
-                ctx.app.addMessage({ role: 'system', content: formatMeSyncReport(pushed, pulled) });
+                // Push first: the pull may create the local file, and pushing that
+                // back would be pointless.
+                const pushed = await pushUserProfileResult();
+                const pulled = await pullUserProfileResult();
+                ctx.app.addMessage({ role: 'system', content: formatMeSyncReport(pushed, pulled, describeSyncFailure) });
                 break;
             }
             if (sub === 'init') {
@@ -601,10 +603,17 @@ export async function handleCommand(command, args, ctx) {
                 return;
             }
             const prompt = composeExecutionPrompt(cur);
-            clearPendingPlan();
-            ctx.app.notify(`Executing plan for: ${cur.task.slice(0, 80)}${cur.task.length > 80 ? '…' : ''}`);
+            ctx.app.notify(`Executing plan for: ${cur.task.slice(0, 80)}${cur.task.length > 80 ? '…' : ''} — it stays pending until it has run successfully`);
             const { runAgentTask } = await import('./agentExecution.js');
-            runAgentTask(prompt, false, ctx, () => null, () => { });
+            // The plan stays pending until it has run: a failed, stopped or
+            // declined run can be started again with /go.
+            runAgentTask(prompt, false, ctx, () => null, () => { }, {
+                onFinished: (outcome) => {
+                    // A /plan issued meanwhile replaced it; that one has not run.
+                    if (outcome === 'success' && getPendingPlan() === cur)
+                        clearPendingPlan();
+                },
+            });
             break;
         }
         case 'stop': {
@@ -759,7 +768,6 @@ export async function handleCommand(command, args, ctx) {
                         if (local && local.length > 0) {
                             ctx.app.setMessages(local);
                             ctx.setSessionId(localName);
-                            config.set('currentSessionId', localName);
                             ctx.setSessionDisplayName?.(selected.sessionName ?? null);
                             ctx.app.notify('Local copy is newer than the cloud record — loaded the local session instead.');
                             return;
@@ -770,11 +778,11 @@ export async function handleCommand(command, args, ctx) {
                 saveSession(localName, history, ctx.projectPath);
                 ctx.app.setMessages(history);
                 // Keep ALL session-identity state in step, not just the renderer's
-                // copy: autosave + agent-mode sync read config.currentSessionId, and
-                // the next syncSession reads the display name — leaving either stale
-                // writes/renames the pulled history under the PREVIOUS session.
+                // copy: autosave + agent-mode sync read config.currentSessionId (which
+                // setSessionId updates), and the next syncSession reads the display
+                // name — leaving either stale writes/renames the pulled history under
+                // the PREVIOUS session.
                 ctx.setSessionId(localName);
-                config.set('currentSessionId', localName);
                 ctx.setSessionDisplayName?.(selected.sessionName ?? null);
                 ctx.app.notify(`Resumed from cloud: ${selected.sessionName || localName}`);
             };
@@ -819,15 +827,21 @@ export async function handleCommand(command, args, ctx) {
         }
         case 'undo': {
             import('../utils/agent.js').then(({ undoLastAction }) => {
-                const result = undoLastAction();
+                // Only a run in this workspace; the agent records runs under this root.
+                const result = undoLastAction(ctx.projectContext?.root || ctx.projectPath);
                 ctx.app.notify(result.success ? `Undo: ${result.message}` : `Cannot undo: ${result.message}`);
             });
             break;
         }
         case 'undo-all': {
             import('../utils/agent.js').then(({ undoAllActions }) => {
-                const result = undoAllActions();
-                ctx.app.notify(result.success ? `Undone ${result.results.length} action(s)` : 'Nothing to undo');
+                const result = undoAllActions(ctx.projectContext?.root || ctx.projectPath);
+                if (!result.success && result.results.length <= 1) {
+                    ctx.app.notify(result.results[0] ?? 'Nothing to undo');
+                }
+                else {
+                    ctx.app.addMessage({ role: 'system', content: formatUndoAllReport(result) });
+                }
             });
             break;
         }
@@ -851,9 +865,12 @@ export async function handleCommand(command, args, ctx) {
                 return;
             }
             ctx.app.notify('Scanning project...');
-            import('../utils/projectIntelligence.js').then(({ scanProject, saveProjectIntelligence, generateContextFromIntelligence }) => {
+            import('../utils/projectIntelligence.js').then(({ scanProject, saveProjectIntelligence, generateContextFromIntelligence, INTELLIGENCE_NOT_SAVED }) => {
                 scanProject(ctx.projectContext.root).then(intelligence => {
-                    saveProjectIntelligence(ctx.projectContext.root, intelligence);
+                    if (!saveProjectIntelligence(ctx.projectContext.root, intelligence)) {
+                        ctx.app.notify(INTELLIGENCE_NOT_SAVED);
+                        return;
+                    }
                     const context = generateContextFromIntelligence(intelligence);
                     ctx.app.addMessage({ role: 'assistant', content: `# Project Scan Complete\n\n${context}` });
                     ctx.app.notify(`Scanned: ${intelligence.structure.totalFiles} files`);
@@ -935,6 +952,11 @@ Format: use headers per category, only include categories where you found issues
                 return;
             }
             const newName = joinSessionName(args);
+            const nameProblem = sessionNameProblem(newName);
+            if (nameProblem) {
+                ctx.app.notify(nameProblem);
+                return;
+            }
             const messages = ctx.app.getMessages();
             if (messages.length === 0) {
                 ctx.app.notify('No messages to save. Start a conversation first.');
@@ -959,7 +981,14 @@ Format: use headers per category, only include categories where you found issues
                 }).catch(() => { });
             }
             else {
-                ctx.app.notify('Failed to rename session');
+                // renameSession refuses to replace another saved conversation. Looked
+                // up only now: a case-only rename finds this same file and succeeds.
+                const { existsSync } = await import('fs');
+                const { join } = await import('path');
+                const { getSessionsDir } = await import('../config/index.js');
+                ctx.app.notify(existsSync(join(getSessionsDir(ctx.projectPath), `${newName}.json`))
+                    ? `A session named "${newName}" already exists — pick another name`
+                    : 'Failed to rename session');
             }
             break;
         }
@@ -1186,9 +1215,25 @@ Format: use headers per category, only include categories where you found issues
                 ctx.app.notify('Usage: /git-commit <message>');
                 return;
             }
-            // Use execFile to avoid shell injection — pass commit message as a direct argument
-            import('child_process').then(({ execFile }) => {
-                execFile('git', ['commit', '-m', message], { cwd: ctx.projectPath, encoding: 'utf-8' }, (err) => {
+            // Use execFile to avoid shell injection — pass commit message as a direct argument.
+            // hardenedGitEnv() on top of that: the repo's own .git/config can name programs
+            // git would run for this commit (core.fsmonitor, core.hooksPath, …).
+            Promise.all([import('child_process'), import('../utils/git.js')]).then(([{ execFile }, { hardenedGitEnv }]) => {
+                // The SAME cwd the commit runs in. Called with no argument, the scan
+                // read process.cwd() instead — so a project opened anywhere other
+                // than the directory Codeep was launched from was "hardened" against
+                // a different repository's config entirely.
+                let env;
+                try {
+                    env = hardenedGitEnv({ cwd: ctx.projectPath });
+                }
+                catch (error) {
+                    // It refuses rather than hand git a half-scanned environment, and
+                    // its message names the key and what to do about it.
+                    ctx.app.notify(error instanceof Error ? error.message : 'Commit failed');
+                    return;
+                }
+                execFile('git', ['commit', '-m', message], { cwd: ctx.projectPath, encoding: 'utf-8', env }, (err) => {
                     if (err) {
                         ctx.app.notify(`Commit failed: ${err.message}`);
                     }
@@ -1510,7 +1555,8 @@ Format: use headers per category, only include categories where you found issues
         }
         case 'changes': {
             import('../utils/agent.js').then(({ getCurrentSessionActions }) => {
-                const actions = getCurrentSessionActions();
+                // Changes of the run /undo acts on, in this project.
+                const actions = getCurrentSessionActions(ctx.projectContext?.root || ctx.projectPath);
                 if (actions.length === 0) {
                     ctx.app.notify('No changes in current session');
                     return;
@@ -1572,18 +1618,25 @@ Format: use headers per category, only include categories where you found issues
             }
             const name = args.join(' ').trim() || undefined;
             const provider = getCurrentProvider();
-            const filesTouched = Array.from(new Set(getCurrentSessionActions()
-                .filter(a => a.target && (a.type === 'write' || a.type === 'edit' || a.type === 'delete' || a.type === 'mkdir'))
+            const filesTouched = Array.from(new Set(getCurrentSessionActions(ctx.projectContext?.root || ctx.projectPath)
+                .filter(a => a.target && a.result !== 'undone' && (a.type === 'write' || a.type === 'edit' || a.type === 'delete' || a.type === 'mkdir'))
                 .map(a => a.target)));
-            const cp = createCheckpoint({
-                workspaceRoot: ctx.projectPath,
-                sessionId: ctx.sessionId,
-                provider: provider.id,
-                model: config.get('model'),
-                messages: ctx.app.getMessages(),
-                filesTouched,
-                name,
-            });
+            let cp;
+            try {
+                cp = createCheckpoint({
+                    workspaceRoot: ctx.projectPath,
+                    sessionId: ctx.sessionId,
+                    provider: provider.id,
+                    model: config.get('model'),
+                    messages: ctx.app.getMessages(),
+                    filesTouched,
+                    name,
+                });
+            }
+            catch (err) {
+                ctx.app.notify(`Could not save the checkpoint: ${err.message}`);
+                break;
+            }
             ctx.app.addMessage({
                 role: 'system',
                 content: `# Checkpoint created\n\n\`${cp.id}\`${cp.name ? ` — **${cp.name}**` : ''}\n\nCaptured ${cp.messages.length} message${cp.messages.length === 1 ? '' : 's'}, ${cp.filesTouched.length} file${cp.filesTouched.length === 1 ? '' : 's'} touched${cp.gitHead ? `, git \`${cp.gitHead}\`` : ''}.\n\nUse \`/rewind ${cp.id}\` to restore.`,
@@ -1731,7 +1784,7 @@ Format: use headers per category, only include categories where you found issues
             }
             if (args[0] === 'rule' && args.length > 1) {
                 import('../utils/learning.js').then(({ addCustomRule }) => {
-                    addCustomRule(ctx.projectPath, args.slice(1).join(' '));
+                    addCustomRule(args.slice(1).join(' '), ctx.projectPath);
                     ctx.app.notify('Custom rule added');
                 }).catch(() => ctx.app.notify('Learning module not available'));
                 return;
@@ -1962,7 +2015,7 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
             break;
         }
         case 'skill': {
-            import('../utils/skills.js').then(({ findSkill, formatSkillHelp, createSkillTemplate, saveCustomSkill, deleteCustomSkill, }) => {
+            import('../utils/skills.js').then(({ findSkill, formatSkillHelp, createSkillTemplate, saveCustomSkill, deleteCustomSkill, customSkillFileExists, getSkippedCustomSkills, formatSkippedCustomSkills, }) => {
                 const subCommand = args[0]?.toLowerCase();
                 const skillName = args[1];
                 if (!subCommand) {
@@ -1992,6 +2045,17 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                             ctx.app.notify(`Skill "${skillName}" already exists`);
                             return;
                         }
+                        // A file that does not load is not found above, and is still the
+                        // user's work.
+                        if (customSkillFileExists(skillName)) {
+                            const skipped = getSkippedCustomSkills().filter(f => f.file === `${skillName}.json`);
+                            ctx.app.addMessage({
+                                role: 'system',
+                                content: `~/.codeep/skills/${skillName}.json already exists — not replaced.`
+                                    + (skipped.length ? `\n\n${formatSkippedCustomSkills(skipped)}` : ''),
+                            });
+                            return;
+                        }
                         const template = createSkillTemplate(skillName);
                         saveCustomSkill(template);
                         ctx.app.addMessage({
@@ -2300,10 +2364,18 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
             // Sync the hand-written user profile (~/.codeep/profile.md). Push sends
             // the local file; pull is additive (writes only if no local profile).
             if (subCmd === 'all' || subCmd === 'profile') {
-                const { pushUserProfile, pullUserProfile } = await import('../utils/codeepCloud.js');
-                if (await pushUserProfile())
+                const { pushUserProfileResult, pullUserProfileResult, describeSyncFailure } = await import('../utils/codeepCloud.js');
+                // Without a local profile there is nothing to push, which is not a
+                // failure. Pushed before the pull, which may create the file.
+                const pushedProfile = await pushUserProfileResult();
+                if (!pushedProfile.ok)
+                    results.push(`✗ Failed to push your profile (about you) — ${describeSyncFailure(pushedProfile.reason)}`);
+                else if (pushedProfile.count > 0)
                     results.push('✓ Your profile (about you) pushed');
-                if ((await pullUserProfile()) === 1)
+                const pulledProfile = await pullUserProfileResult();
+                if (!pulledProfile.ok)
+                    results.push(`✗ Failed to pull your profile (about you) — ${describeSyncFailure(pulledProfile.reason)}`);
+                else if (pulledProfile.count > 0)
                     results.push('✓ Your profile pulled to this machine');
             }
             ctx.app.addMessage({
@@ -2358,7 +2430,10 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                     break;
                 }
                 const removed = intelligence.notes.splice(idx - 1, 1)[0];
-                saveProjectIntelligence(projectRoot, intelligence);
+                if (!saveProjectIntelligence(projectRoot, intelligence)) {
+                    ctx.app.notify(INTELLIGENCE_NOT_SAVED);
+                    break;
+                }
                 import('../utils/codeepCloud.js').then(({ syncMemoryNotes }) => syncMemoryNotes(projectCtx?.name || '', intelligence.notes)).catch(() => { });
                 ctx.app.notify(`Removed: "${removed}"`);
                 break;
@@ -2366,7 +2441,10 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
             if (sub === 'clear') {
                 const count = intelligence.notes.length;
                 intelligence.notes = [];
-                saveProjectIntelligence(projectRoot, intelligence);
+                if (!saveProjectIntelligence(projectRoot, intelligence)) {
+                    ctx.app.notify(INTELLIGENCE_NOT_SAVED);
+                    break;
+                }
                 import('../utils/codeepCloud.js').then(({ syncMemoryNotes }) => syncMemoryNotes(projectCtx?.name || '', [])).catch(() => { });
                 ctx.app.notify(`Cleared ${count} memory note${count !== 1 ? 's' : ''}.`);
                 break;
@@ -2378,7 +2456,10 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                 break;
             }
             intelligence.notes.push(note);
-            saveProjectIntelligence(projectRoot, intelligence);
+            if (!saveProjectIntelligence(projectRoot, intelligence)) {
+                ctx.app.notify(INTELLIGENCE_NOT_SAVED);
+                break;
+            }
             import('../utils/codeepCloud.js').then(({ syncMemoryNotes }) => syncMemoryNotes(projectCtx?.name || '', intelligence.notes)).catch(() => { });
             ctx.app.notify(`Memory saved (${intelligence.notes.length} total): "${note}"`);
             break;
@@ -2428,8 +2509,32 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                 }
                 return true;
             };
-            const { addProjectMcpServer, removeProjectMcpServer, loadMcpServerConfig, loadMcpServerConfigSplit, isWorkspaceMcpTrusted, trustWorkspaceMcp, untrustWorkspaceMcp } = await import('../utils/mcpConfig.js');
+            const { addProjectMcpServer, removeProjectMcpServer, loadMcpServerConfigSplit, selectSessionMcpServers, isWorkspaceMcpTrusted, trustWorkspaceMcp, untrustWorkspaceMcp } = await import('../utils/mcpConfig.js');
             const { registerSessionServers } = await import('../utils/mcpRegistry.js');
+            // The servers this session may run, chosen by the same rule startup and
+            // ACP use: workspace entries arrive with the repo and start only once the
+            // workspace is trusted. `addedHere` is an entry the user just typed into
+            // /mcp add or /mcp install; starting that one needs no further consent.
+            // registerSessionServers replaces the whole session, so everything that
+            // should keep running has to be in the list.
+            const serversToStart = (addedHere) => selectSessionMcpServers(projectPath, { userAdded: addedHere ? [addedHere] : [] });
+            const untrustedNote = ({ servers, skipped }) => {
+                if (skipped.length === 0)
+                    return '';
+                const n = skipped.length;
+                let note = `\n\n${n} workspace MCP server${n === 1 ? '' : 's'} not started — this workspace isn't trusted. Run \`/mcp trust\` to start ${n === 1 ? 'it' : 'them'}.`;
+                // A repo entry that shares a name with one of the user's own servers
+                // can keep that one from starting too; say so rather than let it look
+                // like the user's server just vanished.
+                const running = new Set(servers.map(s => s.name));
+                const globalNames = new Set(loadMcpServerConfigSplit(undefined).global.map(s => s.name));
+                const shadowed = skipped.map(s => s.name).filter(name => globalNames.has(name) && !running.has(name));
+                if (shadowed.length > 0) {
+                    const list = shadowed.map(name => `\`${name}\``).join(', ');
+                    note += `\n\nYour own server${shadowed.length === 1 ? '' : 's'} ${list} ${shadowed.length === 1 ? 'is' : 'are'} not running either: this workspace defines a server with the same name, which takes its place once trusted.`;
+                }
+                return note;
+            };
             if (sub === 'trust') {
                 if (!requireProject())
                     break;
@@ -2443,8 +2548,8 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                     ctx.app.notify('Workspace trusted — no workspace MCP servers defined yet.');
                     break;
                 }
-                ctx.app.notify(`Workspace trusted. Spawning ${workspace.length} MCP server(s)…`);
-                const { registered, errors } = await registerSessionServers(TUI_SESSION, workspace, { workspaceRoot: projectPath });
+                ctx.app.notify(`Workspace trusted. Restarting MCP servers with ${workspace.length} from this workspace…`);
+                const { registered, errors } = await registerSessionServers(TUI_SESSION, serversToStart().servers, { workspaceRoot: projectPath });
                 if (registered.length > 0)
                     ctx.app.notify(`MCP: ${registered.length} tool(s) ready. Type /mcp.`);
                 for (const e of errors)
@@ -2455,7 +2560,7 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                 if (!requireProject())
                     break;
                 untrustWorkspaceMcp(projectPath);
-                ctx.app.notify('Workspace MCP trust revoked — workspace servers won\'t spawn on next start. (Running servers stop when you exit.)');
+                ctx.app.notify('Workspace MCP trust revoked — workspace servers won\'t start again. Those running now stop at the next /mcp reload, add or remove, or when you exit.');
                 break;
             }
             if (sub === 'add') {
@@ -2470,15 +2575,15 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                 const extraArgs = args.slice(3);
                 addProjectMcpServer(projectPath, { name, command, args: extraArgs });
                 ctx.app.notify(`Saved MCP server ${name} to .codeep/mcp_servers.json. Spawning…`);
-                const merged = loadMcpServerConfig(projectPath);
-                const { registered, errors } = await registerSessionServers(TUI_SESSION, merged, { workspaceRoot: projectPath });
+                const selection = serversToStart(name);
+                const { registered, errors } = await registerSessionServers(TUI_SESSION, selection.servers, { workspaceRoot: projectPath });
                 const ok = registered.filter(t => t.serverName === name);
                 const failed = errors.find(e => e.server === name);
                 ctx.app.addMessage({
                     role: 'system',
-                    content: failed
+                    content: (failed
                         ? `Saved \`${name}\` but spawn failed: \`${failed.error}\``
-                        : `Added \`${name}\` (${ok.length} tool${ok.length === 1 ? '' : 's'} available).`,
+                        : `Added \`${name}\` (${ok.length} tool${ok.length === 1 ? '' : 's'} available).`) + untrustedNote(selection),
                 });
                 break;
             }
@@ -2495,9 +2600,9 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                     ctx.app.addMessage({ role: 'system', content: `No project-scoped MCP server named \`${name}\`.` });
                     break;
                 }
-                const merged = loadMcpServerConfig(projectPath);
-                await registerSessionServers(TUI_SESSION, merged, { workspaceRoot: projectPath });
-                ctx.app.addMessage({ role: 'system', content: `Removed \`${name}\` from project config and stopped its process.` });
+                const selection = serversToStart();
+                await registerSessionServers(TUI_SESSION, selection.servers, { workspaceRoot: projectPath });
+                ctx.app.addMessage({ role: 'system', content: `Removed \`${name}\` from project config and stopped its process.` + untrustedNote(selection) });
                 break;
             }
             if (sub === 'browse') {
@@ -2542,8 +2647,8 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                     headers: entry.server.headers,
                 });
                 ctx.app.notify(`Saved ${entry.id} to project config. Spawning…`);
-                const merged = loadMcpServerConfig(projectPath);
-                const { registered, errors } = await registerSessionServers(TUI_SESSION, merged, { workspaceRoot: projectPath });
+                const selection = serversToStart(entry.id);
+                const { registered, errors } = await registerSessionServers(TUI_SESSION, selection.servers, { workspaceRoot: projectPath });
                 const failed = errors.find(e => e.server === entry.id);
                 const lines = [];
                 if (failed) {
@@ -2560,16 +2665,16 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                         lines.push(`- \`${e.name}\`${req} — ${e.description}`);
                     }
                 }
-                ctx.app.addMessage({ role: 'system', content: lines.join('\n') });
+                ctx.app.addMessage({ role: 'system', content: lines.join('\n') + untrustedNote(selection) });
                 break;
             }
             if (sub === 'reload') {
                 if (!requireProject())
                     break;
                 ctx.app.notify('Reloading MCP server config…');
-                const merged = loadMcpServerConfig(projectPath);
-                const { registered, errors } = await registerSessionServers(TUI_SESSION, merged, { workspaceRoot: projectPath });
-                ctx.app.addMessage({ role: 'system', content: formatMcpReloadReport(registered.length, merged.length, errors) });
+                const selection = serversToStart();
+                const { registered, errors } = await registerSessionServers(TUI_SESSION, selection.servers, { workspaceRoot: projectPath });
+                ctx.app.addMessage({ role: 'system', content: formatMcpReloadReport(registered.length, selection.servers.length, errors) + untrustedNote(selection) });
                 break;
             }
             if (sub === 'resources') {
@@ -2641,9 +2746,20 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                 break;
             }
             // 2. Fall through to skill registry.
-            runSkill(command, args, ctx).then(handled => {
-                if (!handled)
-                    ctx.app.notify(`Unknown command: /${command}`);
+            runSkill(command, args, ctx).then(async (handled) => {
+                if (handled)
+                    return;
+                ctx.app.notify(`Unknown command: /${command}`);
+                // The command may be a custom skill whose file does not load. Scanned
+                // afresh here rather than trusting whatever the lookup left behind.
+                const { loadCustomSkills, getSkippedCustomSkills, formatSkippedCustomSkills } = await import('../utils/skills.js');
+                loadCustomSkills();
+                const skipped = getSkippedCustomSkills().filter(f => f.file.toLowerCase() === `${command.toLowerCase()}.json`);
+                if (skipped.length > 0) {
+                    ctx.app.addMessage({ role: 'system', content: `Unknown command: /${command}\n\n${formatSkippedCustomSkills(skipped)}` });
+                }
+            }).catch(err => {
+                ctx.app.notify(`Skill error: ${err.message}`);
             });
         }
     }

package/dist/renderer/main.d.ts

@@ -5,5 +5,46 @@
  * This file contains only startup/init logic. Command dispatch lives in
  * commands.ts and agent execution in agentExecution.ts.
  */
+import { App } from './App';
+import { type GitStatus } from '../utils/git';
+import type { McpServer } from '../acp/protocol';
+/**
+ * What to tell the user when git would not run in this project, or null when
+ * there is nothing to tell them.
+ *
+ * Without it the only symptom is the branch quietly missing from the header,
+ * which reads as "not a repository" — so a repository whose own `.git/config`
+ * names a program git would run looks like an ordinary folder, and the one
+ * thing the user has to do (remove that key) is never said anywhere. The
+ * refusal names the key and the `git config --unset` that clears it, so it is
+ * passed through verbatim rather than summarised into "git failed".
+ *
+ * Read off `refusal` and NOT off `error`, which is the field an earlier cut
+ * of this used. `error` is every way git can fail in a repository, and the
+ * commonest of them is a brand-new `git init` with no commit yet: `git
+ * rev-parse --abbrev-ref HEAD` answers `fatal: ambiguous argument 'HEAD'`
+ * there (git 2.54), so the first thing a user does in a new project met a
+ * warning made of git internals telling them to remove a config key that does
+ * not exist. `refusal` is filled on the hardening path and nowhere else, so
+ * an ordinary git failure stays as silent as it was before this notice
+ * existed — the branch is simply missing from the header, which is what it
+ * has always done.
+ */
+export declare function gitRefusalNotice(status: GitStatus): string | null;
 /** Derive a short display name from a user message (first ~5 words, max 48 chars). */
 export declare function deriveSessionName(message: string): string;
+/**
+ * Start the MCP servers this terminal may run, under the fixed session id
+ * `codeep-tui`: the global servers (~/.codeep, the user's own) plus the
+ * workspace ones once the workspace is trusted. Registering replaces the
+ * session's whole set, so they go in one call; starting the global list and
+ * then the workspace list stopped the global servers. Returns the workspace
+ * servers left out because the workspace is not trusted yet.
+ */
+export declare function startTuiMcpServers(root: string, ui: Pick<App, 'notify' | 'notifyWarn'>): Promise<McpServer[]>;
+/** Start the servers of a workspace the user has just trusted. A failure is
+ *  shown, not swallowed: the user asked for these servers. */
+export declare function startTrustedWorkspaceMcp(root: string, ui: Pick<App, 'notify' | 'notifyWarn'>): Promise<void>;
+/** The CLI entry point. Exported so tests can drive a command without the
+ *  module starting the app on import. */
+export declare function main(): Promise<void>;