codeep 3.3.3 → 3.4.1

package/dist/renderer/main.js

@@ -11,13 +11,13 @@ import { Input } from './Input.js';
 import { LoginScreen, renderProviderSelect } from './components/Login.js';
 import { chat, setProjectContext } from '../api/index.js';
 import { getZaiVisionConfig, getMinimaxMcpConfig, callZaiVisionApi, callMinimaxApi } from '../utils/mcpIntegration.js';
-import { config, loadApiKey, loadAllApiKeys, getCurrentProvider, autoSaveSession, startNewSession, getCurrentSessionId, loadSession, listSessionsWithInfo, deleteSession, hasReadPermission, hasWritePermission, setProjectPermission, initializeAsProject, isManuallyInitializedProject, setApiKey, setProvider, getGithubId, } from '../config/index.js';
+import { config, loadApiKey, loadAllApiKeys, getCurrentProvider, autoSaveSession, flushAutoSave, startNewSession, getCurrentSessionId, loadSession, listSessionsWithInfo, deleteSession, hasReadPermission, hasWritePermission, setProjectPermission, initializeAsProject, isManuallyInitializedProject, setApiKey, setProvider, getGithubId, } from '../config/index.js';
 import { isProjectDirectory, getProjectContext, } from '../utils/project.js';
 import { getCurrentVersion, checkForUpdates, getUpdateInstructions } from '../utils/update.js';
 import { getProviderList, isNoApiKeyProvider, resolveReasoningTier } from '../config/providers.js';
 import { getSessionStats, getCostBreakdown, getRecordCount } from '../utils/tokenTracker.js';
 import { getGitStatus, isGitRepository } from '../utils/git.js';
-import { reportStats, syncSession, generateProjectId, ensureDeviceRegistered } from '../utils/codeepCloud.js';
+import { reportStats, syncSession, syncSessionAsync, generateProjectId, ensureDeviceRegistered } from '../utils/codeepCloud.js';
 import { expandFileAndFolderMentions, expandGitMentions } from '../utils/mentions.js';
 import { expandWebMentions } from '../utils/webFetch.js';
 import { handleCommand as dispatchCommand } from './commands.js';
@@ -27,32 +27,123 @@ import { attachTelegramInbox } from '../utils/telegramInbox.js';
 import { sharedUpdates } from '../utils/telegramUpdates.js';
 import { sendTelegramNotice } from '../utils/telegramNotify.js';
 import { executeAgentTask, runAgentTask, } from './agentExecution.js';
+import { symlinkedCodeepNotice } from '../utils/projectPaths.js';
 // ─── Global state ─────────────────────────────────────────────────────────────
 let projectPath = process.cwd();
 /** Cached header branch. Resolved on first use so `--version`/`--help` never
- *  shell out to git, and cached because getStatus runs on every render frame. */
+ *  shell out to git, and cached because getStatus runs on every render frame.
+ *  `refusal` is the message getGitStatus carries back when git would not run
+ *  here at all — see reportGitRefusal(). */
 let gitBranchCache = null;
+/** Projects whose refusal has already been put in the transcript, so a cache
+ *  dropped after every agent run does not repeat it once a minute. */
+const gitRefusalReported = new Set();
 let projectContext = null;
 let hasWriteAccess = false;
 let sessionId = getCurrentSessionId();
 let app;
 /** Human-readable session name derived from the first user message */
 let sessionDisplayName = null;
+/** Switch the conversation this terminal is on. The config copy is kept in
+ *  step because the next launch resumes from it, and anything still reading
+ *  the global id would otherwise save into the conversation left behind. */
+function setSessionId(id) {
+    sessionId = id;
+    config.set('currentSessionId', id);
+}
 const addedFiles = new Map();
 /** Branch shown in the persistent header, re-read whenever the project moved
  *  or an agent run finished (an agent can check out a different branch). */
 function getHeaderBranch() {
     if (!gitBranchCache || gitBranchCache.path !== projectPath) {
-        gitBranchCache = { path: projectPath, branch: getGitStatus(projectPath).branch };
+        const status = getGitStatus(projectPath);
+        const refusal = gitRefusalNotice(status);
+        gitBranchCache = { path: projectPath, branch: status.branch, refusal: refusal ?? undefined };
+        reportGitRefusal(projectPath, refusal);
     }
     return gitBranchCache.branch;
 }
