vigthoria-cli 1.13.31 → 1.13.42

package/README.md

@@ -35,78 +35,33 @@ The `vigthoria-cli` package installs the `vigthoria`, `vig`, and `vigthoria-chat
 ### Quick Install (Linux/macOS)
 
 ```bash
-curl -fsSL https://cli.vigthoria.io/install.sh | bash
+curl -fsSL https://extension.vigthoria.io/downloads/install.sh | bash
 ```
 
 ### Quick Install (Windows PowerShell)
 
 ```powershell
-irm https://cli.vigthoria.io/install.ps1 | iex
+irm https://extension.vigthoria.io/downloads/install.ps1 | iex
 ```
 
-### npm Install (All Platforms)
-
-```bash
-npm install -g vigthoria-cli
-```
-
-### Manual Install
-
-```bash
-# Clone from Vigthoria Market
-git clone https://market.vigthoria.io/vigthoria/vigthoria-cli.git
-cd vigthoria-cli
-
-# Or from Vigthoria Community
-git clone https://community.vigthoria.io/repos/vigthoria-cli.git
-cd vigthoria-cli
-
-# Install dependencies
-npm install
-
-# Build
-npm run build
-
-# Link globally
-npm link
-```
+The installer downloads the signed release manifest and package only from
+`extension.vigthoria.io`, verifies the detached Ed25519 signature and SHA-256
+identity, and installs the verified local archive transactionally.
 
 ## Troubleshooting Installation
 
-### Network Issues (npm ENOTFOUND)
+### Network Issues
 
-If you see `ENOTFOUND registry.npmjs.org`, try these solutions:
+If the canonical extension endpoint cannot be reached:
 
 1. **Check internet connection:**
    ```bash
-   ping registry.npmjs.org
+   curl -I https://extension.vigthoria.io/downloads/manifest.json
    ```
 
-2. **If behind a corporate proxy:**
-   ```bash
-   npm config set proxy http://proxy.company.com:8080
-   npm config set https-proxy http://proxy.company.com:8080
-   ```
-
-3. **Try an alternative npm registry:**
-   ```bash
-   npm config set registry https://registry.npmmirror.com
-   npm install -g vigthoria-cli
-   # Reset to default after:
-   npm config delete registry
-   ```
-
-4. **Direct tarball download:**
-   ```bash
-   # Download directly
-   npm install -g https://coder.vigthoria.io/releases/vigthoria-cli-latest.tgz
-   ```
-
-5. **Use Git clone method (no npm registry needed):**
-   ```bash
-   git clone https://market.vigthoria.io/vigthoria/vigthoria-cli.git
-   cd vigthoria-cli && npm install && npm run build && npm link
-   ```
+2. Permit outbound HTTPS to `extension.vigthoria.io` through the corporate
+   proxy or firewall. Do not substitute a registry, mirror, Git clone, or
+   alternate download host for the signed release path.
 
 ### Windows-Specific Issues
 

package/SECURITY_HARDENING.md

@@ -21,7 +21,7 @@ The code model is now branded as **Vigthoria_v3_Code_30B**:
 
 1. **Installation:**
    ```bash
-   npm install -g vigthoria-cli
+   curl -fsSL https://extension.vigthoria.io/downloads/install.sh | bash
    ```
 
 2. **Login:**
@@ -57,14 +57,12 @@ When users with version < 1.4.0 run the CLI, they will see:
 ⚠️  SECURITY UPDATE AVAILABLE
    Version 1.3.0 has security vulnerabilities.
    Please update to 1.4.0 immediately:
-   npm install -g vigthoria-cli@latest
+   vigthoria update
 ```
 
 ### Update Command
 ```bash
 vigthoria update
-# or
-npm install -g vigthoria-cli@latest
 ```
 
 ## Vulnerabilities Fixed

package/dist/commands/auth.js

@@ -525,25 +525,27 @@ export async function statusAction() {
             console.log(chalk.yellow('Not logged in.'));
             return;
         }
