vigthoria-cli 1.10.51 → 1.11.0

package/dist/commands/background.d.ts

@@ -0,0 +1,19 @@
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+interface BackgroundOptions {
+    json?: boolean;
+    limit?: number;
+    workspace?: string;
+}
+export declare class BackgroundCommand {
+    private config;
+    private logger;
+    private api;
+    constructor(config: Config, logger: Logger);
+    start(promptParts: string[], options?: BackgroundOptions): Promise<void>;
+    list(options?: BackgroundOptions): Promise<void>;
+    status(jobId: string, options?: BackgroundOptions): Promise<void>;
+    apply(jobId: string, options?: BackgroundOptions): Promise<void>;
+    cancel(jobId: string, options?: BackgroundOptions): Promise<void>;
+}
+export {};

package/dist/commands/background.js

@@ -0,0 +1,160 @@
+import chalk from 'chalk';
+import { createSpinner, CH } from '../utils/logger.js';
+import { APIClient } from '../utils/api.js';
+export class BackgroundCommand {
+    config;
+    logger;
+    api;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+        this.api = new APIClient(config, logger);
+    }
+    async start(promptParts, options = {}) {
+        const prompt = promptParts.join(' ').trim();
+        if (!prompt) {
+            this.logger.error('Usage: vigthoria background start "<task>"');
+            return;
+        }
+        const workspacePath = options.workspace || process.cwd();
+        const spinner = createSpinner('Starting background agent job...').start();
+        try {
+            const job = await this.api.startV3BackgroundJob(prompt, {
+                workspacePath,
+                projectPath: workspacePath,
+                targetPath: workspacePath,
+                localMachineCapable: true,
+                executionSurface: 'cli',
+                clientSurface: 'cli',
+                clientToolExecution: false,
+            });
+            spinner.stop();
+            if (options.json) {
+                console.log(JSON.stringify(job, null, 2));
+                return;
+            }
+            console.log(chalk.green(`${CH.success} Background job started`));
+            console.log(chalk.gray(`  Job:       ${job.job_id}`));
+            console.log(chalk.gray(`  Status:    ${job.status}`));
+            console.log(chalk.gray(`  Workspace: ${workspacePath}`));
+            console.log();
+            console.log(chalk.gray(`Use ${chalk.cyan(`vigthoria background status ${job.job_id}`)} to check progress.`));
+            console.log(chalk.gray(`Use ${chalk.cyan(`vigthoria background apply ${job.job_id}`)} when it is completed.`));
+        }
+        catch (error) {
+            spinner.stop();
+            this.logger.error(error?.message || String(error));
+        }
+    }
+    async list(options = {}) {
+        const spinner = createSpinner('Loading background jobs...').start();
+        try {
+            const jobs = await this.api.listV3BackgroundJobs(options.limit || 20);
+            spinner.stop();
+            if (options.json) {
+                console.log(JSON.stringify({ jobs }, null, 2));
+                return;
+            }
+            if (jobs.length === 0) {
+                console.log(chalk.gray('No background jobs found.'));
+                return;
+            }
+            console.log(chalk.bold(`\n${CH.success} Background Jobs\n`));
+            for (const job of jobs) {
+                const color = job.status === 'completed' ? chalk.green : job.status === 'failed' ? chalk.red : job.status === 'cancelled' ? chalk.yellow : chalk.cyan;
+                console.log(`${color(String(job.status || 'unknown').padEnd(10))} ${chalk.cyan(job.job_id)} ${chalk.gray(job.updated_at || '')}`);
+                console.log(chalk.gray(`  ${String(job.request || '').slice(0, 100)}`));
+                console.log(chalk.gray(`  files: ${job.file_count || 0} workspace: ${job.local_workspace_path || job.workspace_name || '-'}`));
+            }
+            console.log();
+        }
+        catch (error) {
+            spinner.stop();
+            this.logger.error(error?.message || String(error));
+        }
+    }
+    async status(jobId, options = {}) {
+        if (!jobId) {
+            this.logger.error('Usage: vigthoria background status <job-id>');
+            return;
+        }
+        const spinner = createSpinner('Loading background job...').start();
+        try {
+            const job = await this.api.getV3BackgroundJob(jobId);
+            spinner.stop();
+            if (options.json) {
+                console.log(JSON.stringify(job, null, 2));
+                return;
+            }
+            console.log(chalk.bold(`\nBackground Job ${chalk.cyan(job.job_id)}\n`));
+            console.log(`Status:    ${job.status}`);
+            console.log(`Files:     ${job.file_count || 0}`);
+            console.log(`Updated:   ${job.updated_at || '-'}`);
+            console.log(`Workspace: ${job.local_workspace_path || job.workspace_name || '-'}`);
+            if (job.error)
+                console.log(chalk.red(`Error:     ${job.error}`));
+            console.log(chalk.gray(`\n${String(job.request || '').slice(0, 500)}`));
+            if (job.status === 'completed' && (job.file_count || 0) > 0) {
+                console.log(chalk.gray(`\nUse ${chalk.cyan(`vigthoria background apply ${job.job_id}`)} to apply files locally.`));
+            }
+        }
+        catch (error) {
+            spinner.stop();
+            this.logger.error(error?.message || String(error));
+        }
+    }
+    async apply(jobId, options = {}) {
+        if (!jobId) {
+            this.logger.error('Usage: vigthoria background apply <job-id>');
+            return;
+        }
+        const workspacePath = options.workspace || process.cwd();
+        const spinner = createSpinner('Applying background job files...').start();
+        try {
+            const result = await this.api.applyV3BackgroundJobFiles(jobId, {
+                workspacePath,
+                projectPath: workspacePath,
+                targetPath: workspacePath,
+            });
+            spinner.stop();
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            console.log(chalk.green(`${CH.success} Applied ${result.applied.length} file(s) from ${jobId}`));
+            for (const file of result.applied.slice(0, 20)) {
+                console.log(chalk.gray(`  + ${file}`));
+            }
+            if (result.applied.length > 20) {
+                console.log(chalk.gray(`  ... and ${result.applied.length - 20} more`));
+            }
+            if (result.skipped.length > 0) {
+                console.log(chalk.yellow(`Skipped ${result.skipped.length} unchanged or unsafe file(s).`));
+            }
+        }
+        catch (error) {
+            spinner.stop();
+            this.logger.error(error?.message || String(error));
+        }
+    }
+    async cancel(jobId, options = {}) {
+        if (!jobId) {
+            this.logger.error('Usage: vigthoria background cancel <job-id>');
+            return;
+        }
+        const spinner = createSpinner('Cancelling background job...').start();
+        try {
+            const result = await this.api.cancelV3BackgroundJob(jobId);
+            spinner.stop();
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            console.log(chalk.yellow(`${CH.warn} Background job cancelled: ${jobId}`));
+        }
+        catch (error) {
+            spinner.stop();
+            this.logger.error(error?.message || String(error));
+        }
+    }
+}

