byterover-cli 1.7.2 → 2.0.0

package/dist/oclif/commands/status.js

@@ -1,31 +1,11 @@
-import { Args, Command, Flags } from '@oclif/core';
-import { ProjectConfigStore } from '../../server/infra/config/file-config-store.js';
-import { FileContextTreeService } from '../../server/infra/context-tree/file-context-tree-service.js';
-import { FileContextTreeSnapshotService } from '../../server/infra/context-tree/file-context-tree-snapshot-service.js';
-import { FileGlobalConfigStore } from '../../server/infra/storage/file-global-config-store.js';
-import { createTokenStore } from '../../server/infra/storage/token-store.js';
-import { HeadlessTerminal } from '../../server/infra/terminal/headless-terminal.js';
-import { OclifTerminal } from '../../server/infra/terminal/oclif-terminal.js';
-import { MixpanelTrackingService } from '../../server/infra/tracking/mixpanel-tracking-service.js';
-import { StatusUseCase } from '../../server/infra/usecase/status-use-case.js';
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { StatusEvents } from '../../shared/transport/events/status-events.js';
+import { formatConnectionError, withDaemonRetry } from '../lib/daemon-client.js';
+import { writeJsonResponse } from '../lib/json-response.js';
 export default class Status extends Command {
-    static args = {
-        directory: Args.string({ description: 'Project directory (defaults to current directory)', required: false }),
-    };
     static description = 'Show CLI status and project information. Display local context tree managed by ByteRover CLI';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '# Check status after login (in REPL):',
-        '/login',
-        '/status',
-        '',
-        '# Verify project initialization (in REPL):',
-        '/init',
-        '/status',
-        '',
-        '<%= config.bin %> <%= command.id %> /path/to/project',
-        '<%= config.bin %> <%= command.id %> --format json',
-    ];
+    static examples = ['<%= config.bin %> <%= command.id %>', '<%= config.bin %> <%= command.id %> --format json'];
     static flags = {
         format: Flags.string({
             char: 'f',
@@ -33,33 +13,98 @@ export default class Status extends Command {
             description: 'Output format',
             options: ['text', 'json'],
         }),
-        headless: Flags.boolean({
-            default: false,
-            description: 'Run in headless mode (no TTY required, suitable for automation)',
-        }),
     };
-    createUseCase(options) {
-        const tokenStore = createTokenStore();
-        const globalConfigStore = new FileGlobalConfigStore();
-        const trackingService = new MixpanelTrackingService({ globalConfigStore, tokenStore });
-        const contextTreeSnapshotService = new FileContextTreeSnapshotService();
-        // Use HeadlessTerminal for headless mode or JSON format
-        const terminal = options.headless || options.format === 'json'
-            ? new HeadlessTerminal({ failOnPrompt: true, outputFormat: options.format })
-            : new OclifTerminal(this);
-        return new StatusUseCase({
-            contextTreeService: new FileContextTreeService(),
-            contextTreeSnapshotService,
-            projectConfigStore: new ProjectConfigStore(),
-            terminal,
-            tokenStore,
-            trackingService,
-        });
+    async fetchStatus(options) {
+        return withDaemonRetry(async (client) => {
+            const response = await client.requestWithAck(StatusEvents.GET);
+            return response.status;
+        }, options);
     }
     async run() {
         const { flags } = await this.parse(Status);
         const format = flags.format;
-        const { headless } = flags;
-        await this.createUseCase({ format, headless }).run({ cliVersion: this.config.version, format });
+        try {
+            const status = await this.fetchStatus();
+            if (format === 'json') {
+                writeJsonResponse({
+                    command: 'status',
+                    data: { ...status, cliVersion: this.config.version },
+                    success: true,
+                });
+            }
+            else {
+                this.formatTextOutput(status);
+            }
+        }
+        catch (error) {
+            if (format === 'json') {
+                writeJsonResponse({
+                    command: 'status',
+                    data: { error: formatConnectionError(error) },
+                    success: false,
+                });
+            }
+            else {
+                this.log(formatConnectionError(error));
+            }
+        }
+    }
+    formatTextOutput(status) {
+        this.log(`CLI Version: ${this.config.version}`);
+        // Auth status (cloud sync only — not required for local usage)
+        switch (status.authStatus) {
+            case 'expired': {
+                this.log('Account: Session expired');
+                break;
+            }
+            case 'logged_in': {
+                this.log(`Account: ${status.userEmail}`);
+                break;
+            }
+            case 'not_logged_in': {
+                this.log('Account: Not connected (optional — login for push/pull sync)');
+                break;
+            }
+            default: {
+                this.log('Account: Unable to check');
+            }
+        }
+        this.log(`Current Directory: ${status.currentDirectory}`);
+        // Space
+        if (status.teamName && status.spaceName) {
+            this.log(`Space: ${status.teamName}/${status.spaceName}`);
+        }
+        else {
+            this.log('Space: Not connected');
+        }
+        // Context tree status
+        switch (status.contextTreeStatus) {
+            case 'has_changes': {
+                if (status.contextTreeChanges && status.contextTreeRelativeDir) {
+                    const formatPath = (file) => `${status.contextTreeRelativeDir}/${file}`;
+                    const allChanges = [
+                        ...status.contextTreeChanges.modified.map((f) => ({ path: f, status: 'modified:' })),
+                        ...status.contextTreeChanges.added.map((f) => ({ path: f, status: 'new file:' })),
+                        ...status.contextTreeChanges.deleted.map((f) => ({ path: f, status: 'deleted:' })),
+                    ].sort((a, b) => a.path.localeCompare(b.path));
+                    this.log('Context Tree Changes:');
+                    for (const change of allChanges) {
+                        this.log(`   ${chalk.red(`${change.status.padEnd(10)} ${formatPath(change.path)}`)}`);
+                    }
+                }
+                break;
+            }
+            case 'no_changes': {
+                this.log('Context Tree: No changes');
+                break;
+            }
+            case 'not_initialized': {
+                this.log('Context Tree: Not initialized');
+                break;
+            }
+            default: {
+                this.log('Context Tree: Unable to check status');
+            }
+        }
     }
 }

package/dist/oclif/hooks/prerun/validate-brv-config-version.d.ts

@@ -1,28 +1,33 @@
 import type { Hook } from '@oclif/core';
 import type { IProjectConfigStore } from '../../../server/core/interfaces/storage/i-project-config-store.js';
+import { type AutoInitDeps } from '../../../server/infra/config/auto-init.js';
 /**
- * Commands that should skip config version validation.
- * These commands either don't need config or create/recreate it.
+ * Commands that should skip auto-init and config version validation.
  */
 export declare const SKIP_COMMANDS: Set<string>;
 /**
- * Context for hook error handling.
+ * Dependencies for the curate-view patch marker, injected for testability.
+ * The marker file lives in the XDG/global data dir scoped to the current project,
+ * keeping internal patch bookkeeping out of the user-facing .brv/config.json.
  */
-type HookErrorContext = {
-    error: (message: string, options: {
-        exit: number;
-    }) => void;
+export type PatchMarkerDeps = {
+    isPatched(): Promise<boolean>;
+    markPatched(): Promise<void>;
+    patchFn?: (cwd: string) => Promise<void>;
 };
 /**
  * Core validation logic extracted for testability.
+ * Auto-initializes .brv/ if it doesn't exist, then migrates config version if needed.
+ * Also ensures connector files are patched with `brv curate view` docs (once per project).
+ *
  * @param commandId - The command being executed
  * @param configStore - The config store to use for reading config
- * @param errorContext - Context with error function to call on version errors
+ * @param autoInitDeps - Dependencies for auto-init (optional, for testing)
+ * @param patchMarkerDeps - Dependencies for the curate-view patch marker (optional, for testing)
  */
-export declare const validateBrvConfigVersion: (commandId: string, configStore: IProjectConfigStore, errorContext: HookErrorContext) => Promise<void>;
+export declare const validateBrvConfigVersion: (commandId: string, configStore: IProjectConfigStore, autoInitDeps?: AutoInitDeps, patchMarkerDeps?: PatchMarkerDeps) => Promise<void>;
 /**
- * Prerun hook that validates the .brv/config.json version before command execution.
- * Throws an error if the config version is missing or mismatched, prompting users to re-run `brv init`.
+ * Prerun hook that auto-initializes .brv/ if missing, then validates config version.
  */
 declare const hook: Hook<'prerun'>;
 export default hook;

package/dist/oclif/hooks/prerun/validate-brv-config-version.js

@@ -1,43 +1,86 @@
-import { BrvConfigVersionError } from '../../../server/core/domain/errors/brv-config-version-error.js';
+import { access, mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { BRV_CONFIG_VERSION } from '../../../server/constants.js';
+import { ensureProjectInitialized } from '../../../server/infra/config/auto-init.js';
 import { ProjectConfigStore } from '../../../server/infra/config/file-config-store.js';
+import { ensureCurateViewPatched } from '../../../server/infra/connectors/shared/rule-segment-patcher.js';
+import { FileContextTreeService } from '../../../server/infra/context-tree/file-context-tree-service.js';
+import { FileContextTreeSnapshotService } from '../../../server/infra/context-tree/file-context-tree-snapshot-service.js';
+import { syncConfigToXdg } from '../../../server/utils/config-xdg-sync.js';
+import { getProjectDataDir } from '../../../server/utils/path-utils.js';
 /**
- * Commands that should skip config version validation.
- * These commands either don't need config or create/recreate it.
+ * Commands that should skip auto-init and config version validation.
  */
-export const SKIP_COMMANDS = new Set(['--help', 'help', 'init', 'login', 'logout']);
+export const SKIP_COMMANDS = new Set(['--help', 'help', 'login', 'logout']);
+const getCurateViewMarkerPath = (cwd) => join(getProjectDataDir(cwd), 'patches', 'curate-view.done');
+const defaultPatchMarkerDeps = (cwd) => ({
+    async isPatched() {
+        try {
+            await access(getCurateViewMarkerPath(cwd));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    async markPatched() {
+        const markerPath = getCurateViewMarkerPath(cwd);
+        await mkdir(dirname(markerPath), { recursive: true });
+        await writeFile(markerPath, '');
+    },
+});
 /**
  * Core validation logic extracted for testability.
+ * Auto-initializes .brv/ if it doesn't exist, then migrates config version if needed.
+ * Also ensures connector files are patched with `brv curate view` docs (once per project).
+ *
  * @param commandId - The command being executed
  * @param configStore - The config store to use for reading config
- * @param errorContext - Context with error function to call on version errors
+ * @param autoInitDeps - Dependencies for auto-init (optional, for testing)
+ * @param patchMarkerDeps - Dependencies for the curate-view patch marker (optional, for testing)
  */
-export const validateBrvConfigVersion = async (commandId, configStore, errorContext) => {
-    // Skip version check for commands that don't need config
+export const validateBrvConfigVersion = async (commandId, configStore, autoInitDeps, patchMarkerDeps) => {
+    // Skip for commands that don't need config
     if (SKIP_COMMANDS.has(commandId)) {
         return;
     }
-    try {
-        // If config doesn't exist, let the command handle it
-        const exists = await configStore.exists();
-        if (!exists) {
-            return;
-        }
-        // read() will throw BrvConfigVersionError if version is invalid
-        await configStore.read();
+    const exists = await configStore.exists();
+    if (!exists) {
+        // Auto-init: create .brv/ with minimal local config
+        const deps = autoInitDeps ?? {
+            contextTreeService: new FileContextTreeService(),
+            contextTreeSnapshotService: new FileContextTreeSnapshotService(),
+            projectConfigStore: configStore,
+        };
+        await ensureProjectInitialized(deps);
+        return;
     }
-    catch (error) {
-        if (error instanceof BrvConfigVersionError) {
-            errorContext.error(error.message, { exit: 1 });
-        }
-        // Re-throw other errors (corrupted JSON, etc.)
-        throw error;
+    // Read existing config — fromJson() preserves original version
+    const config = await configStore.read();
+    if (!config)
+        return;
+    // ProjectConfigStore checks .brv/ at process.cwd() directly (no walk-up),
+    // so configStore.exists() returning true means process.cwd() IS the project root.
+    const cwd = process.cwd();
+    // Gate the connector-file patch behind a per-project marker file in the XDG data dir.
+    // This keeps internal bookkeeping out of the user-facing .brv/config.json.
+    const marker = patchMarkerDeps ?? defaultPatchMarkerDeps(cwd);
+    const alreadyPatched = await marker.isPatched();
+    if (!alreadyPatched) {
+        const patchFn = patchMarkerDeps?.patchFn ?? ensureCurateViewPatched;
+        await patchFn(cwd).catch(() => { });
+        await marker.markPatched().catch(() => { });
+    }
+    if (config.version !== BRV_CONFIG_VERSION) {
+        const updated = config.withVersion(BRV_CONFIG_VERSION);
+        await configStore.write(updated);
+        await syncConfigToXdg(updated, cwd);
     }
 };
 /**
- * Prerun hook that validates the .brv/config.json version before command execution.
- * Throws an error if the config version is missing or mismatched, prompting users to re-run `brv init`.
+ * Prerun hook that auto-initializes .brv/ if missing, then validates config version.
  */
 const hook = async function (options) {
-    await validateBrvConfigVersion(options.Command.id, new ProjectConfigStore(), this);
+    await validateBrvConfigVersion(options.Command.id, new ProjectConfigStore());
 };
 export default hook;

package/dist/oclif/lib/daemon-client.d.ts

@@ -0,0 +1,40 @@
+import { type ConnectionResult, type ITransportClient } from '@campfirein/brv-transport-client';
+import { type TransportConnector } from '../../server/infra/transport/transport-connector.js';
+export interface DaemonClientOptions {
+    /** Max retry attempts. Default: 3 */
+    maxRetries?: number;
+    /** Delay between retries in ms. Default: 2000. Set to 0 in tests. */
+    retryDelayMs?: number;
+    /** Optional transport connector for DI/testing */
+    transportConnector?: TransportConnector;
+}
+/**
+ * Connects to the daemon, auto-starting it if needed.
+ */
+export declare function connectToDaemonClient(options?: Pick<DaemonClientOptions, 'transportConnector'>): Promise<ConnectionResult>;
+/**
+ * Executes an operation against the daemon with retry logic.
+ *
+ * Retries on infrastructure failures (daemon spawn timeout, connection dropped,
+ * agent disconnected). Does NOT retry on business errors (auth, validation, etc.).
+ */
+export declare function withDaemonRetry<T>(fn: (client: ITransportClient, projectRoot?: string) => Promise<T>, options?: DaemonClientOptions & {
+    /** Called before each retry with attempt number (1-indexed) */
+    onRetry?: (attempt: number, maxRetries: number) => void;
+}): Promise<T>;
+/**
+ * Checks if an error is retryable (daemon/agent infrastructure failure).
+ */
+export declare function isRetryableError(error: unknown): boolean;
+/**
+ * Checks if an error left leaked Socket.IO handles that prevent Node.js from exiting.
+ */
+export declare function hasLeakedHandles(error: unknown): boolean;
+export interface ProviderErrorContext {
+    activeModel?: string;
+    activeProvider?: string;
+}
+/**
+ * Formats a connection error into a user-friendly message.
+ */
+export declare function formatConnectionError(error: unknown, providerContext?: ProviderErrorContext): string;

package/dist/oclif/lib/daemon-client.js

@@ -0,0 +1,142 @@
+import { ConnectionError, ConnectionFailedError, DaemonSpawnError, InstanceCrashedError, NoInstanceRunningError, TransportRequestError, TransportRequestTimeoutError, } from '@campfirein/brv-transport-client';
+import { TaskErrorCode } from '../../server/core/domain/errors/task-error.js';
+import { createDaemonAwareConnector } from '../../server/infra/transport/transport-connector.js';
+import { getSandboxEnvironmentName, isSandboxEnvironment, isSandboxNetworkError, } from '../../server/utils/sandbox-detector.js';
+/** Max retry attempts when daemon disconnects mid-task */
+const MAX_RETRIES = 3;
+/** Delay between retry attempts (ms) */
+const DEFAULT_RETRY_DELAY_MS = 2000;
+/** Maps handler error codes to user-friendly CLI messages */
+const USER_FRIENDLY_MESSAGES = {
+    [TaskErrorCode.AGENT_NOT_INITIALIZED]: "Agent failed to initialize. Run 'brv restart' to force a clean restart.",
+    [TaskErrorCode.CONTEXT_TREE_NOT_INITIALIZED]: 'Context tree not initialized.',
+    [TaskErrorCode.LOCAL_CHANGES_EXIST]: 'You have local changes. Run "brv push" to save your changes before pulling.',
+    [TaskErrorCode.NOT_AUTHENTICATED]: 'Not authenticated. Cloud sync features (push/pull/space) require login — local query and curate work without authentication.',
+    [TaskErrorCode.PROJECT_NOT_INIT]: 'Project not initialized. Run "brv restart" to reinitialize.',
+    [TaskErrorCode.PROVIDER_NOT_CONFIGURED]: 'No provider connected. Run "brv providers connect byterover" to use the free built-in provider, or connect another provider.',
+    [TaskErrorCode.SPACE_NOT_CONFIGURED]: 'No space configured. Run "brv space list" to see available spaces, then "brv space switch --team <team> --name <space>" to select one.',
+    [TaskErrorCode.SPACE_NOT_FOUND]: 'Space not found. Check your configuration.',
+};
+/**
+ * Connects to the daemon, auto-starting it if needed.
+ */
+export async function connectToDaemonClient(options) {
+    const connector = options?.transportConnector ?? createDaemonAwareConnector();
+    return connector();
+}
+/**
+ * Executes an operation against the daemon with retry logic.
+ *
+ * Retries on infrastructure failures (daemon spawn timeout, connection dropped,
+ * agent disconnected). Does NOT retry on business errors (auth, validation, etc.).
+ */
+export async function withDaemonRetry(fn, options) {
+    const maxRetries = options?.maxRetries ?? MAX_RETRIES;
+    const retryDelayMs = options?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+    const connector = options?.transportConnector ?? createDaemonAwareConnector();
+    let lastError;
+    /* eslint-disable no-await-in-loop -- intentional sequential retry loop */
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        let client;
+        try {
+            const { client: connectedClient, projectRoot } = await connector();
+            client = connectedClient;
+            const value = await fn(client, projectRoot);
+            await client.disconnect().catch(() => { });
+            return value;
+        }
+        catch (error) {
+            if (client) {
+                await client.disconnect().catch(() => { });
+            }
+            lastError = error;
+            if (isRetryableError(error) && attempt < maxRetries) {
+                options?.onRetry?.(attempt + 1, maxRetries);
+                await new Promise((resolve) => {
+                    setTimeout(resolve, retryDelayMs);
+                });
+                continue;
+            }
+            break;
+        }
+    }
+    /* eslint-enable no-await-in-loop */
+    throw lastError;
+}
+/**
+ * Checks if an error is retryable (daemon/agent infrastructure failure).
+ */
+export function isRetryableError(error) {
+    if (error instanceof DaemonSpawnError || error instanceof ConnectionFailedError)
+        return true;
+    if (error instanceof TransportRequestTimeoutError)
+        return true;
+    return hasLeakedHandles(error);
+}
+/**
+ * Checks if an error left leaked Socket.IO handles that prevent Node.js from exiting.
+ */
+export function hasLeakedHandles(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (!('code' in error))
+        return false;
+    return error.code === TaskErrorCode.AGENT_DISCONNECTED || error.code === TaskErrorCode.AGENT_NOT_AVAILABLE;
+}
+/**
+ * Formats a connection error into a user-friendly message.
+ */
+export function formatConnectionError(error, providerContext) {
+    if (error instanceof NoInstanceRunningError) {
+        if (isSandboxEnvironment()) {
+            const sandboxName = getSandboxEnvironmentName();
+            return (`Daemon failed to start automatically.\n` +
+                `⚠️  Sandbox environment detected (${sandboxName}).\n\n` +
+                `Run 'brv' in a terminal outside the sandbox, then allow network access so this sandbox can connect.`);
+        }
+        return 'Daemon failed to start automatically.\n\nRestart your terminal and retry the command.';
+    }
+    if (error instanceof InstanceCrashedError) {
+        return "Daemon crashed unexpectedly.\n\nRun 'brv restart' to force a clean restart.";
+    }
+    if (error instanceof ConnectionFailedError) {
+        const isSandboxError = isSandboxNetworkError(error.originalError ?? error);
+        if (isSandboxError) {
+            const sandboxName = getSandboxEnvironmentName();
+            return (`Failed to connect to the daemon.\n` +
+                `Port: ${error.port ?? 'unknown'}\n` +
+                `⚠️  Sandbox network restriction detected (${sandboxName}).\n\n` +
+                `Please allow network access in the sandbox and retry the command.`);
+        }
+        return `Failed to connect to the daemon: ${error.message}\nRun 'brv restart' if the daemon is unresponsive.`;
+    }
+    if (error instanceof ConnectionError) {
+        return `Connection error: ${error.message}\nRun 'brv restart' if the daemon is unresponsive.`;
+    }
+    // Business errors from transport handlers (auth, validation, etc.)
+    if (error instanceof TransportRequestError) {
+        // Strip the " for event '...'" suffix that TransportRequestError appends
+        const baseMessage = error.message.replace(/ for event '[^']+'$/, '');
+        if (error.code && typeof error.code === 'string') {
+            return USER_FRIENDLY_MESSAGES[error.code] ?? baseMessage;
+        }
+        return baseMessage;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const lowerMessage = message.toLowerCase();
+    if (lowerMessage.includes('401') || lowerMessage.includes('unauthorized')) {
+        return "Authentication required for cloud sync. Run 'brv login' to connect your account.";
+    }
+    if (lowerMessage.includes('api key') || lowerMessage.includes('invalid key')) {
+        const provider = providerContext?.activeProvider ?? '<provider>';
+        const model = providerContext?.activeModel;
+        const currentInfo = model ? `Provider: ${provider}  Model: ${model}\n\n` : `Provider: ${provider}\n\n`;
+        return (`LLM provider API key is missing or invalid.\n${currentInfo}` +
+            '  Reconnect with your API key:\n' +
+            `    brv providers connect ${provider} --api-key <key>\n\n` +
+            '  Switch to a different provider:\n' +
+            '    brv providers switch <provider>\n\n' +
+            '  See all options:  brv providers --help');
+    }
+    return `Unexpected error: ${message}`;
+}

package/dist/oclif/lib/json-response.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Writes a JSON final response to stdout.
+ * Used by oclif commands for --format json output.
+ */
+export declare function writeJsonResponse(options: {
+    command: string;
+    data: unknown;
+    success: boolean;
+}): void;

package/dist/oclif/lib/json-response.js

@@ -0,0 +1,10 @@
+/**
+ * Writes a JSON final response to stdout.
+ * Used by oclif commands for --format json output.
+ */
+export function writeJsonResponse(options) {
+    process.stdout.write(JSON.stringify({
+        ...options,
+        timestamp: new Date().toISOString(),
+    }) + '\n');
+}

package/dist/oclif/lib/task-client.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Shared task event subscription utilities for oclif commands.
+ *
+ * Mirrors TUI's useTaskSubscriptions pattern: subscribes to all task and LLM events,
+ * collects tool calls, and streams output in real-time.
+ *
+ * Used by: curate, query commands.
+ */
+import type { ITransportClient } from '@campfirein/brv-transport-client';
+/** Collected tool call with result (mirrors TUI ToolCallEvent) */
+export interface ToolCallRecord {
+    args: Record<string, unknown>;
+    callId?: string;
+    error?: string;
+    result?: unknown;
+    status: 'completed' | 'error' | 'running';
+    success?: boolean;
+    toolName: string;
+}
+/** Completion result passed to onCompleted callback */
+export interface TaskCompletionResult {
+    logId?: string;
+    result?: string;
+    taskId: string;
+    toolCalls: ToolCallRecord[];
+}
+/** Error result passed to onError callback */
+export interface TaskErrorResult {
+    error: {
+        code?: string;
+        message: string;
+    };
+    logId?: string;
+    taskId: string;
+    toolCalls: ToolCallRecord[];
+}
+/** Options for waitForTaskCompletion */
+export interface WaitForTaskOptions {
+    /** Client to subscribe events on */
+    client: ITransportClient;
+    /** Command name for JSON output */
+    command: string;
+    /** Output format */
+    format: 'json' | 'text';
+    /** Called on task:completed */
+    onCompleted: (result: TaskCompletionResult) => void;
+    /** Called on task:error */
+    onError: (result: TaskErrorResult) => void;
+    /** Called on llmservice:response (optional, used by query to display final answer) */
+    onResponse?: (content: string, taskId: string) => void;
+    /** Task ID to wait for */
+    taskId: string;
+    /** Timeout in ms (default: 5 minutes) */
+    timeoutMs?: number;
+}
+/**
+ * Format tool call for CLI display (simplified version of TUI formatToolDisplay).
+ */
+export declare function formatToolDisplay(toolName: string, args: Record<string, unknown>): string;
+/**
+ * Wait for task completion by subscribing to all events (same as TUI useTaskSubscriptions).
+ * In text mode: streams tool calls and thinking in real-time via log().
+ * In JSON mode: streams each event as a separate JSON line.
+ *
+ * Rejects with a retryable error (AGENT_DISCONNECTED) on daemon disconnect,
+ * allowing withDaemonRetry to handle reconnection.
+ */
+export declare function waitForTaskCompletion(options: WaitForTaskOptions, log: (msg: string) => void): Promise<void>;