-        const authProbeHeaders = {
-            Authorization: `Bearer ${effectiveToken}`,
-            Cookie: `vigthoria-auth-token=${effectiveToken}`,
-        };
-        let authLooksValid = true;
         try {
-            const authProbe = await fetch(`${effectiveApiUrl}/api/user/subscription`, { headers: authProbeHeaders, signal: AbortSignal.timeout(6000) });
-            if (authProbe.status === 401 || authProbe.status === 403) {
-                authLooksValid = false;
-            }
-        }
-        catch {
-            // Network failures should not force logout status.
+            validateTokenStructure(effectiveToken, effectiveApiUrl);
         }
-        if (!authLooksValid) {
+        catch (error) {
             throw new CliCommandError('Not logged in. Session expired or invalid. Run: vigthoria login', {
-                code: 'AUTH_SESSION_INVALID', category: 'authentication',
+                code: 'AUTH_SESSION_INVALID', category: 'authentication', cause: error,
             });
         }
+        try {
+            await new AuthSessionService(sharedConfig).validateServerAcceptance(effectiveToken, effectiveApiUrl);
+        }
+        catch (error) {
+            // An explicit authorization rejection invalidates the session. Network
+            // and optional-route failures keep local status available as degraded,
+            // matching the health-probe behavior below.
+            if (/HTTP\s+(?:401|403)\b/i.test(humanMessage(error))) {
+                throw new CliCommandError('Not logged in. Session expired or invalid. Run: vigthoria login', {
+                    code: 'AUTH_SESSION_INVALID', category: 'authentication', cause: error,
+                });
+            }
+        }
         let user = legacyConfig.user;
         try {
             user = await whoami();

package/dist/commands/cancel.d.ts

@@ -5,6 +5,7 @@ interface CancelOptions {
     list?: boolean;
     json?: boolean;
 }
+export declare function resolveCancelRunsPath(baseUrl: string): '/api/runs' | '/api/runs-cli';
 export declare class CancelCommand {
     private config;
     private logger;

package/dist/commands/cancel.js

@@ -10,6 +10,18 @@ import chalk from 'chalk';
 import { createSpinner, CH } from '../utils/logger.js';
 import { SessionManager } from '../utils/session.js';
 import { CliCommandError, formatSuccessJson } from '../utils/command-contract.js';
+export function resolveCancelRunsPath(baseUrl) {
+    try {
+        return new Set(['8032', '18032']).has(new URL(String(baseUrl)).port)
+            ? '/api/runs'
+            : '/api/runs-cli';
+    }
+    catch {
+        return /(?:127\.0\.0\.1|localhost|172\.19\.0\.1|host\.lan):(?:8032|18032)(?:\/|$)/i.test(String(baseUrl))
+            ? '/api/runs'
+            : '/api/runs-cli';
+    }
+}
 export class CancelCommand {
     config;
     logger;
@@ -19,7 +31,11 @@ export class CancelCommand {
         this.logger = logger;
     }
     getHeaders() {
-        const headers = { 'Content-Type': 'application/json' };
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-Vigthoria-Agent-Lane': 'cli',
+            'X-Vigthoria-Source-Product': 'vigthoria-cli',
+        };
         const token = process.env.VIGTHORIA_TOKEN ||
             process.env.VIGTHORIA_AUTH_TOKEN ||
             this.config.get('authToken');
@@ -37,11 +53,12 @@ export class CancelCommand {
         const allowLocal = process.env.VIGTHORIA_ALLOW_LOCAL_V3_AGENT === '1';
         return (process.env.VIGTHORIA_V3_AGENT_URL ||
             process.env.V3_AGENT_URL ||
-            (allowLocal ? 'http://127.0.0.1:8030' : null) ||
+            (allowLocal ? 'http://127.0.0.1:8032' : null) ||
             configuredApiUrl);
     }
     async listActive(baseUrl) {
-        const resp = await fetch(`${baseUrl}/api/runs/active`, { headers: this.getHeaders() });
+        const runsPath = resolveCancelRunsPath(baseUrl);
+        const resp = await fetch(`${baseUrl}${runsPath}/active`, { headers: this.getHeaders() });
         if (!resp.ok) {
             if (resp.status === 404 || resp.status === 502 || resp.status === 503) {
                 throw new CliCommandError(`V3 cancel API is not available on ${baseUrl}. Backend may not expose /api/runs/active.`, { code: 'CANCEL_API_UNAVAILABLE', category: 'network', status: resp.status });
@@ -59,7 +76,7 @@ export class CancelCommand {
         return (await resp.json());
     }
     async cancelOne(baseUrl, contextId) {
-        const resp = await fetch(`${baseUrl}/api/runs/${encodeURIComponent(contextId)}/cancel`, { method: 'POST', headers: this.getHeaders() });
+        const resp = await fetch(`${baseUrl}${resolveCancelRunsPath(baseUrl)}/${encodeURIComponent(contextId)}/cancel`, { method: 'POST', headers: this.getHeaders() });
         if (!resp.ok) {
             if (resp.status === 404) {
                 throw new CliCommandError(`No active run for context_id=${contextId}`, { code: 'ACTIVE_RUN_NOT_FOUND', status: resp.status });

package/dist/commands/chat.d.ts

@@ -52,6 +52,9 @@ export declare class ChatCommand {
     private retryPromptSignature;
     private retryPromptStreak;
     private readonly streamState;
+    private processInterruptHandled;
+    private readonly onSigint;
+    private readonly onSigterm;
     private lastAgentRoute;
     private pendingGoaContext;
     private lastAgentRunOutcome;
@@ -131,6 +134,16 @@ export declare class ChatCommand {
     private updateOperatorSpinner;
     constructor(config: Config, logger: Logger, commandProgram?: Command);
     run(options: ChatOptions): Promise<void>;
+    private installProcessInterruptHandlers;
+    private removeProcessInterruptHandlers;
+    private handleProcessInterrupt;
+    /**
+     * Signal handlers cannot await the normal run lifecycle. Persist the
+     * terminal checkpoint synchronously after workspace rollback so a killed
+     * foreground process is never advertised as resumable work still running.
+     */
+    private finalizeInterruptedAgentCheckpoint;
+    private runWithLifecycle;
     /** Handle an inbound admin command from the Commando Bridge. */
     private handleAdminCommand;
     private ensureProjectWorkspace;

package/dist/commands/chat.js

@@ -33,8 +33,9 @@ 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';
+import { AgentStreamState, classifyAgentToolResultPresentation, normalizeAgentToolOutputForDisplay, } from '../utils/agent-stream-state.js';
 import { CliCommandError, commandFailure, commandNameFromArgv, failureEnvelope, normalizeCommandError, successEnvelope, } from '../utils/command-contract.js';
+import { rollbackActiveMutationJournals } from '../utils/mutation-journal.js';
 // Stream health policy (corrected 2026-07-04 after TestFarm incident with
 // Gideon Lenz / C:\vigthoria\Apps\monopoly): agentic tasks have no
 // predictable duration, so there is intentionally NO overall wall-clock
@@ -161,6 +162,9 @@ export class ChatCommand {
     retryPromptSignature = null;
     retryPromptStreak = 0;
     streamState;
+    processInterruptHandled = false;
+    onSigint = () => this.handleProcessInterrupt('SIGINT');
+    onSigterm = () => this.handleProcessInterrupt('SIGTERM');
     lastAgentRoute = null;
     pendingGoaContext = null;
     // Last completed Agent run — used by /retry, /continue, and the final summary block.
@@ -788,10 +792,7 @@ export class ChatCommand {
         return `${visible.slice(0, Math.max(1, width - 1))}…`;
     }
     normalizeToolOutputForDisplay(output) {
-        return String(output || '')
-            .replace(/\/r\/n|\/n|\\n/g, '\n')
-            .replace(/\/r|\\r/g, '')
-            .replace(/\t/g, '  ');
+        return normalizeAgentToolOutputForDisplay(output);
     }
     toolEventKey(event) {
         const name = String(event?.name || event?.tool || event?.tool_name || '').trim();
@@ -908,6 +909,9 @@ export class ChatCommand {
         if (!event || typeof event !== 'object') {
             return;
         }
+        if (event.user_visible === false || String(event.visibility || '').toLowerCase() === 'internal') {
+            return;
+        }
         this.streamState.noteActivity();
         if (isV3StreamKeepaliveEvent(event)) {
             return;
@@ -960,12 +964,24 @@ export class ChatCommand {
                 this.streamState.seenToolResults.add(eventKey);
             const success = event.success !== false;
             const toolName = event.name || event.tool || '';
+            const presentation = classifyAgentToolResultPresentation(event);
             emitDeckEvent({
                 type: 'tool_end',
                 tool: toolName,
                 success,
                 index: this.streamState.toolCallCount,
             });
+            if (presentation === 'hidden')
+                return;
+            if (presentation === 'correcting') {
+                if (!this.streamState.shouldShowCorrectionNotice())
+                    return;
+                if (spinner.isSpinning)
+                    spinner.stop();
+                this.writeAgentActivityLine(chalk.gray('  ↻ Agent adjusted this step and is continuing.\n'));
+                spinner.text = 'Correcting step...';
+                return;
+            }
             const indicator = success ? chalk.green('  ✓') : chalk.red('  ✗');
             if (spinner.isSpinning)
                 spinner.stop();
@@ -1337,6 +1353,73 @@ export class ChatCommand {
         this.sessionManager = new SessionManager(this.config.getStateRoot());
     }
     async run(options) {
+        this.installProcessInterruptHandlers();
+        try {
+            await this.runWithLifecycle(options);
+        }
+        finally {
+            this.removeProcessInterruptHandlers();
+        }
+    }
+    installProcessInterruptHandlers() {
+        this.processInterruptHandled = false;
+        process.once('SIGINT', this.onSigint);
+        process.once('SIGTERM', this.onSigterm);
+    }
+    removeProcessInterruptHandlers() {
+        process.off('SIGINT', this.onSigint);
+        process.off('SIGTERM', this.onSigterm);
+    }
+    handleProcessInterrupt(signal) {
+        if (this.processInterruptHandled)
+            return;
+        this.processInterruptHandled = true;
+        const ownedMutation = this.api.destroy();
+        const fallbackMutations = rollbackActiveMutationJournals();
+        const mutation = ownedMutation || fallbackMutations[0] || null;
+        this.finalizeInterruptedAgentCheckpoint(signal);
+        this.workspaceBrain?.destroy();
+        getBridgeClient()?.destroy();
+        if (!this.jsonOutput) {
+            const restored = mutation?.rolledBack
+                ? ` Workspace changes were restored (${mutation.affectedPaths.length} path(s)).`
+                : mutation?.partialMutation
+                    ? ' WARNING: the workspace could not be restored completely; inspect the mutation journal before continuing.'
+                    : '';
+            process.stderr.write(`\nAgent interrupted.${restored}\n`);
+        }
+        this.removeProcessInterruptHandlers();
+        // Rollback is synchronous and complete before ownership returns to the OS.
+        // Re-raise the original signal after removing our handlers so the central
+        // process lifecycle retains the conventional 130/143 shell status without
+        // letting a command implementation terminate the process directly.
+        process.kill(process.pid, signal);
+    }
+    /**
+     * Signal handlers cannot await the normal run lifecycle. Persist the
+     * terminal checkpoint synchronously after workspace rollback so a killed
+     * foreground process is never advertised as resumable work still running.
+     */
+    finalizeInterruptedAgentCheckpoint(signal) {
+        const checkpoint = this.currentSession?.activeAgentRun;
+        if (!checkpoint || ['completed', 'cancelled'].includes(checkpoint.status)) {
+            return;
+        }
+        try {
+            assertAgentStatusTransition(checkpoint.status, 'cancelled');
+            this.currentSession.activeAgentRun = {
+                ...checkpoint,
+                status: 'cancelled',
+                updatedAt: new Date().toISOString(),
+                error: `Interrupted by ${signal}; workspace rollback completed before process exit.`,
+            };
+            this.sessionManager.save(this.currentSession);
+        }
+        catch (error) {
+            this.logger.warn('Workspace rollback completed, but the interrupted session checkpoint could not be persisted.', error);
+        }
+    }
+    async runWithLifecycle(options) {
         this.agentMode = options.agent === true;
         this.operatorMode = options.operator === true;
         const hasRuntimeToken = Boolean(process.env.VIGTHORIA_TOKEN || process.env.VIGTHORIA_AUTH_TOKEN);
@@ -2934,6 +3017,9 @@ export class ChatCommand {
             liveOutcome.workspaceHasOutput = requiresWorkspaceChanges ? workspaceHasOutput : false;
             liveOutcome.answerContent = answerContent;
             const workflowError = response.metadata?.workflowError;
+            const workflowErrorCode = typeof workflowError === 'object' && workflowError
+                ? String(workflowError.code || '').trim().toUpperCase()
+                : '';
             if (workflowError && !liveOutcome.executorError) {
                 liveOutcome.executorError = typeof workflowError === 'string'
                     ? workflowError
@@ -2952,10 +3038,36 @@ export class ChatCommand {
                     watcher?.stop();
                     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 workflowFailure = workflowError
+                    ? (typeof workflowError === 'string'
+                        ? workflowError
+                        : String(workflowError.message || ''))
+                    : '';
+                const actionableFailure = sanitizeUserFacingErrorText(liveOutcome.plannerError
+                    || workflowFailure
+                    || liveOutcome.executorError
+                    || previewGate?.error
+                    || 'The agent stopped before it could validate the requested workspace changes.');
+                const reportedMutation = response.metadata?.mutation
+                    || previewGate?.mutation;
+                const rollbackNote = reportedMutation?.rolledBack === true
+                    ? ' Unvalidated workspace changes were rolled back; your prior files were preserved.'
+                    : '';
+                const errorMessage = `${actionableFailure}${rollbackNote}`.trim();
                 const partialMutation = resolveAgentPartialMutation(changedFileCount, response.metadata?.partialMutation);
-                liveOutcome.executorError = previewGate?.error || 'Template Service preview proof did not pass.';
-                liveOutcome.failedTaskIds.add('preview-gate');
+                const preservedTerminalCodes = new Set([
+                    'AGENT_PLAN_INVALID',
+                    'AGENT_CAPACITY_BUSY',
+                    'V3_RUNTIME_IDENTITY_MISMATCH',
+                ]);
+                const terminalCode = preservedTerminalCodes.has(workflowErrorCode)
+                    ? workflowErrorCode
+                    : '';
+                liveOutcome.executorError = actionableFailure;
+                liveOutcome.failedTaskIds.add(terminalCode === 'AGENT_PLAN_INVALID' ? 'agent-plan'
+                    : terminalCode === 'AGENT_CAPACITY_BUSY' ? 'architect-capacity'
+                        : terminalCode === 'V3_RUNTIME_IDENTITY_MISMATCH' ? 'runtime-identity'
+                            : 'preview-gate');
                 liveOutcome.unfinishedTaskIds.delete('agent-run-in-progress');
                 if (spinner) {
                     spinner.stop();
@@ -2965,10 +3077,19 @@ export class ChatCommand {
                 this.messages.push({ role: 'assistant', content: errorMessage });
                 watcher?.stop();
                 throw new CliCommandError(errorMessage, {
-                    code: 'AGENT_PREVIEW_FAILED',
-                    category: partialMutation === false ? 'execution' : 'partial_mutation',
+                    code: terminalCode || 'AGENT_PREVIEW_FAILED',
+                    category: terminalCode === 'V3_RUNTIME_IDENTITY_MISMATCH'
+                        ? 'configuration'
+                        : partialMutation === false ? 'execution' : 'partial_mutation',
                     partialMutation,
-                    details: { executionPath: 'v3-agent', previewGate },
+                    details: {
+                        executionPath: 'v3-agent',
+                        previewGate,
+                        tasksSucceeded: liveOutcome.tasksSucceeded,
+                        tasksTotal: liveOutcome.tasksTotal,
+                        failedTaskIds: [...liveOutcome.failedTaskIds],
+                        nextAction: 'Resolve the first reported blocker, then retry from the same workspace.',
+                    },
                 });
             }
             if (!this.jsonOutput && previewGate?.required) {
@@ -3219,7 +3340,12 @@ export class ChatCommand {
                     liveOutcome.executorError = safeFailure;
                 if (failure.code === 'AGENT_PLAN_INVALID')
                     liveOutcome.failedTaskIds.add('agent-plan');
-                liveOutcome.unfinishedTaskIds.delete('agent-run-in-progress');
+                if (failure.code === 'AGENT_OUTCOME_UNKNOWN') {
+                    liveOutcome.unfinishedTaskIds.add('agent-run-in-progress');
+                }
+                else {
+                    liveOutcome.unfinishedTaskIds.delete('agent-run-in-progress');
+                }
                 this.commitAgentRunOutcome({
                     prompt,
                     originalPrompt: null,
@@ -3263,6 +3389,27 @@ export class ChatCommand {
                 persistTypedAgentFailure(planFailure);
                 throw planFailure;
             }
+            if (error?.code === 'AGENT_OUTCOME_UNKNOWN') {
+                const interruptedFailure = new CliCommandError(error.message, {
+                    code: 'AGENT_OUTCOME_UNKNOWN',
+                    category: 'partial_mutation',
+                    partialMutation: 'unknown',
+                    details: {
+                        operationId: error?.operationId || null,
+                        contextId: error?.contextId || executionId,
+                        resumeCommand: '/continue',
+                    },
+                    cause: error,
+                });
+                if (spinner)
+                    spinner.stop();
+                persistTypedAgentFailure(interruptedFailure);
+                if (!this.jsonOutput && !this.directPromptMode) {
+                    console.log(chalk.yellow('Agent connection interrupted after the run started.'));
+                    console.log(chalk.gray('The task was not submitted again. Type /continue to resume the saved run without duplicating changes.'));
+                }
+                throw interruptedFailure;
+            }
             if (error instanceof CliCommandError) {
                 if (spinner)
                     spinner.stop();
@@ -3348,10 +3495,15 @@ export class ChatCommand {
                     this.printAgentRunSummary(this.lastAgentRunOutcome, failedEval, 0);
                 }
             }
+            const reportedMutation = error?.mutation;
+            const reportedPartialMutation = reportedMutation?.rolledBack === true
+                ? false
+                : (error?.partialMutation ?? reportedMutation?.partialMutation);
+            const partialMutation = resolveAgentPartialMutation(liveOutcome.changedFileCount, reportedPartialMutation);
             throw new CliCommandError(errorMessage, {
                 code: 'AGENT_EXECUTION_FAILED',
-                category: liveOutcome.tasksSucceeded > 0 ? 'partial_mutation' : 'execution',
-                partialMutation: liveOutcome.tasksSucceeded > 0 ? 'unknown' : false,
+                category: partialMutation === false ? 'execution' : 'partial_mutation',
+                partialMutation,
                 details: {
                     executionPath: 'v3-agent',
                     mode: 'agent',
@@ -3359,12 +3511,16 @@ export class ChatCommand {
                     tasksSucceeded: liveOutcome.tasksSucceeded,
                     tasksTotal: liveOutcome.tasksTotal,
                     statusHeadline: evaluateExecutorSuccess(liveOutcome).statusHeadline,
+                    ...(reportedMutation ? { mutation: reportedMutation } : {}),
                 },
                 cause: error,
             });
         }
     }
     async tryRecoverV3ServiceAndRetry(executionPrompt, rawPrompt, workspaceContext, routingPolicy, spinner, error) {
+        if (error?.code === 'AGENT_OUTCOME_UNKNOWN') {
+            return false;
+        }
         const recovery = await this.api.attemptV3ServiceRecovery((error && error.message) || '');
         if (!recovery.recovered) {
             return false;

package/dist/commands/fork.js

@@ -16,7 +16,11 @@ export class ForkCommand {
         this.logger = logger;
     }
     getHeaders() {
-        const headers = { 'Content-Type': 'application/json' };
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-Vigthoria-Agent-Lane': 'cli',
+            'X-Vigthoria-Source-Product': 'vigthoria-cli',
+        };
         const token = process.env.VIGTHORIA_TOKEN ||
             process.env.VIGTHORIA_AUTH_TOKEN ||
             this.config.get('authToken');
@@ -34,7 +38,7 @@ export class ForkCommand {
         const allowLocal = hasLocalV3AgentCapability();
         return (process.env.VIGTHORIA_V3_AGENT_URL ||
             process.env.V3_AGENT_URL ||
-            (allowLocal ? 'http://127.0.0.1:8030' : null) ||
+            (allowLocal ? 'http://127.0.0.1:8032' : null) ||
             configuredApiUrl);
     }
     buildForkHistory(events, eventIndex) {
@@ -92,7 +96,8 @@ export class ForkCommand {
                 local_workspace_path: workspaceRef,
                 project_path: workspaceRef,
             });
-            const resp = await guardedFetch(`${baseUrl}/api/runs/${encodeURIComponent(runId)}/events?${params}`, {
+            const runsPath = /:8032\/?$/.test(baseUrl) ? '/api/runs' : '/api/runs-cli';
+            const resp = await guardedFetch(`${baseUrl}${runsPath}/${encodeURIComponent(runId)}/events?${params}`, {
                 headers: this.getHeaders(),
                 signal: streamController.signal,
             }, { audience: 'v3' });

package/dist/commands/history.js

@@ -15,7 +15,11 @@ export class HistoryCommand {
         this.logger = logger;
     }
     getHeaders() {
-        const headers = { 'Content-Type': 'application/json' };
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-Vigthoria-Agent-Lane': 'cli',
+            'X-Vigthoria-Source-Product': 'vigthoria-cli',
+        };
         const token = process.env.VIGTHORIA_TOKEN ||
             process.env.VIGTHORIA_AUTH_TOKEN ||
             this.config.get('authToken');
@@ -33,7 +37,7 @@ export class HistoryCommand {
         const allowLocal = hasLocalV3AgentCapability();
         return (process.env.VIGTHORIA_V3_AGENT_URL ||
             process.env.V3_AGENT_URL ||
-            (allowLocal ? 'http://127.0.0.1:8030' : null) ||
+            (allowLocal ? 'http://127.0.0.1:8032' : null) ||
             configuredApiUrl);
     }
     async run(options) {
@@ -49,7 +53,8 @@ export class HistoryCommand {
                 local_workspace_path: workspaceRef,
                 project_path: workspaceRef,
             });
-            const resp = await guardedFetch(`${baseUrl}/api/runs?${params}`, {
+            const runsPath = /:8032\/?$/.test(baseUrl) ? '/api/runs' : '/api/runs-cli';
+            const resp = await guardedFetch(`${baseUrl}${runsPath}?${params}`, {
                 headers: this.getHeaders(),
             }, { audience: 'v3' });
             if (!resp.ok) {

package/dist/commands/legion.js

@@ -303,7 +303,7 @@ export class LegionCommand {
             console.log(chalk.yellow('Budget depleted for current round. Additional paid loop required.'));
             console.log(chalk.gray(`  Next round: ${nextRound}`));
             console.log(chalk.gray(`  Failed step: ${execution.failedStepId || 'unknown'} (${execution.failedWorker || 'unknown'})`));
-            console.log(chalk.gray(`  Additional estimate: $${nextQuote.finalUsd.toFixed(4)} / ${nextQuote.vigcoinRequired.toFixed(3)} VIG`));
+            console.log(chalk.gray(`  Additional estimate: $${nextQuote.finalUsd.toFixed(4)} / ${nextQuote.vigcoinRequired.toFixed(3)} credits`));
             const answer = (await rl.question('Confirm additional PAYG credit deduction and continue? (y/N): ')).trim().toLowerCase();
             return answer === 'y' || answer === 'yes';
         }

package/dist/commands/replay.js

@@ -13,7 +13,11 @@ export class ReplayCommand {
         this.config = config;
     }
     getHeaders() {
-        const headers = { 'Content-Type': 'application/json' };
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-Vigthoria-Agent-Lane': 'cli',
+            'X-Vigthoria-Source-Product': 'vigthoria-cli',
+        };
         const token = process.env.VIGTHORIA_TOKEN ||
             process.env.VIGTHORIA_AUTH_TOKEN ||
             this.config.get('authToken');
@@ -31,7 +35,7 @@ export class ReplayCommand {
         const allowLocal = hasLocalV3AgentCapability();
         return (process.env.VIGTHORIA_V3_AGENT_URL ||
             process.env.V3_AGENT_URL ||
-            (allowLocal ? 'http://127.0.0.1:8030' : null) ||
+            (allowLocal ? 'http://127.0.0.1:8032' : null) ||
             configuredApiUrl);
     }
     sleep(ms) {
@@ -49,7 +53,8 @@ export class ReplayCommand {
                 local_workspace_path: workspaceRef,
                 project_path: workspaceRef,
             });
-            const resp = await guardedFetch(`${baseUrl}/api/runs/${encodeURIComponent(runId)}/events?${params}`, {
+            const runsPath = /:8032\/?$/.test(baseUrl) ? '/api/runs' : '/api/runs-cli';
+            const resp = await guardedFetch(`${baseUrl}${runsPath}/${encodeURIComponent(runId)}/events?${params}`, {
                 headers: this.getHeaders(),
             }, { audience: 'v3' });
             if (!resp.ok) {