package/dist/commands/chat.js

@@ -13,6 +13,7 @@ import { TaskDisplay } from '../utils/task-display.js';
 import { ProjectMemoryService } from '../utils/project-memory.js';
 import { buildPersonaOverlay, normalizePersonaMode } from '../utils/persona.js';
 import { runAgentSessionMenu, shouldShowAgentSessionMenu } from './agent-session-menu.js';
+import { evaluateExecutorSuccess, handleTaskEvent, noteAnalysisToolUse, } from '../utils/agentRunOutcome.js';
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS;
     if (!rawValue) {
@@ -353,7 +354,12 @@ export class ChatCommand {
      * question — these should use analysis_only workflow, not full_autonomy.
      */
     isAnalysisLookupPrompt(prompt) {
-        return /^(what|which|where|how many|who|find|list|show|check|inspect|analyze|analyse|audit|explain|describe|summarize|summarise|review|overview|count|read|look at|tell me|locate|search for|does .* exist)/i.test(prompt.trim());
+        const trimmed = prompt.trim();
+        if (/^(what|which|where|how many|who|find|list|show|check|inspect|analyze|analyse|audit|explain|describe|summarize|summarise|review|overview|count|read|look at|tell me|locate|search for|does .* exist)/i.test(trimmed)) {
+            return true;
+        }
+        // Mid-conversation accountability / lookup questions (Gideon regression)
+        return /\b(where\s+(?:is|are)|what\s+(?:is|are|have|did|was|were)|how\s+(?:do|does|is|are)|what\s+(?:have\s+)?you\s+(?:done|changed|built)|what\s+(?:is|was)\s+(?:your|the)\s+answer)\b/i.test(trimmed);
     }
     extractExplicitLocalPath(prompt) {
         // Try to extract Windows paths (C:\ D:\ etc.)
@@ -746,6 +752,7 @@ export class ChatCommand {
             .replace(/^\s*(?:json\s*)?\[\s*\{[\s\S]*?"tool"[\s\S]*$/gim, '')
             .replace(/^\s*(?:list_dir|read_file|write_file|edit_file|glob|grep|bash)\s*$/gim, '')
             .replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '')
+            .replace(/<tool_code>[\s\S]*?<\/tool_code>/gi, '')
             .replace(/\n{3,}/g, '\n\n');
         return output;
     }
@@ -2371,6 +2378,10 @@ export class ChatCommand {
             plannerError: null,
             executorError: null,
             executorFailed: false,
+            analysisToolsUsed: 0,
+            changedFileCount: 0,
+            requiresWorkspaceChanges: false,
+            workspaceHasOutput: false,
         };
         const parsePlannerSummary = (raw) => {
             if (!raw || typeof raw !== 'string')
@@ -2486,17 +2497,23 @@ export class ChatCommand {
                     }
                     else if (event.type === 'executor_complete') {
                         const summary = event.summary || {};
-                        const tid = summary.task_id || summary.id;
+                        handleTaskEvent(summary, liveOutcome);
                         if (summary.status === 'failed') {
-                            if (tid)
-                                liveOutcome.failedTaskIds.add(String(tid));
-                            liveOutcome.executorFailed = true;
+                            const err = typeof summary.error === 'string' ? summary.error.trim() : '';
+                            if (err && !liveOutcome.executorError)
+                                liveOutcome.executorError = err;
                         }
-                        else if (summary.status === 'completed' || summary.status === 'success') {
-                            if (tid)
-                                liveOutcome.failedTaskIds.delete(String(tid));
-                            liveOutcome.tasksSucceeded += 1;
+                    }
+                    else if (event.type === 'tool_call' || event.type === 'tool_result') {
+                        const toolName = String(event.name || event.tool || '').trim();
+                        if (toolName)
+                            noteAnalysisToolUse(toolName, liveOutcome);
+                    }
+                    else if (event.type === 'complete') {
+                        if (Number(event.discovery_tools_used) > 0) {
+                            liveOutcome.analysisToolsUsed = Math.max(liveOutcome.analysisToolsUsed, Number(event.discovery_tools_used));
                         }
+                        taskDisplay.complete(1);
                     }
                     else if (event.type === 'executor_error') {
                         const msg = typeof event.error === 'string' ? event.error : '';
@@ -2516,9 +2533,6 @@ export class ChatCommand {
                             parsePlannerSummary(msg);
                         }
                     }
-                    else if (event.type === 'complete') {
-                        taskDisplay.complete(1);
-                    }
                     if (spinner)
                         this.updateV3AgentSpinner(spinner, event);
                 },
@@ -2535,6 +2549,9 @@ export class ChatCommand {
             const workspaceHasOutput = this.api.hasAgentWorkspaceOutput(workspaceContext);
             const changedFileCount = response.changedFiles ? Object.keys(response.changedFiles).length : 0;
             const requiresWorkspaceChanges = this.taskRequiresWorkspaceChanges(prompt);
+            liveOutcome.changedFileCount = changedFileCount;
+            liveOutcome.requiresWorkspaceChanges = requiresWorkspaceChanges;
+            liveOutcome.workspaceHasOutput = workspaceHasOutput;
             const success = previewGate?.required === true
                 ? (previewGate?.passed === true || workspaceHasOutput)
                 : true;
@@ -2630,12 +2647,23 @@ export class ChatCommand {
             // executor errors and the spinner needs to clearly say "failed", not "✓".
             let selfHealStatus = null;
             let selfHealTool = null;
-            const executorSucceeded = !liveOutcome.executorFailed
-                && !liveOutcome.plannerError
-                && !liveOutcome.executorError
-                && (requiresWorkspaceChanges ? (workspaceHasOutput && changedFileCount > 0) : true);
+            const runEvaluation = evaluateExecutorSuccess(liveOutcome);
+            const executorSucceeded = runEvaluation.executorSucceeded;
             if (!executorSucceeded && requiresWorkspaceChanges && changedFileCount === 0 && !liveOutcome.executorError) {
-                liveOutcome.executorError = 'No workspace files were changed for a build/edit request.';
+                const clientToolErrors = this.api.getClientToolErrors();
+                const transportErrors = this.api.getLastChatTransportErrors();
+                if (clientToolErrors.length > 0) {
+                    liveOutcome.executorError = clientToolErrors[0];
+                }
+                else if (workspaceHasOutput && changedFileCount === 0) {
+                    liveOutcome.executorError = 'Files may exist locally but were not tracked by the agent stream. Try /retry or check your workspace path.';
+                }
+                else {
+                    liveOutcome.executorError = 'No workspace files were changed for a build/edit request.';
+                }
+                if (transportErrors.length > 0 && !liveOutcome.plannerError) {
+                    liveOutcome.plannerError = transportErrors[0];
+                }
             }
             if (executorSucceeded) {
                 taskDisplay.complete(1);
@@ -2708,10 +2736,16 @@ export class ChatCommand {
                 selfHealTool,
                 plannerError: liveOutcome.plannerError ? sanitizeUserFacingErrorText(liveOutcome.plannerError) : null,
                 executorError: liveOutcome.executorError ? sanitizeUserFacingErrorText(liveOutcome.executorError) : null,
+                clientToolErrors: this.api.getClientToolErrors(),
+                transportErrors: this.api.getLastChatTransportErrors(),
+                workspacePath: workspacePath || null,
+                workspaceSyncIssue: (!executorSucceeded && workspaceHasOutput && changedFileCount === 0)
+                    ? 'Local workspace has files but the agent did not confirm tracked changes.'
+                    : null,
                 finishedAt: Date.now(),
             };
             if (!this.jsonOutput && !this.directPromptMode) {
-                this.printAgentRunSummary(this.lastAgentRunOutcome, executorSucceeded, changedFileCount);
+                this.printAgentRunSummary(this.lastAgentRunOutcome, runEvaluation, changedFileCount);
             }
             this.messages.push({ role: 'assistant', content: response.content || 'V3 agent workflow completed.' });
             watcher?.stop();
@@ -2767,6 +2801,10 @@ export class ChatCommand {
                 selfHealTool: null,
                 plannerError: liveOutcome.plannerError ? sanitizeUserFacingErrorText(liveOutcome.plannerError) : null,
                 executorError: liveOutcome.executorError ? sanitizeUserFacingErrorText(liveOutcome.executorError) : safeDetail || null,
+                clientToolErrors: this.api.getClientToolErrors(),
+                transportErrors: this.api.getLastChatTransportErrors(),
+                workspacePath: workspacePath || null,
+                workspaceSyncIssue: null,
                 finishedAt: Date.now(),
             };
             if (this.jsonOutput) {
@@ -2782,7 +2820,19 @@ export class ChatCommand {
                 }, null, 2));
             }
             else if (!this.directPromptMode) {
-                this.printAgentRunSummary(this.lastAgentRunOutcome, false, 0);
+                const failedEval = evaluateExecutorSuccess({
+                    executorFailed: true,
+                    plannerError: liveOutcome.plannerError,
+                    executorError: liveOutcome.executorError || safeDetail,
+                    tasksTotal: liveOutcome.tasksTotal,
+                    tasksSucceeded: liveOutcome.tasksSucceeded,
+                    changedFileCount: 0,
+                    requiresWorkspaceChanges: this.taskRequiresWorkspaceChanges(prompt),
+                    workspaceHasOutput: this.api.hasAgentWorkspaceOutput(workspaceContext),
+                    failedTaskIds: liveOutcome.failedTaskIds,
+                    analysisToolsUsed: liveOutcome.analysisToolsUsed,
+                });
+                this.printAgentRunSummary(this.lastAgentRunOutcome, failedEval, 0);
             }
             return true;
         }
@@ -3079,7 +3129,8 @@ export class ChatCommand {
      *   - User can answer "What do I type next?" without reading 200 scrollback lines.
      *   - Never leave the spinners (`⟳`, `–`) ambiguous when the prompt returns.
      */
-    printAgentRunSummary(outcome, executorSucceeded, changedFileCount) {
+    printAgentRunSummary(outcome, evaluation, changedFileCount) {
+        const executorSucceeded = evaluation.executorSucceeded;
         const bar = chalk.gray('─'.repeat(63));
         const ok = chalk.green('✓');
         const warn = chalk.yellow('⚠');
@@ -3089,15 +3140,9 @@ export class ChatCommand {
         const hasTaskInfo = outcome.tasksTotal > 0 || failedList.length > 0 || unfinishedList.length > 0;
         console.log('');
         console.log(bar);
-        if (executorSucceeded && outcome.selfHealStatus !== 'partial' && outcome.selfHealStatus !== 'failed' && failedList.length === 0) {
-            console.log(`${ok} ${chalk.bold('Agent run finished')}${changedFileCount ? chalk.gray(` — ${changedFileCount} file${changedFileCount === 1 ? '' : 's'} changed`) : ''}`);
-        }
-        else if (executorSucceeded) {
-            console.log(`${warn} ${chalk.bold('Agent run finished with warnings')}${changedFileCount ? chalk.gray(` — ${changedFileCount} file${changedFileCount === 1 ? '' : 's'} changed`) : ''}`);
-        }
-        else {
-            console.log(`${bad} ${chalk.bold('Agent run did not complete')}${changedFileCount ? chalk.gray(` — ${changedFileCount} file${changedFileCount === 1 ? '' : 's'} changed`) : ''}`);
-        }
+        const headlineIcon = evaluation.uiTheme === 'success' ? ok : evaluation.uiTheme === 'warning' ? warn : bad;
+        const headlineText = evaluation.statusHeadline.replace(/^[✓⚠✕]\s*/, '');
+        console.log(`${headlineIcon} ${chalk.bold(headlineText)}${changedFileCount ? chalk.gray(` — ${changedFileCount} file${changedFileCount === 1 ? '' : 's'} changed`) : ''}`);
         if (hasTaskInfo) {
             const succ = outcome.tasksTotal > 0 ? `${outcome.tasksSucceeded}/${outcome.tasksTotal}` : `${outcome.tasksSucceeded}`;
             console.log(chalk.gray(`  Tasks completed: ${succ}`));
@@ -3129,7 +3174,29 @@ export class ChatCommand {
             console.log(chalk.gray('  Planner:  ') + chalk.red(outcome.plannerError.slice(0, 140)));
         }
         if (outcome.executorError) {
-            console.log(chalk.gray('  Executor: ') + chalk.red(outcome.executorError.slice(0, 140)));
+            console.log(chalk.gray('  Executor: ') + chalk.red(outcome.executorError.slice(0, 240)));
+        }
+        const hasDiagnostics = outcome.clientToolErrors.length > 0
+            || outcome.transportErrors.length > 0
+            || outcome.workspaceSyncIssue;
+        if (hasDiagnostics) {
+            console.log('');
+            console.log(chalk.gray('Why this run struggled:'));
+            if (outcome.workspacePath) {
+                console.log('  ' + chalk.white(`Workspace: ${outcome.workspacePath}`));
+            }
+            for (const err of outcome.clientToolErrors.slice(0, 3)) {
+                console.log('  ' + chalk.yellow('Local tools: ') + chalk.white(err.slice(0, 220)));
+            }
+            for (const err of outcome.transportErrors.slice(0, 2)) {
+                console.log('  ' + chalk.yellow('Connectivity: ') + chalk.white(err.slice(0, 220)));
+            }
+            if (outcome.workspaceSyncIssue) {
+                console.log('  ' + chalk.yellow('Sync: ') + chalk.white(outcome.workspaceSyncIssue));
+            }
+            if (outcome.clientToolErrors.some((e) => /no pending client tool call|rejected/i.test(e))) {
+                console.log('  ' + chalk.gray('The agent tried to use your local machine for file tools, but the server timed out waiting. /retry usually works after the SSE bridge fix.'));
+            }
         }
         console.log('');
         console.log(chalk.gray('Result:'));
@@ -3244,12 +3311,19 @@ export class ChatCommand {
             return;
         }
         const o = this.lastAgentRunOutcome;
-        const executorSucceeded = o.failedTaskIds.length === 0
-            && o.unfinishedTaskIds.length === 0
-            && !o.plannerError
-            && !o.executorError
-            && o.hasOutput;
-        this.printAgentRunSummary(o, executorSucceeded, 0);
+        const statusEval = evaluateExecutorSuccess({
+            executorFailed: o.failedTaskIds.length > 0,
+            plannerError: o.plannerError,
+            executorError: o.executorError,
+            tasksTotal: o.tasksTotal,
+            tasksSucceeded: o.tasksSucceeded,
+            changedFileCount: 0,
+            requiresWorkspaceChanges: this.taskRequiresWorkspaceChanges(o.prompt),
+            workspaceHasOutput: o.hasOutput,
+            failedTaskIds: new Set(o.failedTaskIds),
+            analysisToolsUsed: 0,
+        });
+        this.printAgentRunSummary(o, statusEval, 0);
     }
     showContext() {
         if (!this.currentSession) {

package/dist/index.js

@@ -35,6 +35,7 @@ import { HistoryCommand } from './commands/history.js';
 import { ReplayCommand } from './commands/replay.js';
 import { ForkCommand } from './commands/fork.js';
 import { CancelCommand } from './commands/cancel.js';
+import { BackgroundCommand } from './commands/background.js';
 import { SecurityCommand } from './commands/security.js';
 import { Config } from './utils/config.js';
 import { Logger, CH } from './utils/logger.js';
@@ -333,7 +334,7 @@ function isAuthProtectedCommand(command) {
         'agent', 'a', 'operator', 'op',
         'edit', 'e', 'generate', 'g', 'explain', 'x', 'fix', 'f', 'review', 'r',
         'workflow', 'flow', 'hub', 'marketplace', 'deploy', 'host', 'preview', 'device',
-        'legion', 'history', 'runs', 'replay', 'fork', 'cancel',
+        'legion', 'history', 'runs', 'replay', 'fork', 'cancel', 'background', 'bg',
         'repo', 'repository',
     ]);
     return protectedCommands.has(command);
@@ -489,7 +490,7 @@ export async function main(args) {
     const isLegionCortexRequest = invokedBinaryName === 'vigthoria' && argv[2] === 'legion' && argv.includes('--cortex');
     if (invokedBinaryName === 'vigthoria-chat') {
         const knownCommands = new Set([
-            'chat', 'chat-resume', 'agent', 'edit', 'generate', 'explain', 'fix', 'review', 'cancel',
+            'chat', 'chat-resume', 'agent', 'edit', 'generate', 'explain', 'fix', 'review', 'cancel', 'background', 'bg',
             'hub', 'repo', 'deploy', 'operator', 'workflow', 'flow', 'device', 'security', 'vsec', 'login', 'logout', 'status', 'config', 'update',
             '--help', '-h', '--version', '-V', 'help', 'version',
         ]);
@@ -1088,6 +1089,58 @@ Examples:
     repoCommand.action(() => {
         repoCommand.outputHelp();
     });
+    // ==================== BACKGROUND AGENT JOBS ====================
+    const backgroundCommand = program
+        .command('background')
+        .alias('bg')
+        .description('Run and manage detached Vigthoria Agent jobs');
+    backgroundCommand
+        .command('start <prompt...>')
+        .description('Start an Agent job in the background and return immediately')
+        .option('--workspace <path>', 'Local workspace path', process.cwd())
+        .option('--json', 'Emit JSON output', false)
+        .action(async (prompt, options) => {
+        const bg = new BackgroundCommand(config, logger);
+        await bg.start(prompt, options);
+    });
+    backgroundCommand
+        .command('list')
+        .alias('ls')
+        .description('List recent background jobs')
+        .option('--limit <n>', 'Maximum jobs to show', '20')
+        .option('--json', 'Emit JSON output', false)
+        .action(async (options) => {
+        const bg = new BackgroundCommand(config, logger);
+        await bg.list({ ...options, limit: Number(options.limit) || 20 });
+    });
+    backgroundCommand
+        .command('status <jobId>')
+        .description('Show background job status')
+        .option('--json', 'Emit JSON output', false)
+        .action(async (jobId, options) => {
+        const bg = new BackgroundCommand(config, logger);
+        await bg.status(jobId, options);
+    });
+    backgroundCommand
+        .command('apply <jobId>')
+        .description('Apply completed background job file changes to the local workspace')
+        .option('--workspace <path>', 'Local workspace path', process.cwd())
+        .option('--json', 'Emit JSON output', false)
+        .action(async (jobId, options) => {
+        const bg = new BackgroundCommand(config, logger);
+        await bg.apply(jobId, options);
+    });
+    backgroundCommand
+        .command('cancel <jobId>')
+        .description('Cancel a running background job')
+        .option('--json', 'Emit JSON output', false)
+        .action(async (jobId, options) => {
+        const bg = new BackgroundCommand(config, logger);
+        await bg.cancel(jobId, options);
+    });
+    backgroundCommand.action(() => {
+        backgroundCommand.outputHelp();
+    });
     // ==================== DEPLOY COMMANDS ====================
     // Deploy command - Host projects on Vigthoria
     const deployCommand = program

package/dist/utils/agentRunOutcome.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Task-and-quality-validated success evaluation for V3 agent runs.
+ * Decouples CLI verdict from raw file-change counts (1.11.0+).
+ */
+export interface LiveOutcome {
+    executorFailed: boolean;
+    plannerError: string | null;
+    executorError: string | null;
+    tasksTotal: number;
+    tasksSucceeded: number;
+    changedFileCount: number;
+    requiresWorkspaceChanges: boolean;
+    workspaceHasOutput: boolean;
+    failedTaskIds: Set<string>;
+    analysisToolsUsed: number;
+}
+export interface TaskSummaryEvent {
+    status?: string;
+    task_id?: string;
+    id?: string;
+}
+export interface RunEvaluation {
+    executorSucceeded: boolean;
+    statusHeadline: string;
+    uiTheme: 'success' | 'warning' | 'error';
+}
+export declare function createLiveOutcome(): LiveOutcome;
+/** Process executor_complete / task summary events from the V3 SSE stream. */
+export declare function handleTaskEvent(summary: TaskSummaryEvent, liveOutcome: LiveOutcome): void;
+/** Track read/discovery tool usage for analysis-turn accountability. */
+export declare function noteAnalysisToolUse(toolName: string, liveOutcome: LiveOutcome): void;
+/**
+ * Compute the real CLI success verdict.
+ * When tasks were planned, ALL must succeed — file changes alone never imply victory.
+ */
+export declare function evaluateExecutorSuccess(liveOutcome: LiveOutcome): RunEvaluation;