codeep 2.14.0 → 2.16.0

package/dist/renderer/commands.js

@@ -12,31 +12,27 @@ import { getProviderList, getProvider, modelSupportsReasoningEffort, reasoningPa
 import { setProjectContext } from '../api/index.js';
 import { runSkill, runCommandChain } from './agentExecution.js';
 import { loadProjectIntelligence, saveProjectIntelligence } 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 { resolveCommand } from './commands/registry.js';
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 /**
  * Returns a hint for an Ollama model name based on parameter count.
  * Models ≥7B are suitable for agent mode; smaller ones are chat-only.
  */
-function ollamaModelHint(modelId) {
-    const lower = modelId.toLowerCase();
-    // Extract number before 'b' (e.g. "7b", "1.5b", "14b", "72b")
-    const match = lower.match(/(\d+(?:\.\d+)?)b/);
-    if (!match)
-        return '';
-    const params = parseFloat(match[1]);
-    if (params >= 7)
-        return '✓ agent mode';
-    return '⚠ chat only (< 7B)';
-}
 // ─── Main dispatch ────────────────────────────────────────────────────────────
 export async function handleCommand(command, args, ctx) {
+    // Resolve command aliases (e.g. `webcache` → `web-cache`) to their
+    // canonical name before dispatching.
+    const resolved = resolveCommand(command);
+    const canonical = resolved?.name ?? command;
     // Handle skill chaining (e.g., /commit+push)
-    if (command.includes('+')) {
-        const commands = command.split('+').filter(c => c.trim());
+    if (canonical.includes('+')) {
+        const commands = canonical.split('+').filter(c => c.trim());
         runCommandChain(commands, 0, ctx);
         return;
     }
-    switch (command) {
+    switch (canonical) {
         case 'version': {
             const version = getCurrentVersion();
             const provider = getCurrentProvider();
@@ -317,7 +313,7 @@ export async function handleCommand(command, args, ctx) {
                     ctx.app.notify('Thinking effort: auto — each model uses its own default.');
                 }
                 else if (!supported) {
-                    ctx.app.notify(`Thinking effort set to "${sub}", but ${model} has no graded thinking control — it will be ignored until you switch to a model that does (e.g. Opus 4.8, GPT-5.x, Gemini 3, DeepSeek V4, GLM-5.2).`);
+                    ctx.app.notify(`Thinking effort set to "${sub}", but ${model} has no graded thinking control — it will be ignored until you switch to a model that does (e.g. Opus 5, GPT-5.x, Gemini 3, DeepSeek V4, GLM-5.2).`);
                 }
                 else {
                     // Tell the user what THIS model will actually run (the tier may
@@ -433,21 +429,7 @@ export async function handleCommand(command, args, ctx) {
         }
         case 'insights': {
             const { formatInsights } = await import('../utils/insights.js');
-            // Parse `--days N` (default 7). Accept both `--days 30` and `--days=30`.
-            let days = 7;
-            for (let i = 0; i < args.length; i++) {
-                const a = args[i];
-                if (a === '--days' && args[i + 1]) {
-                    const n = parseInt(args[i + 1], 10);
-                    if (Number.isFinite(n))
-                        days = n;
-                }
-                else if (a.startsWith('--days=')) {
-                    const n = parseInt(a.slice('--days='.length), 10);
-                    if (Number.isFinite(n))
-                        days = n;
-                }
-            }
+            const days = parseInsightsDays(args);
             ctx.app.addMessage({ role: 'system', content: formatInsights({ days }) });
             break;
         }
@@ -522,12 +504,7 @@ export async function handleCommand(command, args, ctx) {
                     break;
                 }
                 const file = scope === 'global' ? '~/.codeep/profile.learned.md' : '.codeep/profile.learned.md';
-                ctx.app.addMessage({
-                    role: 'system',
-                    content: res.updated
-                        ? `Updated your ${scope} learned profile (\`${file}\`):\n\n${res.facts}\n\nClear it anytime with \`/me forget\`.`
-                        : `No changes — your ${scope} learned profile already covers this:\n\n${res.facts}`,
-                });
+                ctx.app.addMessage({ role: 'system', content: formatMeLearnResult(scope, file, res) });
                 break;
             }
             if (sub === 'forget') {
@@ -546,14 +523,7 @@ export async function handleCommand(command, args, ctx) {
                 ctx.app.notify('Syncing your profile with codeep.dev…');
                 const pushed = await pushUserProfile();
                 const pulled = await pullUserProfile();
-                const lines = [];
-                if (pushed)
-                    lines.push('✓ Profile pushed to the dashboard');
-                if (pulled === 1)
-                    lines.push('✓ Profile pulled to this machine');
-                if (lines.length === 0)
-                    lines.push('Nothing to sync yet — run `/me init` and fill in your profile first.');
-                ctx.app.addMessage({ role: 'system', content: `## Profile sync\n\n${lines.join('\n')}` });
+                ctx.app.addMessage({ role: 'system', content: formatMeSyncReport(pushed, pulled) });
                 break;
             }
             if (sub === 'init') {
@@ -567,12 +537,7 @@ export async function handleCommand(command, args, ctx) {
                     ctx.app.notify('Could not create the profile file.');
                     break;
                 }
-                ctx.app.addMessage({
-                    role: 'system',
-                    content: res.created
-                        ? `Created ${scope} profile: \`${res.path}\`\n\nEdit it in your editor — Codeep uses it automatically. View anytime with \`/me\`.`
-                        : `${scope === 'global' ? 'Global' : 'Project'} profile already exists: \`${res.path}\`\n\nEdit it directly, or view it with \`/me\`.`,
-                });
+                ctx.app.addMessage({ role: 'system', content: formatMeInitResult(scope, res) });
                 break;
             }
             // Default: show the profile view.
@@ -676,6 +641,142 @@ export async function handleCommand(command, args, ctx) {
             });
             break;
         }
+        case 'cloud': {
+            // Cross-device resume: list sessions synced from other devices/Mac app
+            // and pull the selected one into the local store, then load it.
+            //
+            // Not linked → friendly prompt to run `codeep account`.
+            // Network/empty → notify (no crash).
+            //
+            // We scope to the current project when one is open, so a user on their
+            // laptop sees the sessions they ran on the desktop for the same repo.
+            // BUT: project identity is a hash of the LOCAL absolute path, so the
+            // same repo cloned at a different path (the normal cross-device case)
+            // has a different projectId. When the scoped list comes back empty we
+            // fall back to listing everything, and a non-empty scoped list still
+            // offers a "show all" escape hatch — otherwise cross-device resume
+            // only works when both machines use identical directory layouts.
+            const { listCloudSessions, pullCloudSession, generateProjectId } = await import('../utils/codeepCloud.js');
+            const projectId = ctx.projectPath ? generateProjectId(ctx.projectPath) : undefined;
+            ctx.app.notify('Fetching cloud sessions…');
+            let summaries = await listCloudSessions(projectId);
+            if (summaries === null) {
+                ctx.app.notify('Not linked — run `codeep account` to enable cloud sync.');
+                break;
+            }
+            let scopedToProject = Boolean(projectId);
+            if (summaries.length === 0 && projectId) {
+                // Nothing under this project's path-hash — try the unscoped list so
+                // sessions synced from a machine with a different path still show up.
+                const all = await listCloudSessions();
+                if (all && all.length > 0) {
+                    summaries = all;
+                    scopedToProject = false;
+                    ctx.app.notify('No sessions matched this project — showing all cloud sessions.');
+                }
+            }
+            if (summaries.length === 0) {
+                ctx.app.notify(projectId
+                    ? 'No cloud sessions for this project yet.'
+                    : 'No cloud sessions yet.');
+                break;
+            }
+            // Non-null binding for the picker closure — TS can't carry the null
+            // narrowing of a reassigned `let` into the callback.
+            let sessionList = summaries;
+            const SHOW_ALL = 'Show all cloud sessions…';
+            const labels = summaries.map(formatCloudSessionLabel);
+            if (scopedToProject)
+                labels.push(SHOW_ALL);
+            // Named so the "Show all" branch can re-present the picker with the
+            // same handler (a const arrow can reference itself; the binding is
+            // initialized long before the callback can fire).
+            const onPickCloudSession = async (index) => {
+                if (scopedToProject && index === sessionList.length) {
+                    // "Show all" — re-list unscoped. Re-dispatching /cloud would
+                    // re-scope to the project, so fetch + present inline instead.
+                    const all = await listCloudSessions();
+                    if (!all || all.length === 0) {
+                        ctx.app.notify('No other cloud sessions.');
+                        return;
+                    }
+                    sessionList = all;
+                    scopedToProject = false;
+                    const allLabels = all.map(s => {
+                        const date = new Date(s.updatedAt).toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+                        const title = s.sessionName || s.sessionId.slice(0, 8);
+                        const projectTag = s.projectName ? ` · ${s.projectName}` : '';
+                        return `${title}  ·  ${date} · ${s.messageCount} msg${projectTag}`;
+                    });
+                    ctx.app.showList('Cloud Sessions (all)', allLabels, onPickCloudSession);
+                    return;
+                }
+                const selected = sessionList[index];
+                // The cloud id becomes a local FILENAME (saveSession joins it into
+                // .codeep/sessions/<name>.json) — whitelist it so a hostile or
+                // corrupted server response can't traverse outside the sessions dir.
+                if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(selected.sessionId)) {
+                    ctx.app.notify('Cloud session has an unexpected id format — refusing to save it locally.');
+                    return;
+                }
+                ctx.app.notify(`Pulling ${selected.sessionName || selected.sessionId.slice(0, 8)}…`);
+                const full = await pullCloudSession(selected.sessionId);
+                if (!full) {
+                    ctx.app.notify('Failed to pull session (network or not found).');
+                    return;
+                }
+                // Cloud messages are {role, content}; local Message is the same shape
+                // plus 'system'. Filter to user/assistant (the server already does,
+                // but be defensive) and coerce.
+                const history = full.messages
+                    .filter(m => m.role === 'user' || m.role === 'assistant')
+                    .map(m => ({ role: m.role, content: m.content }));
+                if (history.length === 0) {
+                    ctx.app.notify('Cloud session has no loadable messages.');
+                    return;
+                }
+                // Persist locally so the resumed session is first-class: it appears
+                // in /sessions, autosaves on next change, and re-syncs on next turn.
+                // We reuse the cloud sessionId as the local name so a subsequent
+                // push updates the same cloud record (ON DUPLICATE KEY UPDATE).
+                const localName = selected.sessionId;
+                // If a local copy of this session exists and is NEWER than the cloud
+                // record (continued locally since the last sync), load it instead of
+                // clobbering the newer history with the older cloud copy.
+                try {
+                    const { statSync, existsSync } = await import('fs');
+                    const { join } = await import('path');
+                    const { getSessionsDir } = await import('../config/index.js');
+                    const localPath = join(getSessionsDir(ctx.projectPath), `${localName}.json`);
+                    const cloudUpdatedAt = Date.parse(selected.updatedAt);
+                    if (existsSync(localPath) && Number.isFinite(cloudUpdatedAt)
+                        && statSync(localPath).mtimeMs > cloudUpdatedAt) {
+                        const local = loadSession(localName, ctx.projectPath);
+                        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;
+                        }
+                    }
+                }
+                catch { /* mtime probe is best-effort — fall through to cloud copy */ }
+                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.
+                ctx.setSessionId(localName);
+                config.set('currentSessionId', localName);
+                ctx.setSessionDisplayName?.(selected.sessionName ?? null);
+                ctx.app.notify(`Resumed from cloud: ${selected.sessionName || localName}`);
+            };
+            ctx.app.showList('Cloud Sessions', labels, onPickCloudSession);
+            break;
+        }
         case 'new': {
             ctx.app.clearMessages();
             ctx.setSessionId(startNewSession());
@@ -829,7 +930,7 @@ Format: use headers per category, only include categories where you found issues
                 ctx.app.notify('Usage: /rename <new-name>');
                 return;
             }
-            const newName = args.join('-');
+            const newName = joinSessionName(args);
             const messages = ctx.app.getMessages();
             if (messages.length === 0) {
                 ctx.app.notify('No messages to save. Start a conversation first.');
@@ -865,18 +966,7 @@ Format: use headers per category, only include categories where you found issues
             }
             const searchTerm = args.join(' ').toLowerCase();
             const messages = ctx.app.getMessages();
-            const searchResults = [];
-            messages.forEach((m, index) => {
-                if (m.content.toLowerCase().includes(searchTerm)) {
-                    const lowerContent = m.content.toLowerCase();
-                    const matchStart = Math.max(0, lowerContent.indexOf(searchTerm) - 30);
-                    const matchEnd = Math.min(m.content.length, lowerContent.indexOf(searchTerm) + searchTerm.length + 50);
-                    const matchedText = (matchStart > 0 ? '...' : '') +
-                        m.content.slice(matchStart, matchEnd).replace(/\n/g, ' ') +
-                        (matchEnd < m.content.length ? '...' : '');
-                    searchResults.push({ role: m.role, messageIndex: index, matchedText });
-                }
-            });
+            const searchResults = buildSearchSnippets(messages, searchTerm);
             if (searchResults.length === 0) {
                 ctx.app.notify(`No matches for "${searchTerm}"`);
             }
@@ -1063,18 +1153,13 @@ Format: use headers per category, only include categories where you found issues
         case 'copy': {
             const blockNum = args[0] ? parseInt(args[0], 10) : -1;
             const messages = ctx.app.getMessages();
-            const codeBlocks = [];
-            for (const msg of messages) {
-                for (const match of msg.content.matchAll(/```[\w]*\n([\s\S]*?)```/g)) {
-                    codeBlocks.push(match[1]);
-                }
-            }
+            const codeBlocks = messages.flatMap(m => extractCodeBlocks(m.content));
             if (codeBlocks.length === 0) {
                 ctx.app.notify('No code blocks found');
                 return;
             }
-            const index = blockNum === -1 ? codeBlocks.length - 1 : blockNum - 1;
-            if (Number.isNaN(index) || index < 0 || index >= codeBlocks.length) {
+            const index = resolveBlockIndex(blockNum, codeBlocks.length);
+            if (index === null) {
                 ctx.app.notify(`Invalid block number. Available: 1-${codeBlocks.length}`);
                 return;
             }
@@ -1112,20 +1197,7 @@ Format: use headers per category, only include categories where you found issues
                 ctx.app.notify('No assistant response to apply');
                 return;
             }
-            const changes = [];
-            const fenceFilePattern = /```\w*\s+([\w./\\-]+(?:\.\w+))\n([\s\S]*?)```/g;
-            let match;
-            while ((match = fenceFilePattern.exec(lastAssistant.content)) !== null) {
-                const p = match[1].trim();
-                if (p.includes('.') && !p.includes(' '))
-                    changes.push({ path: p, content: match[2] });
-            }
-            if (changes.length === 0) {
-                const commentPattern = /```(\w+)?\s*\n(?:\/\/|#|--|\/\*)\s*(?:File|Path|file|path):\s*([^\n*]+)\n([\s\S]*?)```/g;
-                while ((match = commentPattern.exec(lastAssistant.content)) !== null) {
-                    changes.push({ path: match[2].trim(), content: match[3] });
-                }
-            }
+            const changes = extractFileChanges(lastAssistant.content);
             if (changes.length === 0) {
                 ctx.app.notify('No file changes found in response');
                 return;
@@ -1134,64 +1206,168 @@ Format: use headers per category, only include categories where you found issues
                 ctx.app.notify('Write access required. Use /grant first.');
                 return;
             }
+            // Parse optional selective hunk spec: /apply --only file.ts:0,1 other.ts:2
+            // Without --only, all hunks are applied (existing behavior).
+            const selective = args.includes('--only') || args.includes('-o');
+            const interactive = args.includes('--interactive') || args.includes('-i');
+            const hunkSpecs = new Map();
+            if (selective) {
+                for (const a of args) {
+                    if (a === '--only' || a === '-o')
+                        continue;
+                    const m = a.match(/^(.+):([\d,]+)$/);
+                    if (m) {
+                        const [, file, idxStr] = m;
+                        const idxs = new Set(idxStr.split(',').map((n) => parseInt(n, 10)).filter((n) => !isNaN(n)));
+                        hunkSpecs.set(file, idxs);
+                    }
+                }
+                // A spec that parsed to nothing must NOT fall through to the
+                // apply-everything branch below — the user asked to restrict the
+                // apply, so writing every change is the opposite of the request.
+                if (hunkSpecs.size === 0) {
+                    ctx.app.notify('Invalid --only spec. Expected `--only <file>:<hunk>[,<hunk>]` (e.g. --only src/a.ts:0,2). Nothing applied.');
+                    return;
+                }
+            }
             import('fs').then(async (fs) => {
                 import('path').then(async (pathModule) => {
+                    const { createFileDiff, applyHunksToFiles, countChangeHunks } = await import('../utils/diffPreview.js');
                     const diffLines = [];
+                    const fileDiffs = [];
                     for (const change of changes) {
                         const fullPath = pathModule.isAbsolute(change.path)
                             ? change.path
                             : pathModule.join(ctx.projectPath, change.path);
-                        const shortPath = change.path.length > 40 ? '...' + change.path.slice(-37) : change.path;
                         let existingContent = '';
                         try {
                             existingContent = await fs.promises.readFile(fullPath, 'utf-8');
                         }
                         catch { }
-                        if (!existingContent) {
-                            diffLines.push(`+ CREATE: ${shortPath}`);
-                            diffLines.push(`  (${change.content.split('\n').length} lines)`);
+                        const fd = createFileDiff(change.path, change.content, ctx.projectPath);
+                        fileDiffs.push(fd);
+                        const hunkCount = countChangeHunks(fd);
+                        diffLines.push(...formatApplyDiffLine(change, existingContent));
+                        if (hunkCount > 0) {
+                            diffLines.push(`  ↳ ${hunkCount} hunk(s) — use /apply --only ${change.path}:0,1 to select`);
                         }
-                        else {
-                            const oldLines = existingContent.split('\n').length;
-                            const newLines = change.content.split('\n').length;
-                            const lineDiff = newLines - oldLines;
-                            diffLines.push(`~ MODIFY: ${shortPath}`);
-                            diffLines.push(`  ${oldLines} → ${newLines} lines (${lineDiff >= 0 ? '+' : ''}${lineDiff})`);
+                    }
+                    // Interactive mode: open the hunk picker (`git add -p` style).
+                    if (interactive) {
+                        const items = [];
+                        for (const fd of fileDiffs) {
+                            for (let hi = 0; hi < fd.hunks.length; hi++) {
+                                const hunk = fd.hunks[hi];
+                                // Skip pure-context hunks (no add/remove).
+                                if (!hunk.lines.some((l) => l.type === 'add' || l.type === 'remove'))
+                                    continue;
+                                const header = `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`;
+                                const lines = hunk.lines.map((l) => {
+                                    if (l.type === 'add')
+                                        return `+${l.content}`;
+                                    if (l.type === 'remove')
+                                        return `-${l.content}`;
+                                    return ` ${l.content}`;
+                                });
+                                items.push({ path: fd.path, hunkIndex: hi, header, lines });
+                            }
                         }
+                        if (items.length === 0) {
+                            ctx.app.notify('No change hunks to review');
+                            return;
+                        }
+                        ctx.app.showHunkPicker({
+                            title: '🎯 Review hunks',
+                            items,
+                            onComplete: (accepted) => {
+                                if (accepted.length === 0) {
+                                    ctx.app.notify('No hunks applied');
+                                    return;
+                                }
+                                (async () => {
+                                    // Group accepted hunk indices by file path.
+                                    const byPath = new Map();
+                                    for (const a of accepted) {
+                                        let set = byPath.get(a.path);
+                                        if (!set) {
+                                            set = new Set();
+                                            byPath.set(a.path, set);
+                                        }
+                                        set.add(a.hunkIndex);
+                                    }
+                                    const results = applyHunksToFiles(fileDiffs, byPath);
+                                    let applied = 0;
+                                    for (const r of results) {
+                                        try {
+                                            const fullPath = pathModule.isAbsolute(r.path)
+                                                ? r.path
+                                                : pathModule.join(ctx.projectPath, r.path);
+                                            await fs.promises.mkdir(pathModule.dirname(fullPath), { recursive: true });
+                                            await fs.promises.writeFile(fullPath, r.content);
+                                            applied++;
+                                        }
+                                        catch { }
+                                    }
+                                    ctx.app.notify(`Applied ${accepted.length} hunk(s) across ${applied} file(s)`);
+                                })().catch((e) => ctx.app.notify(`Apply failed: ${e instanceof Error ? e.message : String(e)}`));
+                            },
+                        });
+                        return;
                     }
+                    const summary = selective && hunkSpecs.size > 0
+                        ? `Selective apply (${hunkSpecs.size} file(s) with chosen hunks)`
+                        : `Found ${changes.length} file(s) to apply`;
                     ctx.app.showConfirm({
                         title: '📝 Apply Changes',
                         message: [
-                            `Found ${changes.length} file(s) to apply:`,
+                            summary,
                             '',
-                            ...diffLines.slice(0, 10),
-                            ...(diffLines.length > 10 ? [`  ...and ${diffLines.length - 10} more`] : []),
+                            ...diffLines.slice(0, 12),
+                            ...(diffLines.length > 12 ? [`  ...and ${diffLines.length - 12} more`] : []),
                             '',
-                            'Apply these changes?',
+                            selective && hunkSpecs.size > 0 ? 'Apply selected hunks?' : 'Apply these changes?',
                         ],
                         confirmLabel: 'Apply',
                         cancelLabel: 'Cancel',
                         onConfirm: () => {
                             (async () => {
                                 let applied = 0;
-                                for (const change of changes) {
-                                    try {
-                                        const fullPath = pathModule.isAbsolute(change.path)
-                                            ? change.path
-                                            : pathModule.join(ctx.projectPath, change.path);
-                                        await fs.promises.mkdir(pathModule.dirname(fullPath), { recursive: true });
-                                        await fs.promises.writeFile(fullPath, change.content);
-                                        applied++;
+                                if (selective && hunkSpecs.size > 0) {
+                                    // Per-hunk selective apply.
+                                    const results = applyHunksToFiles(fileDiffs, hunkSpecs);
+                                    for (const r of results) {
+                                        try {
+                                            const fullPath = pathModule.isAbsolute(r.path)
+                                                ? r.path
+                                                : pathModule.join(ctx.projectPath, r.path);
+                                            await fs.promises.mkdir(pathModule.dirname(fullPath), { recursive: true });
+                                            await fs.promises.writeFile(fullPath, r.content);
+                                            applied++;
+                                        }
+                                        catch { }
                                     }
-                                    catch { }
                                 }
-                                ctx.app.notify(`Applied ${applied}/${changes.length} file(s)`);
-                            })();
+                                else {
+                                    // All-or-nothing apply (original behavior).
+                                    for (const change of changes) {
+                                        try {
+                                            const fullPath = pathModule.isAbsolute(change.path)
+                                                ? change.path
+                                                : pathModule.join(ctx.projectPath, change.path);
+                                            await fs.promises.mkdir(pathModule.dirname(fullPath), { recursive: true });
+                                            await fs.promises.writeFile(fullPath, change.content);
+                                            applied++;
+                                        }
+                                        catch { }
+                                    }
+                                }
+                                ctx.app.notify(`Applied ${applied}/${selective ? hunkSpecs.size : changes.length} file(s)`);
+                            })().catch((e) => ctx.app.notify(`Apply failed: ${e instanceof Error ? e.message : String(e)}`));
                         },
                         onCancel: () => ctx.app.notify('Apply cancelled'),
                     });
                 });
-            });
+            }).catch((e) => ctx.app.notify(`Apply failed: ${e instanceof Error ? e.message : String(e)}`));
             break;
         }
         case 'add': {
@@ -1302,7 +1478,7 @@ Format: use headers per category, only include categories where you found issues
         }
         case 'compact': {
             const messages = ctx.app.getMessages();
-            const keepRecent = args[0] ? Math.max(2, parseInt(args[0], 10) || 4) : 4;
+            const keepRecent = parseKeepRecent(args[0]);
             if (messages.length <= keepRecent + 2) {
                 ctx.app.notify(`Nothing to compact — only ${messages.length} message(s) in this session.`);
                 break;
@@ -1646,10 +1822,7 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                     ctx.app.notify(`Skill ${name} not found`);
                     break;
                 }
-                ctx.app.addMessage({
-                    role: 'system',
-                    content: `# ${bundle.name}\n_${bundle.description}_\n\n**Source:** ${bundle.source}\n\n---\n\n${bundle.body}`,
-                });
+                ctx.app.addMessage({ role: 'system', content: formatSkillsShow(bundle) });
                 break;
             }
             // Marketplace operations against codeep.dev.
@@ -1667,10 +1840,7 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                     ctx.app.notify(`Publish failed: ${result.error}`);
                     break;
                 }
-                ctx.app.addMessage({
-                    role: 'system',
-                    content: `Published \`${slug}\` (${isPublic ? 'public' : 'private'}) to codeep.dev. Install elsewhere with \`/skills install ${result.skill?.owner_username ?? '<you>'}/${slug}\`.`,
-                });
+                ctx.app.addMessage({ role: 'system', content: formatSkillsPublishResult(slug, isPublic, result.skill?.owner_username) });
                 break;
             }
             if (sub === 'install') {
@@ -1700,7 +1870,7 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                 }
                 const skills = result.skills ?? [];
                 if (skills.length === 0) {
-                    ctx.app.addMessage({ role: 'system', content: query ? `_No public skills matching "${query}"._` : '_No public skills published yet._' });
+                    ctx.app.addMessage({ role: 'system', content: formatSkillsBrowseEmpty(query) });
                     break;
                 }
                 const lines = [`# ${query ? `Skills matching "${query}"` : 'Public skills'}`, ''];
@@ -1894,31 +2064,7 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
             // as the description — the same field the dashboard + macOS app set, and
             // which the list view and the agent task-context prompt already render.
             if (subCmd === 'add') {
-                const TASK_TYPES = ['task', 'bug', 'feature'];
-                let type = 'task';
-                const titleWords = [];
-                const descWords = [];
-                let capturingDesc = false;
-                for (const w of args.slice(1)) {
-                    const flag = /^--([\w-]+)$/.exec(w);
-                    if (flag) {
-                        const name = flag[1].toLowerCase();
-                        if (name === 'desc' || name === 'description') {
-                            capturingDesc = true;
-                            continue;
-                        }
-                        if (TASK_TYPES.includes(name))
-                            type = name;
-                        capturingDesc = false; // any non-desc flag ends description capture
-                        continue;
-                    }
-                    if (capturingDesc)
-                        descWords.push(w);
-                    else
-                        titleWords.push(w);
-                }
-                const title = titleWords.join(' ').trim();
-                const description = descWords.join(' ').trim();
+                const { title, description, type } = parseTaskAddArgs(args.slice(1));
                 if (!title) {
                     ctx.app.notify('Usage: /tasks add <title> [--bug | --feature] [--desc <text>]');
                     break;
@@ -1963,18 +2109,7 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                 break;
             }
             setTaskContext(tasks);
-            const TYPE_ICON = { bug: '[bug]', feature: '[feature]', task: '[task]' };
-            const lines = [`## Tasks${projectName ? ` — ${projectName}` : ''}`, ''];
-            tasks.forEach((t, i) => {
-                const icon = TYPE_ICON[t.type] ?? '[task]';
-                // In a global listing (not scoped to one project) tag each row with its
-                // project so a mixed list is legible — matches the macOS/web task rows.
-                const proj = !projectName && t.project_name ? ` _(${t.project_name})_` : '';
-                lines.push(`${i + 1}. ${icon} ${t.title}${proj}${t.description ? `\n   ${t.description}` : ''}`);
-            });
-            lines.push('', `*${tasks.length} pending task${tasks.length > 1 ? 's' : ''}. Use /tasks done <n> to mark complete.*`);
-            lines.push('*Tasks loaded into agent context — agent will see them in the next message.*');
-            ctx.app.addMessage({ role: 'system', content: lines.join('\n') });
+            ctx.app.addMessage({ role: 'system', content: formatTaskList(tasks, projectName) });
             break;
         }
         case 'profile': {
@@ -1986,7 +2121,7 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                     ctx.app.notify('No profiles saved. Use /profile save <name>');
                 }
                 else {
-                    ctx.app.addMessage({ role: 'system', content: `## Profiles\n\n${profiles.map(p => `- ${p}`).join('\n')}\n\nUse /profile load <name> to apply.` });
+                    ctx.app.addMessage({ role: 'system', content: formatProfileList(profiles) });
                 }
                 break;
             }
