@phuetz/code-buddy 2.0.0 → 2.2.0

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.d.ts

@@ -1,5 +1,18 @@
 import { Command } from 'commander';
 export declare function confirmPrompt(prompt: string): Promise<boolean>;
+/**
+ * How to confirm a stdio MCP add. `--yes` skips the prompt.
+ * Without a TTY and without `--yes`, abort instead of hanging on readline.
+ */
+export declare function stdioAddConfirmMode(yes: boolean, stdinIsTTY?: boolean | undefined): 'skip' | 'prompt' | 'abort';
+/**
+ * `mcp test` / add / add-json only probe the server then persist config.
+ * Tear down the live client so a stdio child cannot keep the CLI event loop open.
+ * Same path as `buddy mcp test` (removeServer → transport.disconnect → reap PID).
+ */
+export declare function releaseMcpProbe(manager: {
+    removeServer(name: string): Promise<void>;
+}, name: string): Promise<void>;
 export interface MCPServeOptions {
     allowWrite?: boolean;
     tools?: string;

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';
@@ -35,6 +37,30 @@ export function confirmPrompt(prompt) {
         });
     });
 }
+/**
+ * How to confirm a stdio MCP add. `--yes` skips the prompt.
+ * Without a TTY and without `--yes`, abort instead of hanging on readline.
+ */
+export function stdioAddConfirmMode(yes, stdinIsTTY = process.stdin.isTTY) {
+    if (yes)
+        return 'skip';
+    if (stdinIsTTY)
+        return 'prompt';
+    return 'abort';
+}
+/**
+ * `mcp test` / add / add-json only probe the server then persist config.
+ * Tear down the live client so a stdio child cannot keep the CLI event loop open.
+ * Same path as `buddy mcp test` (removeServer → transport.disconnect → reap PID).
+ */
+export async function releaseMcpProbe(manager, name) {
+    try {
+        await manager.removeServer(name);
+    }
+    catch {
+        // Probe teardown must not mask the add/test result.
+    }
+}
 /** Start the distribution-facing stdio server. Logs stay on stderr via logger. */
 export async function serveMCP(options = {}) {
     const { CodeBuddyMCPServer } = await import('../mcp/mcp-server.js');
@@ -52,6 +78,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')
@@ -213,9 +240,9 @@ export function createMCPCommand() {
                 }
                 addMCPServer(preset);
                 console.log(chalk.green(`✓ Added predefined MCP server: ${name}`));
-                // Try to connect immediately
+                // Try to connect immediately, then drop the probe (same as `mcp test`).
+                const manager = getMCPManager();
                 try {
-                    const manager = getMCPManager();
                     await manager.addServer(preset);
                     console.log(chalk.green(`✓ Connected to MCP server: ${name}`));
                     const tools = manager.getTools().filter(t => t.serverName === name);
@@ -225,6 +252,9 @@ export function createMCPCommand() {
                     console.log(chalk.yellow(`⚠ Server saved but connection failed: ${getErrorMessage(connectError)}`));
                     console.log(chalk.yellow('  Check your API key and try: buddy mcp test ' + name));
                 }
+                finally {
+                    await releaseMcpProbe(manager, name);
+                }
                 return;
             }
             // Custom server
@@ -282,12 +312,16 @@ export function createMCPCommand() {
             };
             addMCPServer(config);
             console.log(chalk.green(`✓ Added MCP server: ${name}`));
-            // Try to connect immediately
             const manager = getMCPManager();
-            await manager.addServer(config);
-            console.log(chalk.green(`✓ Connected to MCP server: ${name}`));
-            const tools = manager.getTools().filter(t => t.serverName === name);
-            console.log(chalk.blue(`  Available tools: ${tools.length}`));
+            try {
+                await manager.addServer(config);
+                console.log(chalk.green(`✓ Connected to MCP server: ${name}`));
+                const tools = manager.getTools().filter(t => t.serverName === name);
+                console.log(chalk.blue(`  Available tools: ${tools.length}`));
+            }
+            finally {
+                await releaseMcpProbe(manager, name);
+            }
         }
         catch (error) {
             logger.error(chalk.red(`Error adding MCP server: ${getErrorMessage(error)}`));
@@ -298,7 +332,8 @@ export function createMCPCommand() {
     mcpCommand
         .command('add-json <name> <json>')
         .description('Add an MCP server from JSON configuration')
-        .action(async (name, jsonConfig) => {
+        .option('-y, --yes', 'skip confirmation for stdio MCP servers (required when stdin is not a TTY)')
+        .action(async (name, jsonConfig, options) => {
         try {
             let config;
             try {
@@ -333,20 +368,31 @@ export function createMCPCommand() {
                 console.log(chalk.yellow('\nSecurity notice: This MCP server will execute a command on your system.'));
                 console.log(chalk.yellow(`  Command: ${serverConfig.transport.command} ${(serverConfig.transport.args || []).join(' ')}`));
                 console.log(chalk.yellow('  Only add MCP servers from trusted sources.\n'));
-                const confirmed = await confirmPrompt('Do you want to proceed? (y/N): ');
-                if (!confirmed) {
-                    console.log('MCP server addition cancelled.');
-                    return;
+                const mode = stdioAddConfirmMode(options.yes === true);
+                if (mode === 'abort') {
+                    logger.error(chalk.red('Error: stdin is not a TTY. Re-run with --yes to confirm adding this stdio MCP server.'));
+                    process.exit(1);
+                }
+                if (mode === 'prompt') {
+                    const confirmed = await confirmPrompt('Do you want to proceed? (y/N): ');
+                    if (!confirmed) {
+                        console.log('MCP server addition cancelled.');
+                        return;
+                    }
                 }
             }
             addMCPServer(serverConfig);
             console.log(chalk.green(`✓ Added MCP server: ${name}`));
-            // Try to connect immediately
             const manager = getMCPManager();
-            await manager.addServer(serverConfig);
-            console.log(chalk.green(`✓ Connected to MCP server: ${name}`));
-            const tools = manager.getTools().filter(t => t.serverName === name);
-            console.log(chalk.blue(`  Available tools: ${tools.length}`));
+            try {
+                await manager.addServer(serverConfig);
+                console.log(chalk.green(`✓ Connected to MCP server: ${name}`));
+                const tools = manager.getTools().filter(t => t.serverName === name);
+                console.log(chalk.blue(`  Available tools: ${tools.length}`));
+            }
+            finally {
+                await releaseMcpProbe(manager, name);
+            }
         }
         catch (error) {
             logger.error(chalk.red(`Error adding MCP server: ${getErrorMessage(error)}`));
@@ -516,14 +562,13 @@ export function createMCPCommand() {
             process.exit(1);
         }
         finally {
-            // `mcp test` is a probe, not a long-lived session. Always tear down the
-            // transport so stdio children and their database/network handles do not
-            // keep the CLI process alive after a successful discovery.
+            // Probe only: drop the client/stdio child so the CLI can exit.
             if (connected) {
-                await manager.removeServer(name);
+                await releaseMcpProbe(manager, name);
             }
         }
     });
+    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

package/dist/commands/skills-cli/index.js

@@ -134,11 +134,24 @@ export function registerSkillsCommands(program) {
         const all = hub.listWithIntegrity();
         const shown = opts.all ? all : all.filter((s) => s.enabled !== false);
         const health = buildSkillListHealth(all, shown);
-        const usableCount = all.filter((skill) => skill.enabled !== false && skill.integrityOk).length;
+        const { readLocalSkillInventory } = await import('../../skills/local-inventory.js');
+        const inventory = await readLocalSkillInventory(all);
+        const availableSkills = inventory.entries.filter((skill) => skill.available);
+        const usableCount = availableSkills.filter((skill) => skill.source === 'hub').length;
         if (opts.json) {
-            console.log(JSON.stringify({ count: shown.length, health, total: all.length, skills: shown }, null, 2));
+            console.log(JSON.stringify({ availableSkills, availableCount: availableSkills.length,
+                unavailableSkills: inventory.entries.filter((skill) => !skill.available),
+                discoveryErrors: inventory.errors,
+                count: shown.length, health, total: all.length, skills: shown }, null, 2));
             return;
         }
+        console.log(`\nAvailable local skills (${availableSkills.length}):`);
+        for (const skill of availableSkills) {
+            console.log(`  + ${skill.name} (${skill.source})${skill.description ? ` — ${skill.description}` : ''}`);
+        }
+        if (inventory.errors.length > 0) {
+            console.log(`\n${inventory.errors.length} skill file(s) could not be loaded; use --json for details.`);
+        }
         if (shown.length === 0) {
             if (all.length === 0) {
                 const { getBundledSkillsPath } = await import('../../skills/index.js');
@@ -280,26 +293,36 @@ export function registerSkillsCommands(program) {
     });
     skills
         .command('usage')
-        .description('Show local usage telemetry, most-used first')
+        .description('Show local usage telemetry: hub invocations and view/use activity of every skill')
         .option('--json', 'output JSON')
         .action(async (opts) => {
         const { getSkillsHub } = await import('../../skills/hub.js');
+        const { listSkillActivity } = await import('../../skills/skill-usage-store.js');
         const summary = getSkillsHub().usageSummary();
+        const activity = listSkillActivity();
         if (opts.json) {
-            console.log(JSON.stringify({ count: summary.length, skills: summary }, null, 2));
+            console.log(JSON.stringify({ count: summary.length, skills: summary, activityCount: activity.length, activity }, null, 2));
             return;
         }
-        if (summary.length === 0) {
+        if (summary.length === 0 && activity.length === 0) {
             console.log('No skill usage recorded yet.');
             return;
         }
-        console.log('\nSkill usage (most used first):');
-        for (const skill of summary) {
-            const u = skill.usage;
-            const avg = u.averageDurationMs !== undefined ? `, avg ${Math.round(u.averageDurationMs)}ms` : '';
-            console.log(`  ${skill.name}: ${u.invocationCount} run(s), ${u.successCount} ok / ${u.failureCount} fail${avg}`);
-            if (u.lastError)
-                console.log(`      last error: ${u.lastError}`);
+        if (summary.length > 0) {
+            console.log('\nSkill usage (most used first):');
+            for (const skill of summary) {
+                const u = skill.usage;
+                const avg = u.averageDurationMs !== undefined ? `, avg ${Math.round(u.averageDurationMs)}ms` : '';
+                console.log(`  ${skill.name}: ${u.invocationCount} run(s), ${u.successCount} ok / ${u.failureCount} fail${avg}`);
+                if (u.lastError)
+                    console.log(`      last error: ${u.lastError}`);
+            }
+        }
+        if (activity.length > 0) {
+            console.log('\nSkill activity (most recent first):');
+            for (const entry of activity) {
+                console.log(`  ${entry.skill}: ${entry.viewCount} view(s), ${entry.useCount} use(s), last ${entry.lastActivityAt}`);
+            }
         }
         console.log('');
     });

package/dist/commands/slash/builtin-commands.js

@@ -342,9 +342,12 @@ const devCommands = [
     {
         name: 'debug-issue',
         description: 'Help debug a code issue',
-        prompt: `Help debug the described issue:
+        // A bare /debug-issue used to send "the described issue" with nothing
+        // described; the prompt now stands on its own with or without a symptom.
+        prompt: `Debug a problem in this project.
+Reported symptom (empty if the user gave none): $ARGUMENTS
 
-1. Gather information about the problem
+1. Gather information about the problem. Without a reported symptom, start from the working tree: git status --short, git diff for unstaged changes, git diff --cached for staged changes, then run the project's test script if one exists
 2. Analyze relevant code and logs
 3. Identify potential causes
 4. Suggest debugging steps
@@ -352,7 +355,10 @@ const devCommands = [
 
 Be systematic and thorough in your analysis.`,
         filePath: '',
-        isBuiltin: true
+        isBuiltin: true,
+        arguments: [
+            { name: 'symptom', description: 'Error message or behaviour to debug (optional)', required: false }
+        ]
     },
     {
         name: 'refactor',
@@ -1309,6 +1315,13 @@ const agentControlCommands = [
         filePath: '',
         isBuiltin: true
     },
+    {
+        name: 'resources',
+        description: 'List declared resources (RagChat, GPU, storage…) and observation freshness — read-only, no probe',
+        prompt: '__RESOURCES__',
+        filePath: '',
+        isBuiltin: true
+    },
     {
         name: 'new',
         description: 'Start a new conversation, optionally switching to a different model',

package/dist/commands/slash/index.d.ts

@@ -3,5 +3,7 @@
  *
  * Exports types, built-in commands, and utilities for the slash command system.
  */
-export type { SlashCommand, SlashCommandArgument, SlashCommandResult, SlashCommandCategory, CategorizedSlashCommand } from './types.js';
+export type { SlashCommand, SlashCommandArgument, SlashCommandResult, SlashCommandCategory, CategorizedSlashCommand, SlashSurface, SlashAvailability } from './types.js';
 export { builtinCommands, getCommandsByCategory } from './builtin-commands.js';
+export { CHANNEL_SLASH_SURFACES, channelPlatformsFor, COWORK_TOKEN_SURFACES, COWORK_UNAVAILABLE_REASON, coworkHeadlessAllowlist, coworkUiEffectTokens, isEngineToken, resolveSlashAvailability, withAvailability, } from './surfaces.js';
+export type { ChannelSlashSpec, CoworkTokenMode, SlashCommandWithAvailability } from './surfaces.js';

package/dist/commands/slash/index.js

@@ -5,4 +5,6 @@
  */
 // Built-in commands
 export { builtinCommands, getCommandsByCategory } from './builtin-commands.js';
+// Per-surface availability (single declaration for CLI, Cowork and the wiki)
+export { CHANNEL_SLASH_SURFACES, channelPlatformsFor, COWORK_TOKEN_SURFACES, COWORK_UNAVAILABLE_REASON, coworkHeadlessAllowlist, coworkUiEffectTokens, isEngineToken, resolveSlashAvailability, withAvailability, } from './surfaces.js';
 //# sourceMappingURL=index.js.map