+/**
+ * What to tell the user when git would not run in this project, or null when
+ * there is nothing to tell them.
+ *
+ * Without it the only symptom is the branch quietly missing from the header,
+ * which reads as "not a repository" — so a repository whose own `.git/config`
+ * names a program git would run looks like an ordinary folder, and the one
+ * thing the user has to do (remove that key) is never said anywhere. The
+ * refusal names the key and the `git config --unset` that clears it, so it is
+ * passed through verbatim rather than summarised into "git failed".
+ *
+ * Read off `refusal` and NOT off `error`, which is the field an earlier cut
+ * of this used. `error` is every way git can fail in a repository, and the
+ * commonest of them is a brand-new `git init` with no commit yet: `git
+ * rev-parse --abbrev-ref HEAD` answers `fatal: ambiguous argument 'HEAD'`
+ * there (git 2.54), so the first thing a user does in a new project met a
+ * warning made of git internals telling them to remove a config key that does
+ * not exist. `refusal` is filled on the hardening path and nowhere else, so
+ * an ordinary git failure stays as silent as it was before this notice
+ * existed — the branch is simply missing from the header, which is what it
+ * has always done.
+ */
+export function gitRefusalNotice(status) {
+    const refusal = status.isRepo ? status.refusal : undefined;
+    if (!refusal)
+        return null;
+    return `⚠️  ${refusal}\n\nUntil then the header shows no branch, and everything Codeep does with git here — the status line, \`@git\`, \`/commit\`, the review hook — is off.`;
+}
+/**
+ * Put that message in the transcript once per project.
+ *
+ * A transcript message and not notify(): a toast is gone in three seconds,
+ * and this is a thing to act on, not a thing to glance at. Once per project
+ * because the cache it rides on is dropped after every agent run, and a
+ * warning repeated after each run is one the user learns to scroll past.
+ *
+ * Queued rather than added inline because the only caller runs inside
+ * getStatus(), which the render loop calls — pushing a message onto the list
+ * the frame is reading would tear that frame. The microtask lands before the
+ * next one.
+ */
+function reportGitRefusal(path, notice) {
+    if (!notice || gitRefusalReported.has(path))
+        return;
+    gitRefusalReported.add(path);
+    queueMicrotask(() => { app?.addMessage({ role: 'system', content: notice }); });
+}
 /** Derive a short display name from a user message (first ~5 words, max 48 chars). */
 export function deriveSessionName(message) {
     const clean = message.replace(/\s+/g, ' ').trim();
     const words = clean.split(' ').slice(0, 5).join(' ');
     return words.length > 48 ? words.slice(0, 45) + '…' : words;
 }
