vigthoria-cli 1.13.25 → 1.13.29

package/dist/commands/chat.js

@@ -22,7 +22,7 @@ import { renderDynamicHelp } from '../utils/command-menu.js';
 import { resolvePromptWorkspace } from '../utils/prompt-workspace-resolver.js';
 import { FileUtils } from '../utils/files.js';
 import { isDirectModeFollowUpQuestion, sanitizeDirectModeOutput, stripHiddenThoughtBlocks } from '../utils/direct-output-policy.js';
-import { createLiveOutcome, evaluateExecutorSuccess, handleRunCompleteEvent, handleTaskEvent, isSubstantiveAgentAnswer, isToolEvidenceStubAnswer, normalizeAgentAnswerContent, noteAnalysisToolUse, } from '../utils/agentRunOutcome.js';
+import { createLiveOutcome, evaluateExecutorSuccess, handleRunCompleteEvent, handleTaskEvent, isSubstantiveAgentAnswer, isToolEvidenceStubAnswer, normalizeAgentAnswerContent, noteAnalysisToolUse, resolveAgentPartialMutation, } from '../utils/agentRunOutcome.js';
 import { looksLikeMarkdownReport, renderMarkdownToTerminal, summarizeMarkdownReport, } from '../utils/terminalMarkdown.js';
 import { emitDeckEvent, isDeckModeEnabled } from '../utils/deckEvents.js';
 import { formatGoaSystemGrounding, splitGoaContextFromInput, } from '../utils/goaEvents.js';
@@ -30,6 +30,7 @@ import { inferAgentTaskTypeWithContext, resolvePlannerAgentTimeoutMs, resolveWor
 import { resolveAgentRoute } from '../utils/agentRoute.js';
 import { isV3StreamKeepaliveEvent } from '../utils/v3-stream-events.js';
 import { resolveAutoApproval } from '../utils/process-policy.js';
+import { hasLocalV3ServiceIdentity } from '../utils/runtime-capability.js';
 import { ChatToolCallParser } from '../utils/chat-tool-call-parser.js';
 import { ChatPromptPolicy } from '../utils/chat-prompt-policy.js';
 import { AgentStreamState } from '../utils/agent-stream-state.js';
@@ -1333,17 +1334,18 @@ export class ChatCommand {
             isJsonOutput: () => this.jsonOutput,
             idleTimeoutMs: () => DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS,
         });
