@phuetz/code-buddy 2.0.0 → 2.1.0

package/dist/commands/handlers/switch-handler.d.ts

@@ -9,7 +9,7 @@
 import type { CommandHandlerResult } from './branch-handlers.js';
 /**
  * Provider for model routing state.
- * Set from enhanced-command-handler when the agent is available.
+ * Set by the conversation-loop dispatcher from the live agent.
  */
 export interface SwitchModelProvider {
     /** Get list of available model names */

package/dist/commands/handlers/switch-handler.js

@@ -23,6 +23,21 @@ export function setSwitchModelProvider(provider) {
  *   /switch auto            — Return to auto-routing / default
  */
 export async function handleSwitch(args) {
+    try {
+        return await runSwitch(args);
+    }
+    catch (error) {
+        return {
+            handled: true,
+            entry: {
+                type: 'assistant',
+                content: `Model switch failed: ${error instanceof Error ? error.message : String(error)}`,
+                timestamp: new Date(),
+            },
+        };
+    }
+}
+async function runSwitch(args) {
     const modelName = args[0]?.trim();
     // No provider set — try to get models from config
     if (!providerRef) {

package/dist/commands/handlers/test-handlers.js

@@ -1,6 +1,5 @@
 import { CodeBuddyClient } from "../../codebuddy/client.js";
 import { AITestRunner, createAITestRunner } from "../../testing/ai-integration-tests.js";
-import stringWidth from "string-width";
 /**
  * Generate Tests - Create test scaffolds
  */
@@ -47,7 +46,7 @@ export async function handleAITest(args, codebuddyClient) {
     const option = args[0]?.toLowerCase();
     // Check for API key
     const apiKey = process.env.GROK_API_KEY;
-    if (!apiKey) {
+    if (!codebuddyClient && !apiKey) {
         return {
             handled: true,
             entry: {
@@ -66,9 +65,8 @@ Set your API key to run integration tests.`,
         // Fallback: create client from environment variables
         const model = process.env.GROK_MODEL || process.env.OPENAI_MODEL;
         const baseURL = process.env.GROK_BASE_URL || process.env.OPENAI_BASE_URL;
-        client = new CodeBuddyClient(apiKey, model, baseURL);
+        client = new CodeBuddyClient(apiKey ?? '', model, baseURL);
     }
-    const currentModel = client.getCurrentModel();
     const currentBaseURL = client.getBaseURL();
     // Detect local models (LM Studio, Ollama) and increase timeout
     const isLocalModel = currentBaseURL.includes(':1234') ||
@@ -86,87 +84,11 @@ Set your API key to run integration tests.`,
         testTools: option !== 'stream',
         testStreaming: option !== 'tools',
     };
-    // Fun test names and emojis
-    const testEmojis = {
-        'Basic Completion': '🧠',
-        'Simple Math': '🔢',
-        'JSON Output': '📋',
-        'Code Generation': '💻',
-        'Context Understanding': '🧩',
-        'Streaming Response': '🌊',
-        'Tool Calling': '🔧',
-        'Error Handling': '🛡️',
-        'Long Context': '📚',
-    };
-    const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    let spinnerIndex = 0;
-    let currentTest = '';
-    const completedTests = [];
-    let spinnerInterval = null;
-    // Create client and run tests
+    // Ink owns the terminal. Render the final report through the conversation
+    // instead of writing cursor-control sequences over the active UI.
     try {
         const runner = createAITestRunner(client, testOptions);
-        // Helper to pad string to width accounting for emoji visual width
-        const padEnd = (str, targetWidth) => {
-            const currentWidth = stringWidth(str);
-            if (currentWidth >= targetWidth)
-                return str;
-            return str + ' '.repeat(targetWidth - currentWidth);
-        };
-        const W = 60; // box width
-        // Build progress display with proper emoji width handling
-        const buildProgressDisplay = () => {
-            const lines = [];
-            lines.push('┌' + '─'.repeat(W - 2) + '┐');
-            lines.push('│' + padEnd('          🧪 AI INTEGRATION TESTS IN PROGRESS', W - 2) + '│');
-            lines.push('├' + '─'.repeat(W - 2) + '┤');
-            lines.push('│' + padEnd(`  Model: ${currentModel}`, W - 2) + '│');
-            lines.push('├' + '─'.repeat(W - 2) + '┤');
-            // Show completed tests
-            for (const test of completedTests) {
-                lines.push('│' + padEnd(`  ${test}`, W - 2) + '│');
-            }
-            // Show current test with spinner
-            if (currentTest) {
-                const emoji = testEmojis[currentTest] || '🔬';
-                const spinner = spinnerFrames[spinnerIndex % spinnerFrames.length];
-                lines.push('│' + padEnd(`  ${spinner} ${emoji} ${currentTest}...`, W - 2) + '│');
-            }
-            lines.push('└' + '─'.repeat(W - 2) + '┘');
-            return lines.join('\n');
-        };
-        // Track progress
-        runner.on('test:start', ({ name }) => {
-            currentTest = name;
-        });
-        runner.on('test:complete', (result) => {
-            const emoji = testEmojis[result.name] || '🔬';
-            const status = result.passed ? '✅' : '❌';
-            const duration = result.duration ? `${(result.duration / 1000).toFixed(1)}s` : '';
-            completedTests.push(`${status} ${emoji} ${result.name} ${duration}`);
-            currentTest = '';
-        });
-        runner.on('test:skipped', ({ name }) => {
-            const emoji = testEmojis[name] || '🔬';
-            completedTests.push(`⏭️  ${emoji} ${name} (skipped)`);
-        });
-        // Start spinner animation (write to stderr to not interfere with output)
-        spinnerInterval = setInterval(() => {
-            spinnerIndex++;
-            // Clear and redraw progress (using ANSI escape codes)
-            const progress = buildProgressDisplay();
-            process.stderr.write(`\x1b[${completedTests.length + 7}A\x1b[0J${progress}\n`);
-        }, 100);
-        // Show initial progress
-        process.stderr.write('\n' + buildProgressDisplay() + '\n');
         const suite = await runner.runAll();
-        // Stop spinner
-        if (spinnerInterval) {
-            clearInterval(spinnerInterval);
-        }
-        // Clear progress display
-        const clearLines = completedTests.length + 8;
-        process.stderr.write(`\x1b[${clearLines}A\x1b[0J`);
         // Format final results
         const resultContent = AITestRunner.formatResults(suite);
         return {
@@ -179,10 +101,6 @@ Set your API key to run integration tests.`,
         };
     }
     catch (error) {
-        // Stop spinner on error
-        if (spinnerInterval) {
-            clearInterval(spinnerInterval);
-        }
         return {
             handled: true,
             entry: {

package/dist/commands/handlers/ui-handlers.js

@@ -4,17 +4,17 @@ import { getThemeManager } from "../../themes/theme-manager.js";
  */
 export function handleTheme(args) {
     const themeManager = getThemeManager();
-    const action = args[0]?.toLowerCase();
+    const action = (args[0]?.toLowerCase() === "set" ? args[1] : args[0])?.toLowerCase();
     let content;
-    if (!action || action === "list") {
+    if (!action || action === "list" || action === "status" || action === "current") {
         const themes = themeManager.getAvailableThemes();
         const currentTheme = themeManager.getCurrentTheme();
-        content = `🎨 Available Themes\n${"═".repeat(40)}\n\n`;
+        content = `🎨 Current theme: ${currentTheme.name} (${currentTheme.id})\nAvailable Themes\n${"═".repeat(40)}\n\n`;
         for (const theme of themes) {
             const isCurrent = theme.id === currentTheme.id;
             const marker = isCurrent ? "▶" : " ";
             const builtinMarker = theme.isBuiltin ? "" : " (custom)";
-            content += `${marker} ${theme.name}${builtinMarker}\n`;
+            content += `${marker} ${theme.name} (${theme.id})${builtinMarker}\n`;
             content += `    ${theme.description}\n\n`;
         }
         content += `\n💡 Usage: /theme <name>\n`;
@@ -28,7 +28,13 @@ export function handleTheme(args) {
             content = `🎨 Theme Changed!\n\n`;
             content += `Now using: ${theme.name}\n`;
             content += `${theme.description}\n\n`;
-            content += `💡 The theme will be applied to new messages.`;
+            content += `The theme is active immediately.`;
+            if (themeManager.getPreferenceSaveStatus() === false) {
+                content += `\nCould not save the preference; this change may be lost after restarting Buddy.`;
+            }
+            if (themeManager.getOverrideKeys().colors.length > 0) {
+                content += `\nCustom color overrides are still applied.`;
+            }
         }
         else {
             const themes = themeManager.getAvailableThemes();

package/dist/commands/login-chatgpt.d.ts

@@ -0,0 +1,8 @@
+import { type ChatGptAuth } from '../providers/codex-oauth.js';
+interface LoginOutput {
+    stdout: (message: string) => unknown;
+    warn: (message: string) => unknown;
+}
+/** Keep the callback alive so a failed browser launch can be completed manually. */
+export declare function loginChatGptWithBrowser(output: LoginOutput): Promise<ChatGptAuth>;
+export {};

package/dist/commands/login-chatgpt.js

@@ -0,0 +1,17 @@
+import open from 'open';
+import { loginInteractive } from '../providers/codex-oauth.js';
+/** Keep the callback alive so a failed browser launch can be completed manually. */
+export function loginChatGptWithBrowser(output) {
+    return loginInteractive(async (url) => {
+        output.stdout('If the browser does not open, copy this entire URL into your browser:');
+        output.stdout(url);
+        output.stdout('Keep this terminal open until sign-in completes.\n');
+        try {
+            await open(url);
+        }
+        catch {
+            output.warn('Could not open the browser automatically. Open the URL above manually; login is still waiting.');
+        }
+    });
+}
+//# sourceMappingURL=login-chatgpt.js.map

package/dist/commands/mcp-import.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from 'commander';
+export declare function importMCPFile(filename: string, source: 'hermes' | 'openclaw', options?: {
+    dryRun?: boolean;
+    output?: string;
+}): {
+    written: boolean;
+    servers: import("../mcp/types.js").MCPServerConfig[];
+    warnings: string[];
+    rejected: string[];
+};
+export declare function registerMCPImportCommand(command: Command): void;

package/dist/commands/mcp-import.js

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parse } from 'yaml';
+import { normalizeMCPImports } from '../mcp/import-normalize.js';
+import { writeJsonAtomicSync } from '../utils/atomic-write.js';
+const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+export function importMCPFile(filename, source, options = {}) {
+    const stat = fs.statSync(filename);
+    if (!stat.isFile() || stat.size > 1024 * 1024)
+        throw new Error('MCP import file must be at most 1 MiB');
+    let input;
+    try {
+        input = parse(fs.readFileSync(filename, 'utf8'), { uniqueKeys: true });
+    }
+    catch {
+        throw new Error('Invalid MCP import JSON/YAML');
+    }
+    if (!object(input))
+        throw new Error('MCP import requires an object');
+    const map = input.mcpServers ?? input.mcp_servers ?? (object(input.mcp) ? input.mcp.servers : undefined) ?? input;
+    const normalized = normalizeMCPImports(map, source);
+    if (options.dryRun || normalized.servers.length === 0)
+        return { ...normalized, written: false };
+    const output = options.output ?? path.join(process.cwd(), '.codebuddy', 'mcp.json');
+    let existing = {};
+    if (fs.existsSync(output)) {
+        const target = fs.lstatSync(output);
+        if (!target.isFile() || target.isSymbolicLink() || target.size > 1024 * 1024)
+            throw new Error('Invalid existing MCP target');
+        try {
+            const parsed = JSON.parse(fs.readFileSync(output, 'utf8'));
+            if (!object(parsed) || (parsed.mcpServers !== undefined && !object(parsed.mcpServers)))
+                throw new Error();
+            existing = parsed;
+        }
+        catch {
+            throw new Error('Existing MCP configuration is invalid; not replaced');
+        }
+    }
+    const servers = object(existing.mcpServers) ? existing.mcpServers : {};
+    for (const server of normalized.servers) {
+        if (Object.hasOwn(servers, server.name))
+            normalized.warnings.push(`${server.name}: existing configuration preserved`);
+        else
+            servers[server.name] = server;
+    }
+    fs.mkdirSync(path.dirname(output), { recursive: true, mode: 0o700 });
+    writeJsonAtomicSync(output, { ...existing, mcpServers: servers }, { mode: 0o600 });
+    return { ...normalized, written: true };
+}
+export function registerMCPImportCommand(command) {
+    command.command('import <file>').requiredOption('--from <source>', 'hermes or openclaw')
+        .option('--dry-run', 'Show sanitized mapping without writing or connecting')
+        .option('--output <file>', 'Target MCP JSON file (default project .codebuddy/mcp.json)')
+        .description('Import MCP declarations; credentials become environment references and existing entries are preserved')
+        .action((file, options) => {
+        if (options.from !== 'hermes' && options.from !== 'openclaw')
+            command.error('Source must be hermes or openclaw');
+        try {
+            process.stdout.write(JSON.stringify(importMCPFile(file, options.from, options), null, 2) + '\n');
+        }
+        catch {
+            command.error('MCP import failed; check input/target configuration. No credentials are printed.');
+        }
+    });
+}
+//# sourceMappingURL=mcp-import.js.map

package/dist/commands/mcp-invoke.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerMCPInvocationCommands(command: Command): void;

package/dist/commands/mcp-invoke.js

@@ -0,0 +1,68 @@
+import { readFile, stat } from 'node:fs/promises';
+import { MCPManager } from '../mcp/client.js';
+import { loadMCPConfig } from '../mcp/config.js';
+import { getErrorMessage } from '../types/index.js';
+const MAX_ARGUMENT_BYTES = 1024 * 1024;
+export function registerMCPInvocationCommands(command) {
+    command.command('tools <server>')
+        .description('Print one configured MCP server tool catalog as JSON, without an LLM')
+        .option('--query <text>', 'Filter tool names and descriptions before printing schemas')
+        .action(async (server, options) => run(server, undefined, options));
+    command.command('call <server> <tool>')
+        .description('Invoke one MCP tool directly and print its result as JSON')
+        .option('--args <json>', 'JSON object of tool arguments')
+        .option('--args-file <path>', 'Read JSON arguments from a file (maximum 1 MiB)')
+        .action(async (server, tool, options) => {
+        await run(server, tool, options);
+    });
+}
+async function run(server, tool, options = {}) {
+    const manager = new MCPManager();
+    try {
+        if (options.args !== undefined && options.argsFile !== undefined) {
+            throw new Error('Use either --args or --args-file');
+        }
+        let raw = options.args ?? '{}';
+        if (options.argsFile !== undefined) {
+            const info = await stat(options.argsFile);
+            if (!info.isFile() || info.size > MAX_ARGUMENT_BYTES)
+                throw new Error('Arguments must be a regular file no larger than 1 MiB');
+            raw = await readFile(options.argsFile, 'utf8');
+        }
+        if (Buffer.byteLength(raw) > MAX_ARGUMENT_BYTES)
+            throw new Error('Arguments exceed 1 MiB');
+        let args;
+        try {
+            args = JSON.parse(raw);
+        }
+        catch {
+            throw new Error('Tool arguments must be valid JSON');
+        }
+        if (!args || typeof args !== 'object' || Array.isArray(args))
+            throw new Error('Tool arguments must be a JSON object');
+        const config = loadMCPConfig().servers.find(candidate => candidate.name === server);
+        if (!config)
+            throw new Error(`Enabled MCP server not found: ${server}`);
+        await manager.addServer(config);
+        if (!tool) {
+            const catalog = manager.getTools().filter(item => item.serverName === server);
+            const query = options.query?.toLowerCase();
+            const tools = query ? catalog.filter(item => `${item.name} ${item.description}`.toLowerCase().includes(query)) : catalog;
+            console.log(JSON.stringify({ server, totalTools: catalog.length, tools }));
+            return;
+        }
+        const qualified = `mcp__${server}__${tool}`;
+        const result = await manager.callTool(qualified, args);
+        console.log(JSON.stringify(result));
+        if (result.isError)
+            process.exitCode = 1;
+    }
+    catch (error) {
+        console.log(JSON.stringify({ isError: true, error: getErrorMessage(error) }));
+        process.exitCode = 1;
+    }
+    finally {
+        await manager.dispose();
+    }
+}
+//# sourceMappingURL=mcp-invoke.js.map

package/dist/commands/mcp.js

@@ -1,3 +1,5 @@
+import { registerMCPImportCommand } from './mcp-import.js';
+import { registerMCPInvocationCommands } from './mcp-invoke.js';
 import { Command } from 'commander';
 import { addMCPServer, removeMCPServer, loadMCPConfig, PREDEFINED_SERVERS, setMCPServerEnabled, } from '../mcp/config.js';
 import { getMCPManager } from '../codebuddy/tools.js';
@@ -52,6 +54,7 @@ export async function serveMCP(options = {}) {
 export function createMCPCommand() {
     const mcpCommand = new Command('mcp');
     mcpCommand.description('Manage MCP servers or expose Code Buddy over MCP');
+    registerMCPImportCommand(mcpCommand);
     mcpCommand
         .command('serve')
         .description('Expose Code Buddy tools as an MCP server over stdio')
@@ -524,6 +527,7 @@ export function createMCPCommand() {
             }
         }
     });
+    registerMCPInvocationCommands(mcpCommand);
     return mcpCommand;
 }
 //# sourceMappingURL=mcp.js.map

package/dist/commands/pipeline.d.ts

@@ -5,6 +5,11 @@
  * Supports running from YAML/JSON files, listing, validating, and status checks.
  */
 import { Command } from 'commander';
+import type { PipelineConfig, ApprovalGateConfig } from '../workflows/pipeline.js';
+/** Standalone CLI bridge; tool policy, trust and confirmations stay in ToolHandler. */
+export declare function createPipelineRuntime(): Pick<PipelineConfig, 'toolExecutor' | 'approvalHandler'> & {
+    dispose(): Promise<void>;
+};
 /**
  * Pipeline definition loaded from a file (YAML/JSON)
  */
@@ -14,10 +19,11 @@ export interface PipelineFileDefinition {
     version?: string;
     steps: Array<{
         name: string;
-        type?: 'tool' | 'skill' | 'function' | 'transform';
+        type?: 'tool' | 'skill' | 'function' | 'transform' | 'approval';
         args?: Record<string, unknown>;
         timeout?: number;
         label?: string;
+        approvalGate?: Pick<ApprovalGateConfig, 'message' | 'timeoutMs'>;
     }>;
     config?: {
         maxSteps?: number;

package/dist/commands/pipeline.js

@@ -6,6 +6,90 @@
  */
 import { Command } from 'commander';
 import { logger } from '../utils/logger.js';
+/** Standalone CLI bridge; tool policy, trust and confirmations stay in ToolHandler. */
+export function createPipelineRuntime() {
+    const controller = new AbortController();
+    let handler;
+    let marketplace;
+    let repair;
+    let service;
+    let readline;
+    let ownsListener = false;
+    const onConfirmation = (options) => {
+        void (async () => {
+            try {
+                const { createInterface } = await import('node:readline/promises');
+                readline = createInterface({ input: process.stdin, output: process.stderr });
+                process.stderr.write(`${JSON.stringify({ operation: options.operation, target: options.filename,
+                    preview: options.diffPreview ?? options.content })}\n`);
+                const answer = await readline.question('Approve this operation? [y/N] ');
+                service?.confirmOperation(/^(y|yes|o|oui)$/i.test(answer.trim()));
+            }
+            catch {
+                service?.rejectOperation('Approval input closed');
+            }
+            finally {
+                readline?.close();
+                readline = undefined;
+            }
+        })();
+    };
+    const confirmations = async () => {
+        if (!service) {
+            const { ConfirmationService } = await import('../utils/confirmation-service.js');
+            service = ConfirmationService.getInstance();
+            if (process.stdin.isTTY && service.listenerCount('confirmation-requested') === 0) {
+                service.on('confirmation-requested', onConfirmation);
+                ownsListener = true;
+            }
+        }
+        return service;
+    };
+    return {
+        toolExecutor: async (name, args) => {
+            await confirmations();
+            if (!handler) {
+                const [{ ToolHandler }, { CheckpointManager }, { HooksManager }, { PluginMarketplace }, { RepairCoordinator }] = await Promise.all([
+                    import('../agent/tool-handler.js'), import('../checkpoints/checkpoint-manager.js'),
+                    import('../hooks/lifecycle-hooks.js'), import('../plugins/marketplace.js'),
+                    import('../agent/execution/repair-coordinator.js'),
+                ]);
+                marketplace = new PluginMarketplace({ autoUpdate: false });
+                repair = new RepairCoordinator({ enabled: false });
+                handler = new ToolHandler({ checkpointManager: new CheckpointManager(),
+                    hooksManager: new HooksManager(process.cwd()), marketplace, repairCoordinator: repair });
+                handler.setWorkingDirectory(process.cwd());
+            }
+            const { randomUUID } = await import('node:crypto');
+            const result = await handler.executeTool({ id: `pipeline_${randomUUID()}`, type: 'function',
+                function: { name, arguments: JSON.stringify(args) } }, { surface: 'cli', abortSignal: controller.signal });
+            return { success: result.success, output: result.output ?? '', error: result.error };
+        },
+        approvalHandler: async (gate) => {
+            const confirmation = await confirmations();
+            const timer = setTimeout(() => {
+                confirmation.rejectOperation('Pipeline approval timed out');
+                readline?.close();
+            }, gate.timeoutMs);
+            try {
+                const result = await confirmation.requestConfirmation({ operation: 'Approve pipeline step',
+                    filename: gate.message, toolName: 'pipeline_approval', forcePrompt: true }, 'tool');
+                return { approved: result.confirmed, timestamp: new Date(), comment: result.feedback };
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+        dispose: async () => {
+            controller.abort();
+            if (ownsListener)
+                service?.off('confirmation-requested', onConfirmation);
+            readline?.close();
+            repair?.dispose();
+            await marketplace?.dispose();
+        },
+    };
+}
 /**
  * Load a pipeline definition from a YAML or JSON file.
  * Uses lazy imports for yaml parsing.
@@ -86,8 +170,12 @@ export function validatePipelineDefinition(definition) {
             warnings.push(`Step ${i + 1}: duplicate step name "${step.name}"`);
         }
         stepNames.add(step.name);
-        if (step.type && !['tool', 'skill', 'function', 'transform'].includes(step.type)) {
-            errors.push(`Step ${i + 1} ("${step.name}"): invalid type "${step.type}" (must be tool, skill, function, or transform)`);
+        if (step.type && !['tool', 'skill', 'function', 'transform', 'approval'].includes(step.type)) {
+            errors.push(`Step ${i + 1} ("${step.name}"): invalid type "${step.type}" (must be tool, skill, function, transform, or approval)`);
+        }
+        if (step.approvalGate && (typeof step.approvalGate.message !== 'string' ||
+            !Number.isFinite(step.approvalGate.timeoutMs) || step.approvalGate.timeoutMs <= 0)) {
+            errors.push(`Step ${i + 1}: approvalGate requires a message and positive timeoutMs`);
         }
         if (step.timeout !== undefined && (typeof step.timeout !== 'number' || step.timeout <= 0)) {
             warnings.push(`Step ${i + 1} ("${step.name}"): timeout should be a positive number`);
@@ -117,6 +205,8 @@ export function createPipelineCommand() {
         .option('-t, --timeout <ms>', 'Override default step timeout in milliseconds')
         .option('--dry-run', 'Validate and show steps without executing')
         .action(async (file, options) => {
+        let runtime;
+        let compositor;
         try {
             console.log(`Loading pipeline from: ${file}`);
             const definition = await loadPipelineFile(file);
@@ -164,7 +254,9 @@ export function createPipelineCommand() {
             if (definition.config?.maxDurationMs) {
                 config.maxDurationMs = definition.config.maxDurationMs;
             }
-            const compositor = new PipelineCompositor(config);
+            runtime = createPipelineRuntime();
+            compositor = new PipelineCompositor({ ...config, toolExecutor: runtime.toolExecutor,
+                approvalHandler: runtime.approvalHandler });
             // Set up event listeners for progress
             compositor.on('step:start', (step, index) => {
                 console.log(`  [${index + 1}/${definition.steps.length}] Running: ${step.name}...`);
@@ -175,11 +267,13 @@ export function createPipelineCommand() {
             });
             // Convert file definition steps to PipelineStep format
             const steps = definition.steps.map(step => ({
-                type: (step.type || 'tool'),
+                type: step.type || 'tool',
                 name: step.name,
                 args: step.args || {},
                 timeout: step.timeout,
                 label: step.label,
+                approvalGate: step.type === 'approval' ? { message: step.approvalGate?.message ?? step.name,
+                    timeoutMs: step.approvalGate?.timeoutMs ?? 300000, requireExplicit: true } : undefined,
             }));
             console.log(`\nRunning pipeline: ${definition.name} (${steps.length} steps)`);
             const result = await compositor.execute(steps);
@@ -191,14 +285,17 @@ export function createPipelineCommand() {
             }
             else {
                 console.error(`\nPipeline failed: ${result.error || 'Unknown error'}`);
-                process.exit(1);
+                process.exitCode = 1;
             }
-            compositor.dispose();
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
             logger.error(`Pipeline error: ${msg}`);
-            process.exit(1);
+            process.exitCode = 1;
+        }
+        finally {
+            compositor?.dispose();
+            await runtime?.dispose();
         }
     });
     // List available pipeline definitions

package/dist/commands/resources.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createResourcesCommand(): Command;

package/dist/commands/resources.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs/promises';
+import { Command } from 'commander';
+import { ResourceCatalog, resourceSchema, selectionWarning } from '../fleet/resource-catalog.js';
+export function createResourcesCommand() {
+    const command = new Command('resources').description('Explicit resource inventory and bounded read-only health probes (JSON output)');
+    const run = (action) => async () => {
+        try {
+            process.stdout.write(`${JSON.stringify(await action(), null, 2)}\n`);
+        }
+        catch (error) {
+            command.error(error instanceof Error ? error.message : 'RESOURCE_OPERATION_FAILED');
+        }
+    };
+    command.command('schema').description('Show the resource registration fields').action(() => {
+        process.stdout.write(`${JSON.stringify({ kinds: resourceSchema.shape.kind.options,
+            fields: ['id', 'kind', 'hostId', 'declaredCapabilities', 'endpointRef', 'healthPath', 'permissions', 'ttlMs', 'timeoutMs'],
+            endpointRef: 'Environment variable containing HTTP(S) origin; no embedded credentials, path, query or fragment',
+            permissions: { probe: false, use: false }, load: 'unknown (not collected)', usageConfirmed: false }, null, 2)}\n`);
+    });
+    command.command('add <file>').description('Register one explicit JSON resource; never scans the network').action(async (file) => {
+        await run(async () => {
+            const stat = await fs.stat(file);
+            if (!stat.isFile() || stat.size > 16384)
+                throw new Error('RESOURCE_INPUT_TOO_LARGE');
+            let input;
+            try {
+                input = JSON.parse(await fs.readFile(file, 'utf8'));
+            }
+            catch {
+                throw new Error('INVALID_RESOURCE_JSON');
+            }
+            return new ResourceCatalog().add(input);
+        })();
+    });
+    command.command('remove <id>').description('Remove an explicit registration and its observation').action(async (id) => {
+        await run(() => new ResourceCatalog().remove(id))();
+    });
+    command.command('list').description('List declarations and observation freshness; no network I/O').action(run(() => new ResourceCatalog().list()));
+    command.command('status <id>').description('Read one resource state; does not refresh observations').action(async (id) => {
+        await run(async () => {
+            const result = (await new ResourceCatalog().list()).find(e => e.resource.id === id);
+            if (!result)
+                throw new Error('RESOURCE_NOT_FOUND');
+            return result;
+        })();
+    });
+    command.command('probe <id>').description('Run one explicitly permitted, bounded GET health probe').action(async (id) => {
+        await run(() => new ResourceCatalog().probe(id))();
+    });
+    command.command('select <capability>').option('--kind <kind>', 'Required resource kind').description('Select fresh compatible resource; no task dispatch or automatic replay').action(async (capability, options) => {
+        await run(async () => {
+            const parsed = options.kind === undefined ? undefined : resourceSchema.shape.kind.safeParse(options.kind);
+            if (parsed && !parsed.success)
+                throw new Error('INVALID_RESOURCE_KIND');
+            const result = await new ResourceCatalog().select(capability, parsed?.data);
+            if (!result.selected)
+                process.exitCode = 2;
+            const warning = selectionWarning(result.selected);
+            return warning ? { ...result, warning } : result;
+        })();
+    });
+    return command;
+}
+//# sourceMappingURL=resources.js.map