@@ -2127,54 +2262,15 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
         case 'stats': {
             const { getCostBreakdown, getSessionStats, formatTokenCount, getPricingTable, getCacheStats } = await import('../utils/tokenTracker.js');
             const stats = getSessionStats();
-            const lines = ['## Session Cost', ''];
-            if (stats.requestCount === 0) {
-                lines.push('*No API calls made yet this session.*');
-                lines.push('');
-            }
-            else {
-                lines.push(`Requests: ${stats.requestCount}`);
-                lines.push(`Tokens: ${formatTokenCount(stats.totalTokens)} total (${formatTokenCount(stats.totalPromptTokens)} in / ${formatTokenCount(stats.totalCompletionTokens)} out)`);
-                const breakdown = getCostBreakdown();
-                if (breakdown.length > 0) {
-                    lines.push('');
-                    lines.push('### By model');
-                    for (const b of breakdown) {
-                        const isFree = b.provider === 'ollama';
-                        const costStr = isFree ? 'free' : b.estimatedCost > 0 ? `~$${b.estimatedCost.toFixed(4)}` : '(no pricing data)';
-                        lines.push(`- **${b.model}** (${b.provider}): ${formatTokenCount(b.promptTokens)} in / ${formatTokenCount(b.completionTokens)} out — ${costStr}`);
-                    }
-                    lines.push('');
-                    const currentProvider = config.get('provider');
-                    if (currentProvider === 'ollama') {
-                        lines.push(`**Total: free · ${formatTokenCount(stats.totalTokens)} tokens**`);
-                    }
-                    else if (stats.estimatedCost > 0) {
-                        lines.push(`**Total: ~$${stats.estimatedCost.toFixed(4)}**`);
-                    }
-                }
-                // Prompt caching — parity with /cost (the 2.0.2 caching section was
-                // only wired into formatCostReport). Shown only when caching landed.
-                const cache = getCacheStats();
-                if (cache.cacheReadTokens > 0 || cache.cacheCreationTokens > 0) {
-                    lines.push('', '### Prompt caching');
-                    lines.push(`Cache reads: ${formatTokenCount(cache.cacheReadTokens)} tokens (billed at 0.1× input rate)`);
-                    if (cache.cacheCreationTokens > 0) {
-                        lines.push(`Cache writes: ${formatTokenCount(cache.cacheCreationTokens)} tokens (billed at 1.25× input rate)`);
-                    }
-                    if (cache.estimatedSavingsUsd > 0) {
-                        lines.push(`Estimated savings vs no caching: $${cache.estimatedSavingsUsd.toFixed(4)}`);
-                    }
-                }
-                lines.push('');
-            }
-            lines.push('### Pricing (per 1M tokens)');
-            lines.push('| Model | Input | Output |');
-            lines.push('|---|---|---|');
-            for (const p of getPricingTable()) {
-                lines.push(`| ${p.model} | $${p.inputPer1M.toFixed(3)} | $${p.outputPer1M.toFixed(3)} |`);
-            }
-            ctx.app.addMessage({ role: 'system', content: lines.join('\n') });
+            const content = formatStatsReport({
+                totals: stats,
+                breakdown: getCostBreakdown(),
+                cache: getCacheStats(),
+                pricing: getPricingTable(),
+                currentProvider: config.get('provider'),
+                fmt: formatTokenCount,
+            });
+            ctx.app.addMessage({ role: 'system', content });
             break;
         }
         case 'memory': {
@@ -2192,8 +2288,7 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                     ctx.app.notify('No memory notes. Add one with: /memory <note>');
                 }
                 else {
-                    const lines = intelligence.notes.map((n, i) => `  ${i + 1}. ${n}`).join('\n');
-                    ctx.app.addMessage({ role: 'assistant', content: `**Project memory notes:**\n${lines}` });
+                    ctx.app.addMessage({ role: 'assistant', content: formatMemoryList(intelligence.notes) });
                 }
                 break;
             }