+/**
+ * Start the MCP servers this terminal may run, under the fixed session id
+ * `codeep-tui`: the global servers (~/.codeep, the user's own) plus the
+ * workspace ones once the workspace is trusted. Registering replaces the
+ * session's whole set, so they go in one call; starting the global list and
+ * then the workspace list stopped the global servers. Returns the workspace
+ * servers left out because the workspace is not trusted yet.
+ */
+export async function startTuiMcpServers(root, ui) {
+    const { selectSessionMcpServers } = await import('../utils/mcpConfig.js');
+    const { registerSessionServers } = await import('../utils/mcpRegistry.js');
+    const { servers, skipped } = selectSessionMcpServers(root);
+    if (servers.length > 0) {
+        const { registered, errors } = await registerSessionServers('codeep-tui', servers, { workspaceRoot: root });
+        if (registered.length > 0) {
+            ui.notify(`MCP: ${registered.length} tool(s) from ${servers.length} server(s) ready. Type /mcp.`);
+        }
+        for (const e of errors) {
+            ui.notifyWarn(`MCP server "${e.server}" failed: ${e.error}`);
+        }
+    }
+    return skipped;
+}
+/** Start the servers of a workspace the user has just trusted. A failure is
+ *  shown, not swallowed: the user asked for these servers. */
+export function startTrustedWorkspaceMcp(root, ui) {
+    return startTuiMcpServers(root, ui).then(() => { }, (err) => ui.notifyWarn(`MCP: could not start workspace servers: ${err.message}`));
+}
 let isAgentRunningFlag = false;
 /** Set once the phone is allowed to send instructions; null when it is not. */
 let telegramInbox = null;
