orquesta-cli 0.2.22 → 0.2.24

package/dist/core/git-auto-updater.d.ts

@@ -0,0 +1,58 @@
+export type UpdateStatus = {
+    type: 'checking';
+} | {
+    type: 'no_update';
+} | {
+    type: 'first_run';
+    step: number;
+    totalSteps: number;
+    message: string;
+} | {
+    type: 'updating';
+    step: number;
+    totalSteps: number;
+    message: string;
+} | {
+    type: 'complete';
+    needsRestart: boolean;
+    message: string;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'skipped';
+    reason: string;
+};
+export type StatusCallback = (status: UpdateStatus) => void;
+export declare class GitAutoUpdater {
+    private repoUrl;
+    private repoDir;
+    private commitFile;
+    private enabled;
+    private onStatus;
+    constructor(options?: {
+        repoUrl?: string;
+        enabled?: boolean;
+        onStatus?: StatusCallback;
+    });
+    setStatusCallback(callback: StatusCallback): void;
+    private emitStatus;
+    run(options?: {
+        noUpdate?: boolean;
+    }): Promise<boolean>;
+    private runBinaryMode;
+    private getRemoteCommit;
+    private getSavedCommit;
+    private saveCommit;
+    private updateBinary;
+    private initialSetup;
+    private pullAndUpdate;
+    private freshClone;
+    private rebuildAndLink;
+    private copyBinariesInternal;
+    private ensurePathConfigured;
+    private unlinkNpm;
+    private cleanupRepo;
+}
+export default GitAutoUpdater;
+//# sourceMappingURL=git-auto-updater.d.ts.map

package/dist/core/git-auto-updater.js

