vigthoria-cli 1.10.37 → 1.10.47

package/dist/utils/task-display.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Vigthoria CLI — Multi-Step Terminal Task Display
  *
@@ -6,22 +7,27 @@
  *
  * Only activates when stderr is a real TTY; JSON mode and piped output stay clean.
  */
-import chalk from 'chalk';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskDisplay = void 0;
+const chalk_1 = __importDefault(require("chalk"));
 const ICONS = {
-    pending: chalk.gray('○'),
-    running: chalk.cyan('⟳'),
-    done: chalk.green('✓'),
-    error: chalk.red('✗'),
-    skipped: chalk.gray('\u2013'),
+    pending: chalk_1.default.gray('○'),
+    running: chalk_1.default.cyan('⟳'),
+    done: chalk_1.default.green('✓'),
+    error: chalk_1.default.red('✗'),
+    skipped: chalk_1.default.gray('\u2013'),
 };
 const LABEL_FN = {
-    pending: (s) => chalk.gray(s),
-    running: (s) => chalk.cyan.bold(s),
-    done: (s) => chalk.gray(s),
-    error: (s) => chalk.red(s),
-    skipped: (s) => chalk.gray(s),
+    pending: (s) => chalk_1.default.gray(s),
+    running: (s) => chalk_1.default.cyan.bold(s),
+    done: (s) => chalk_1.default.gray(s),
+    error: (s) => chalk_1.default.red(s),
+    skipped: (s) => chalk_1.default.gray(s),
 };