-        this.sessionManager = new SessionManager();
+        this.sessionManager = new SessionManager(this.config.getStateRoot());
     }
     async run(options) {
+        this.agentMode = options.agent === true;
+        this.operatorMode = options.operator === true;
         const hasRuntimeToken = Boolean(process.env.VIGTHORIA_TOKEN || process.env.VIGTHORIA_AUTH_TOKEN);
-        if (!this.config.isAuthenticated() && !hasRuntimeToken) {
+        const hasAgentServiceIdentity = this.agentMode && hasLocalV3ServiceIdentity();
+        if (!this.config.isAuthenticated() && !hasRuntimeToken && !hasAgentServiceIdentity) {
             throw new CliCommandError('Not authenticated. Run: vigthoria login', {
                 code: 'AUTH_REQUIRED', category: 'authentication',
             });
         }
-        this.agentMode = options.agent === true;
-        this.operatorMode = options.operator === true;
         this.workflowTarget = typeof options.workflow === 'string' && options.workflow.trim()
             ? options.workflow.trim()
             : null;
@@ -1884,26 +1886,14 @@ export class ChatCommand {
             await this.runOperatorDirectAnswer(prompt);
             return;
         }
-        // ── Repo-grounded operator path: try V3 agent first, then fall back ──
-        // Prompts that reference files, code symbols, or analysis verbs need
-        // tool access to read actual file contents.  Route these through the
-        // V3 agent (which archives runs for history/replay/fork and supports
-        // workspace hydration) first.  Falls back to local agent loop if V3
-        // is unreachable.
-        if (this.isRepoGroundedPrompt(prompt) && this.tools) {
-            this.operatorMode = true;
-            const handledByV3 = await this.tryV3AgentWorkflow(prompt);
-            if (handledByV3) {
-                this.saveSession();
-                return;
-            }
-            await this.runLocalAgentLoop(prompt);
-            return;
-        }
         getBridgeClient()?.emitPrompt({ prompt, mode: 'operator', model: this.currentModel });
         const runtimeContext = await this.getPromptRuntimeContext(prompt);
         const spinner = this.jsonOutput ? null : createSpinner({ text: 'Thinking like an operator...', spinner: 'clock' }).start();
-        const workflowType = 'full';
+        // Operator is the BMAD surface. Keep grounded repository analysis on the
+        // Operator service and make mutation intent explicit instead of silently
+        // diverting it into V3 Agent mode. Read-only is the fail-safe default.
+        const operatorTaskType = inferAgentTaskTypeWithContext(prompt);
+        const workflowType = resolveWorkflowType(operatorTaskType, prompt);
         const executionPrompt = this.buildExecutionPrompt(prompt);
         try {
             this.rememberBrainEvent('task', `GoA operator workflow started for prompt: ${prompt.slice(0, 220)}`, 'operator');
@@ -2931,15 +2921,24 @@ export class ChatCommand {
             if (this.streamState.streamingStarted && !this.streamState.streamedAnswerDisplayed) {
                 this.displayV3StreamedAnswer();
             }
-            const previewGate = (response.metadata?.previewGate || null);
+            const serverPreviewGate = (response.metadata?.previewGate || null);
             const workspaceHasOutput = this.api.hasAgentWorkspaceOutput(workspaceContext);
             const changedFileCount = response.changedFiles ? Object.keys(response.changedFiles).length : 0;
             const requiresWorkspaceChanges = taskRequiresWorkspaceChangesWithContext(contextualPrompt, intentContext);
+            const previewGate = requiresWorkspaceChanges
+                ? serverPreviewGate
+                : { required: false, passed: true, skipped: false };
             const answerContent = normalizeAgentAnswerContent(response.content, this.streamState.streamedAnswerBuffer);
             liveOutcome.changedFileCount = changedFileCount;
             liveOutcome.requiresWorkspaceChanges = requiresWorkspaceChanges;
             liveOutcome.workspaceHasOutput = requiresWorkspaceChanges ? workspaceHasOutput : false;
             liveOutcome.answerContent = answerContent;
+            const workflowError = response.metadata?.workflowError;
+            if (workflowError && !liveOutcome.executorError) {
+                liveOutcome.executorError = typeof workflowError === 'string'
+                    ? workflowError
+                    : String(workflowError.message || 'Agent execution failed.');
+            }
             const success = previewGate?.required === true
                 ? previewGate?.passed === true && previewGate?.skipped !== true
                 : true;
@@ -2954,6 +2953,10 @@ export class ChatCommand {
                     return false;
                 }
                 const errorMessage = `V3 agent workflow returned an incomplete result and legacy fallback is disabled. ${previewGate?.error || 'Workspace changes were not fully validated.'}`;
+                const partialMutation = resolveAgentPartialMutation(changedFileCount, response.metadata?.partialMutation);
+                liveOutcome.executorError = previewGate?.error || 'Template Service preview proof did not pass.';
+                liveOutcome.failedTaskIds.add('preview-gate');
+                liveOutcome.unfinishedTaskIds.delete('agent-run-in-progress');
                 if (spinner) {
                     spinner.stop();
                 }
@@ -2963,8 +2966,8 @@ export class ChatCommand {
                 watcher?.stop();
                 throw new CliCommandError(errorMessage, {
                     code: 'AGENT_PREVIEW_FAILED',
-                    category: previewGate?.partialMutation === false ? 'execution' : 'partial_mutation',
-                    partialMutation: previewGate?.partialMutation ?? 'unknown',
+                    category: partialMutation === false ? 'execution' : 'partial_mutation',
+                    partialMutation,
                     details: { executionPath: 'v3-agent', previewGate },
                 });
             }
@@ -3159,10 +3162,11 @@ export class ChatCommand {
                 }
             }
             if (!executorSucceeded) {
+                const partialMutation = resolveAgentPartialMutation(changedFileCount, response.metadata?.partialMutation);
                 throw new CliCommandError(runEvaluation.statusHeadline, {
                     code: 'AGENT_INCOMPLETE',
-                    category: response.partial === true || liveOutcome.tasksSucceeded > 0 ? 'partial_mutation' : 'execution',
-                    partialMutation: response.partial === true || liveOutcome.tasksSucceeded > 0 ? 'unknown' : false,
+                    category: partialMutation === false ? 'execution' : 'partial_mutation',
+                    partialMutation,
                     details: {
                         mode: 'agent',
                         model: routingPolicy.selectedModel,
@@ -3208,9 +3212,61 @@ export class ChatCommand {
         catch (error) {
             this.stopV3IdleWatch();
             watcher?.stop();
+            const persistTypedAgentFailure = (failure) => {
+                const safeFailure = sanitizeUserFacingErrorText(failure.message || 'Agent execution failed.');
+                liveOutcome.streamAborted = true;
+                if (!liveOutcome.executorError)
+                    liveOutcome.executorError = safeFailure;
+                if (failure.code === 'AGENT_PLAN_INVALID')
+                    liveOutcome.failedTaskIds.add('agent-plan');
+                liveOutcome.unfinishedTaskIds.delete('agent-run-in-progress');
+                this.commitAgentRunOutcome({
+                    prompt,
+                    originalPrompt: null,
+                    taskId: null,
+                    contextId: executionId,
+                    tasksSucceeded: liveOutcome.tasksSucceeded,
+                    tasksTotal: liveOutcome.tasksTotal,
+                    failedTaskIds: [...liveOutcome.failedTaskIds],
+                    unfinishedTaskIds: [...liveOutcome.unfinishedTaskIds],
+                    qualityScore: liveOutcome.qualityScore,
+                    qualityMissing: liveOutcome.qualityMissing,
+                    qualityBlockers: liveOutcome.qualityBlockers,
+                    hasOutput: this.api.hasAgentWorkspaceOutput(workspaceContext),
+                    answerContent: null,
+                    selfHealStatus: 'failed',
+                    selfHealTool: null,
+                    plannerError: liveOutcome.plannerError ? sanitizeUserFacingErrorText(liveOutcome.plannerError) : null,
+                    executorError: liveOutcome.executorError,
+                    clientToolErrors: this.api.getClientToolErrors(),
+                    transportErrors: this.api.getLastChatTransportErrors(),
+                    workspacePath: workspacePath || null,
+                    workspaceSyncIssue: null,
+                    finishedAt: Date.now(),
+                }, prompt);
+                this.updateAgentExecutionCheckpoint({
+                    status: 'failed',
+                    contextId: executionId,
+                    failedTaskIds: [...liveOutcome.failedTaskIds],
+                    unfinishedTaskIds: [...liveOutcome.unfinishedTaskIds],
+                    error: liveOutcome.executorError,
+                });
+            };
+            if (error?.code === 'AGENT_PLAN_INVALID') {
+                const planFailure = new CliCommandError(error.message, {
+                    code: 'AGENT_PLAN_INVALID',
+                    category: 'execution',
+                    partialMutation: error?.partialMutation ?? false,
+                    details: error?.mutation ? { mutation: error.mutation } : undefined,
+                    cause: error,
+                });
+                persistTypedAgentFailure(planFailure);
+                throw planFailure;
+            }
             if (error instanceof CliCommandError) {
                 if (spinner)
                     spinner.stop();
+                persistTypedAgentFailure(error);
                 throw error;
             }
             if (!this.api.hasAgentWorkspaceOutput(workspaceContext)) {

package/dist/commands/config.js

@@ -101,8 +101,8 @@ export class ConfigCommand {
                     message: 'Default AI model:',
                     choices: [
                         { name: '═══ Code Models ═══', disabled: true },
-                        { name: 'Vigthoria v4 Creative 27B - Architect and planning', value: 'architect' },
-                        { name: 'Vigthoria v4 Code 27B - Production executor', value: 'code' },
+                        { name: 'Vigthoria v4.2 Creative 27B - Multimodal architect and planning', value: 'architect' },
+                        { name: 'Vigthoria v4.2 Code 27B - Production executor', value: 'code' },
                         { name: 'Vigthoria v4 Assistant 9B - Fast FIM and diagnostics', value: 'assistant' },
                     ],
                     default: 'code',
@@ -309,8 +309,8 @@ export class ConfigCommand {
                 name: 'defaultModel',
                 message: 'Default AI model:',
                 choices: [
-                    { name: 'Vigthoria v4 Creative 27B — Architect', value: 'architect' },
-                    { name: 'Vigthoria v4 Code 27B — Executor', value: 'code' },
+                    { name: 'Vigthoria v4.2 Creative 27B — Multimodal Architect', value: 'architect' },
+                    { name: 'Vigthoria v4.2 Code 27B — Executor', value: 'code' },
                     { name: 'Vigthoria v4 Assistant 9B — FIM and diagnostics', value: 'assistant' },
                 ],
                 default: current.preferences.defaultModel,

package/dist/commands/fork.d.ts

@@ -7,10 +7,11 @@ interface ForkOptions {
 }
 export declare class ForkCommand {
     private config;
-    constructor(config: Config, _logger: Logger);
+    private logger;
+    constructor(config: Config, logger: Logger);
     private getHeaders;
     private getBaseUrl;
-    private resolveWorkspaceRoot;
+    private buildForkHistory;
     run(runId: string, message: string, options: ForkOptions): Promise<void>;
 }
 export {};

package/dist/commands/fork.js

@@ -3,14 +3,17 @@ import { hasLocalV3AgentCapability } from '../utils/runtime-capability.js';
  * fork.ts — Fork from an existing V3 agent run and stream the result.
  */
 import chalk from 'chalk';
-import { createRequire } from 'node:module';
 import { createSpinner, CH } from '../utils/logger.js';
 import { CliCommandError, commandFailure, formatSuccessJson } from '../utils/command-contract.js';
-const require = createRequire(import.meta.url);
+import { createAPIClient } from '../utils/api-client-factory.js';
+import { buildLocalWorkspaceReference } from '../utils/workspace-reference.js';
+import { guardedFetch } from '../utils/network-policy.js';
 export class ForkCommand {
     config;
-    constructor(config, _logger) {
+    logger;
+    constructor(config, logger) {
         this.config = config;
+        this.logger = logger;
     }
     getHeaders() {
         const headers = { 'Content-Type': 'application/json' };
@@ -34,50 +37,69 @@ export class ForkCommand {
             (allowLocal ? 'http://127.0.0.1:8030' : null) ||
             configuredApiUrl);
     }
-    resolveWorkspaceRoot(project) {
-        if (/^[a-zA-Z]:[\\/]/.test(project) || /^\\\\/.test(project))
-            return '';
-        if (typeof require !== 'undefined') {
-            try {
-                const path = require('path');
-                if (!path.isAbsolute(project))
-                    return '';
+    buildForkHistory(events, eventIndex) {
+        const selected = eventIndex > 0 ? events.slice(0, eventIndex) : events;
+        const lines = [
+            `Fork point: ${eventIndex > 0 ? eventIndex : events.length} of ${events.length} recorded events.`,
+            'Prior run evidence (metadata only; re-read current files through client tools):',
+        ];
+        let toolCalls = 0;
+        for (const event of selected.slice(-120)) {
+            const type = String(event?.type || 'unknown');
+            if (type === 'plan') {
+                const count = Array.isArray(event.tasks) ? event.tasks.length : 0;
+                lines.push(`- plan: ${count} task(s)`);
             }
-            catch { }
+            else if (type === 'tool_call') {
+                toolCalls += 1;
+                lines.push(`- tool_call ${toolCalls}: ${String(event.name || 'unknown').slice(0, 80)}`);
+            }
+            else if (type === 'tool_result') {
+                lines.push(`- tool_result: ${String(event.name || 'unknown').slice(0, 80)} success=${event.success !== false}`);
+            }
+            else if (type === 'file_mutation') {
+                lines.push(`- file_mutation: ${String(event.kind || 'change').slice(0, 32)} (path intentionally omitted)`);
+            }
+            else if (type === 'complete') {
+                lines.push('- prior run reached its completion event');
+            }
+            else if (type === 'error') {
+                lines.push(`- prior run error code: ${String(event.code || event.error_code || 'unspecified').slice(0, 80)}`);
+            }
+            if (lines.join('\n').length > 12_000)
+                break;
         }
-        return project;
+        return lines.join('\n').slice(0, 12_000);
     }
     async run(runId, message, options) {
         const project = options.project || process.cwd();
-        const workspace = this.resolveWorkspaceRoot(project);
+        const workspaceRef = buildLocalWorkspaceReference(project, String(this.config.get('userId') || this.config.get('email') || ''));
         const eventIndex = options.eventIndex || 0;
-        const spinner = createSpinner(`Forking run ${runId}...`).start();
+        const spinner = createSpinner(`Loading run ${runId} for a local fork...`).start();
         const streamController = new AbortController();
+        let api = null;
         let interrupted = false;
         const onInterrupt = () => {
             interrupted = true;
             streamController.abort();
+            api?.destroy();
         };
         process.once('SIGINT', onInterrupt);
         try {
             const baseUrl = this.getBaseUrl();
-            const body = {
-                workspace_root: workspace,
-                from_event_index: eventIndex,
-                new_request: message || '',
-                stream: true,
-                context: '',
-            };
-            const resp = await fetch(`${baseUrl}/api/runs/${encodeURIComponent(runId)}/fork`, {
-                method: 'POST',
+            const params = new URLSearchParams({
+                workspace_root: '',
+                local_workspace_path: workspaceRef,
+                project_path: workspaceRef,
+            });
+            const resp = await guardedFetch(`${baseUrl}/api/runs/${encodeURIComponent(runId)}/events?${params}`, {
                 headers: this.getHeaders(),
-                body: JSON.stringify(body),
                 signal: streamController.signal,
-            });
+            }, { audience: 'v3' });
             if (!resp.ok) {
                 spinner.stop();
                 if (resp.status === 404) {
-                    throw new CliCommandError(`Run ${runId} not found or has no event log.`, {
+                    throw new CliCommandError(`Run ${runId} was not found or has no event log.`, {
                         code: 'RUN_NOT_FOUND', status: resp.status,
                     });
                 }
@@ -87,116 +109,94 @@ export class ForkCommand {
                     });
                 }
                 else {
-                    throw new CliCommandError(`Fork failed: ${resp.status} ${resp.statusText}`, {
+                    throw new CliCommandError(`Could not load the fork source: ${resp.status} ${resp.statusText}`, {
                         code: 'RUN_FORK_FAILED', status: resp.status,
                     });
                 }
             }
+            const source = (await resp.json());
+            const sourceEvents = Array.isArray(source.events) ? source.events : [];
+            if (eventIndex < 0 || eventIndex > sourceEvents.length) {
+                throw new CliCommandError(`Fork event index ${eventIndex} is outside 0..${sourceEvents.length}.`, {
+                    code: 'RUN_FORK_EVENT_INDEX_INVALID',
+                });
+            }
+            const forkHistory = this.buildForkHistory(sourceEvents, eventIndex);
             spinner.stop();
-            if (!options.json)
-                console.log(chalk.bold(`\n${CH.success} Forked from ${chalk.cyan(runId)} at event ${eventIndex}\n`));
-            if (!resp.body) {
-                throw new CliCommandError('Fork response did not contain an event stream', { code: 'RUN_FORK_STREAM_MISSING' });
+            if (!options.json) {
+                console.log(chalk.bold(`\n${CH.success} Starting local fork from ${chalk.cyan(runId)} at event ${eventIndex || sourceEvents.length}\n`));
             }
-            // Stream SSE events
-            const reader = resp.body.getReader();
-            const decoder = new TextDecoder();
-            let buffer = '';
+            const streamEvents = [];
             let toolCallNum = 0;
-            let completed = false;
-            const events = [];
-            const configuredIdle = Number.parseInt(process.env.VIGTHORIA_FORK_IDLE_TIMEOUT_MS || '', 10);
-            const idleTimeoutMs = Number.isFinite(configuredIdle) && configuredIdle > 0 ? configuredIdle : 60_000;
-            stream: while (true) {
-                let timer;
-                const { done, value } = await Promise.race([
-                    reader.read(),
-                    new Promise((_resolve, reject) => {
-                        timer = setTimeout(() => {
-                            streamController.abort();
-                            reject(new CliCommandError(`Fork event stream was idle for ${idleTimeoutMs}ms.`, {
-                                code: 'RUN_FORK_IDLE_TIMEOUT', category: 'network',
-                            }));
-                        }, idleTimeoutMs);
-                    }),
-                ]).finally(() => {
-                    if (timer)
-                        clearTimeout(timer);
-                });
-                if (done)
-                    break;
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split('\n');
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    if (!line.startsWith('data: '))
-                        continue;
-                    const payload = line.slice(6).trim();
-                    if (payload === '[DONE]') {
-                        completed = true;
-                        break stream;
+            api = createAPIClient(this.config, this.logger);
+            const request = [
+                message.trim() || 'Continue the previous run from the selected fork point.',
+                '',
+                forkHistory,
+                '',
+                'Use the current client-authoritative workspace as truth. Re-read every needed file through client tools; do not assume prior file contents.',
+            ].join('\n');
+            const result = await api.runV3AgentWorkflow(request, {
+                projectPath: project,
+                targetPath: project,
+                workspacePath: project,
+                localWorkspacePath: project,
+                localMachineCapable: true,
+                clientToolExecution: true,
+                executionSurface: 'fork',
+                clientSurface: 'cli',
+                rawPrompt: message || request,
+                contextualPrompt: forkHistory,
+                forkedFrom: runId,
+                forkEventIndex: eventIndex,
+                onStreamEvent: (event) => {
+                    streamEvents.push({
+                        type: String(event.type || 'unknown'),
+                        name: typeof event.name === 'string' ? event.name : undefined,
+                        success: typeof event.success === 'boolean' ? event.success : undefined,
+                        code: typeof event.code === 'string' ? event.code : undefined,
+                    });
+                    if (options.json)
+                        return;
+                    const type = String(event.type || 'unknown');
+                    if (type === 'plan') {
+                        console.log(chalk.magenta(`  📋 PLAN`) + ` ${event.tasks?.length || 0} tasks`);
                     }
-                    try {
-                        const evt = JSON.parse(payload);
-                        const type = evt.type || 'unknown';
-                        events.push(evt);
-                        if (options.json) {
-                            continue;
-                        }
-                        switch (type) {
-                            case 'context':
-                                console.log(chalk.blue(`  context: ${evt.context_id || '?'}`) +
-                                    (evt.forked_from ? chalk.dim(` (forked from ${evt.forked_from})`) : ''));
-                                break;
-                            case 'start':
-                                console.log(chalk.green(`  ▶ START`) + ` task=${evt.task_id || '?'}` +
-                                    (evt.forked_from ? chalk.dim(` forked_from=${evt.forked_from}`) : ''));
-                                break;
-                            case 'plan':
-                                console.log(chalk.magenta(`  📋 PLAN`) + ` ${evt.tasks?.length || 0} tasks`);
-                                break;
-                            case 'tool_call':
-                                toolCallNum++;
-                                console.log(chalk.yellow(`  🔧 #${toolCallNum}`) + ` ${evt.name || '?'}(${JSON.stringify(evt.arguments || {}).substring(0, 60)})`);
-                                break;
-                            case 'tool_result': {
-                                const icon = evt.success !== false ? chalk.green('✓') : chalk.red('✗');
-                                console.log(`    ${icon} ${evt.name || '?'}: ${chalk.dim((evt.output || '').substring(0, 100))}`);
-                                break;
-                            }
-                            case 'message':
-                                console.log(chalk.cyan(`  💬 `) + (evt.content || '').substring(0, 150));
-                                break;
-                            case 'complete': {
-                                const seal = evt.seal_score ? `[${evt.seal_score.tier} ${evt.seal_score.overall}]` : '';
-                                console.log(chalk.green(`  ✅ COMPLETE `) + chalk.yellow(seal) +
-                                    ` ${evt.iterations || '?'} iterations, ${evt.tool_calls || '?'} tool calls`);
-                                break;
-                            }
-                            case 'error':
-                                throw new CliCommandError(String(evt.message || 'Fork stream reported an error.'), {
-                                    code: 'RUN_FORK_STREAM_ERROR', details: evt,
-                                });
-                            default:
-                                console.log(chalk.dim(`  ${type}: ${JSON.stringify(evt).substring(0, 80)}`));
-                        }
+                    else if (type === 'tool_call') {
+                        toolCallNum += 1;
+                        console.log(chalk.yellow(`  🔧 #${toolCallNum}`) + ` ${event.name || '?'}`);
                     }
-                    catch (error) {
-                        if (error instanceof CliCommandError)
-                            throw error;
-                        throw new CliCommandError('Fork event stream contained malformed JSON.', {
-                            code: 'RUN_FORK_STREAM_MALFORMED', details: { payload: payload.slice(0, 200) }, cause: error,
-                        });
+                    else if (type === 'tool_result') {
+                        const icon = event.success !== false ? chalk.green('✓') : chalk.red('✗');
+                        console.log(`    ${icon} ${event.name || '?'}`);
                     }
-                }
-            }
-            if (!completed) {
-                throw new CliCommandError('Fork event stream ended without a completion marker.', { code: 'RUN_FORK_STREAM_INCOMPLETE' });
+                    else if (type === 'message' && event.content) {
+                        console.log(chalk.cyan('  💬 ') + String(event.content).slice(0, 180));
+                    }
+                    else if (type === 'complete') {
+                        console.log(chalk.green('  ✅ COMPLETE'));
+                    }
+                },
+            });
+            if (result.partial) {
+                throw new CliCommandError('Fork execution ended with a partial result.', {
+                    code: 'RUN_FORK_PARTIAL', details: { contextId: result.contextId, taskId: result.taskId },
+                });
             }
             if (options.json) {
-                console.log(formatSuccessJson('fork', { runId, eventIndex, events }, { stream: true, eventCount: events.length }));
+                console.log(formatSuccessJson('fork', {
+                    runId,
+                    eventIndex: eventIndex || sourceEvents.length,
+                    taskId: result.taskId,
+                    contextId: result.contextId,
+                    content: result.content,
+                    changedFiles: Object.keys(result.changedFiles || {}),
+                    events: streamEvents,
+                }, { stream: true, eventCount: streamEvents.length, workspaceAuthority: 'client-tool-bridge' }));
             }
             else {
+                if (result.content)
+                    console.log(result.content);
                 console.log(chalk.bold(`\n${CH.success} Fork run complete\n`));
             }
         }
@@ -208,6 +208,7 @@ export class ForkCommand {
             throw commandFailure(err, { code: 'RUN_FORK_FAILED' });
         }
         finally {
+            api?.destroy();
             process.removeListener('SIGINT', onInterrupt);
         }
     }

package/dist/commands/game.d.ts

@@ -8,6 +8,14 @@ export declare function gameProcessInvocation(pm: Manager, args: readonly string
     executable: string;
     args: string[];
 };
+export declare function windowsProcessTreeTerminationInvocation(pid: number, systemRoot?: string): {
+    executable: string;
+    args: string[];
+};
+export declare const runGameProcess: (pm: Manager, args: string[], cwd: string, timeoutMs?: number, outputMode?: "inherit" | "capture") => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
 export declare class GameCommand {
     private logger;
     constructor(logger: Logger);