@@ -83,7 +174,8 @@ function makeCtx() {
         setAbortController: (ctrl) => { agentAbortController = ctrl; },
         formatAddedFilesContext,
         handleCommand: (cmd, args) => dispatchCommand(cmd, args, makeCtx()),
-        setSessionId: (id) => { sessionId = id; },
+        setSessionId,
+        getSessionId: () => sessionId,
         setSessionDisplayName: (name) => { sessionDisplayName = name; },
         setProjectContext: (ctx) => {
             projectContext = ctx;
@@ -270,7 +362,7 @@ async function handleSubmit(message) {
         const enrichedMessage = fileContext ? fileContext + webExpanded : webExpanded;
         await chat(enrichedMessage, history, (chunk) => app.addStreamChunk(chunk), undefined, projectContext, undefined);
         app.endStreaming();
-        autoSaveSession(app.getMessages(), projectPath);
+        autoSaveSession(app.getMessages(), projectPath, sessionId);
         // Sync to dashboard after every successful manual chat (not just on shutdown).
         // Mirrors the agent-mode behaviour in agentExecution.ts so dashboard stays
         // in sync regardless of Agent Mode setting.
@@ -410,7 +502,7 @@ function showSessionPickerInline() {
         else {
             const messages = loadSession(selectedName, projectPath);
             if (messages) {
-                sessionId = selectedName;
+                setSessionId(selectedName);
                 app.setMessages(messages);
                 app.notify(`Loaded: ${selectedName}`);
             }
@@ -422,7 +514,9 @@ function showSessionPickerInline() {
     }, (sessionName) => { deleteSession(sessionName, projectPath); });
 }
 // ─── Main ─────────────────────────────────────────────────────────────────────
-async function main() {
+/** The CLI entry point. Exported so tests can drive a command without the
+ *  module starting the app on import. */
+export async function main() {
     const args = process.argv.slice(2);
     // Headless, deterministic code review for CI (no API key, no TUI). Handled
     // before the global --help/--version checks so `codeep review --help` shows
@@ -511,7 +605,7 @@ Commands (in chat):
             // Also pull portable personal config — personalities + custom commands +
             // the user profile. Web-edited personalities replace their local copy
             // after a safety backup; commands/profile retain additive merge rules.
-            const { pullPersonalities, pullCommands, pullUserProfile, getLastPersonalityPullBackupCount } = await import('../utils/codeepCloud.js');
+            const { pullPersonalities, pullCommands, pullUserProfileResult, getLastPersonalityPullBackupCount } = await import('../utils/codeepCloud.js');
             // Report all three outcomes, not just the interesting one. Printing only
             // on count > 0 made a failed sync look identical to a sync with nothing
             // new — silence meant either, and the user could not tell which.
@@ -539,8 +633,11 @@ Commands (in chat):
             else if (commands.count > 0) {
                 console.log(`  Pulled ${commands.count} custom command${commands.count === 1 ? '' : 's'}.`);
             }
-            const profPulled = await pullUserProfile();
-            if (profPulled === 1) {
+            const profile = await pullUserProfileResult();
+            if (!profile.ok) {
+                console.log(`  Could not pull your profile (about you) — ${describeSyncFailure(profile.reason)}.`);
+            }
+            else if (profile.count > 0) {
                 console.log('  Pulled your profile (about you).');
             }
             console.log('');
@@ -580,7 +677,7 @@ Commands (in chat):
                 console.log('  Cloud key sync is off — skipping API keys. Enable with: /keysync on');
             }
             // Also push portable personal config — personalities + commands + profile.
-            const { pushPersonalities, pushCommands, pushUserProfile } = await import('../utils/codeepCloud.js');
+            const { pushPersonalities, pushCommands, pushUserProfileResult } = await import('../utils/codeepCloud.js');
             const { describeSyncFailure } = await import('../utils/codeepCloud.js');
             const personalities = await pushPersonalities();
             if (!personalities.ok) {
@@ -596,11 +693,20 @@ Commands (in chat):
             else if (commands.count > 0) {
                 console.log(`  Pushed ${commands.count} custom command${commands.count === 1 ? '' : 's'}.`);
             }
-            if (await pushUserProfile()) {
+            // No local profile is nothing to push, not a failure.
+            const profile = await pushUserProfileResult();
+            const profilePushFailed = !profile.ok;
+            if (!profile.ok) {
+                console.log(`  Could not push your profile (about you) — ${describeSyncFailure(profile.reason)}.`);
+            }
+            else if (profile.count > 0) {
                 console.log('  Pushed your profile (about you).');
             }
             console.log('');
-            process.exit(keyPushFailed ? 1 : 0);
+            // Any push that was reported as failed fails the command, so a script
+            // running it can tell.
+            const anyFailed = keyPushFailed || !personalities.ok || !commands.ok || profilePushFailed;
+            process.exit(anyFailed ? 1 : 0);
         }
         if (sub === 'purge-keys') {
             const { getSyncToken } = await import('../config/index.js');
@@ -765,6 +871,9 @@ Commands (in chat):
     welcomeLines.push('  /help  ·  Ctrl+L clear  ·  Esc cancel');
     app.addMessage({ role: 'welcome', content: welcomeLines.join('\n') });
     app.start();
+    const codeepNotice = symlinkedCodeepNotice(projectPath);
+    if (codeepNotice)
+        app.notifyWarn(codeepNotice);
     // Let the phone send instructions, if it has been switched on. Started after
     // app.start() so a prompt that arrives immediately has somewhere to land.
     void (async () => {
@@ -804,32 +913,14 @@ Commands (in chat):
     if (projectPath) {
         (async () => {
             try {
-                const { loadMcpServerConfigSplit, isWorkspaceMcpTrusted, trustWorkspaceMcp } = await import('../utils/mcpConfig.js');
-                const { registerSessionServers } = await import('../utils/mcpRegistry.js');
-                const { global: globalServers, workspace: workspaceServers } = loadMcpServerConfigSplit(projectPath);
-                const spawnServers = async (servers) => {
-                    if (servers.length === 0)
-                        return;
-                    const { registered, errors } = await registerSessionServers('codeep-tui', servers, { workspaceRoot: projectPath });
-                    if (registered.length > 0) {
-                        app.notify(`MCP: ${registered.length} tool(s) from ${servers.length} server(s) ready. Type /mcp.`);
-                    }
-                    for (const e of errors) {
-                        app.notifyWarn(`MCP server "${e.server}" failed: ${e.error}`);
-                    }
-                };
-                // ~/.codeep servers are the user's own machine-wide config — spawn.
-                await spawnServers(globalServers);
+                const { trustWorkspaceMcp } = await import('../utils/mcpConfig.js');
+                const workspaceServers = await startTuiMcpServers(projectPath, app);
                 // Workspace files (.codeep/mcp_servers.json, .mcp.json) travel WITH
                 // the repo — a cloned project could otherwise execute arbitrary
                 // commands at startup. One-time per-workspace approval, mirroring
                 // the trustedHookProjects gate for hooks.
                 if (workspaceServers.length === 0)
                     return;
-                if (isWorkspaceMcpTrusted(projectPath)) {
-                    await spawnServers(workspaceServers);
-                    return;
-                }
                 const preview = workspaceServers.slice(0, 5).map(s => `  ${s.name}: ${s.command ? [s.command, ...(s.args ?? [])].join(' ') : s.url ?? ''}`);
                 if (workspaceServers.length > 5)
                     preview.push(`  …and ${workspaceServers.length - 5} more`);
@@ -845,7 +936,7 @@ Commands (in chat):
                     cancelLabel: 'Not now',
                     onConfirm: () => {
                         trustWorkspaceMcp(projectPath);
-                        void spawnServers(workspaceServers);
+                        void startTrustedWorkspaceMcp(projectPath, app);
                     },
                     onCancel: () => {
                         app.notify('Workspace MCP servers skipped. Run /mcp trust to enable them.');
@@ -1001,9 +1092,12 @@ async function gracefulShutdown() {
     console.log('Goodbye!');
     if (!app)
         return;
+    // Write the conversation before anything that can fail or take time: the
+    // process exits as soon as this returns or throws, and a debounced save
+    // left on its timer never happens.
     const messages = app.getMessages();
-    autoSaveSession(messages, projectPath);
-    const { syncSessionAsync, generateProjectId } = require('../utils/codeepCloud.js');
+    autoSaveSession(messages, projectPath, sessionId);
+    flushAutoSave();
     const projectId = projectPath ? generateProjectId(projectPath) : undefined;
     // Successful manual and agent turns report their token deltas immediately.
     // Re-sending the cumulative session total here would count every token a
@@ -1017,47 +1111,54 @@ async function gracefulShutdown() {
     });
 }
 // ─── Last-resort crash handlers ───────────────────────────────────────────────
-// Without these, a stray throw or rejected promise (deep in the agent loop or a
-// background cloud sync) crashes Node with the terminal still in raw mode +
-// alternate screen — leaving the user's shell garbled — or vanishes silently.
-process.on('uncaughtException', (error) => {
-    logAppError(error instanceof Error ? error : new Error(String(error)), 'uncaughtException');
-    // After an uncaught exception the process state is undefined; Node's guidance
-    // is to clean up synchronously and exit rather than limp on. Restore the
-    // terminal and best-effort save the conversation so the crash doesn't lose it.
-    try {
-        if (app)
-            app.stop();
-    }
-    catch { /* ignore */ }
-    try {
-        process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
-    }
-    catch { /* ignore */ }
-    console.error('Fatal error:', error);
-    try {
+// A test that imports this module for its helpers must not start the app:
+// main() reads the OS keychain, draws the TUI and goes to the network, and
+// these handlers would exit the test worker. Every real launch — node, the
+// npm bin, the bun-compiled binaries — runs this module as the program.
+if (!process.env.VITEST) {
+    // Without these, a stray throw or rejected promise (deep in the agent loop or a
+    // background cloud sync) crashes Node with the terminal still in raw mode +
+    // alternate screen — leaving the user's shell garbled — or vanishes silently.
+    process.on('uncaughtException', (error) => {
+        logAppError(error instanceof Error ? error : new Error(String(error)), 'uncaughtException');
+        // After an uncaught exception the process state is undefined; Node's guidance
+        // is to clean up synchronously and exit rather than limp on. Restore the
+        // terminal and best-effort save the conversation so the crash doesn't lose it.
+        try {
+            if (app)
+                app.stop();
+        }
+        catch { /* ignore */ }
+        try {
+            process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
+        }
+        catch { /* ignore */ }
+        console.error('Fatal error:', error);
+        try {
+            if (app)
+                autoSaveSession(app.getMessages(), projectPath, sessionId);
+            flushAutoSave();
+        }
+        catch { /* ignore */ }
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (reason) => {
+        logAppError(reason instanceof Error ? reason : new Error(String(reason)), 'unhandledRejection');
+        // A rejected promise is usually recoverable (failed background sync, network
+        // blip), so surface it and keep the TUI alive instead of tearing it down.
+        // Fall back to stderr if the app isn't up yet.
+        const message = reason instanceof Error ? reason.message : String(reason);
         if (app)
-            autoSaveSession(app.getMessages(), projectPath);
-    }
-    catch { /* ignore */ }
-    process.exit(1);
-});
-process.on('unhandledRejection', (reason) => {
-    logAppError(reason instanceof Error ? reason : new Error(String(reason)), 'unhandledRejection');
-    // A rejected promise is usually recoverable (failed background sync, network
-    // blip), so surface it and keep the TUI alive instead of tearing it down.
-    // Fall back to stderr if the app isn't up yet.
-    const message = reason instanceof Error ? reason.message : String(reason);
-    if (app)
-        app.notifyWarn(`Background error: ${message}`);
-    else
-        console.error('Unhandled rejection:', reason);
-});
-process.on('SIGINT', () => {
-    gracefulShutdown().finally(() => process.exit(0));
-});
-main().catch((error) => {
-    logAppError(error instanceof Error ? error : new Error(String(error)), 'main');
-    console.error('Fatal error:', error);
-    process.exit(1);
-});
+            app.notifyWarn(`Background error: ${message}`);
+        else
+            console.error('Unhandled rejection:', reason);
+    });
+    process.on('SIGINT', () => {
+        gracefulShutdown().finally(() => process.exit(0));
+    });
+    main().catch((error) => {
+        logAppError(error instanceof Error ? error : new Error(String(error)), 'main');
+        console.error('Fatal error:', error);
+        process.exit(1);
+    });
+}

package/dist/utils/agent.d.ts

@@ -10,6 +10,7 @@ import { type Personality } from './personalities';
 export { loadProjectRules, loadProgressLog, writeProgressLog, formatChatHistoryForAgent };
 export type { AgentChatResponse };
 import { ToolCall, ToolResult, ActionLog } from './tools';
+import { type TrustBearingWrite } from './toolExecution';
 import { undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession, ActionSession } from './history';
 import { VerifyResult } from './verify';
 import { TaskPlan, SubTask } from './taskPlanner';
@@ -31,6 +32,29 @@ export declare function classifyPermissionOutcome(outcome: string | undefined |
  * session's mode into the TUI and race on restore). Exported for unit testing.
  */
 export declare function buildDangerousTools(extra?: string[]): Set<string>;
+/**
+ * Whether a tool call must go through the permission prompt this run.
+ *
+ * MCP tools (`<server>__<tool>`) can do anything their server can — write
+ * files, run SQL, drive a browser — and their names never appear in the
+ * built-in set, so a mode that confirms dangerous operations confirms these
+ * too. The resource/prompt wrappers only read, and stay unprompted.
+ */
+export declare function requiresPermission(tool: string, dangerousTools: ReadonlySet<string>): boolean;
+/** Provider, model and protocol a run talks to. */
+export interface AgentModelRuntime {
+    providerId: string;
+    model: string;
+    protocol: 'openai' | 'anthropic';
+}
+/**
+ * Read a sub-agent's `model:` setting ("provider/model" or a bare model) as
+ * the runtime for its nested run. A known provider prefix switches provider;
+ * anything else is a model on the current provider. The protocol is kept when
+ * the provider stays the same and supports it, and is otherwise that
+ * provider's default.
+ */
+export declare function resolveDelegateModel(spec: string, current: AgentModelRuntime): Promise<AgentModelRuntime>;
 export interface AgentOptions {
     maxIterations: number;
     maxDuration: number;
@@ -42,7 +66,18 @@ export interface AgentOptions {
     onVerification?: (results: VerifyResult[]) => void;
     onTaskPlan?: (plan: TaskPlan) => void;
     onTaskUpdate?: (task: SubTask) => void;
-    onRequestPermission?: (toolCall: ToolCall) => Promise<PermissionOutcome>;
+    /**
+     * Ask the user about one tool call.
+     *
+     * `trustBearing` is what this run already worked out about the call — the
+     * file it would write that decides what runs later, or null when it writes
+     * no such file. It is passed so the side putting up the dialog can word it
+     * without calling trustBearingWrite() a second time: that call stats the
+     * path, follows a symlink and may ask git where the repo's hooks live.
+     * Optional, so a caller that would rather work it out itself (or was not
+     * called from the gate below) still type-checks.
+     */
+    onRequestPermission?: (toolCall: ToolCall, trustBearing?: TrustBearingWrite | null) => Promise<PermissionOutcome>;
     /** Tool names to force into the per-run dangerous set, on top of the global
      *  agentConfirm* settings. ACP manual mode passes ['write_file','edit_file']
      *  here to gate them for THIS run only, instead of mutating global config. */
@@ -98,6 +133,21 @@ export interface AgentOptions {
     allowedTools?: string[];
     /** Role system-prompt addendum injected for a delegated sub-agent. */
     roleAddendum?: string;
+    /** "Always allow" / "always deny" answers shared with a delegating parent,
+     *  so a sub-agent neither asks again about a tool the user already decided
+     *  on nor runs one the user refused. `alwaysRejectedPaths` holds the same
+     *  for a single file that decides what runs later, which is refused by name
+     *  rather than by tool. */
+    permissionMemory?: {
+        alwaysAllowed: Set<string>;
+        alwaysRejected: Set<string>;
+        alwaysRejectedPaths?: Set<string>;
+    };
+    /** Provider/model for this run only, used in place of the global selection.
+     *  A sub-agent with its own `model:` runs on it this way; the global config
+     *  is saved to disk and read by every session in the process, so it is
+     *  never changed for a single run. */
+    modelOverride?: AgentModelRuntime;
 }
 /** Why a run stopped early at a safety limit — both are resumable, not errors. */
 export type InterruptKind = 'iteration_limit' | 'time_limit';
@@ -111,6 +161,19 @@ export interface AgentResult {
     /** Set when the run paused at a step/time safety limit. The caller can offer
      *  a "continue" affordance instead of treating it as a failure. */
     interrupted?: InterruptKind;
+    /** Commands of the verification checks that still failed when the run
+     *  ended. Set only when that is why the run did not succeed. */
+    failedChecks?: string[];
+    /**
+     * The end of `finalResponse` that runAgent wrote itself instead of taking
+     * it from the model's last reply: the verification passed / failed / could
+     * not run blocks and the auto-review section, or the whole notice when one
+     * replaced the reply (stopped, paused, API errors). None of it went through
+     * `onChunk`, so a client that streamed the reply sends exactly this after
+     * it, separated by a blank line. Trimmed; '' when `finalResponse` is only
+     * the model's reply. Set on every result runAgent returns.
+     */
+    unstreamedText?: string;
 }
 /**
  * Build the result for a run that paused at a safety limit. Pausing is a normal,
@@ -147,10 +210,12 @@ export declare function getAgentHistory(): Array<{
     success: boolean;
 }>;
 /**
- * Get current session actions
+ * Actions of the run undo acts on (see getCurrentSession). Pass the workspace
+ * to leave out a run in another one. `result` is 'undone' for an action that
+ * has since been undone, 'success' otherwise.
  */
-export declare function getCurrentSessionActions(): Array<{
+export declare function getCurrentSessionActions(projectRoot?: string): Array<{
     type: string;
     target: string;
-    result: string;
+    result: 'success' | 'undone';
 }>;