-export class TaskDisplay {
+class TaskDisplay {
     tasks = [];
     linesRendered = 0;
     enabled;
@@ -38,7 +44,7 @@ export class TaskDisplay {
         return this.tasks.map((t) => {
             const icon = ICONS[t.status];
             const label = LABEL_FN[t.status](t.label);
-            const detail = t.detail ? chalk.gray(` \u2014 ${t.detail.slice(0, 60)}`) : '';
+            const detail = t.detail ? chalk_1.default.gray(` \u2014 ${t.detail.slice(0, 60)}`) : '';
             return `  ${icon} ${label}${detail}`;
         });
     }
@@ -106,3 +112,4 @@ export class TaskDisplay {
         return this.enabled;
     }
 }
+exports.TaskDisplay = TaskDisplay;

package/dist/utils/workspace-brain-service.js

@@ -1,10 +1,46 @@
+"use strict";
 /**
  * Workspace Brain — local codebase index + Brain Hub sync for CLI.
  */
-import * as path from 'path';
-import { BrainHubClient } from './brain-hub-client.js';
-import { CodebaseIndexer } from './codebase-indexer.js';
-export class WorkspaceBrainService {
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceBrainService = void 0;
+const path = __importStar(require("path"));
+const brain_hub_client_js_1 = require("./brain-hub-client.js");
+const codebase_indexer_js_1 = require("./codebase-indexer.js");
+class WorkspaceBrainService {
     workspacePath;
     indexer;
     brainClient;
@@ -13,8 +49,8 @@ export class WorkspaceBrainService {
     accountContextCache = null;
     constructor(options) {
         this.workspacePath = path.resolve(options.workspacePath);
-        this.indexer = new CodebaseIndexer(this.workspacePath);
-        this.brainClient = new BrainHubClient({
+        this.indexer = new codebase_indexer_js_1.CodebaseIndexer(this.workspacePath);
+        this.brainClient = new brain_hub_client_js_1.BrainHubClient({
             apiBase: options.apiBase,
             getAuthToken: options.getAuthToken,
         });
@@ -31,7 +67,7 @@ export class WorkspaceBrainService {
             indexedFileCount: status.indexedFileCount,
             totalChunks: status.totalChunks,
             isIndexing: status.isIndexing,
-            meta: CodebaseIndexer.loadMeta(this.workspacePath),
+            meta: codebase_indexer_js_1.CodebaseIndexer.loadMeta(this.workspacePath),
         };
     }
     async ensureIndexed(options = {}) {
@@ -41,7 +77,7 @@ export class WorkspaceBrainService {
             return { indexed: true, fileCount: meta.indexedFileCount, chunkCount: meta.totalChunks };
         }
         if (this.indexer.hasLocalIndex()) {
-            const meta = CodebaseIndexer.loadMeta(this.workspacePath);
+            const meta = codebase_indexer_js_1.CodebaseIndexer.loadMeta(this.workspacePath);
             return {
                 indexed: true,
                 fileCount: meta?.indexedFileCount || this.indexer.getStatus().indexedFileCount,
@@ -119,3 +155,4 @@ export class WorkspaceBrainService {
         }).catch(() => undefined);
     }
 }
+exports.WorkspaceBrainService = WorkspaceBrainService;

package/dist/utils/workspace-cache.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Vigthoria CLI — Workspace Hash Cache
  *
@@ -6,17 +7,24 @@
  *   - Changed/new files → sent first (highest budget priority)
  *   - Unchanged files → sent last (trimmed by budget if token limit reached)
  */
-import { createHash } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChangedFiles = getChangedFiles;
+exports.updateWorkspaceCache = updateWorkspaceCache;
+exports.summarizeChanges = summarizeChanges;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const CACHE_SUBDIR = '.vigthoria';
 const CACHE_FILENAME = 'file-hashes.json';
 function getCachePath(workspacePath) {
-    return path.join(workspacePath, CACHE_SUBDIR, CACHE_FILENAME);
+    return node_path_1.default.join(workspacePath, CACHE_SUBDIR, CACHE_FILENAME);
 }
 function hashFile(absPath) {
     try {
-        return createHash('sha256').update(fs.readFileSync(absPath)).digest('hex');
+        return (0, node_crypto_1.createHash)('sha256').update(node_fs_1.default.readFileSync(absPath)).digest('hex');
     }
     catch {
         return '';
@@ -24,7 +32,7 @@ function hashFile(absPath) {
 }
 function loadCache(workspacePath) {
     try {
-        return JSON.parse(fs.readFileSync(getCachePath(workspacePath), 'utf-8'));
+        return JSON.parse(node_fs_1.default.readFileSync(getCachePath(workspacePath), 'utf-8'));
     }
     catch {
         return {};
@@ -32,10 +40,10 @@ function loadCache(workspacePath) {
 }
 function persistCache(workspacePath, hashes) {
     try {
-        const cacheDir = path.join(workspacePath, CACHE_SUBDIR);
-        if (!fs.existsSync(cacheDir))
-            fs.mkdirSync(cacheDir, { recursive: true });
-        fs.writeFileSync(getCachePath(workspacePath), JSON.stringify(hashes, null, 2), 'utf-8');
+        const cacheDir = node_path_1.default.join(workspacePath, CACHE_SUBDIR);
+        if (!node_fs_1.default.existsSync(cacheDir))
+            node_fs_1.default.mkdirSync(cacheDir, { recursive: true });
+        node_fs_1.default.writeFileSync(getCachePath(workspacePath), JSON.stringify(hashes, null, 2), 'utf-8');
     }
     catch { /* non-fatal */ }
 }
@@ -45,13 +53,13 @@ function persistCache(workspacePath, hashes) {
  * @param workspacePath  Absolute project root.
  * @param relativePaths  Workspace-relative (or absolute) file paths to check.
  */
-export function getChangedFiles(workspacePath, relativePaths) {
+function getChangedFiles(workspacePath, relativePaths) {
     const cache = loadCache(workspacePath);
     const changed = [];
     const unchanged = [];
     for (const rel of relativePaths) {
-        const abs = path.isAbsolute(rel) ? rel : path.join(workspacePath, rel);
-        const key = path.relative(workspacePath, abs).replace(/\\/g, '/');
+        const abs = node_path_1.default.isAbsolute(rel) ? rel : node_path_1.default.join(workspacePath, rel);
+        const key = node_path_1.default.relative(workspacePath, abs).replace(/\\/g, '/');
         const currentHash = hashFile(abs);
         if (!currentHash || cache[key] !== currentHash) {
             changed.push(rel);
@@ -66,13 +74,13 @@ export function getChangedFiles(workspacePath, relativePaths) {
  * Write current hashes for the given files into the persistent cache.
  * Call this after an agent run completes successfully.
  */
-export function updateWorkspaceCache(workspacePath, relativePaths) {
-    if (!workspacePath || !fs.existsSync(workspacePath))
+function updateWorkspaceCache(workspacePath, relativePaths) {
+    if (!workspacePath || !node_fs_1.default.existsSync(workspacePath))
         return;
     const cache = loadCache(workspacePath);
     for (const rel of relativePaths) {
-        const abs = path.isAbsolute(rel) ? rel : path.join(workspacePath, rel);
-        const key = path.relative(workspacePath, abs).replace(/\\/g, '/');
+        const abs = node_path_1.default.isAbsolute(rel) ? rel : node_path_1.default.join(workspacePath, rel);
+        const key = node_path_1.default.relative(workspacePath, abs).replace(/\\/g, '/');
         const hash = hashFile(abs);
         if (hash)
             cache[key] = hash;
@@ -82,7 +90,7 @@ export function updateWorkspaceCache(workspacePath, relativePaths) {
 /**
  * Return a human-readable summary of changes since last cache update.
  */
-export function summarizeChanges(workspacePath, relativePaths) {
+function summarizeChanges(workspacePath, relativePaths) {
     const { changed, unchanged, total } = getChangedFiles(workspacePath, relativePaths);
     return `${changed.length} changed, ${unchanged.length} unchanged of ${total} files tracked`;
 }

package/dist/utils/workspace-stream.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Workspace Stream — Real-time bidirectional file sync between CLI and V3.
  *
@@ -17,12 +18,51 @@
  *   {"type": "file_sync", "path": "rel/path", "content": "...", "action": "write"|"delete"}
  *   {"type": "file_batch", "files": [{path, content}, ...]}
  */
-import * as chokidar from 'chokidar';
-import fs from 'fs';
-import path from 'path';
-import WebSocket from 'ws';
-import { Logger } from './logger.js';
-const logger = new Logger();
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceWSClient = exports.WorkspaceWatcher = void 0;
+exports.applyFileMutation = applyFileMutation;
+const chokidar = __importStar(require("chokidar"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ws_1 = __importDefault(require("ws"));
+const logger_js_1 = require("./logger.js");
+const logger = new logger_js_1.Logger();
 logger.setVerbose(!!process.env.VIGTHORIA_DEBUG);
 // Files/dirs to ignore in the watcher
 const IGNORE_PATTERNS = [
@@ -69,27 +109,27 @@ const _v3MuteTimeout = 2000; // 2s mute window after V3 writes a file
  * Apply a file_mutation event from V3's SSE stream to the local workspace.
  * Call this from the SSE event handler for real-time file application.
  */
-export function applyFileMutation(event, workspaceRoot) {
+function applyFileMutation(event, workspaceRoot) {
     if (event.type !== 'file_mutation')
         return false;
     if (!event.path || !workspaceRoot)
         return false;
-    const absPath = path.resolve(workspaceRoot, event.path);
+    const absPath = path_1.default.resolve(workspaceRoot, event.path);
     // Safety: ensure the resolved path is within the workspace
-    if (!absPath.startsWith(path.resolve(workspaceRoot) + path.sep) && absPath !== path.resolve(workspaceRoot)) {
+    if (!absPath.startsWith(path_1.default.resolve(workspaceRoot) + path_1.default.sep) && absPath !== path_1.default.resolve(workspaceRoot)) {
         logger.warn(`Refusing to apply mutation outside workspace: ${event.path}`);
         return false;
     }
     try {
         if (event.action === 'delete') {
-            if (fs.existsSync(absPath)) {
-                fs.unlinkSync(absPath);
+            if (fs_1.default.existsSync(absPath)) {
+                fs_1.default.unlinkSync(absPath);
                 logger.debug(`Deleted: ${event.path}`);
             }
         }
         else if (typeof event.content === 'string') {
-            fs.mkdirSync(path.dirname(absPath), { recursive: true });
-            fs.writeFileSync(absPath, event.content, 'utf8');
+            fs_1.default.mkdirSync(path_1.default.dirname(absPath), { recursive: true });
+            fs_1.default.writeFileSync(absPath, event.content, 'utf8');
             // Mute the watcher for this file to prevent echo
             _v3MutatedFiles.add(absPath);
             setTimeout(() => _v3MutatedFiles.delete(absPath), _v3MuteTimeout);
@@ -102,13 +142,13 @@ export function applyFileMutation(event, workspaceRoot) {
         return false;
     }
 }
-export class WorkspaceWatcher {
+class WorkspaceWatcher {
     watcher = null;
     workspaceRoot;
     onFileChange;
     _ready = false;
     constructor(options) {
-        this.workspaceRoot = path.resolve(options.workspaceRoot);
+        this.workspaceRoot = path_1.default.resolve(options.workspaceRoot);
         this.onFileChange = options.onFileChange;
     }
     start() {
@@ -173,10 +213,10 @@ export class WorkspaceWatcher {
         // Skip if this file was just written by V3 (echo prevention)
         if (_v3MutatedFiles.has(filePath))
             return;
-        const ext = path.extname(filePath).toLowerCase();
+        const ext = path_1.default.extname(filePath).toLowerCase();
         if (BINARY_EXTENSIONS.has(ext))
             return;
-        const relativePath = path.relative(this.workspaceRoot, filePath);
+        const relativePath = path_1.default.relative(this.workspaceRoot, filePath);
         if (relativePath.startsWith('..'))
             return; // safety
         if (action === 'delete') {
@@ -184,10 +224,10 @@ export class WorkspaceWatcher {
             return;
         }
         try {
-            const stat = fs.statSync(filePath);
+            const stat = fs_1.default.statSync(filePath);
             if (stat.size > MAX_SYNC_FILE_BYTES)
                 return;
-            const content = fs.readFileSync(filePath, 'utf8');
+            const content = fs_1.default.readFileSync(filePath, 'utf8');
             this.onFileChange?.(relativePath, content, 'write');
         }
         catch {
@@ -195,7 +235,8 @@ export class WorkspaceWatcher {
         }
     }
 }
-export class WorkspaceWSClient {
+exports.WorkspaceWatcher = WorkspaceWatcher;
+class WorkspaceWSClient {
     ws = null;
     opts;
     reconnectTimer = null;
@@ -209,7 +250,7 @@ export class WorkspaceWSClient {
         if (this.ws)
             return;
         const url = `${this.opts.serverUrl}/ws/workspace`;
-        this.ws = new WebSocket(url);
+        this.ws = new ws_1.default(url);
         this.ws.on('open', () => {
             this._connected = true;
             this._send({
@@ -302,3 +343,4 @@ export class WorkspaceWSClient {
         }
     }
 }
+exports.WorkspaceWSClient = WorkspaceWSClient;

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.10.37",
+  "version": "1.10.47",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
-  "type": "module",
   "main": "dist/index.js",
   "files": [
     "dist",
@@ -65,9 +64,7 @@
     "test:model:governance": "npm run build && node scripts/test-model-governance-no-agent.js",
     "validate:no-go": "bash scripts/release/validate-no-go-gates.sh",
     "test:legion:billing:e2e": "npm run build && node scripts/test-legion-godmode-billing-e2e.js",
-    "test:windows:v3-sync": "npm run build && node scripts/test-windows-v3-sync-recovery.js",
-    "test:persona": "npm run build && node scripts/test-persona-mode.mjs",
-    "test:error-wording": "npm run build && node scripts/test-error-wording.mjs"
+    "test:windows:v3-sync": "npm run build && node scripts/test-windows-v3-sync-recovery.js"
   },
   "keywords": [
     "ai",
@@ -84,7 +81,7 @@
     "archiver": "^6.0.1",
     "axios": "^1.6.0",
     "chalk": "^5.3.0",
-    "chokidar": "^4.0.0",
+    "chokidar": "^5.0.0",
     "commander": "^11.1.0",
     "conf": "^12.0.0",
     "diff": "^5.1.0",

package/dist/commands/fork.d.ts

@@ -1,17 +0,0 @@
-import { Config } from '../utils/config.js';
-import { Logger } from '../utils/logger.js';
-interface ForkOptions {
-    eventIndex?: number;
-    project?: string;
-    json?: boolean;
-}
-export declare class ForkCommand {
-    private config;
-    private logger;
-    constructor(config: Config, logger: Logger);
-    private getHeaders;
-    private getBaseUrl;
-    private resolveWorkspaceRoot;
-    run(runId: string, message: string, options: ForkOptions): Promise<void>;
-}
-export {};

package/dist/commands/fork.js

@@ -1,164 +0,0 @@
-import { isServerRuntime } from '../utils/api.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';
-const require = createRequire(import.meta.url);
-export class ForkCommand {
-    config;
-    logger;
-    constructor(config, logger) {
-        this.config = config;
-        this.logger = logger;
-    }
-    getHeaders() {
-        const headers = { 'Content-Type': 'application/json' };
-        const token = process.env.VIGTHORIA_TOKEN ||
-            process.env.VIGTHORIA_AUTH_TOKEN ||
-            this.config.get('authToken');
-        if (token) {
-            headers['Authorization'] = `Bearer ${token}`;
-            headers['Cookie'] = `vigthoria-auth-token=${token}`;
-        }
-        const serviceKey = process.env.VIGTHORIA_V3_SERVICE_KEY;
-        if (serviceKey)
-            headers['X-Service-Key'] = serviceKey;
-        return headers;
-    }
-    getBaseUrl() {
-        const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
-        const allowLocal = !isServerRuntime() || 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) ||
-            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 '';
-            }
-            catch { }
-        }
-        return project;
-    }
-    async run(runId, message, options) {
-        const project = options.project || process.cwd();
-        const workspace = this.resolveWorkspaceRoot(project);
-        const eventIndex = options.eventIndex || 0;
-        const spinner = createSpinner(`Forking run ${runId}...`).start();
-        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',
-                headers: this.getHeaders(),
-                body: JSON.stringify(body),
-            });
-            if (!resp.ok) {
-                spinner.stop();
-                if (resp.status === 404) {
-                    this.logger.error(`Run ${runId} not found or has no event log.`);
-                }
-                else if (resp.status === 502 || resp.status === 503) {
-                    this.logger.error(`V3 run-history route is not available on ${baseUrl}. Backend may not expose /api/runs.`);
-                }
-                else {
-                    this.logger.error(`Fork failed: ${resp.status} ${resp.statusText}`);
-                }
-                return;
-            }
-            spinner.stop();
-            console.log(chalk.bold(`\n${CH.success} Forked from ${chalk.cyan(runId)} at event ${eventIndex}\n`));
-            if (!resp.body) {
-                this.logger.error('No response body');
-                return;
-            }
-            // Stream SSE events
-            const reader = resp.body.getReader();
-            const decoder = new TextDecoder();
-            let buffer = '';
-            let toolCallNum = 0;
-            while (true) {
-                const { done, value } = await reader.read();
-                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]') {
-                        console.log(chalk.bold(`\n${CH.success} Fork run complete\n`));
-                        return;
-                    }
-                    try {
-                        const evt = JSON.parse(payload);
-                        const type = evt.type || 'unknown';
-                        if (options.json) {
-                            console.log(JSON.stringify(evt));
-                            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':
-                                console.log(chalk.red(`  ❌ ERROR: `) + (evt.message || '').substring(0, 200));
-                                break;
-                            default:
-                                console.log(chalk.dim(`  ${type}: ${JSON.stringify(evt).substring(0, 80)}`));
-                        }
-                    }
-                    catch {
-                        // skip unparseable lines
-                    }
-                }
-            }
-        }
-        catch (err) {
-            spinner.stop();
-            this.logger.error(`Fork error: ${err.message}`);
-        }
-    }
-}

package/dist/commands/history.d.ts

@@ -1,17 +0,0 @@
-import { Config } from '../utils/config.js';
-import { Logger } from '../utils/logger.js';
-interface HistoryOptions {
-    limit?: number;
-    json?: boolean;
-    project?: string;
-}
-export declare class HistoryCommand {
-    private config;
-    private logger;
-    constructor(config: Config, logger: Logger);
-    private getHeaders;
-    private getBaseUrl;
-    private resolveWorkspaceRoot;
-    run(options: HistoryOptions): Promise<void>;
-}
-export {};