codeep 3.3.3 → 3.4.1

package/dist/renderer/agentExecution.js

@@ -14,10 +14,14 @@ import { takeRunFromPhone } from '../utils/telegramInbox.js';
 import { isFlatFeeProvider } from '../config/providers.js';
 import { raceApproval } from '../utils/approvalRace.js';
 import { describeAuditTarget } from '../utils/auditLog.js';
+import { trustBearingWrite, forgetHooksDirectory } from '../utils/toolExecution.js';
+import { shellCommandEnv } from '../utils/shell.js';
+import { charWidth } from './ansi.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, getRecordCount } from '../utils/tokenTracker.js';
+import { createFileDiff, createEditDiff, formatDiffForDisplay } from '../utils/diffPreview.js';
 export function getActionType(toolName) {
     return toolName.includes('write') ? 'write' :
         toolName.includes('edit') ? 'edit' :
@@ -44,7 +48,8 @@ export function requestToolConfirmation(app, tool, parameters, onConfirm, onCanc
         parameters.command ||
         parameters.pattern ||
         'unknown';
-    const shortTarget = target.length > 50 ? '...' + target.slice(-47) : target;
+    const safeTarget = showControls(target);
+    const shortTarget = safeTarget.length > 50 ? '...' + safeTarget.slice(-47) : safeTarget;
     app.showConfirm({
         title: '⚠️  Confirm Action',
         message: [
@@ -61,19 +66,77 @@ export function requestToolConfirmation(app, tool, parameters, onConfirm, onCanc
         onCancel,
     });
 }
-// ─── Agent task execution ─────────────────────────────────────────────────────
-export async function runAgentTask(task, dryRun, ctx, getPendingInteractive, setPendingInteractive) {
+/**
+ * Model-written text shown in a permission dialog, with every character that
+ * could change how the rest of it looks spelled out: an ESC sequence would be
+ * read as a style (conceal, black on black) and a bidi override or zero-width
+ * character reorders or hides text, so the user could approve a command they
+ * were not shown. Newlines are left for the caller to lay out.
+ */
+export function showControls(text) {
+    return text.replace(/[\x00-\x09\x0b-\x1f\x7f-\x9f\u200b-\u200f\u2028-\u202e\u2060-\u2069\ufeff]/g, (c) => {
+        const code = c.charCodeAt(0);
+        return code <= 0xff ? `\\x${code.toString(16).padStart(2, '0')}` : `\\u${code.toString(16).padStart(4, '0')}`;
+    });
+}
+/**
+ * The target of a tool call as dialog lines, each `width` terminal columns at
+ * most. Shown whole where it fits: an MCP call's arguments or a long command
+ * matter from the first character. Past `maxLines` the middle gives way, and a
+ * line says how much of it is not shown.
+ */
+export function wrapConfirmTarget(target, width, maxLines = 6) {
+    const w = Math.max(20, Math.floor(width));
+    const lines = [];
+    for (const part of target.split(/\r?\n/)) {
+        const text = showControls(part);
+        if (text.length === 0) {
+            lines.push('');
+            continue;
+        }
+        // By columns, not UTF-16 units: the screen drops what passes the edge, so
+        // a line of wide characters cut by length would lose its end unmarked.
+        // Iterating code points also keeps a surrogate pair whole.
+        let line = '';
+        let cols = 0;
+        for (const ch of text) {
+            const cw = charWidth(ch);
+            if (cols + cw > w && line) {
+                lines.push(line);
+                line = '';
+                cols = 0;
+            }
+            line += ch;
+            cols += cw;
+        }
+        lines.push(line);
+    }
+    const max = Math.max(3, maxLines);
+    if (lines.length <= max)
+        return lines;
+    const hidden = lines.length - (max - 1);
+    return [...lines.slice(0, max - 2), `… ${hidden} more line${hidden === 1 ? '' : 's'} …`, lines[lines.length - 1]];
+}
+export async function runAgentTask(task, dryRun, ctx, getPendingInteractive, setPendingInteractive, opts = {}) {
     const { app, projectContext } = ctx;
+    const notStarted = () => opts.onFinished?.('not-started');
+    // executeAgentTask catches its own errors, so this always settles.
+    const execute = () => {
+        void executeAgentTask(task, dryRun, ctx).then(outcome => opts.onFinished?.(outcome));
+    };
     if (!projectContext) {
         app.notify('Agent requires project context');
+        notStarted();
         return;
     }
     if (!ctx.hasWriteAccess && !dryRun) {
         app.notify('Agent requires write access. Use /grant first.');
+        notStarted();
         return;
     }
     if (ctx.isAgentRunning()) {
         app.notify('Agent already running. Use /stop to cancel.');
+        notStarted();
         return;
     }
     const interactiveMode = config.get('agentInteractive') !== false;
@@ -84,12 +147,13 @@ export async function runAgentTask(task, dryRun, ctx, getPendingInteractive, set
             setPendingInteractive({ originalTask: task, context: interactiveContext, dryRun });
             app.addMessage({ role: 'assistant', content: formatQuestions(interactiveContext) });
             app.notify('Answer questions or type "proceed" to continue');
+            notStarted();
             return;
         }
     }
     const confirmationMode = config.get('agentConfirmation') || 'dangerous';
     if (confirmationMode === 'never' || dryRun) {
-        executeAgentTask(task, dryRun, ctx);
+        execute();
         return;
     }
     if (confirmationMode === 'always') {
@@ -106,8 +170,8 @@ export async function runAgentTask(task, dryRun, ctx, getPendingInteractive, set
             ],
             confirmLabel: 'Run Agent',
             cancelLabel: 'Cancel',
-            onConfirm: () => executeAgentTask(task, dryRun, ctx),
-            onCancel: () => app.notify('Agent task cancelled'),
+            onConfirm: execute,
+            onCancel: () => { app.notify('Agent task cancelled'); notStarted(); },
         });
         return;
     }
@@ -127,34 +191,40 @@ export async function runAgentTask(task, dryRun, ctx, getPendingInteractive, set
             ],
             confirmLabel: 'Proceed',
             cancelLabel: 'Cancel',
-            onConfirm: () => executeAgentTask(task, dryRun, ctx),
-            onCancel: () => app.notify('Agent task cancelled'),
+            onConfirm: execute,
+            onCancel: () => { app.notify('Agent task cancelled'); notStarted(); },
         });
         return;
     }
