codeep 2.13.2 → 2.15.0

package/dist/renderer/agentExecution.d.ts

@@ -7,6 +7,7 @@
  */
 import { App } from './App';
 import { ProjectContext } from '../utils/project';
+export declare function getActionType(toolName: string): string;
 export interface AppExecutionContext {
     app: App;
     projectPath: string;
@@ -23,7 +24,7 @@ export interface AppExecutionContext {
     formatAddedFilesContext: () => string;
     handleCommand: (command: string, args: string[]) => Promise<void>;
     sessionDisplayName?: string;
-    setSessionDisplayName?: (name: string) => void;
+    setSessionDisplayName?: (name: string | null) => void;
 }
 export declare function isDangerousTool(toolName: string, parameters: Record<string, unknown>): boolean;
 export declare function requestToolConfirmation(app: App, tool: string, parameters: Record<string, unknown>, onConfirm: () => void, onCancel: () => void): void;

package/dist/renderer/agentExecution.js

@@ -10,8 +10,8 @@ import { runAgent } from '../utils/agent.js';
 import { config, autoSaveSession, getCurrentSessionId } from '../config/index.js';
 import { reportStats, syncSession, generateProjectId } from '../utils/codeepCloud.js';
 import { getGitStatus, isGitRepository } from '../utils/git.js';
-import { getCostBreakdown, resetTokenTracking } from '../utils/tokenTracker.js';
-function getActionType(toolName) {
+import { getCostBreakdown, getRecordCount } from '../utils/tokenTracker.js';
+export function getActionType(toolName) {
     return toolName.includes('write') ? 'write' :
         toolName.includes('edit') ? 'edit' :
             toolName.includes('read') ? 'read' :
@@ -27,7 +27,8 @@ export function isDangerousTool(toolName, parameters) {
     const lowerName = toolName.toLowerCase();
     if (DANGEROUS_TOOLS.some(d => lowerName.includes(d)))
         return true;
-    const command = parameters.command || '';
+    const rawCommand = parameters.command;
+    const command = typeof rawCommand === 'string' ? rawCommand : '';
     const dangerousCommands = ['rm ', 'rm -', 'rmdir', 'del ', 'delete', 'drop ', 'truncate'];
     return dangerousCommands.some(c => command.toLowerCase().includes(c));
 }
@@ -140,7 +141,9 @@ export async function executeAgentTask(task, dryRun, ctx) {
     ctx.setAgentRunning(true);
     const abortController = new AbortController();
     ctx.setAbortController(abortController);
-    resetTokenTracking(); // Reset per-run so reportStats sends only this run's tokens
+    // Marker for cloud reporting: report only this run's tokens to the dashboard
+    // without wiping the session-cumulative store the status bar and `/cost` read.
+    const tokenReportStart = getRecordCount();
     const prefix = dryRun ? '[DRY RUN] ' : '[AGENT] ';
     app.addMessage({ role: 'user', content: prefix + task });
     app.setAgentRunning(true);
@@ -378,8 +381,9 @@ export async function executeAgentTask(task, dryRun, ctx) {
             messages: app.getMessages(),
         });
         // Report per-model so tokens are attributed to the correct model/provider
-        // even if the user switched model mid-session.
-        const costBreakdown = getCostBreakdown();
+        // even if the user switched model mid-session. Only this run's delta
+        // (since tokenReportStart) is reported; the cumulative store is preserved.
+        const costBreakdown = getCostBreakdown(tokenReportStart);
         const sharedFields = {
             sessionId,
             sessionName: displayName,

package/dist/renderer/commands/helpers.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Pure helpers extracted from `renderer/commands.ts`.
+ *
+ * The dispatcher is one giant switch/case; many cases contain small but
+ * tricky bits of pure logic (arg parsing, snippet extraction, message
+ * formatting) that were previously untestable because they were inlined
+ * alongside `ctx.app.*` calls. Pulling them here gives them direct unit
+ * coverage.
+ */
+export interface SearchSnippet {
+    role: string;
+    messageIndex: number;
+    matchedText: string;
+}
+/** Snippet window: chars of context before / after the match. */
+export declare const SEARCH_SNIPPET_BEFORE = 30;
+export declare const SEARCH_SNIPPET_AFTER = 50;
+/**
+ * Build search-result snippets for messages matching `term`. Mirrors the
+ * inline loop that used to live in the `/search` case. Case-insensitive.
+ */
+export declare function buildSearchSnippets(messages: Array<{
+    role: string;
+    content: string;
+}>, term: string): SearchSnippet[];
+/**
+ * Parse the `/compact <n>` argument. Returns a value of at least 2
+ * (never compacts below 2 messages); defaults to `fallback` when the arg
+ * is missing or unparseable.
+ *
+ * Note: we use `Number.isNaN` rather than `parsed || fallback` because
+ * `0` is a valid (if useless) numeric input that should clamp to 2, not
+ * silently fall through to the default.
+ */
+export declare function parseKeepRecent(arg: string | undefined, fallback?: number): number;
+/**
+ * Join slash-command args into a single hyphen-separated name, as used by
+ * `/rename`. Empty args are dropped so `/rename  my  session ` still
+ * yields `my-session`.
+ */
+export declare function joinSessionName(args: string[]): string;
+export declare const TASK_TYPES: readonly ["task", "bug", "feature"];
+export type TaskType = (typeof TASK_TYPES)[number];
+/** Result of parsing `/tasks add` flags. */
+export interface ParsedTaskAdd {
+    title: string;
+    description: string;
+    type: TaskType;
+}
+/**
+ * Parse the args following `/tasks add` into a title, description, and
+ * type. Flags (`--bug`, `--feature`, `--task`) set the type; `--desc` /
+ * `--description` captures the following words until the next flag.
+ * Non-flag words before any `--desc` form the title.
+ */
+export declare function parseTaskAddArgs(args: string[]): ParsedTaskAdd;
+/** Render a list of tasks as a Markdown list, mirroring `/tasks`. */
+export declare function formatTaskList(tasks: Array<{
+    title: string;
+    type?: string | null;
+    description?: string | null;
+    project_name?: string | null;
+}>, scopeProjectName?: string): string;

package/dist/renderer/commands/helpers.js

@@ -0,0 +1,108 @@
+/**
+ * Pure helpers extracted from `renderer/commands.ts`.
+ *
+ * The dispatcher is one giant switch/case; many cases contain small but
+ * tricky bits of pure logic (arg parsing, snippet extraction, message
+ * formatting) that were previously untestable because they were inlined
+ * alongside `ctx.app.*` calls. Pulling them here gives them direct unit
+ * coverage.
+ */
+/** Snippet window: chars of context before / after the match. */
+export const SEARCH_SNIPPET_BEFORE = 30;
+export const SEARCH_SNIPPET_AFTER = 50;
+/**
+ * Build search-result snippets for messages matching `term`. Mirrors the
+ * inline loop that used to live in the `/search` case. Case-insensitive.
+ */
+export function buildSearchSnippets(messages, term) {
+    const lowerTerm = term.toLowerCase();
+    const results = [];
+    messages.forEach((m, index) => {
+        const lowerContent = m.content.toLowerCase();
+        if (!lowerContent.includes(lowerTerm))
+            return;
+        const matchIdx = lowerContent.indexOf(lowerTerm);
+        const matchStart = Math.max(0, matchIdx - SEARCH_SNIPPET_BEFORE);
+        const matchEnd = Math.min(m.content.length, matchIdx + lowerTerm.length + SEARCH_SNIPPET_AFTER);
+        const matchedText = (matchStart > 0 ? '...' : '') +
+            m.content.slice(matchStart, matchEnd).replace(/\n/g, ' ') +
+            (matchEnd < m.content.length ? '...' : '');
+        results.push({ role: m.role, messageIndex: index, matchedText });
+    });
+    return results;
+}
+// ─── Argument parsing ─────────────────────────────────────────────────────────
+/**
+ * Parse the `/compact <n>` argument. Returns a value of at least 2
+ * (never compacts below 2 messages); defaults to `fallback` when the arg
+ * is missing or unparseable.
+ *
+ * Note: we use `Number.isNaN` rather than `parsed || fallback` because
+ * `0` is a valid (if useless) numeric input that should clamp to 2, not
+ * silently fall through to the default.
+ */
+export function parseKeepRecent(arg, fallback = 4) {
+    if (!arg)
+        return fallback;
+    const parsed = parseInt(arg, 10);
+    return Math.max(2, Number.isNaN(parsed) ? fallback : parsed);
+}
+/**
+ * Join slash-command args into a single hyphen-separated name, as used by
+ * `/rename`. Empty args are dropped so `/rename  my  session ` still
+ * yields `my-session`.
+ */
+export function joinSessionName(args) {
+    return args.filter((a) => a.length > 0).join('-');
+}
+// ─── /tasks helpers ───────────────────────────────────────────────────────────
+export const TASK_TYPES = ['task', 'bug', 'feature'];
+/**
+ * Parse the args following `/tasks add` into a title, description, and
+ * type. Flags (`--bug`, `--feature`, `--task`) set the type; `--desc` /
+ * `--description` captures the following words until the next flag.
+ * Non-flag words before any `--desc` form the title.
+ */
+export function parseTaskAddArgs(args) {
+    let type = 'task';
+    const titleWords = [];
+    const descWords = [];
+    let capturingDesc = false;
+    for (const w of args) {
+        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);
+    }
+    return {
+        title: titleWords.join(' ').trim(),
+        description: descWords.join(' ').trim(),
+        type,
+    };
+}
+/** Icon/badge for a task type, used in list rendering. */
+const TYPE_ICON = { bug: '[bug]', feature: '[feature]', task: '[task]' };
+/** Render a list of tasks as a Markdown list, mirroring `/tasks`. */
+export function formatTaskList(tasks, scopeProjectName) {
+    const lines = [`## Tasks${scopeProjectName ? ` — ${scopeProjectName}` : ''}`, ''];
+    tasks.forEach((t, i) => {
+        const icon = TYPE_ICON[t.type ?? 'task'] ?? '[task]';
+        const proj = !scopeProjectName && 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.*');
+    return lines.join('\n');
+}

package/dist/renderer/commands/registry.js

@@ -87,6 +87,11 @@ export const COMMANDS = [
         category: 'sessions',
         usage: ['<query>', '<query> --resume', '<query> --summarize'],
     },
+    {
+        name: 'cloud',
+        description: 'List and resume sessions synced from other devices',
+        category: 'sessions',
+    },
     { name: 'export', description: 'Export chat', category: 'sessions', usage: ['[md|json|txt]'] },
     { name: 'compact', description: 'AI-summarize older messages to free up context (keeps last N)', category: 'sessions', usage: ['[keepN]'] },
     // ── checkpoints ────────────────────────────────────────────────────────────

package/dist/renderer/commands.d.ts

@@ -13,4 +13,8 @@ export interface AppCommandContext extends AppExecutionContext {
     setProjectContext: (ctx: ReturnType<typeof getProjectContext>) => void;
     setHasWriteAccess: (v: boolean) => void;
 }
+/**
+ * Returns a hint for an Ollama model name based on parameter count.
+ * Models ≥7B are suitable for agent mode; smaller ones are chat-only.
+ */
 export declare function handleCommand(command: string, args: string[], ctx: AppCommandContext): Promise<void>;

package/dist/renderer/commands.js

@@ -12,22 +12,13 @@ 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 } from './commands/helpers.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) {
     // Handle skill chaining (e.g., /commit+push)
@@ -676,9 +667,155 @@ 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;
+            // Render each row as: title · date · N msg · [project?]
+            // Mirrors the /sessions list layout so the picker feels familiar.
+            const SHOW_ALL = 'Show all cloud sessions…';
+            const labels = summaries.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}`;
+            });
+            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());
+            // Clear the derived display name so the next chat re-derives it — else
+            // the new session syncs/reports under the PREVIOUS session's name.
+            ctx.setSessionDisplayName?.(null);
             ctx.app.notify('New session started');
             break;
         }
@@ -826,7 +963,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.');
@@ -862,18 +999,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}"`);
             }
@@ -1071,7 +1197,7 @@ Format: use headers per category, only include categories where you found issues
                 return;
             }
             const index = blockNum === -1 ? codeBlocks.length - 1 : blockNum - 1;