@@ -2234,6 +2329,29 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
             ctx.app.addMessage({ role: 'system', content: formatCommandList(loadCustomCommands(ctx.projectPath)) });
             break;
         }
+        case 'web-cache': {
+            const sub = args[0]?.toLowerCase();
+            const { clearWebCache, webCacheStats } = await import('../utils/webFetch.js');
+            if (sub === 'clear' || sub === 'reset' || sub === 'flush') {
+                clearWebCache();
+                ctx.app.notify('Web cache cleared');
+            }
+            else {
+                const stats = webCacheStats();
+                ctx.app.addMessage({
+                    role: 'system',
+                    content: [
+                        '🌐 Web fetch cache',
+                        '',
+                        `  Entries: ${stats.entries}/${stats.maxEntries}`,
+                        `  TTL:     ${stats.ttlMinutes} min`,
+                        '',
+                        'Usage: /web-cache clear',
+                    ].join('\n'),
+                });
+            }
+            break;
+        }
         case 'mcp': {
             // Mirrors the ACP `/mcp` handler in src/acp/commands.ts. In TUI the
             // session id is the constant `codeep-tui` (the same one main.ts uses
@@ -2251,8 +2369,36 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                 }
                 return true;
             };
-            const { addProjectMcpServer, removeProjectMcpServer, loadMcpServerConfig } = await import('../utils/mcpConfig.js');
+            const { addProjectMcpServer, removeProjectMcpServer, loadMcpServerConfig, loadMcpServerConfigSplit, isWorkspaceMcpTrusted, trustWorkspaceMcp, untrustWorkspaceMcp } = await import('../utils/mcpConfig.js');
             const { registerSessionServers } = await import('../utils/mcpRegistry.js');