@@ -0,0 +1,374 @@
+import { spawn } from 'child_process';
+import fs, { createReadStream, createWriteStream } from 'fs';
+import { rm, copyFile, chmod } from 'fs/promises';
+import { pipeline } from 'stream/promises';
+import path from 'path';
+import os from 'os';
+import zlib from 'zlib';
+import { logger } from '../utils/logger.js';
+function isRunningAsBinary() {
+    const execPath = process.execPath;
+    const isNodeRuntime = execPath.includes('node') || execPath.includes('nodejs');
+    return !isNodeRuntime;
+}
+function execAsync(command, options = {}) {
+    return new Promise((resolve, reject) => {
+        const [cmd, ...args] = command.split(' ');
+        const child = spawn(cmd, args, {
+            cwd: options.cwd,
+            shell: true,
+            stdio: 'pipe',
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve({ stdout, stderr });
+            }
+            else {
+                const error = new Error(`Command failed: ${command}`);
+                error.stdout = stdout;
+                error.stderr = stderr;
+                error.code = code;
+                reject(error);
+            }
+        });
+        child.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+export class GitAutoUpdater {
+    repoUrl = 'https://github.com/A2G-Dev-Space/Local-CLI.git';
+    repoDir;
+    commitFile;
+    enabled = true;
+    onStatus = null;
+    constructor(options) {
+        this.repoDir = path.join(os.homedir(), '.local-cli', 'repo');
+        this.commitFile = path.join(os.homedir(), '.local-cli', 'current-commit');
+        if (options?.repoUrl) {
+            this.repoUrl = options.repoUrl;
+        }
+        if (options?.enabled !== undefined) {
+            this.enabled = options.enabled;
+        }
+        if (options?.onStatus) {
+            this.onStatus = options.onStatus;
+        }
+    }
+    setStatusCallback(callback) {
+        this.onStatus = callback;
+    }
+    emitStatus(status) {
+        if (this.onStatus) {
+            this.onStatus(status);
+        }
+    }
+    async run(options = {}) {
+        logger.enter('GitAutoUpdater.run', {
+            noUpdate: options.noUpdate,
+            enabled: this.enabled,
+            repoDir: this.repoDir
+        });
+        if (options.noUpdate || !this.enabled) {
+            logger.flow('Git auto-update disabled - skipping');
+            this.emitStatus({ type: 'skipped', reason: 'disabled' });
+            return false;
+        }
+        this.emitStatus({ type: 'checking' });
+        try {
+            if (isRunningAsBinary() && fs.existsSync(this.repoDir)) {
+                logger.flow('Cleaning up leftover repo from previous version');
+                await this.cleanupRepo();
+            }
+            if (isRunningAsBinary()) {
+                return await this.runBinaryMode();
+            }
+            logger.flow('Checking repository directory');
+            if (!fs.existsSync(this.repoDir)) {
+                logger.flow('First run detected - need initial setup');
+                return await this.initialSetup();
+            }
+            else {
+                return await this.pullAndUpdate();
+            }
+        }
+        catch (error) {
+            logger.error('Git auto-update failed', error);
+            this.emitStatus({ type: 'error', message: 'Auto-update failed, continuing with current version' });
+        }
+        return false;
+    }
+    async runBinaryMode() {
+        logger.flow('Running in binary mode - using ls-remote for update check');
+        try {
+            const remoteCommit = await this.getRemoteCommit();
+            if (!remoteCommit) {
+                logger.error('Failed to get remote commit');
+                this.emitStatus({ type: 'error', message: 'Failed to check for updates' });
+                return false;
+            }
+            const savedCommit = this.getSavedCommit();
+            logger.debug('Version check', { remote: remoteCommit.slice(0, 7), saved: savedCommit?.slice(0, 7) || 'none' });
+            if (savedCommit === remoteCommit) {
+                logger.flow('Already up to date');
+                this.emitStatus({ type: 'no_update' });
+                return false;
+            }
+            logger.flow('Update available, starting update process');
+            return await this.updateBinary(remoteCommit);
+        }
+        catch (error) {
+            logger.error('Binary mode update failed', error);
+            this.emitStatus({ type: 'error', message: 'Update check failed' });
+            return false;
+        }
+    }
+    async getRemoteCommit() {
+        try {
+            const result = await execAsync(`git ls-remote ${this.repoUrl} refs/heads/main`);
+            const match = result.stdout.match(/^([a-f0-9]+)/);
+            return match && match[1] ? match[1] : null;
+        }
+        catch (error) {
+            logger.error('Failed to get remote commit via ls-remote', error);
+            return null;
+        }
+    }
+    getSavedCommit() {
+        try {
+            if (fs.existsSync(this.commitFile)) {
+                return fs.readFileSync(this.commitFile, 'utf-8').trim();
+            }
+        }
+        catch (error) {
+            logger.debug('Failed to read saved commit: ' + (error instanceof Error ? error.message : String(error)));
+        }
+        return null;
+    }
+    saveCommit(commit) {
+        try {
+            const dir = path.dirname(this.commitFile);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.commitFile, commit);
+            logger.debug('Saved commit hash: ' + commit.slice(0, 7));
+        }
+        catch (error) {
+            logger.debug('Failed to save commit: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    async updateBinary(remoteCommit) {
+        const totalSteps = 3;
+        const isFirstRun = !this.getSavedCommit();
+        try {
+            const statusType = isFirstRun ? 'first_run' : 'updating';
+            this.emitStatus({ type: statusType, step: 1, totalSteps, message: 'Downloading update...' });
+            const parentDir = path.dirname(this.repoDir);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
+            await execAsync(`git clone --depth 1 ${this.repoUrl} ${this.repoDir}`);
+            this.emitStatus({ type: statusType, step: 2, totalSteps, message: 'Installing update...' });
+            const success = await this.copyBinariesInternal();
+            if (!success) {
+                return false;
+            }
+            this.emitStatus({ type: statusType, step: 3, totalSteps, message: 'Finalizing...' });
+            await this.cleanupRepo();
+            this.saveCommit(remoteCommit);
+            const shell = process.env['SHELL'] || '/bin/bash';
+            const rcFile = shell.includes('zsh') ? '~/.zshrc' : '~/.bashrc';
+            const restartMsg = isFirstRun
+                ? `Setup complete! Run: source ${rcFile} && lcli`
+                : 'Update complete! Please restart.';
+            this.emitStatus({ type: 'complete', needsRestart: true, message: restartMsg });
+            return true;
+        }
+        catch (error) {
+            logger.error('Binary update failed', error);
+            await this.cleanupRepo();
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.emitStatus({ type: 'error', message: `Update failed: ${message}` });
+            return false;
+        }
+    }
+    async initialSetup() {
+        logger.enter('initialSetup', {
+            repoDir: this.repoDir,
+            repoUrl: this.repoUrl
+        });
+        const totalSteps = 4;
+        try {
+            this.emitStatus({ type: 'first_run', step: 1, totalSteps, message: 'Cloning repository...' });
+            const parentDir = path.dirname(this.repoDir);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
+            await execAsync(`git clone ${this.repoUrl} ${this.repoDir}`);
+            this.emitStatus({ type: 'first_run', step: 2, totalSteps, message: 'Installing dependencies...' });
+            await execAsync('npm install', { cwd: this.repoDir });
+            this.emitStatus({ type: 'first_run', step: 3, totalSteps, message: 'Building project...' });
+            await execAsync('npm run build', { cwd: this.repoDir });
+            this.emitStatus({ type: 'first_run', step: 4, totalSteps, message: 'Creating global link...' });
+            await execAsync('npm link', { cwd: this.repoDir });
+            this.emitStatus({ type: 'complete', needsRestart: true, message: 'Setup complete! Please restart.' });
+            return true;
+        }
+        catch (error) {
+            logger.error('Initial setup failed', error);
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.emitStatus({ type: 'error', message: `Setup failed: ${message}` });
+            return false;
+        }
+    }
+    async pullAndUpdate() {
+        logger.debug('Checking for updates', { repoDir: this.repoDir });
+        try {
+            await execAsync('git fetch origin main', { cwd: this.repoDir });
+            const currentResult = await execAsync('git rev-parse HEAD', { cwd: this.repoDir });
+            const latestResult = await execAsync('git rev-parse origin/main', { cwd: this.repoDir });
+            const currentCommit = currentResult.stdout.trim();
+            const latestCommit = latestResult.stdout.trim();
+            if (currentCommit === latestCommit) {
+                logger.debug('Already up to date, no rebuild needed');
+                this.emitStatus({ type: 'no_update' });
+                return false;
+            }
+            logger.debug('Resetting to latest commit...', { from: currentCommit.slice(0, 7), to: latestCommit.slice(0, 7) });
+            await execAsync('git reset --hard origin/main', { cwd: this.repoDir });
+            return await this.rebuildAndLink();
+        }
+        catch (error) {
+            logger.error('Pull/reset failed, attempting fresh clone', error);
+            return await this.freshClone();
+        }
+    }
+    async freshClone() {
+        logger.flow('Performing fresh clone');
+        try {
+            this.emitStatus({ type: 'updating', step: 1, totalSteps: 4, message: 'Removing old repository...' });
+            await rm(this.repoDir, { recursive: true, force: true });
+            return await this.initialSetup();
+        }
+        catch (error) {
+            logger.error('Fresh clone failed', error);
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.emitStatus({ type: 'error', message: `Fresh clone failed: ${message}` });
+            return false;
+        }
+    }
+    async rebuildAndLink() {
+        const totalSteps = 3;
+        try {
+            this.emitStatus({ type: 'updating', step: 1, totalSteps, message: 'Updating dependencies...' });
+            await execAsync('npm install', { cwd: this.repoDir });
+            this.emitStatus({ type: 'updating', step: 2, totalSteps, message: 'Building project...' });
+            await execAsync('npm run build', { cwd: this.repoDir });
+            this.emitStatus({ type: 'updating', step: 3, totalSteps, message: 'Updating global link...' });
+            await execAsync('npm link', { cwd: this.repoDir });
+            this.emitStatus({ type: 'complete', needsRestart: true, message: 'Update complete! Please restart.' });
+            return true;
+        }
+        catch (buildError) {
+            logger.error('Build/link failed', buildError);
+            const message = buildError instanceof Error ? buildError.message : 'Unknown error';
+            this.emitStatus({ type: 'error', message: `Build failed: ${message}` });
+            return false;
+        }
+    }
+    async copyBinariesInternal() {
+        try {
+            const repoBinDir = path.join(this.repoDir, 'bin');
+            const installDir = path.join(os.homedir(), '.local', 'bin');
+            const lcliGzSrc = path.join(repoBinDir, 'lcli.gz');
+            const yogaSrc = path.join(repoBinDir, 'yoga.wasm');
+            const lcliDest = path.join(installDir, 'lcli');
+            const yogaDest = path.join(installDir, 'yoga.wasm');
+            if (!fs.existsSync(lcliGzSrc)) {
+                this.emitStatus({ type: 'error', message: 'Binary not found in repository (bin/lcli.gz)' });
+                return false;
+            }
+            if (!fs.existsSync(installDir)) {
+                fs.mkdirSync(installDir, { recursive: true });
+            }
+            await rm(lcliDest, { force: true });
+            await pipeline(createReadStream(lcliGzSrc), zlib.createGunzip(), createWriteStream(lcliDest));
+            await chmod(lcliDest, 0o755);
+            if (fs.existsSync(yogaSrc)) {
+                await copyFile(yogaSrc, yogaDest);
+            }
+            await this.ensurePathConfigured(installDir);
+            await this.unlinkNpm();
+            logger.debug('Binaries copied successfully');
+            return true;
+        }
+        catch (error) {
+            logger.error('Copy binaries internal failed', error);
+            return false;
+        }
+    }
+    async ensurePathConfigured(binDir) {
+        const pathExport = `export PATH="${binDir}:$PATH"`;
+        const marker = '# local-cli binary';
+        const shell = process.env['SHELL'] || '/bin/bash';
+        let rcFile;
+        if (shell.includes('zsh')) {
+            rcFile = path.join(os.homedir(), '.zshrc');
+        }
+        else {
+            rcFile = path.join(os.homedir(), '.bashrc');
+        }
+        try {
+            let content = '';
+            if (fs.existsSync(rcFile)) {
+                content = fs.readFileSync(rcFile, 'utf-8');
+            }
+            if (content.includes(marker)) {
+                logger.debug('PATH already configured (marker found)');
+                return;
+            }
+            const currentPath = process.env['PATH'] || '';
+            if (currentPath.split(':').includes(binDir)) {
+                logger.debug('PATH already contains binDir, adding marker for future reference');
+                fs.appendFileSync(rcFile, `\n${marker}\n# PATH already configured elsewhere\n`);
+                return;
+            }
+            const addition = `\n${marker}\n${pathExport}\n`;
+            fs.appendFileSync(rcFile, addition);
+            logger.debug('PATH configuration added to ' + rcFile);
+        }
+        catch (error) {
+            logger.debug('Failed to configure PATH: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    async unlinkNpm() {
+        try {
+            await execAsync('npm unlink -g local-cli');
+        }
+        catch (error) {
+        }
+    }
+    async cleanupRepo() {
+        try {
+            if (fs.existsSync(this.repoDir)) {
+                logger.debug('Cleaning up repo directory to prevent source code exposure');
+                await rm(this.repoDir, { recursive: true, force: true });
+                logger.debug('Repo directory removed successfully');
+            }
+        }
+        catch (error) {
+            logger.debug('Failed to cleanup repo: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+}
+export default GitAutoUpdater;
+//# sourceMappingURL=git-auto-updater.js.map

package/dist/orchestration/plan-executor.js

@@ -17,6 +17,8 @@ import { formatErrorMessage, buildTodoContext, findActiveTodo, getTodoStats } fr
 import { runParallelGraph, shouldUseParallelOrchestrator } from './parallel-orchestrator.js';
 import { memoryStore } from './memory-store.js';
 import { auditLog } from './audit-log.js';
+import { reportPromptStart, reportPromptComplete, reportPromptCancelled } from '../orquesta/prompt-reporter.js';
+import { usageTracker } from '../core/usage-tracker.js';
 function buildEnvironmentContext() {
     const cwd = process.cwd();
     return `\n\n## Environment\n\nWorking directory (where ALL your tools execute): \`${cwd}\`\nTools (read_file, list_files, bash, edit_file, …) run on the USER'S machine in this directory.\n- Use paths RELATIVE to this directory ("package.json", "src/foo.ts", "."). They resolve against the working directory automatically.\n- Do NOT prepend the absolute working-directory path to tool arguments, and do NOT invent absolute paths from documentation — the repo is already at the working directory above.\n- Ignore any other "current directory" that may appear elsewhere in your context (e.g. a proxy's /tmp); the directory above is authoritative.\n`;
@@ -63,6 +65,14 @@ export class PlanExecutor {
             worktreeEnabled: configManager.isWorktreeIsolationEnabled(),
             maxParallel: configManager.getMaxParallelWorkers(),
         });
+        const orquestaEndpoint = configManager.getCurrentEndpoint();
+        const orquestaTrackingId = await reportPromptStart(userMessage, {
+            cwd: process.cwd(),
+            model: configManager.getCurrentModel()?.name,
+            endpoint: orquestaEndpoint?.baseUrl,
+        });
+        let runError = null;
+        let runInterrupted = false;
         try {
             if (isInterruptedRef.current) {
                 throw new Error('INTERRUPTED');
@@ -212,6 +222,7 @@ export class PlanExecutor {
         }
         catch (error) {
             if (error instanceof Error && error.message === 'INTERRUPTED') {
+                runInterrupted = true;
                 auditLog.emit(auditSid, 'run.error', { runId, reason: 'interrupted' });
                 logger.flow('Plan mode interrupted by user');
                 callbacks.setMessages((prev) => {
@@ -224,6 +235,7 @@ export class PlanExecutor {
                 });
                 return;
             }
+            runError = error;
             auditLog.emit(auditSid, 'run.error', { runId, message: error?.message });
             logger.error('Plan mode execution failed', error);
             const errorMessage = formatErrorMessage(error);
@@ -237,6 +249,23 @@ export class PlanExecutor {
             });
         }
         finally {
+            if (orquestaTrackingId) {
+                try {
+                    if (runInterrupted) {
+                        await reportPromptCancelled(orquestaTrackingId);
+                    }
+                    else {
+                        const usage = usageTracker.getSessionUsage();
+                        await reportPromptComplete(orquestaTrackingId, {
+                            success: !runError,
+                            error: runError ? formatErrorMessage(runError) : undefined,
+                            tokensUsed: usage.totalTokens || undefined,
+                        });
+                    }
+                }
+                catch {
+                }
+            }
             callbacks.setExecutionPhase('idle');
             clearTodoCallbacks();
             clearFinalResponseCallbacks();

package/dist/orquesta/config-sync.d.ts

@@ -65,6 +65,10 @@ export declare function updatePromptStatus(promptId: string, update: {
     success: boolean;
     error?: string;
 }>;
+export declare function streamPromptLogs(promptId: string, logs: Array<Record<string, unknown>>): Promise<{
+    success: boolean;
+    error?: string;
+}>;
 export declare function fullSync(): Promise<{
     pullResult: SyncResult;
     pushResult: PushResult;

package/dist/orquesta/config-sync.js

@@ -264,6 +264,33 @@ export async function updatePromptStatus(promptId, update) {
         };
     }
 }
+export async function streamPromptLogs(promptId, logs) {
+    const orquestaConfig = configManager.getOrquestaConfig();
+    if (!orquestaConfig?.token) {
+        return { success: false, error: 'Not connected to Orquesta' };
+    }
+    try {
+        const response = await fetch(`${ORQUESTA_API}/api/prompts/${promptId}/logs`, {
+            method: 'POST',
+            headers: {
+                'X-Agent-Token': orquestaConfig.token,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ logs }),
+        });
+        if (!response.ok) {
+            const errorData = (await response.json().catch(() => ({})));
+            return { success: false, error: errorData.error || `HTTP ${response.status}` };
+        }
+        return { success: true };
+    }
+    catch (error) {
+        logger.warn('Failed to stream prompt logs to Orquesta', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return { success: false, error: error instanceof Error ? error.message : 'Network error' };
+    }
+}
 export async function fullSync() {
     const pullResult = await syncOrquestaConfigs();
     const pushResult = await pushConfigsToOrquesta();

package/dist/orquesta/prompt-reporter.d.ts

@@ -1,3 +1,4 @@
+export declare function getCurrentPromptId(): string | null;
 export declare function reportPromptStart(content: string, context?: {
     cwd?: string;
     model?: string;
@@ -11,6 +12,11 @@ export declare function reportPromptComplete(trackingId: string, result: {
     costCents?: number;
 }): Promise<void>;
 export declare function reportPromptCancelled(trackingId: string): Promise<void>;
+export declare function reportToolUse(toolName: string, args: Record<string, unknown>, result: {
+    success: boolean;
+    output?: string;
+    error?: string;
+}): Promise<void>;
 export declare function getActivePromptCount(): number;
 export declare function cleanupOldPrompts(maxAgeMs?: number): void;
 //# sourceMappingURL=prompt-reporter.d.ts.map

package/dist/orquesta/prompt-reporter.js

@@ -1,7 +1,12 @@
 import { configManager } from '../core/config/config-manager.js';
-import { submitPromptToOrquesta, updatePromptStatus } from './config-sync.js';
+import { submitPromptToOrquesta, updatePromptStatus, streamPromptLogs } from './config-sync.js';
 import { logger } from '../utils/logger.js';
 const activePrompts = new Map();
+let currentPromptId = null;
+let currentSequence = 0;
+export function getCurrentPromptId() {
+    return currentPromptId;
+}
 export async function reportPromptStart(content, context) {
     if (!configManager.hasOrquestaConnection()) {
         return null;
@@ -23,6 +28,8 @@ export async function reportPromptStart(content, context) {
                 startTime: Date.now(),
                 content,
             });
+            currentPromptId = result.promptId;
+            currentSequence = 0;
             await updatePromptStatus(result.promptId, { status: 'running' });
             return result.promptId;
         }
@@ -48,6 +55,9 @@ export async function reportPromptComplete(trackingId, result) {
             costCents: result.costCents,
         });
         activePrompts.delete(trackingId);
+        if (currentPromptId === trackingId) {
+            currentPromptId = null;
+        }
     }
     catch (error) {
         logger.warn('Failed to report prompt completion', {
@@ -64,6 +74,9 @@ export async function reportPromptCancelled(trackingId) {
             status: 'cancelled',
         });
         activePrompts.delete(trackingId);
+        if (currentPromptId === trackingId) {
+            currentPromptId = null;
+        }
     }
     catch (error) {
         logger.warn('Failed to report prompt cancellation', {
@@ -71,6 +84,69 @@ export async function reportPromptCancelled(trackingId) {
         });
     }
 }
+function describeToolCall(toolName, args) {
+    const str = (v) => (typeof v === 'string' ? v : '');
+    const truncate = (s, max) => s.length > max ? `${s.slice(0, max)}…` : s;
+    const filePath = str(args['file_path'] || args['path']);
+    switch (toolName) {
+        case 'bash':
+        case 'background_bash':
+            return `$ ${truncate(str(args['command']), 500)}`;
+        case 'read_file':
+            return filePath ? `Read ${filePath}` : 'Read file';
+        case 'edit_file':
+            return filePath ? `Edit ${filePath}` : 'Edit file';
+        case 'write_file':
+            return filePath ? `Write ${filePath}` : 'Write file';
+        case 'list_files':
+            return `List ${str(args['path']) || '.'}`;
+        case 'grep':
+        case 'search_files':
+            return `Search "${truncate(str(args['pattern'] || args['query']), 120)}"`;
+        default:
+            return `Using ${toolName}`;
+    }
+}
+export async function reportToolUse(toolName, args, result) {
+    const promptId = currentPromptId;
+    if (!promptId || !configManager.hasOrquestaConnection()) {
+        return;
+    }
+    try {
+        const truncate = (s, max) => s.length > max ? `${s.slice(0, max)}…` : s;
+        const callSeq = (currentSequence += 1);
+        const resultSeq = (currentSequence += 1);
+        const logs = [
+            {
+                type: 'tool_call',
+                level: 'info',
+                sequence: callSeq,
+                tool_call: {
+                    name: toolName,
+                    parameters: args,
+                    message: describeToolCall(toolName, args),
+                },
+            },
+            {
+                type: 'tool_result',
+                level: result.success ? 'success' : 'error',
+                sequence: resultSeq,
+                tool_result: {
+                    name: toolName,
+                    success: result.success,
+                    output: result.output ? truncate(result.output, 10000) : undefined,
+                    error: result.error ? truncate(result.error, 10000) : undefined,
+                },
+            },
+        ];
+        await streamPromptLogs(promptId, logs);
+    }
+    catch (error) {
+        logger.warn('Failed to report tool use to Orquesta', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
 export function getActivePromptCount() {
     return activePrompts.size;
 }

package/dist/tools/llm/simple/simple-tool-executor.js

@@ -1,5 +1,6 @@
 import { isLLMSimpleTool } from '../../types.js';
 import { getStreamLogger } from '../../../utils/json-stream-logger.js';
+import { reportToolUse } from '../../../orquesta/prompt-reporter.js';
 let toolExecutionCallback = null;
 let toolResponseCallback = null;
 let planCreatedCallback = null;
@@ -128,6 +129,13 @@ export async function executeSimpleTool(toolName, args) {
             : (result.error || 'Unknown error');
         toolResponseCallback(toolName, result.success, resultText);
     }
+    if (!isTodoTool) {
+        void reportToolUse(toolName, args, {
+            success: result.success,
+            output: result.success ? result.result : undefined,
+            error: result.success ? undefined : result.error,
+        });
+    }
     return result;
 }
 export const executeFileTool = executeSimpleTool;

package/dist/ui/components/PlanExecuteApp.js

@@ -37,7 +37,7 @@ import { configManager } from '../../core/config/config-manager.js';
 import { logger } from '../../utils/logger.js';
 import { usageTracker } from '../../core/usage-tracker.js';
 import { UpdateNotification } from '../UpdateNotification.js';
-import { checkForCliUpdate, runCliUpdate } from '../../utils/update-checker.js';
+import { checkForCliUpdate, runCliUpdate, setSkippedVersion } from '../../utils/update-checker.js';
 import { setToolExecutionCallback, setTellToUserCallback, setToolResponseCallback, setPlanCreatedCallback, setTodoStartCallback, setTodoCompleteCallback, setTodoFailCallback, setCompactCallback, setAssistantResponseCallback, setToolApprovalCallback, setReasoningCallback, } from '../../tools/llm/simple/file-tools.js';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
@@ -512,6 +512,7 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
                 runCliUpdate(updateLatest, (line) => setUpdateProgress(line.slice(0, 100)))
                     .then(res => {
                     if (res.success) {
+                        setSkippedVersion(updateLatest);
                         setUpdatePhase('done');
                     }
                     else {
@@ -521,7 +522,12 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo }) => {
                 });
                 return;
             }
-            if (key.escape || inputChar === 'n' || inputChar === 'N' || inputChar === 's' || inputChar === 'S') {
+            if (inputChar === 's' || inputChar === 'S') {
+                setSkippedVersion(updateLatest);
+                setUpdatePhase('hidden');
+                return;
+            }
+            if (key.escape || inputChar === 'n' || inputChar === 'N') {
                 setUpdatePhase('hidden');
                 return;
             }

package/dist/utils/update-checker.d.ts

@@ -1,3 +1,5 @@
+export declare function getSkippedVersion(): string | null;
+export declare function setSkippedVersion(version: string): void;
 export declare function checkForCliUpdate(currentVersion: string, timeoutMs?: number): Promise<{
     current: string;
     latest: string;

package/dist/utils/update-checker.js

@@ -1,6 +1,33 @@
 import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
 import { logger } from './logger.js';
 const REGISTRY_URL = 'https://registry.npmjs.org/orquesta-cli/latest';
+const STATE_DIR = path.join(process.env['HOME'] || os.homedir() || '.', '.local-cli');
+const STATE_FILE = path.join(STATE_DIR, 'update-state.json');
+function readUpdateState() {
+    try {
+        return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function getSkippedVersion() {
+    return readUpdateState().skippedVersion ?? null;
+}
+export function setSkippedVersion(version) {
+    try {
+        if (!fs.existsSync(STATE_DIR))
+            fs.mkdirSync(STATE_DIR, { recursive: true });
+        const state = readUpdateState();
+        state.skippedVersion = version;
+        fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+    }
+    catch {
+    }
+}
 function isNewer(a, b) {
     const pa = a.split('.').map(n => parseInt(n, 10) || 0);
     const pb = b.split('.').map(n => parseInt(n, 10) || 0);
@@ -27,6 +54,10 @@ export async function checkForCliUpdate(currentVersion, timeoutMs = 3500) {
         const latest = json?.version;
         if (!latest || !isNewer(latest, currentVersion))
             return null;
+        if (getSkippedVersion() === latest) {
+            logger.debug?.('CLI update available but skipped by user', { latest });
+            return null;
+        }
         logger.debug?.('CLI update available', { current: currentVersion, latest });
         return { current: currentVersion, latest };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.2.22",
+  "version": "0.2.24",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",