-    executeAgentTask(task, dryRun, ctx);
+    execute();
 }
 export async function executeAgentTask(task, dryRun, ctx) {
     const { app, projectContext } = ctx;
     if (!projectContext) {
         app.notify('Agent requires project context');
-        return;
+        return 'not-started';
     }
     // Guard against concurrent execution — set flag immediately before any await
     if (ctx.isAgentRunning()) {
         app.notify('Agent already running. Use /stop to cancel.');
-        return;
+        return 'not-started';
     }
     ctx.setAgentRunning(true);
     const abortController = new AbortController();
     ctx.setAbortController(abortController);
+    // Read once, at the start: by the time the run ends the global id may name
+    // another conversation.
+    const sessionId = ctx.sessionId || getCurrentSessionId();
     // 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 });
+    // Kept by reference: while it is on screen, so is this run's conversation.
+    const runMessage = { role: 'user', content: prefix + task };
+    app.addMessage(runMessage);
     app.setAgentRunning(true);
     const context = projectContext;
+    let outcome = 'failed';
     try {
         const fileContext = ctx.formatAddedFilesContext();
         const enrichedTask = fileContext ? fileContext + task : task;
@@ -162,78 +232,104 @@ export async function executeAgentTask(task, dryRun, ctx) {
         const rawIterations = config.get('agentMaxIterations') || 50;
         app.setAgentMaxIterations(Math.max(5, rawIterations));
         const confirmationMode = config.get('agentConfirmation') || 'dangerous';
+        // 'always' asks before every action that changes something: at least what
+        // 'dangerous' asks about, plus writes, edits and new directories.
+        const asksPerTool = confirmationMode === 'dangerous' || confirmationMode === 'always';
         // Read the Telegram credentials once for the whole run rather than per tool
         // call: they come from the OS keychain, and paying that on every dangerous
-        // tool would put a keychain round-trip in front of each confirmation.
-        // Null means the feature is off or half-configured, and the terminal is
-        // then the only place the question appears — exactly as before.
-        const telegramCredentials = confirmationMode === 'dangerous'
-            ? await loadTelegramCredentials()
-            : null;
-        // The finish notice does not depend on the confirmation mode — a run with
-        // confirmations off is exactly the one you are most likely to walk away
-        // from. Reuse the credentials already read above when there are any, so
-        // this costs a second keychain round-trip only when there are not.
-        const noticeCredentials = telegramCredentials ?? await loadTelegramCredentials();
+        // tool would put a keychain round-trip in front of each confirmation. Read
+        // in every mode, for the finish notice — and because 'never' now asks
+        // about a file that decides what runs later, which is exactly the kind of
+        // run someone has walked away from. Null means the feature is off or
+        // half-configured, and the terminal is then the only place the question
+        // appears — exactly as before.
+        const telegramCredentials = await loadTelegramCredentials();
         const runStartedAt = Date.now();
-        const onRequestPermission = confirmationMode === 'dangerous'
-            ? async (toolCall) => {
-                // `parameters.command` is the binary alone — `git`, not `git status`.
-                // Showing that asks someone to approve a command they have not been
-                // shown, which is the one thing this gate must not do. The audit
-                // record already joins the binary with its arguments; reuse it rather
-                // than writing a second, subtly different answer.
-                const target = describeAuditTarget(toolCall);
-                const shortTarget = target.length > 50 ? '...' + target.slice(-47) : target;
-                const inTerminal = {
-                    answer: new Promise((resolve) => {
-                        app.showConfirm({
-                            title: '⚠️  Confirm Action',
-                            message: [
-                                'The agent wants to execute:',
-                                '',
-                                `  ${toolCall.tool}`,
-                                `  ${shortTarget}`,
-                                '',
-                                telegramCredentials ? 'Allow this action? (or answer on Telegram)' : 'Allow this action?',
-                            ],
-                            confirmLabel: 'Allow',
-                            cancelLabel: 'Deny',
-                            extraOption: { label: 'Always Allow', onSelect: () => resolve('allow_always') },
-                            onConfirm: () => resolve('allow_once'),
-                            onCancel: () => resolve('reject_always'),
-                        });
-                    }),
-                    // Answered on the phone: take the dialog down without running either
-                    // callback, since the decision is already made and taken.
-                    withdraw: (winner) => app.dismissConfirm(`Answered on Telegram — ${winner}.`),
+        // 'never' still gets a callback. A write to a file that decides what runs
+        // later — `.git/config`, a hook, an MCP server list — is asked about in
+        // every mode (the agent gate decides which calls those are), and "never
+        // ask" is then answered here for everything else, exactly as before:
+        // without a callback the agent would have to refuse those writes instead.
+        const onRequestPermission = async (toolCall, 
+        // What the agent gate already worked out about this call, passed rather
+        // than worked out twice: trustBearingWrite() stats the path, resolves a
+        // symlinked ancestor and may ask git where this repo keeps its hooks.
+        // Undefined means the question came from somewhere that has not looked
+        // — a skill's shell line asks through this same callback — so it is
+        // only then that this side looks for itself. `null` is an answer.
+        known) => {
+            const trustBearing = known !== undefined ? known : trustBearingWrite(toolCall, context.root || process.cwd());
+            if (!asksPerTool && !trustBearing)
+                return 'allow_once';
+            // `parameters.command` is the binary alone — `git`, not `git status`.
+            // Showing that asks someone to approve a command they have not been
+            // shown, which is the one thing this gate must not do. The audit
+            // record already joins the binary with its arguments; reuse it rather
+            // than writing a second, subtly different answer.
+            const target = describeAuditTarget(toolCall);
+            // Indented by two in the dialog.
+            const targetLines = wrapConfirmTarget(target, (process.stdout.columns || 80) - 4)
+                .map(line => `  ${line}`);
+            const inTerminal = {
+                answer: new Promise((resolve) => {
+                    app.showConfirm({
+                        title: '⚠️  Confirm Action',
+                        message: [
+                            'The agent wants to execute:',
+                            '',
+                            `  ${showControls(toolCall.tool)}`,
+                            ...targetLines,
+                            // What the file does, not that it is "sensitive": someone
+                            // deciding in one second needs the consequence, not a label.
+                            ...(trustBearing ? ['', ...wrapConfirmTarget(`⚠️  ${trustBearing.reason}`, (process.stdout.columns || 80) - 4)] : []),
+                            '',
+                            telegramCredentials ? 'Allow this action? (or answer on Telegram)' : 'Allow this action?',
+                        ],
+                        confirmLabel: 'Allow',
+                        cancelLabel: 'Deny',
+                        // No "Always Allow" for one of those files: the agent answers
+                        // about this file only and would not remember it anyway.
+                        extraOption: trustBearing ? undefined : { label: 'Always Allow', onSelect: () => resolve('allow_always') },
+                        onConfirm: () => resolve('allow_once'),
+                        // The one "no" there is, and it answers reject_always. For one of
+                        // those files the agent remembers that against the FILE rather
+                        // than the tool, so refusing a `.git/config` prompt does not also
+                        // switch delete_file off for the rest of the run.
+                        onCancel: () => resolve('reject_always'),
+                    });
+                }),
+                // Answered on the phone: take the dialog down without running either
+                // callback, since the decision is already made and taken.
+                withdraw: (winner) => app.dismissConfirm(`Answered on Telegram — ${winner}.`),
+            };
+            let onPhone = null;
+            if (telegramCredentials) {
+                // Report a failure to *ask* once, in the terminal. Without this a
+                // wrong chat id looks exactly like a phone nobody picked up.
+                const telegram = new TelegramApproval(telegramCredentials, reason => app.notifyWarn(`Telegram: ${reason}`));
+                onPhone = {
+                    answer: telegram
+                        // The reason goes with it: a phone showing less than the terminal
+                        // asks for a decision on less than the terminal had.
+                        .ask(target, toolCall.tool, true, undefined, trustBearing?.reason)
+                        .then(answer => (answer ? outcomeForAnswer(answer) : null))
+                        // A phone that cannot be reached is not a denial. Step aside and
+                        // let the terminal decide, however long that takes.
+                        .catch(() => null),
+                    withdraw: (winner) => telegram.withdraw(winner),
                 };
-                let onPhone = null;
-                if (telegramCredentials) {
-                    // Report a failure to *ask* once, in the terminal. Without this a
-                    // wrong chat id looks exactly like a phone nobody picked up.
-                    const telegram = new TelegramApproval(telegramCredentials, reason => app.notifyWarn(`Telegram: ${reason}`));
-                    onPhone = {
-                        answer: telegram
-                            .ask(target, toolCall.tool, true)
-                            .then(answer => (answer ? outcomeForAnswer(answer) : null))
-                            // A phone that cannot be reached is not a denial. Step aside and
-                            // let the terminal decide, however long that takes.
-                            .catch(() => null),
-                        withdraw: (winner) => telegram.withdraw(winner),
-                    };
-                }
-                const { answer } = await raceApproval(inTerminal, onPhone, outcome => describePermissionOutcome(outcome));
-                // Nobody answered — neither side could even ask. `classifyPermissionOutcome`
-                // fails closed on anything it does not recognise, and this is spelled
-                // out rather than left to that: a question that was never put must
-                // never read as a yes.
-                return answer ?? 'reject_once';
             }
-            : undefined;
+            const { answer } = await raceApproval(inTerminal, onPhone, outcome => describePermissionOutcome(outcome));
+            // Nobody answered — neither side could even ask. `classifyPermissionOutcome`
+            // fails closed on anything it does not recognise, and this is spelled
+            // out rather than left to that: a question that was never put must
+            // never read as a yes.
+            return answer ?? 'reject_once';
+        };
         const result = await runAgent(enrichedTask, context, {
             dryRun,
             onRequestPermission,
+            extraDangerousTools: confirmationMode === 'always' ? ['write_file', 'edit_file', 'delete_file', 'execute_command', 'create_directory'] : undefined,
             chatHistory: app.getChatHistory(),
             // Route MCP-prefixed tool calls through the shared TUI session id.
             // Servers were registered against this id at app startup (see
@@ -269,7 +365,6 @@ export async function executeAgentTask(task, dryRun, ctx) {
                 if (actionType === 'write' && tool.parameters.content) {
                     const filePath = tool.parameters.path;
                     try {
-                        const { createFileDiff, formatDiffForDisplay } = require('../utils/diffPreview');
                         const diff = createFileDiff(filePath, tool.parameters.content, context.root);
                         const diffText = formatDiffForDisplay(diff);
                         const additions = diff.hunks.reduce((sum, h) => sum + h.lines.filter((l) => l.type === 'add').length, 0);
@@ -290,7 +385,6 @@ export async function executeAgentTask(task, dryRun, ctx) {
                 else if (actionType === 'edit' && tool.parameters.new_text) {
                     const filePath = tool.parameters.path;
                     try {
-                        const { createEditDiff, formatDiffForDisplay } = require('../utils/diffPreview');
                         const diff = createEditDiff(filePath, tool.parameters.old_text, tool.parameters.new_text, context.root);
                         if (diff) {
                             const additions = diff.hunks.reduce((sum, h) => sum + h.lines.filter((l) => l.type === 'add').length, 0);
@@ -343,6 +437,10 @@ export async function executeAgentTask(task, dryRun, ctx) {
         ctx.setAgentRunning(false);
         ctx.setAbortController(null);
         app.setAgentRunning(false);
+        outcome = result.success ? 'success'
+            : result.aborted ? 'aborted'
+                : result.interrupted ? 'interrupted'
+                    : 'failed';
         if (result.success) {
             const fileChanges = result.actions.filter(a => a.type === 'write' || a.type === 'edit' || a.type === 'delete');
             const otherActions = result.actions.filter(a => a.type !== 'write' && a.type !== 'edit' && a.type !== 'delete');
@@ -416,10 +514,23 @@ export async function executeAgentTask(task, dryRun, ctx) {
                 app.addMessage({ role: 'assistant', content: `Agent could not complete the task: ${result.error || 'Unknown error'}` });
             }
         }
-        autoSaveSession(app.getMessages(), ctx.projectPath);
+        // The messages on screen belong to whatever conversation is on screen.
+        // If the user moved to another one while the run was finishing, saving
+        // them under this run's id would replace that conversation's file with
+        // the new one's contents; the terminal saves the new one itself.
+        const switched = ctx.getSessionId !== undefined && ctx.getSessionId() !== sessionId;
+        if (!switched) {
+            autoSaveSession(app.getMessages(), ctx.projectPath, sessionId);
+        }
+        else if (app.getMessages().includes(runMessage)) {
+            // /rename: the same conversation, still on screen, under its new id.
+            // /new, /sessions and the other loads replace the messages, so a run
+            // left behind by one of those never gets here. (Whether the old file
+            // is gone says nothing: a case-only rename keeps it on macOS.)
+            autoSaveSession(app.getMessages(), ctx.projectPath, ctx.getSessionId());
+        }
         // Report stats to codeep.dev (fire-and-forget, only if github_id is set)
         const { getCurrentVersion } = await import('../utils/update.js');
-        const sessionId = getCurrentSessionId();
         // Auto-name from the task if no display name is set yet.
         //
         // The derived name is kept in a local rather than read back off ctx.
@@ -441,17 +552,22 @@ export async function executeAgentTask(task, dryRun, ctx) {
         let displayName = ctx.sessionDisplayName;
         if (!displayName) {
             displayName = shortLabel(task);
-            ctx.setSessionDisplayName?.(displayName);
+            // Naming the conversation on screen after this run would be wrong
+            // once it is a different one.
+            if (!switched)
+                ctx.setSessionDisplayName?.(displayName);
         }
         if (!displayName)
             displayName = sessionId;
-        syncSession({
-            sessionId,
-            sessionName: displayName,
-            projectName: ctx.projectContext?.name,
-            projectId: ctx.projectPath ? generateProjectId(ctx.projectPath) : undefined,
-            messages: app.getMessages(),
-        });
+        if (!switched) {
+            syncSession({
+                sessionId,
+                sessionName: displayName,
+                projectName: ctx.projectContext?.name,
+                projectId: ctx.projectPath ? generateProjectId(ctx.projectPath) : undefined,
+                messages: app.getMessages(),
+            });
+        }
         // Report per-model so tokens are attributed to the correct model/provider
         // even if the user switched model mid-session. Only this run's delta
         // (since tokenReportStart) is reported; the cumulative store is preserved.
@@ -464,7 +580,7 @@ export async function executeAgentTask(task, dryRun, ctx) {
         // Told once the run is over, and only when it ran long enough that you
         // could plausibly have stopped watching. Awaited so the process does not
         // exit from under the request, but never allowed to fail the run.
-        if (noticeCredentials) {
+        if (telegramCredentials) {
             const elapsedMs = Date.now() - runStartedAt;
             const fromPhone = startedFromPhone;
             // The one-minute threshold exists so a phone is not buzzed about work you
@@ -484,7 +600,7 @@ export async function executeAgentTask(task, dryRun, ctx) {
                     costUsd: payPerUse.reduce((sum, e) => sum + e.estimatedCost, 0),
                 });
                 for (const message of messages) {
-                    await sendTelegramNotice(noticeCredentials, message).catch(() => false);
+                    await sendTelegramNotice(telegramCredentials, message).catch(() => false);
                 }
             }
         }
@@ -527,6 +643,7 @@ export async function executeAgentTask(task, dryRun, ctx) {
     }
     catch (error) {
         const err = error;
+        outcome = 'failed';
         app.addMessage({ role: 'assistant', content: `Agent error: ${err.message}` });
         app.notify(`Agent error: ${err.message}`, 5000);
     }
@@ -537,6 +654,7 @@ export async function executeAgentTask(task, dryRun, ctx) {
         app.setAgentRunning(false);
         app.render();
     }
+    return outcome;
 }
 // ─── Skill execution ──────────────────────────────────────────────────────────
 export async function runSkill(nameOrShortcut, args, ctx) {
@@ -561,12 +679,37 @@ export async function runSkill(nameOrShortcut, args, ctx) {
     try {
         const result = await executeSkill(skill, params, {
             onCommand: async (cmd) => {
+                const cwd = ctx.projectPath || process.cwd();
+                // A raw process.env here handed the repository's own `.git/config`
+                // back to git: `/commit` runs `git commit`, and a repo-scope
+                // `gpg.program` that Codeep's own commit path neutralises executed
+                // through this spawn instead.
+                //
+                // Built before the spawn, and caught: shellCommandEnv() refuses a git
+                // line in a repository whose config names a program no override
+                // switches off, and a refusal escaping here would abort the whole
+                // skill rather than fail the step that asked for git. A step that
+                // cannot run is reported the same way a step that failed is.
+                let env;
+                try {
+                    env = shellCommandEnv(cmd, cwd);
+                }
+                catch (error) {
+                    const why = error instanceof Error ? error.message : String(error);
+                    ctx.app.addMessage({ role: 'system', content: `\`${cmd}\` was not run:\n\`\`\`\n${why}\n\`\`\`` });
+                    throw new Error(why);
+                }
+                // A command line is the one thing in a skill that can move this
+                // repository's hooks (`git config core.hooksPath .evil`), and the
+                // write gate caches where they are for the run.
+                forgetHooksDirectory();
                 const proc = spawnSync(cmd, {
-                    cwd: ctx.projectPath || process.cwd(),
+                    cwd,
                     encoding: 'utf-8',
                     timeout: 60000,
                     shell: true,
                     stdio: ['pipe', 'pipe', 'pipe'],
+                    env,
                 });
                 const stdout = (proc.stdout || '').trim();
                 const stderr = (proc.stderr || '').trim();
@@ -604,7 +747,20 @@ export async function runSkill(nameOrShortcut, args, ctx) {
                         reject(new Error('Agent requires project context'));
                         return;
                     }
-                    executeAgentTask(task, false, ctx).then(() => resolve('Agent completed')).catch(reject);
+                    // A later step (commit, push, deploy) must not run after an agent
+                    // step that failed, was stopped or left checks failing.
+                    executeAgentTask(task, false, ctx).then((outcome) => {
+                        if (outcome === 'success') {
+                            resolve('Agent completed');
+                        }
+                        else if (outcome === 'aborted') {
+                            // The wording runSkill already treats as the user's own stop.
+                            reject(new Error('Cancelled by user'));
+                        }
+                        else {
+                            reject(new Error(outcome === 'not-started' ? 'Agent step did not run' : 'Agent step did not finish successfully'));
+                        }
+                    }).catch(reject);
                 });
             },
             onConfirm: (message) => {

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

@@ -7,6 +7,7 @@
  * alongside `ctx.app.*` calls. Pulling them here gives them direct unit
  * coverage.
  */
+import type { SyncFailure, SyncResult } from '../../utils/codeepCloud';
 export interface SearchSnippet {
     role: string;
     messageIndex: number;
@@ -230,8 +231,23 @@ export declare function formatCloudSessionLabel(s: {
     messageCount: number;
     projectName?: string | null;
 }): string;
-/** Format the `/me sync` result list. `pulled` is `1` on success, `0` or `null` otherwise. */
-export declare function formatMeSyncReport(pushed: boolean, pulled: number | null): string;
+/**
+ * Format the `/me sync` result list. For both results `count` is 1 when the
+ * profile moved and 0 when there was nothing to move (no local profile to
+ * push; nothing new to pull). `describe` turns a failure into a sentence —
+ * codeepCloud's describeSyncFailure, passed in so this module stays free of
+ * the config it loads.
+ */
+export declare function formatMeSyncReport(pushed: SyncResult, pulled: SyncResult, describe: (reason: SyncFailure) => string): string;
+/**
+ * Format what `/undo-all` did, one line per action. The results mix restored
+ * files with actions that cannot be undone (a shell command), so a count of
+ * them says nothing about how much was put back.
+ */
+export declare function formatUndoAllReport(result: {
+    success: boolean;
+    results: string[];
+}): string;
 /**
  * Format the `/me learn` result. `updated` distinguishes "new facts written"
  * from "already covered"; `file` is the human-readable path.

package/dist/renderer/commands/helpers.js

@@ -426,17 +426,40 @@ export function formatCloudSessionLabel(s) {
     return `${title}  ·  ${date} · ${s.messageCount} msg${projectTag}`;
 }
 // ─── /me sync + learn + init formatters ───────────────────────────────────────
-/** Format the `/me sync` result list. `pulled` is `1` on success, `0` or `null` otherwise. */
-export function formatMeSyncReport(pushed, pulled) {
+/**
+ * Format the `/me sync` result list. For both results `count` is 1 when the
+ * profile moved and 0 when there was nothing to move (no local profile to
+ * push; nothing new to pull). `describe` turns a failure into a sentence —
+ * codeepCloud's describeSyncFailure, passed in so this module stays free of
+ * the config it loads.
+ */
+export function formatMeSyncReport(pushed, pulled, describe) {
     const lines = [];
-    if (pushed)
+    if (!pushed.ok)
+        lines.push(`✗ Could not push your profile to the dashboard — ${describe(pushed.reason)}`);
+    else if (pushed.count > 0)
         lines.push('✓ Profile pushed to the dashboard');
-    if (pulled === 1)
+    if (!pulled.ok)
+        lines.push(`✗ Could not fetch your profile from the dashboard — ${describe(pulled.reason)}`);
+    else if (pulled.count > 0)
         lines.push('✓ Profile pulled to this machine');
-    if (lines.length === 0)
+    if (lines.length === 0) {
         lines.push('Nothing to sync yet — run `/me init` and fill in your profile first.');
+    }
     return `## Profile sync\n\n${lines.join('\n')}`;
 }
+// ─── /undo-all ────────────────────────────────────────────────────────────────
+/**
+ * Format what `/undo-all` did, one line per action. The results mix restored
+ * files with actions that cannot be undone (a shell command), so a count of
+ * them says nothing about how much was put back.
+ */
+export function formatUndoAllReport(result) {
+    if (result.results.length === 0)
+        return 'Nothing to undo';
+    const heading = result.success ? '## Undo all' : '## Nothing was undone';
+    return `${heading}\n\n${result.results.map(r => `- ${r}`).join('\n')}`;
+}
 /**
  * Format the `/me learn` result. `updated` distinguishes "new facts written"
  * from "already covered"; `file` is the human-readable path.

package/dist/renderer/commands.d.ts

@@ -9,6 +9,8 @@ import { getProjectContext } from '../utils/project';
 import { AppExecutionContext } from './agentExecution';
 export interface AppCommandContext extends AppExecutionContext {
     sessionId: string;
+    /** Switch the conversation. Also records it as config's currentSessionId,
+     *  which autosave and the next launch read. */
     setSessionId: (id: string) => void;
     setProjectContext: (ctx: ReturnType<typeof getProjectContext>) => void;
     setHasWriteAccess: (v: boolean) => void;