+            if (sub === 'trust') {
+                if (!requireProject())
+                    break;
+                if (isWorkspaceMcpTrusted(projectPath)) {
+                    ctx.app.notify('Workspace MCP servers are already trusted here.');
+                    break;
+                }
+                trustWorkspaceMcp(projectPath);
+                const { workspace } = loadMcpServerConfigSplit(projectPath);
+                if (workspace.length === 0) {
+                    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 });
+                if (registered.length > 0)
+                    ctx.app.notify(`MCP: ${registered.length} tool(s) ready. Type /mcp.`);
+                for (const e of errors)
+                    ctx.app.notifyWarn(`MCP server "${e.server}" failed: ${e.error}`);
+                break;
+            }
+            if (sub === 'untrust') {
+                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.)');
+                break;
+            }
             if (sub === 'add') {
                 if (!requireProject())
                     break;
@@ -2364,35 +2510,14 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                 ctx.app.notify('Reloading MCP server config…');
                 const merged = loadMcpServerConfig(projectPath);
                 const { registered, errors } = await registerSessionServers(TUI_SESSION, merged, { workspaceRoot: projectPath });
-                const lines = [`## MCP reloaded`, '', `**${registered.length}** tool${registered.length === 1 ? '' : 's'} from **${merged.length}** server${merged.length === 1 ? '' : 's'}.`];
-                if (errors.length > 0) {
-                    lines.push('', '### Failed servers');
-                    for (const e of errors)
-                        lines.push(`- **${e.server}** — \`${e.error}\``);
-                }
-                ctx.app.addMessage({ role: 'system', content: lines.join('\n') });
+                ctx.app.addMessage({ role: 'system', content: formatMcpReloadReport(registered.length, merged.length, errors) });
                 break;
             }
             if (sub === 'resources') {
                 const { getSessionResources, awaitSessionReady } = await import('../utils/mcpRegistry.js');
                 await awaitSessionReady(TUI_SESSION);
                 const groups = await getSessionResources(TUI_SESSION);
-                if (groups.length === 0) {
-                    ctx.app.addMessage({ role: 'system', content: '_No MCP server in this session exposes resources._' });
-                    break;
-                }
-                const lines = ['## MCP resources', ''];
-                for (const g of groups) {
-                    lines.push(`**${g.serverName}** — ${g.resources.length} resource${g.resources.length === 1 ? '' : 's'}`);
-                    for (const r of g.resources) {
-                        const label = r.name ? `${r.name} — ` : '';
-                        const mime = r.mimeType ? ` (${r.mimeType})` : '';
-                        lines.push(`- ${label}\`${r.uri}\`${mime}${r.description ? ` — ${r.description}` : ''}`);
-                    }
-                    lines.push('');
-                }
-                lines.push('Read one with `/mcp read <uri>`.');
-                ctx.app.addMessage({ role: 'system', content: lines.join('\n').trim() });
+                ctx.app.addMessage({ role: 'system', content: formatMcpResourcesList(groups) });
                 break;
             }
             if (sub === 'read') {
@@ -2404,23 +2529,7 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                 const { readSessionResource } = await import('../utils/mcpRegistry.js');
                 try {
                     const contents = await readSessionResource(TUI_SESSION, uri);
-                    if (contents.length === 0) {
-                        ctx.app.addMessage({ role: 'system', content: `_No content returned for \`${uri}\`._` });
-                        break;
-                    }
-                    const lines = [`## Resource: \`${uri}\``, ''];
-                    for (const c of contents) {
-                        if (c.text !== undefined) {
-                            const fence = c.mimeType?.includes('json') ? 'json' : c.mimeType?.includes('markdown') ? 'markdown' : '';
-                            lines.push('```' + fence);
-                            lines.push(c.text);
-                            lines.push('```');
-                        }
-                        else if (c.blob) {
-                            lines.push(`_(${c.mimeType ?? 'binary'} blob, ${c.blob.length} base64 chars — not rendered)_`);
-                        }
-                    }
-                    ctx.app.addMessage({ role: 'system', content: lines.join('\n') });
+                    ctx.app.addMessage({ role: 'system', content: formatMcpResourceRead(uri, contents) });
                 }
                 catch (err) {
                     ctx.app.addMessage({ role: 'system', content: `Failed to read \`${uri}\`: ${err.message}` });
@@ -2431,23 +2540,7 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                 const { getSessionPrompts, awaitSessionReady } = await import('../utils/mcpRegistry.js');
                 await awaitSessionReady(TUI_SESSION);
                 const groups = await getSessionPrompts(TUI_SESSION);
-                if (groups.length === 0) {
-                    ctx.app.addMessage({ role: 'system', content: '_No MCP server in this session exposes prompt templates._' });
-                    break;
-                }
-                const lines = ['## MCP prompt templates', ''];
-                for (const g of groups) {
-                    lines.push(`**${g.serverName}** — ${g.prompts.length} prompt${g.prompts.length === 1 ? '' : 's'}`);
-                    for (const p of g.prompts) {
-                        const argList = p.arguments?.length
-                            ? ` (${p.arguments.map(a => a.required ? a.name : `[${a.name}]`).join(', ')})`
-                            : '';
-                        lines.push(`- \`${p.name}\`${argList}${p.description ? ` — ${p.description}` : ''}`);
-                    }
-                    lines.push('');
-                }
-                lines.push('Materialise one with `/mcp prompt <server> <name> [key=value...]`.');
-                ctx.app.addMessage({ role: 'system', content: lines.join('\n').trim() });
+                ctx.app.addMessage({ role: 'system', content: formatMcpPromptsList(groups) });
                 break;
             }
             if (sub === 'prompt') {
@@ -2457,25 +2550,11 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                     ctx.app.addMessage({ role: 'system', content: 'Usage: `/mcp prompt <server> <name> [key=value ...]`' });
                     break;
                 }
-                const promptArgs = {};
-                for (const tok of args.slice(3)) {
-                    const eq = tok.indexOf('=');
-                    if (eq > 0)
-                        promptArgs[tok.slice(0, eq)] = tok.slice(eq + 1);
-                }
+                const promptArgs = parsePromptArgs(args.slice(3));
                 const { getSessionPrompt } = await import('../utils/mcpRegistry.js');
                 try {
                     const { description, messages } = await getSessionPrompt(TUI_SESSION, serverName, name, promptArgs);
-                    const lines = [`## Prompt \`${serverName}/${name}\``];
-                    if (description)
-                        lines.push(`_${description}_`);
-                    lines.push('');
-                    for (const m of messages) {
-                        const text = typeof m.content?.text === 'string' ? m.content.text : JSON.stringify(m.content);
-                        lines.push(`**${m.role}:** ${text}`);
-                        lines.push('');
-                    }
-                    ctx.app.addMessage({ role: 'system', content: lines.join('\n').trim() });
+                    ctx.app.addMessage({ role: 'system', content: formatMcpPromptResult(serverName, name, description, messages) });
                 }
                 catch (err) {
                     ctx.app.addMessage({ role: 'system', content: `Failed to materialise prompt: ${err.message}` });
@@ -2487,41 +2566,7 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
             await awaitSessionReady(TUI_SESSION);
             const tools = await getSessionTools(TUI_SESSION);
             const mcpErrors = getSessionRegistrationErrors(TUI_SESSION);
-            if (tools.length === 0 && mcpErrors.length === 0) {
-                ctx.app.addMessage({
-                    role: 'system',
-                    content: [
-                        '_No MCP servers connected to this session._',
-                        '',
-                        'Add one with `/mcp add <name> <command> [args...]` — it persists to `.codeep/mcp_servers.json`.',
-                        'Or browse the marketplace with `/mcp browse` and install with `/mcp install <id>`.',
-                    ].join('\n'),
-                });
-                break;
-            }
-            const lines = ['## MCP servers', ''];
-            if (tools.length > 0) {
-                const byServer = new Map();
-                for (const t of tools) {
-                    if (!byServer.has(t.serverName))
-                        byServer.set(t.serverName, []);
-                    byServer.get(t.serverName).push(t);
-                }
-                for (const [serverName, serverTools] of byServer) {
-                    lines.push(`**${serverName}** — ${serverTools.length} tool${serverTools.length === 1 ? '' : 's'}`);
-                    for (const t of serverTools) {
-                        const desc = t.description ? ` — ${t.description}` : '';
-                        lines.push(`- \`${t.agentName}\`${desc}`);
-                    }
-                    lines.push('');
-                }
-            }
-            if (mcpErrors.length > 0) {
-                lines.push('### Failed servers');
-                for (const e of mcpErrors)
-                    lines.push(`- **${e.server}** — \`${e.error}\``);
-            }
-            ctx.app.addMessage({ role: 'system', content: lines.join('\n').trim() });
+            ctx.app.addMessage({ role: 'system', content: formatMcpServerList(tools, mcpErrors) });
             break;
         }
         default: {