@phuetz/code-buddy 2.0.0 → 2.1.0

package/dist/commands/cli/tools-commands.js

@@ -8,7 +8,8 @@ import { buildDispatchToolFilter, getDispatchToolPolicy, normalizeDispatchProfil
 import { getBuiltinToolNames } from '../../codebuddy/tools.js';
 import { buildBrowserOperatorSessionDraft, buildInternetScoutPlan, renderBrowserOperatorSessionDraft, renderInternetScoutPlan, } from '../../browser-automation/index.js';
 import { installResearchScriptSkillCandidate, listMaterializedResearchScriptSkillCandidates, readMaterializedResearchScriptSkillCandidate, } from '../../agent/research-script-skill-candidate.js';
-import { getActiveToolMetadata, resolveToolEffect } from '../../tools/metadata.js';
+import { getActiveToolMetadata } from '../../tools/metadata.js';
+import { resolveToolEffect } from '../../tools/tool-effect.js';
 function formatList(values) {
     return values.length > 0 ? values.join(', ') : 'none';
 }

package/dist/commands/cli/triage-command.d.ts

@@ -0,0 +1,8 @@
+/**
+ * buddy triage — write a local, redacted support bundle (src/doctor/triage.ts).
+ *
+ * Never sends anything and never launches an agent: the command to hand the
+ * prompt to a local agent is printed for the user to review and run.
+ */
+import type { Command } from 'commander';
+export declare function registerTriageCommand(program: Command): void;

package/dist/commands/cli/triage-command.js

@@ -0,0 +1,72 @@
+/**
+ * buddy triage — write a local, redacted support bundle (src/doctor/triage.ts).
+ *
+ * Never sends anything and never launches an agent: the command to hand the
+ * prompt to a local agent is printed for the user to review and run.
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+function buddyVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        for (const candidate of [join(here, '..', '..', '..', 'package.json'), join(here, '..', '..', 'package.json')]) {
+            try {
+                const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
+                if (pkg.version && pkg.name?.includes('buddy'))
+                    return pkg.version;
+            }
+            catch { /* try next */ }
+        }
+    }
+    catch { /* fall through */ }
+    return 'unknown';
+}
+export function registerTriageCommand(program) {
+    program
+        .command('triage')
+        .description('Write a local redacted support bundle and a ≤ 8 KiB prompt (no network, launches nothing)')
+        .option('--json', 'Print a JSON summary on stdout')
+        .option('--out <dir>', 'Parent directory for the bundle (default ~/.codebuddy/triage)')
+        .option('--log-lines <n>', 'Maximum log lines to include', '200')
+        .action(async (options) => {
+        const { writeTriageBundle } = await import('../../doctor/triage.js');
+        const directory = program.opts().directory;
+        const cwd = resolve(process.cwd(), directory || process.cwd());
+        const logLines = Math.max(0, Math.min(2000, Number.parseInt(options.logLines ?? '200', 10) || 0));
+        try {
+            const result = await writeTriageBundle({
+                cwd,
+                ...(options.out ? { outParent: resolve(process.cwd(), options.out) } : {}),
+                logLines,
+                buddyVersion: buddyVersion(),
+            });
+            if (options.json) {
+                console.log(JSON.stringify({
+                    dir: result.dir,
+                    files: { json: result.jsonPath, prompt: result.promptPath },
+                    promptBytes: result.promptBytes,
+                    redactions: result.redactions,
+                    withheld: result.withheld,
+                    networkUsed: false,
+                    agentLaunched: false,
+                    suggestedCommand: result.suggestedCommand,
+                }, null, 2));
+                return;
+            }
+            console.log('\nCode Buddy triage (local only — nothing was sent, no agent was started)\n');
+            console.log(`  Bundle     : ${result.dir}`);
+            console.log(`  Prompt     : ${result.promptPath} (${result.promptBytes} bytes)`);
+            console.log(`  Redactions : ${result.redactions}`);
+            if (result.withheld.length > 0)
+                console.log(`  Withheld   : ${result.withheld.join(', ')} (secret scan still matched)`);
+            console.log('\nReview prompt.md, then hand it to a local agent yourself:');
+            console.log(`  ${result.suggestedCommand}\n`);
+        }
+        catch (error) {
+            console.error(`triage failed: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 1;
+        }
+    });
+}
+//# sourceMappingURL=triage-command.js.map

package/dist/commands/cli/utility-commands.js

@@ -19,9 +19,31 @@ export function registerUtilityCommands(program) {
         .description('Diagnose Code Buddy environment, dependencies, and configuration')
         .option('-v, --verbose', 'Show all checks including passing ones')
         .option('--fix', 'Auto-fix issues that can be resolved automatically')
+        .option('--json', 'Print a stable JSON report (includes the Integrations section)')
+        .option('--offline', 'Skip every network call (live key checks, OAuth refresh, local runtime probes)')
+        .option('--integrations', 'Also check LM Resizer, Code Explorer, MCP config, resource catalog and skills (no network)')
         .action(async (options) => {
         const { runDoctorChecks, runFixes, summarizeDoctorChecks } = await import('../../doctor/index.js');
-        const checks = await runDoctorChecks(resolveCommandDirectory(program));
+        const cwd = resolveCommandDirectory(program);
+        const offline = options.offline === true;
+        const coreChecks = await runDoctorChecks(cwd, { offline });
+        const withIntegrations = options.json === true || options.integrations === true;
+        const integrationChecks = withIntegrations
+            ? await (await import('../../doctor/integrations.js')).runIntegrationChecks(cwd)
+            : [];
+        const checks = [...coreChecks, ...integrationChecks];
+        if (options.json) {
+            const { buildDoctorJsonReport } = await import('../../doctor/integrations.js');
+            const fixes = options.fix ? await runFixes(checks.filter((c) => c.fixable)) : undefined;
+            const summary = summarizeDoctorChecks(checks);
+            const report = buildDoctorJsonReport(checks, summary, { offline, ...(fixes ? { fixes } : {}) });
+            console.log(JSON.stringify(report, null, 2));
+            const readinessJson = checks.find((c) => c.name === 'AI provider ready');
+            if (summary.errors > 0 || (readinessJson && readinessJson.status !== 'ok') || fixes?.some((f) => !f.success)) {
+                process.exitCode = 1;
+            }
+            return;
+        }
         console.log('\n🔍 Code Buddy Doctor\n');
         const icons = { ok: '✅', warn: '⚠️', error: '❌' };
         // Headline verdict: the first question a newcomer has is "can I chat yet?"
@@ -39,6 +61,8 @@ export function registerUtilityCommands(program) {
         for (const check of checks) {
             if (check.name === 'AI provider ready')
                 continue; // already shown as the headline
+            if (integrationChecks.length > 0 && check === integrationChecks[0])
+                console.log('\n  Integrations (no network):');
             if (options.verbose || check.status !== 'ok') {
                 const fixTag = check.fixable ? ' [fixable]' : '';
                 console.log(`  ${icons[check.status]} ${check.name}: ${check.message}${fixTag}`);

package/dist/commands/client-dispatcher.d.ts

@@ -37,6 +37,13 @@ export declare class ClientCommandDispatcher {
      * result handling (add entry to chat, pass prompt to AI, clear input).
      */
     private static delegateToEnhanced;
+    /** Session-only /switch overrides, keyed by the live agent. */
+    private static readonly switchState;
+    /**
+     * Back /switch with the running agent so it changes the model used by the
+     * next turns (session only, unlike /model which also saves the preference).
+     */
+    private static createSwitchModelProvider;
     private static handleEnhancedCommand;
     private static handleModelSwitch;
     private static handleShellBypass;

package/dist/commands/client-dispatcher.js

@@ -3,7 +3,9 @@ import { getEnhancedCommandHandler } from "./enhanced-command-handler.js";
 import { GitWorkflowHandler } from "./workflow/git-workflow.js";
 import { getErrorMessage } from "../types/index.js";
 import { ConfirmationService } from "../utils/confirmation-service.js";
+import { isModelCompatibleWithProvider } from "../providers/model-provider-compat.js";
 import { updateCurrentModel } from "../utils/model-config.js";
+import { setSwitchModelProvider } from "./handlers/switch-handler.js";
 export class ClientCommandDispatcher {
     /**
      * Dispatches a command input to the appropriate handler.
@@ -48,6 +50,8 @@ export class ClientCommandDispatcher {
         context.clearInput();
     }
     static async handleSlashCommand(input, context) {
+        // Keep the historical plural spelling on the same live-agent path.
+        input = input.replace(/^\/models(?=\s|$)/, '/model');
         const slashManager = getSlashCommandManager();
         const result = slashManager.execute(input);
         if (result.success && result.prompt) {
@@ -108,18 +112,22 @@ export class ClientCommandDispatcher {
             const args = originalInput.trim().split(/\s+/).slice(1);
             if (args.length === 0) {
                 context.setShowModelSelection(true);
-                context.setSelectedModelIndex(0);
+                context.setSelectedModelIndex(Math.max(0, context.availableModels.findIndex(option => option.model === context.agent.getCurrentModel())));
                 context.clearInput();
                 return true;
             }
-            // With args, delegate to enhanced handler for model switching
-            return await this.delegateToEnhanced(token, originalInput, context);
+            if (args[0] === 'auto' || args[0] === 'list') {
+                return await this.delegateToEnhanced(token, originalInput, context);
+            }
+            await this.handleModelSwitch(originalInput, context);
+            return true;
         }
         // __CLEAR_CHAT__ needs UI state resets beyond what the handler provides
         if (token === "__CLEAR_CHAT__") {
             const handled = await this.delegateToEnhanced(token, originalInput, context);
             if (handled) {
                 // Apply UI-specific side effects
+                context.agent.clearChat();
                 context.setChatHistory([]);
                 context.setIsProcessing(false);
                 context.setIsStreaming(false);
@@ -149,11 +157,13 @@ export class ClientCommandDispatcher {
             getContextStats: () => context.agent.getContextStats(),
             formatContextStats: () => context.agent.formatContextStats(),
             getCurrentModel: () => context.agent.getCurrentModel(),
+            getMemoryScope: () => context.agent.getMemoryScope(),
             getCurrentSessionId: () => context.agent.getCurrentSessionId?.() ?? null,
             getContextMemoryMetrics: () => context.agent.getContextMemoryMetrics(),
             getCompressionStats: () => context.agent.getCompressionStats(),
             getContextBudgetBreakdown: () => context.agent.getContextBudgetBreakdown(),
         });
+        setSwitchModelProvider(this.createSwitchModelProvider(context));
         const args = overrideArgs ?? originalInput.trim().split(" ").slice(1);
         const handlerResult = await enhancedHandler.handleCommand(token, args, originalInput);
         if (handlerResult.handled) {
@@ -173,30 +183,72 @@ export class ClientCommandDispatcher {
         this.finishCommandWithMessage(context, `Command ${commandName} is registered but has no conversation-loop handler yet. Use /help to see working commands.`);
         return true;
     }
+    /** Session-only /switch overrides, keyed by the live agent. */
+    static switchState = new WeakMap();
+    /**
+     * Back /switch with the running agent so it changes the model used by the
+     * next turns (session only, unlike /model which also saves the preference).
+     */
+    static createSwitchModelProvider(context) {
+        const agent = context.agent;
+        const state = () => {
+            let current = this.switchState.get(agent);
+            if (!current) {
+                current = { baseModel: agent.getCurrentModel(), switched: null };
+                this.switchState.set(agent, current);
+            }
+            return current;
+        };
+        return {
+            getAvailableModels: () => context.availableModels.map(option => option.model),
+            getCurrentModel: () => agent.getCurrentModel(),
+            getSwitchedModel: () => this.switchState.get(agent)?.switched ?? null,
+            setSwitchedModel: (model) => {
+                const current = state();
+                if (model === null) {
+                    if (current.switched !== null)
+                        agent.setModel(current.baseModel);
+                    this.switchState.delete(agent);
+                    return;
+                }
+                const provider = agent.getClient().getCurrentProvider?.();
+                if (!isModelCompatibleWithProvider(model, provider)) {
+                    throw new Error(`Model ${model} is incompatible with the active provider ${provider}. Choose a model for this connection.`);
+                }
+                agent.setModel(model);
+                current.switched = model;
+            },
+        };
+    }
     static async handleEnhancedCommand(token, originalInput, context) {
         return await this.delegateToEnhanced(token, originalInput, context);
     }
     static async handleModelSwitch(input, context) {
-        const modelArg = input.trim().split(" ")[1];
-        const modelNames = context.availableModels.map((m) => m.model);
-        if (modelArg !== undefined && modelNames.includes(modelArg)) {
-            context.agent.setModel(modelArg);
-            updateCurrentModel(modelArg);
-            const confirmEntry = {
-                type: "assistant",
-                content: `✓ Switched to model: ${modelArg}`,
-                timestamp: new Date(),
-            };
-            context.setChatHistory((prev) => [...prev, confirmEntry]);
+        const args = input.trim().split(/\s+/).slice(1);
+        const model = args[0];
+        if (!model || args.length !== 1) {
+            this.finishCommandWithMessage(context, 'Usage: /model <model-name>');
+            return;
         }
-        else {
-            const errorEntry = {
-                type: "assistant",
-                content: `Invalid model: ${modelArg}\n\nAvailable models: ${modelNames.join(", ")}`,
-                timestamp: new Date(),
-            };
-            context.setChatHistory((prev) => [...prev, errorEntry]);
+        const provider = context.agent.getClient().getCurrentProvider?.();
+        if (!isModelCompatibleWithProvider(model, provider)) {
+            this.finishCommandWithMessage(context, `Model ${model} is incompatible with the active provider ${provider}. Choose a model for this connection.`);
+            return;
+        }
+        // Change the running client and its context/token limits before announcing success.
+        context.agent.setModel(model);
+        // An explicit /model choice becomes the new base for later /switch auto.
+        this.switchState.delete(context.agent);
+        try {
+            updateCurrentModel(model);
+        }
+        catch (error) {
+            this.finishCommandWithMessage(context, `Model active for this session: ${model}. Could not save the preference: ${getErrorMessage(error)}`);
+            return;
         }
+        context.setChatHistory(prev => [...prev, {
+                type: 'assistant', content: `Switched to model: ${model}`, timestamp: new Date(),
+            }]);
         context.clearInput();
     }
     static async handleShellBypass(command, context) {

package/dist/commands/cron-cli/index.d.ts

@@ -38,6 +38,7 @@ export interface CronAddOptions {
     /** Job-level chain target: id (or id prefix) to run on successful completion. */
     then?: string;
     preCheck?: string;
+    continuity?: string;
     deliver?: string[];
     format?: string;
 }
@@ -56,9 +57,10 @@ export interface CronJobSpec {
     task: CronJob['task'];
     delivery?: CronJob['delivery'];
     preCheck?: CronJob['preCheck'];
+    continuity?: CronJob['continuity'];
     then?: string;
 }
-export type CronJobUpdates = Partial<Pick<CronJob, 'name' | 'type' | 'schedule' | 'task' | 'delivery' | 'preCheck' | 'then'>>;
+export type CronJobUpdates = Partial<Pick<CronJob, 'name' | 'type' | 'schedule' | 'task' | 'delivery' | 'preCheck' | 'then' | 'continuity'>>;
 export type CronJobSpecResult = {
     spec: CronJobSpec;
 } | {

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

@@ -22,6 +22,7 @@
  * Commander actions stay thin wrappers around the scheduler singleton.
  */
 import * as fs from 'fs';
+import { validateContinuity } from '../../scheduler/job-notepad.js';
 /**
  * Build (and validate) a CronJob spec from CLI options. Pure: no side effects,
  * fully unit-testable. Returns either a spec or a human-readable error.
@@ -77,6 +78,17 @@ export function buildCronJobSpec(name, opts) {
         }
         spec.then = opts.then.trim();
     }
+    if (opts.continuity !== undefined) {
+        const parsed = parseJsonOption(opts.continuity, '--continuity');
+        if ('error' in parsed)
+            return parsed;
+        try {
+            spec.continuity = validateContinuity(parsed.value);
+        }
+        catch (error) {
+            return { error: `Invalid --continuity: ${String(error)}` };
+        }
+    }
     // Optional pre-check gate.
     if (opts.preCheck !== undefined) {
         const parsed = parseJsonOption(opts.preCheck, '--pre-check');
@@ -159,6 +171,17 @@ export function buildCronJobUpdates(job, opts) {
         }
         updates.then = opts.then.trim();
     }
+    if (opts.continuity !== undefined) {
+        const parsed = parseJsonOption(opts.continuity, '--continuity');
+        if ('error' in parsed)
+            return parsed;
+        try {
+            updates.continuity = validateContinuity(parsed.value);
+        }
+        catch (error) {
+            return { error: `Invalid --continuity: ${String(error)}` };
+        }
+    }
     if (opts.preCheck !== undefined && opts.clearPreCheck) {
         return { error: 'cron update: --pre-check and --clear-pre-check are mutually exclusive' };
     }
@@ -394,6 +417,7 @@ export function registerCronCommands(program) {
         .option('--skill-request <text>', 'request string passed to the skill executor')
         .option('--then <jobId>', 'chain: run this job id (or prefix) on successful completion')
         .option('--clear-then', 'remove the chain target')
+        .option('--continuity <json>', 'per-job continuity: true, false, or {enabled, notes}; inline JSON or @file')
         .option('--pre-check <json>', 'replace pre-check gate as inline JSON or @file')
         .option('--clear-pre-check', 'remove the pre-check gate')
         .option('--deliver <target>', 'replace delivery targets type:id (repeatable)', collectOption, [])
@@ -433,6 +457,7 @@ export function registerCronCommands(program) {
         .option('--skill <id>', 'no-agent skill run by registered skill name')
         .option('--skill-request <text>', 'request string passed to the skill executor')
         .option('--then <jobId>', 'chain: run this job id (or prefix) on successful completion')
+        .option('--continuity <json>', 'per-job continuity: true, false, or {enabled, notes}; inline JSON or @file')
         .option('--pre-check <json>', 'pre-check gate as inline JSON or @file')
         .option('--deliver <target>', 'delivery target type:id (repeatable)', collectOption, [])
         .option('--format <fmt>', 'delivery body format: full|summary')

package/dist/commands/device-auth.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+import { DeviceAuthStore } from '../server/auth/device-store.js';
+import { type SpawnSyncFn } from './token.js';
+export interface DeviceCommandDependencies {
+    store?: DeviceAuthStore;
+    env?: NodeJS.ProcessEnv;
+    spawn?: SpawnSyncFn;
+}
+export declare function createPairCommand(deps?: DeviceCommandDependencies): Command;
+export declare function createDevicesCommand(deps?: DeviceCommandDependencies): Command;

package/dist/commands/device-auth.js

@@ -0,0 +1,91 @@
+import { Command } from 'commander';
+import { getDeviceAuthStore } from '../server/auth/device-store.js';
+import { renderQrAnsi } from './token.js';
+function pairingUrl(raw) {
+    try {
+        const url = new URL(raw);
+        if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+            throw new Error();
+        return url.toString().replace(/\/+$/, '');
+    }
+    catch {
+        throw new Error('Use a valid HTTP(S) server URL without credentials, query or fragment');
+    }
+}
+export function createPairCommand(deps = {}) {
+    return new Command('pair')
+        .description('Pair an Android authenticator with this server (local one-time code, 10 minutes)')
+        .option('--url <url>', 'Server URL reachable from the phone')
+        .option('--json', 'Print the QR payload as JSON')
+        .action((options) => {
+        try {
+            const env = deps.env ?? process.env;
+            const url = pairingUrl(options.url || env.CODEBUDDY_SERVER_URL || `http://127.0.0.1:${env.CODEBUDDY_SERVER_PORT || env.PORT || '3000'}`);
+            const { pairingCode, expiresAt } = (deps.store ?? getDeviceAuthStore()).createPairing();
+            const payload = JSON.stringify({ url, pairingCode });
+            if (options.json) {
+                console.log(payload);
+                return;
+            }
+            console.log(`Pairing code: ${pairingCode}`);
+            console.log(`Expires: ${expiresAt} (10 minutes, one use)`);
+            console.log(payload);
+            const qr = renderQrAnsi(payload, deps.spawn);
+            if (qr.ok)
+                console.log(qr.output);
+            else
+                console.error(qr.hint);
+        }
+        catch (error) {
+            console.error(error instanceof Error && error.message.startsWith('Use a valid')
+                ? error.message : 'Device pairing unavailable');
+            process.exitCode = 1;
+        }
+    });
+}
+export function createDevicesCommand(deps = {}) {
+    const command = new Command('devices').description('Manage Android authentication devices (local only)');
+    const getStore = () => deps.store ?? getDeviceAuthStore();
+    command.command('list').option('--json', 'Print public device metadata as JSON')
+        .action((options) => {
+        try {
+            const devices = getStore().list().map(({ publicKeyJwk: _key, ...metadata }) => metadata);
+            if (options.json)
+                console.log(JSON.stringify(devices, null, 2));
+            else if (devices.length === 0)
+                console.log('No Android devices paired. Run buddy pair.');
+            else
+                for (const device of devices) {
+                    console.log(`${device.deviceId}  ${device.deviceName}  ${device.revokedAt ? 'revoked' : 'active'}  ${device.createdAt}`);
+                }
+        }
+        catch {
+            console.error('Device store unavailable');
+            process.exitCode = 1;
+        }
+    });
+    command.command('revoke <id>').description('Revoke an Android authentication device')
+        .action((id) => {
+        try {
+            getStore().revoke(id);
+            console.log('Device revoked');
+        }
+        catch {
+            console.error('Unable to revoke device');
+            process.exitCode = 1;
+        }
+    });
+    command.command('rename <id> <name>').description('Rename an Android device')
+        .action((id, name) => {
+        try {
+            getStore().rename(id, name);
+            console.log('Device renamed');
+        }
+        catch {
+            console.error('Unable to rename device');
+            process.exitCode = 1;
+        }
+    });
+    return command;
+}
+//# sourceMappingURL=device-auth.js.map

package/dist/commands/enhanced-command-handler.d.ts

@@ -2,10 +2,19 @@ import { ChatEntry } from "../agent/codebuddy-agent.js";
 import { CodeBuddyClient } from "../codebuddy/client.js";
 import type { CommandHandlerResult } from "./handlers/index.js";
 export type { CommandHandlerResult };
+/**
+ * Give every handled result a visible `entry` when the handler only produced
+ * legacy text fields. Results that already carry an entry are left untouched.
+ */
+export declare function normalizeHandlerResult(result: CommandHandlerResult): CommandHandlerResult;
 /**
  * Proxy interface for agent context stats used by the /context stats command.
  */
 export interface AgentContextProxy {
+    getMemoryScope?: () => {
+        cwd: string;
+        botId?: string;
+    };
     getContextStats: () => unknown;
     formatContextStats: () => string;
     getCurrentModel: () => string;

package/dist/commands/enhanced-command-handler.js

@@ -1,5 +1,6 @@
 import { handleGrillMe } from './handlers/grill-me-handler.js';
 import { handleDeepthink } from './handlers/deepthink-handler.js';
+import { withFactsMemorySessionClient } from "../memory/facts-memory.js";
 // Import all handlers from modular files
 import { 
 // Branch handlers
@@ -116,6 +117,7 @@ handleInfra,
 handleRedo, handleTimeline, handleKnowledgeGraph, handleApprovals, } from "./handlers/index.js";
 import { handleLessonsCommand } from "./handlers/index.js";
 import { handleContextStats } from "./handlers/extra-handlers.js";
+import { handleResources } from "./handlers/resources-handler.js";
 import { handleLogin, handleLogout, handleWhoami } from "./handlers/auth-handlers.js";
 import { handlePromptCommand as handlePromptCommandRaw } from "./slash/prompt-commands.js";
 import { handleShortcuts, handleDebugMode, handleToolAnalytics, handleSecurityReview, handleIdentity, handlePairing, handleElevated, handlePolicy, } from "./handlers/index.js";
@@ -183,6 +185,25 @@ async function handlePromptCommand(args) {
         entry: { type: 'assistant', content: output, timestamp: new Date() },
     };
 }
+/**
+ * Give every handled result a visible `entry` when the handler only produced
+ * legacy text fields. Results that already carry an entry are left untouched.
+ */
+export function normalizeHandlerResult(result) {
+    if (!result.handled || result.entry) {
+        return result;
+    }
+    const legacy = result;
+    const text = [legacy.output, legacy.response, legacy.message, legacy.error]
+        .find((value) => typeof value === 'string' && value.trim().length > 0);
+    if (!text) {
+        return result;
+    }
+    return {
+        ...result,
+        entry: { type: 'assistant', content: text, timestamp: new Date() },
+    };
+}
 /**
  * Enhanced Command Handler.
  *
@@ -225,8 +246,8 @@ export class EnhancedCommandHandler {
         ['__MERGE__', (args) => handleMerge(args)],
         ['__BRANCH__', (args) => handleBranch(args)],
         // Memory & TODOs
-        ['__MEMORY__', (args) => handleMemory(args)],
-        ['__REMEMBER__', (args) => handleRemember(args)],
+        ['__MEMORY__', (args) => this.agentProxy?.getMemoryScope ? handleMemory(args, this.agentProxy.getMemoryScope()) : handleMemory(args)],
+        ['__REMEMBER__', (args) => this.agentProxy?.getMemoryScope ? handleRemember(args, this.agentProxy.getMemoryScope()) : handleRemember(args)],
         ['__SCAN_TODOS__', () => handleScanTodos()],
         ['__ADDRESS_TODO__', (args) => handleAddressTodo(args)],
         // Context & Workspace
@@ -237,7 +258,7 @@ export class EnhancedCommandHandler {
                 : handleContext(args)],
         // Export (context-dependent: conversationHistory)
         ['__SAVE_CONVERSATION__', (args) => handleSaveConversation(args, this.conversationHistory)],
-        ['__EXPORT__', (args) => handleExport(args)],
+        ['__EXPORT__', (args) => handleExport(args, this.conversationHistory, this.agentProxy?.getCurrentModel())],
         ['__EXPORT_LIST__', () => handleExportList()],
         ['__EXPORT_FORMATS__', () => handleExportFormats()],
         // Testing (context-dependent: codebuddyClient)
@@ -306,10 +327,11 @@ export class EnhancedCommandHandler {
         ['__BATCH__', (args) => handleBatchSlashCommand(args, this.createBatchChatFn(), this.createBatchSpawnFn())],
         // Commands previously handled inline in client-dispatcher
         ['__CLEAR_CHAT__', () => handleClearChat()],
-        ['__CHANGE_MODEL__', (args) => handleChangeModel(args)],
+        ['__CHANGE_MODEL__', (args) => handleChangeModel(args, this.agentProxy?.getCurrentModel())],
         ['__CHANGE_MODE__', (args) => handleChangeMode(args)],
         ['__PLAN_MODE__', () => handleChangeMode(['plan'])],
-        ['__STATUS__', () => handleStatus()],
+        ['__STATUS__', () => handleStatus(this.agentProxy?.getCurrentModel())],
+        ['__RESOURCES__', () => handleResources()],
         ['__NEW__', (args) => handleNew(args)],
         ['__ULTRAPLAN__', (args) => handleUltraplan(args)],
         ['__LIST_CHECKPOINTS__', (args) => handleListCheckpoints(args)],
@@ -541,7 +563,7 @@ export class EnhancedCommandHandler {
     async handleCommand(token, args, _fullInput) {
         const handler = this.handlerMap.get(token);
         if (handler) {
-            return handler(args);
+            return withFactsMemorySessionClient(this.codebuddyClient ?? null, async () => normalizeHandlerResult(await handler(args)));
         }
         return { handled: false };
     }

package/dist/commands/handlers/agent-handlers.d.ts

@@ -2,7 +2,7 @@
  * Agent command handlers
  *
  * Handles /agent commands for custom agent management:
- * - /agent - List all agents
+ * - /agent, /agent list - List all agents
  * - /agent <id> - Activate an agent
  * - /agent create <name> - Create a new agent
  * - /agent info <id> - Show agent details

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

@@ -2,7 +2,7 @@
  * Agent command handlers
  *
  * Handles /agent commands for custom agent management:
- * - /agent - List all agents
+ * - /agent, /agent list - List all agents
  * - /agent <id> - Activate an agent
  * - /agent create <name> - Create a new agent
  * - /agent info <id> - Show agent details
@@ -14,14 +14,14 @@ import { setActiveCustomAgentRuntime } from '../../agent/custom/custom-agent-run
  */
 export function handleAgent(args) {
     const loader = getCustomAgentLoader();
-    // No args - list agents
-    if (args.length === 0) {
+    const subcommand = args[0]?.toLowerCase() ?? '';
+    // No args or the documented `list` action - list agents
+    if (args.length === 0 || (subcommand === 'list' && args.length === 1)) {
         return {
             handled: true,
             output: loader.formatAgentList(),
         };
     }
-    const subcommand = args[0]?.toLowerCase() ?? '';
     // Create new agent
     if (subcommand === 'create') {
         return handleAgentCreate(args.slice(1));