-            if (index < 0 || index >= codeBlocks.length) {
+            if (Number.isNaN(index) || index < 0 || index >= codeBlocks.length) {
                 ctx.app.notify(`Invalid block number. Available: 1-${codeBlocks.length}`);
                 return;
             }
@@ -1299,7 +1425,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;
@@ -1891,31 +2017,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;
@@ -1960,18 +2062,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': {
@@ -2248,8 +2339,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;

package/dist/renderer/components/ActionFormatting.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Colour per action kind. Falls back to plain white for unknown kinds so
+ * a new tool type degrades gracefully (visible, just uncoloured) instead
+ * of throwing.
+ */
+export declare function getActionColor(type: string): string;
+/**
+ * Shorten a file path for single-line display. Paths with 3+ segments
+ * keep their last two (parent dir + filename); longer paths get a leading
+ * `...`. The result is capped to `maxLen`, truncating from the left.
+ */
+export declare function formatActionTarget(target: string, maxLen: number): string;
+/**
+ * Present-tense label for an action kind. Falls back to the raw `type`
+ * for unknown kinds.
+ */
+export declare function getActionLabel(type: string): string;

package/dist/renderer/components/ActionFormatting.js

@@ -0,0 +1,67 @@
+/**
+ * Action display helpers for the agent progress panel.
+ *
+ * Pure functions extracted from `App.ts` so they can be unit-tested in
+ * isolation. `getActionColor` / `getActionLabel` map an action `type`
+ * (read/write/edit/delete/command/...) to its colour and present-tense
+ * label; `formatActionTarget` shortens a file path to fit a column.
+ */
+import { fg } from '../ansi.js';
+/**
+ * Colour per action kind. Falls back to plain white for unknown kinds so
+ * a new tool type degrades gracefully (visible, just uncoloured) instead
+ * of throwing.
+ */
+export function getActionColor(type) {
+    const colors = {
+        'read': fg.blue,
+        'write': fg.green,
+        'edit': fg.yellow,
+        'delete': fg.red,
+        'command': fg.magenta,
+        'search': fg.cyan,
+        'list': fg.white,
+        'mkdir': fg.blue,
+        'fetch': fg.cyan,
+    };
+    return colors[type] || fg.white;
+}
+/**
+ * Shorten a file path for single-line display. Paths with 3+ segments
+ * keep their last two (parent dir + filename); longer paths get a leading
+ * `...`. The result is capped to `maxLen`, truncating from the left.
+ */
+export function formatActionTarget(target, maxLen) {
+    if (target.includes('/')) {
+        const parts = target.split('/');
+        const filename = parts[parts.length - 1];
+        if (parts.length > 2) {
+            const short = `.../${parts[parts.length - 2]}/${filename}`;
+            if (short.length <= maxLen)
+                return short;
+            // Still too long: keep the filename and RE-ADD the `...` marker —
+            // a bare slice from the right would cut the marker mid-way and the
+            // result would no longer signal that it was truncated.
+            return '...' + short.slice(-(maxLen - 3));
+        }
+    }
+    return target.length > maxLen ? '...' + target.slice(-(maxLen - 3)) : target;
+}
+/**
+ * Present-tense label for an action kind. Falls back to the raw `type`
+ * for unknown kinds.
+ */
+export function getActionLabel(type) {
+    const labels = {
+        'read': 'Reading',
+        'write': 'Creating',
+        'edit': 'Editing',
+        'delete': 'Deleting',
+        'command': 'Running',
+        'search': 'Searching',
+        'list': 'Listing',
+        'mkdir': 'Creating dir',
+        'fetch': 'Fetching',
+    };
+    return labels[type] || type;
+}