@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/commands/cli/fleet-rooms-commands.js

@@ -0,0 +1,289 @@
+/**
+ * `buddy fleet rooms` — persistent signed messages between fleet members.
+ *
+ * Messages are data: `read` and `tail` print sanitized text and never run
+ * anything. Credentials come from the environment by default
+ * (`CODEBUDDY_FLEET_ROOMS_URL`, `CODEBUDDY_FLEET_API_KEY` / `CODEBUDDY_FLEET_TOKEN`);
+ * the member secret stays in its 0600 identity file and is never printed.
+ */
+const collect = (value, previous) => [...previous, value];
+function addConnectionOptions(command) {
+    return command
+        .option('--url <url>', 'hub WebSocket URL (default $CODEBUDDY_FLEET_ROOMS_URL)')
+        .option('--api-key <key>', 'hub API key with fleet:listen (prefer $CODEBUDDY_FLEET_API_KEY)')
+        .option('--jwt <token>', 'hub JWT with fleet:listen (prefer $CODEBUDDY_FLEET_TOKEN)')
+        .option('--audience <url>', 'hub URL to sign for when reached through a proxy')
+        .option('--identity <file>', 'member identity file (default $CODEBUDDY_FLEET_ROOMS_IDENTITY)')
+        .option('--json', 'machine-readable output');
+}
+function fail(error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+}
+async function connect(options) {
+    const url = options.url ?? process.env.CODEBUDDY_FLEET_ROOMS_URL;
+    if (!url)
+        throw new Error('hub URL required: --url or CODEBUDDY_FLEET_ROOMS_URL');
+    const apiKey = options.apiKey ?? process.env.CODEBUDDY_FLEET_API_KEY;
+    const jwt = options.jwt ?? process.env.CODEBUDDY_FLEET_TOKEN;
+    const [{ FleetRoomClient }, { loadRoomIdentity }] = await Promise.all([
+        import('../../fleet/rooms/room-client.js'),
+        import('../../fleet/rooms/room-identity.js'),
+    ]);
+    const identity = loadRoomIdentity(options.identity);
+    const client = new FleetRoomClient({
+        url,
+        secretKey: identity.secretKey,
+        ...(apiKey ? { apiKey } : jwt ? { jwt } : {}),
+        ...(options.audience ? { audience: options.audience } : {}),
+    });
+    try {
+        const session = await client.connect();
+        return { client, session };
+    }
+    catch (error) {
+        await client.close();
+        throw error;
+    }
+}
+function toJson(message) {
+    return {
+        seq: message.seq,
+        id: message.event.id,
+        room: message.room,
+        author: message.author,
+        createdAt: message.event.created_at,
+        mentions: message.mentions,
+        ...(message.thread ? { thread: message.thread } : {}),
+        text: message.text,
+    };
+}
+function printMessage(message) {
+    const when = new Date(message.event.created_at * 1000).toISOString();
+    const reply = message.thread ? ` ↳${message.thread.parent.slice(0, 8)}` : '';
+    console.log(`#${message.seq} ${when} ${message.author.slice(0, 12)}${reply} [${message.event.id.slice(0, 8)}]\n  ${message.text.replace(/\n/g, '\n  ')}`);
+}
+async function readCursor(file, room) {
+    const fs = await import('node:fs/promises');
+    let raw;
+    try {
+        raw = await fs.readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1 || parsed.room !== room || typeof parsed.storeId !== 'string' ||
+        !Number.isSafeInteger(parsed.throughSeq) || parsed.throughSeq < 0) {
+        throw new Error(`cursor file ${file} does not belong to room ${room}`);
+    }
+    return { storeId: parsed.storeId, throughSeq: parsed.throughSeq };
+}
+async function writeCursor(file, room, cursor) {
+    const { writeJsonAtomic } = await import('../../utils/atomic-write.js');
+    await writeJsonAtomic(file, { version: 1, room, storeId: cursor.storeId, throughSeq: cursor.throughSeq });
+}
+function filterFor(room, options, pubkey) {
+    const filter = { '#h': [room], kinds: [9] };
+    if (options.mentionsMe)
+        filter['#p'] = [pubkey];
+    if (options.limit !== undefined) {
+        const limit = Number(options.limit);
+        if (!Number.isSafeInteger(limit) || limit < 0 || limit > 500)
+            throw new Error('--limit must be an integer between 0 and 500');
+        filter.limit = limit;
+    }
+    return filter;
+}
+export function registerFleetRoomsCommands(fleet) {
+    const rooms = fleet
+        .command('rooms')
+        .description('Persistent signed messages between fleet members (read as data, never executed)');
+    const identity = rooms.command('identity').description('Member key used to sign room messages');
+    identity.command('init')
+        .description('Create this member key (0600 file); prints only the public key')
+        .option('--identity <file>', 'identity file (default $CODEBUDDY_FLEET_ROOMS_IDENTITY)')
+        .option('--force', 'rotate: keep the old file aside and create a new key')
+        .option('--json', 'machine-readable output')
+        .action(async (options) => {
+        try {
+            const { createRoomIdentity } = await import('../../fleet/rooms/room-identity.js');
+            const created = createRoomIdentity(options.identity, { force: options.force === true });
+            console.log(options.json
+                ? JSON.stringify({ publicKey: created.publicKey, path: created.path })
+                : `Room key created: ${created.publicKey}\nAsk the hub operator to add it to rooms.json.`);
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    identity.command('show')
+        .description('Print this member public key')
+        .option('--identity <file>', 'identity file (default $CODEBUDDY_FLEET_ROOMS_IDENTITY)')
+        .option('--json', 'machine-readable output')
+        .action(async (options) => {
+        try {
+            const { loadRoomIdentity } = await import('../../fleet/rooms/room-identity.js');
+            const loaded = loadRoomIdentity(options.identity);
+            console.log(options.json ? JSON.stringify({ publicKey: loaded.publicKey, path: loaded.path }) : loaded.publicKey);
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    addConnectionOptions(rooms.command('post <room> <text...>'))
+        .description('Sign and publish a message; returns once the hub stored it durably')
+        .option('--mention <pubkey>', 'notify a member (repeatable)', collect, [])
+        .option('--reply-to <id>', 'answer this message')
+        .option('--reply-root <id>', 'thread root when answering a nested reply')
+        .action(async (room, words, options) => {
+        let client;
+        try {
+            const connected = await connect(options);
+            client = connected.client;
+            const replyTo = options.replyTo
+                ? { root: options.replyRoot ?? options.replyTo, parent: options.replyTo }
+                : undefined;
+            const ack = await connected.client.publish({
+                room,
+                content: words.join(' '),
+                mentions: options.mention,
+                ...(replyTo ? { replyTo } : {}),
+            });
+            console.log(options.json ? JSON.stringify(ack) : `${ack.duplicate ? 'Already stored' : 'Stored'} #${ack.seq} ${ack.id}`);
+        }
+        catch (error) {
+            fail(error);
+        }
+        finally {
+            await client?.close();
+        }
+    });
+    addConnectionOptions(rooms.command('read <room>'))
+        .description('Print stored messages; with --cursor, only those after the saved cursor')
+        .option('--limit <n>', 'newest messages to show without a cursor (0..500, default 100)')
+        .option('--mentions-me', 'only messages mentioning this member')
+        .option('--cursor <file>', 'resume after, then update, the cursor saved in this file')
+        .action(async (room, options) => {
+        let client;
+        try {
+            const connected = await connect(options);
+            client = connected.client;
+            const previous = options.cursor ? await readCursor(options.cursor, room) : undefined;
+            const result = await connected.client.fetch([filterFor(room, options, connected.client.pubkey)], previous);
+            if (options.cursor)
+                await writeCursor(options.cursor, room, result.cursor);
+            if (options.json) {
+                console.log(JSON.stringify({
+                    messages: result.messages.map(toJson),
+                    cursor: result.cursor,
+                    gap: result.gap,
+                    epochChanged: result.epochChanged,
+                    truncated: result.truncated,
+                }));
+            }
+            else {
+                if (result.gap)
+                    console.log('! some messages after your cursor were evicted by retention');
+                if (result.epochChanged)
+                    console.log('! the hub ledger changed generation; showing current history');
+                if (result.truncated)
+                    console.log('! more messages remain; read again with --cursor to continue');
+                for (const message of result.messages)
+                    printMessage(message);
+                if (result.messages.length === 0)
+                    console.log('(no messages)');
+            }
+        }
+        catch (error) {
+            fail(error);
+        }
+        finally {
+            await client?.close();
+        }
+    });
+    addConnectionOptions(rooms.command('tail <room>'))
+        .description('Follow a room live (reconnects and catches up automatically) until Ctrl+C')
+        .option('--mentions-me', 'only messages mentioning this member')
+        .option('--cursor <file>', 'resume after, and keep updating, the cursor saved in this file')
+        .action(async (room, options) => {
+        let client;
+        let finish = () => { };
+        const done = new Promise(resolve => { finish = resolve; });
+        let pendingWrite;
+        let latestCursor;
+        let caughtUp = false;
+        const persist = (cursor) => {
+            if (!options.cursor)
+                return;
+            latestCursor = cursor;
+            if (pendingWrite)
+                return;
+            const file = options.cursor;
+            pendingWrite = (async () => {
+                while (latestCursor) {
+                    const next = latestCursor;
+                    latestCursor = undefined;
+                    await writeCursor(file, room, next);
+                }
+            })().catch(error => { fail(error); finish(); }).finally(() => {
+                pendingWrite = undefined;
+                if (latestCursor)
+                    persist(latestCursor);
+            });
+        };
+        const disconnected = () => { caughtUp = false; };
+        const exhausted = () => { fail(new Error('Room reconnection attempts exhausted')); finish(); };
+        const reconnectError = (error) => {
+            if (error.code === 'ROOM_AUTH_REFUSED') {
+                fail(error);
+                finish();
+            }
+        };
+        try {
+            client = (await connect(options)).client;
+            const previous = options.cursor ? await readCursor(options.cursor, room) : undefined;
+            process.once('SIGINT', finish);
+            process.once('SIGTERM', finish);
+            client.on('disconnected', disconnected);
+            client.on('reconnect-exhausted', exhausted);
+            client.on('reconnect-error', reconnectError);
+            const handle = client.subscribe('tail', [filterFor(room, { ...options, limit: '20' }, client.pubkey)], {
+                onMessage: (message) => {
+                    if (options.json)
+                        console.log(JSON.stringify(toJson(message)));
+                    else
+                        printMessage(message);
+                    const cursor = handle.cursor();
+                    if (caughtUp && cursor)
+                        persist(cursor);
+                },
+                onEose: (info) => {
+                    caughtUp = true;
+                    persist({ storeId: info.storeId, throughSeq: info.throughSeq });
+                },
+                onClosed: (message) => {
+                    fail(new Error(message));
+                    finish();
+                },
+            }, previous);
+            await done;
+        }
+        catch (error) {
+            fail(error);
+        }
+        finally {
+            process.removeListener('SIGINT', finish);
+            process.removeListener('SIGTERM', finish);
+            client?.off('disconnected', disconnected);
+            client?.off('reconnect-exhausted', exhausted);
+            client?.off('reconnect-error', reconnectError);
+            await client?.close();
+            while (pendingWrite)
+                await pendingWrite;
+        }
+    });
+}
+//# sourceMappingURL=fleet-rooms-commands.js.map

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;
 } | {