@phuetz/code-buddy 2.0.0 → 2.1.0

package/dist/agent/self-improvement/types.d.ts

@@ -113,6 +113,17 @@ export interface ArchiveEntry {
     reviewedBy: string;
     /** Origin of non-lesson archive entries, for example the project CHANGELOG or delegation logs. */
     provenance?: 'changelog' | 'delegation-log' | string;
+    evidence?: {
+        artifactSha256: string;
+        benchmarkSha256: string;
+        wins: number;
+        losses: number;
+        cases: {
+            id: string;
+            before: boolean;
+            after: boolean;
+        }[];
+    };
 }
 export interface SelfImprovementCycleResult {
     schemaVersion: typeof SELF_IMPROVEMENT_SCHEMA_VERSION;

package/dist/agent/tool-handler.d.ts

@@ -243,7 +243,7 @@ export declare class ToolHandler {
     private executeStreamingBash;
     /**
      * Execute a tool with streaming output.
-     * Currently only supports bash. Falls back to executeTool for other tools.
+     * Supports process output, code_exec yields and progress-producing tools.
      * Yields string deltas for real-time output.
      */
     executeToolStreaming(toolCall: CodeBuddyToolCall, executionExtra?: Record<string, unknown>): AsyncGenerator<string, ToolResult, undefined>;

package/dist/agent/tool-handler.js

@@ -15,6 +15,7 @@
  * All tools are registered as ITool adapters in the FormalToolRegistry.
  * Tool instances are lazy-loaded on first access for optimal startup time.
  */
+import { streamToolOutput } from '../tools/stream-tool-output.js';
 import { TextEditorTool, MorphEditorTool, ImageTool, BashTool, } from "../tools/index.js";
 import { isBareChangeDirectory } from "../tools/bash/bash-tool.js";
 import { getFormalToolRegistry } from "../tools/registry/index.js";
@@ -1034,14 +1035,22 @@ export class ToolHandler {
             ...(abortSignal ? { abortSignal } : {}),
             ...(Object.keys(contextExtra).length > 0 ? { extra: contextExtra } : {}),
         };
+        const toolCatalog = toolName === 'code_exec' || toolName === 'tool_search' ? [
+            ...this.registry.getSchemas().map(tool => ({
+                ...tool, keywords: this.registry.get(tool.name)?.metadata.keywords,
+            })),
+            ...getMCPManager().getTools().map(tool => ({ name: tool.name, description: tool.description, parameters: tool.inputSchema })),
+            ...this.deps.marketplace.getTools().map(name => {
+                const definition = this.deps.marketplace.getToolDefinition(name);
+                return { name: `plugin__${name}`, description: definition?.description ?? '', parameters: definition?.parameters };
+            }),
+        ].filter(tool => isToolNameAllowed(tool.name) && isToolVisibleForSurface(tool.name)) : [];
+        if (toolName === 'tool_search') {
+            context = { ...context, extra: { ...context.extra, toolSearchCatalog: toolCatalog } };
+        }
         if (toolName === 'code_exec') {
-            const availableTools = Array.from(new Set([
-                ...this.registry.getNames(),
-                ...getMCPManager().getTools().map((tool) => tool.name),
-                ...this.deps.marketplace.getTools(),
-            ]))
-                .filter((name) => name !== 'code_exec' && name !== 'exec' && isToolNameAllowed(name))
-                .sort();
+            const availableTools = [...new Set(toolCatalog.map(tool => tool.name))]
+                .filter(name => name !== 'code_exec' && name !== 'exec').sort();
             // HTTP uses one host agent and swaps logical conversations under a
             // mutex. Its SessionStore ID therefore cannot isolate code_exec state;
             // the opaque recovery scope is the authoritative logical session.
@@ -1055,7 +1064,11 @@ export class ToolHandler {
                 agentId: stateAgentId,
                 cwd: context.cwd,
                 availableTools,
-                executor: async (nestedToolName, nestedArgs) => {
+                abortSignal,
+                onOutput: typeof executionExtra?.codeExecOnOutput === 'function' ? executionExtra.codeExecOnOutput : undefined,
+                toolMetadata: toolCatalog.map(tool => ({ name: tool.name, description: tool.description })),
+                parallelTools: availableTools.filter(name => this.registry.get(name)?.metadata.fleetSafe === true && this.registry.get(name)?.metadata.effect === 'read'),
+                executor: async (nestedToolName, nestedArgs, nestedSignal) => {
                     // Defense in depth: code_exec is omitted from the child bridge and
                     // rejected again here so tools.call('code_exec', ...) cannot recurse.
                     if (nestedToolName === 'code_exec' || nestedToolName === 'exec') {
@@ -1083,6 +1096,7 @@ export class ToolHandler {
                         },
                     }, {
                         ...(executionExtra ?? {}),
+                        abortSignal: nestedSignal ?? abortSignal,
                         recoverySessionId,
                     });
                 },
@@ -1385,7 +1399,7 @@ export class ToolHandler {
     }
     /**
      * Execute a tool with streaming output.
-     * Currently only supports bash. Falls back to executeTool for other tools.
+     * Supports process output, code_exec yields and progress-producing tools.
      * Yields string deltas for real-time output.
      */
     async *executeToolStreaming(toolCall, executionExtra) {
@@ -1401,6 +1415,11 @@ export class ToolHandler {
         if (toolName === 'bash') {
             return yield* this.executeStreamingBash(toolCall, executionExtra, startTime);
         }
+        if (toolName === 'code_exec') {
+            return yield* streamToolOutput((abortSignal, codeExecOnOutput) => this.executeTool(toolCall, {
+                ...(executionExtra ?? {}), abortSignal, codeExecOnOutput,
+            }), abortSignalFromExecutionExtra(executionExtra));
+        }
         // Reason: stream MCTS progress events in real-time
         if (toolName === 'reason') {
             try {

package/dist/auth/profile-manager.js

@@ -22,7 +22,7 @@ export const DEFAULT_AUTH_PROFILE_MANAGER_CONFIG = {
     cooldownMs: 60_000, // 1 minute
     billingCooldownMs: 18_000_000, // 5 hours
     maxCooldownMs: 86_400_000, // 24 hours
-    persistPath: path.join(os.homedir(), '.codebuddy', 'auth-profiles.json'),
+    get persistPath() { return path.join(os.homedir(), '.codebuddy', 'auth-profiles.json'); },
 };
 // ============================================================================
 // Auth Profile Manager

package/dist/channels/companion-channel-turn.d.ts

@@ -1,12 +1,32 @@
 /**
- * Companion channel generation: a single no-tools chat() call.
+ * Companion channel generation: single chat() call when without tools,
+ * or bounded tool loop (<= 3 rounds) when the speaker is identified.
  *
  * Failover seam: this goes through CodeBuddyClient.chat so
  * feat/provider-fallback-2026-09-06 (`CODEBUDDY_PROVIDER_FALLBACK`) takes
  * over when that lane is merged. Do not reimplement a fallback chain here.
+ *
+ * @module channels/companion-channel-turn
  */
-import { type CodeBuddyMessage, type CodeBuddyResponse } from '../codebuddy/client.js';
+import { type CodeBuddyMessage, type CodeBuddyResponse, type CodeBuddyTool } from '../codebuddy/client.js';
+import type { CompanionIdentity } from '../companion/companion-identity.js';
+import { type CompanionToolExecutionContext } from '../companion/companion-toolset.js';
+import type { ToolResult } from '../types/index.js';
+import type { FormalToolRegistry } from '../tools/registry/tool-registry.js';
+import type { ConfirmationService } from '../utils/confirmation-service.js';
 export declare const COMPANION_CHANNEL_FAILOVER_SEAM = "CodeBuddyClient.chat";
+export declare const MAX_COMPANION_TOOL_ROUNDS = 3;
+export interface CompanionChannelMedia {
+    type: 'image';
+    imagePath: string;
+    caption?: string;
+}
+export interface CompanionExecutedTool {
+    name: string;
+    success: boolean;
+    output?: string;
+    imagePath?: string;
+}
 export interface CompanionChannelTurnInput {
     apiKey: string;
     baseUrl: string;
@@ -15,16 +35,45 @@ export interface CompanionChannelTurnInput {
     signal?: AbortSignal;
     maxTokens?: number;
     /** Injectable chat for tests. Production uses CodeBuddyClient. */
-    chat?: (messages: CodeBuddyMessage[], tools: [], opts: {
+    chat?: (messages: CodeBuddyMessage[], tools: CodeBuddyTool[], opts: {
         model: string;
         maxTokens?: number;
         signal?: AbortSignal;
-        tool_choice: 'none';
+        tool_choice: 'none' | 'auto' | 'required';
     }) => Promise<CodeBuddyResponse>;
+    /** Authenticated identity of the interlocutor */
+    identity?: CompanionIdentity;
+    /** Surface: 'telegram' | 'mobile' | 'pwa' | 'voice' | 'channel' */
+    surface?: string;
+    /** Environment override */
+    env?: NodeJS.ProcessEnv;
+    /** Callback fired immediately when a long-running tool starts */
+    onWaitingWord?: (word: string) => Promise<void> | void;
+    /** Optional media delivery callback */
+    deliverMedia?: (media: CompanionChannelMedia) => Promise<void>;
+    /** Optional custom tool executor (injectable for tests) */
+    executeTool?: (toolName: string, args: Record<string, unknown>, context: CompanionToolExecutionContext) => Promise<ToolResult>;
+    /** Optional tool registry */
+    registry?: FormalToolRegistry;
+    /** Optional confirmation service */
+    confirmationService?: ConfirmationService;
+    /** Timeout in milliseconds (defaults to CODEBUDDY_CHANNEL_TURN_TIMEOUT_MS or 120_000) */
+    timeoutMs?: number;
+    /** Working directory */
+    cwd?: string;
 }
 export interface CompanionChannelTurnResult {
     text: string;
     model: string;
     promptTokens?: number;
+    media?: CompanionChannelMedia[];
+    executedTools?: CompanionExecutedTool[];
+    historySuffix?: string;
 }
+/**
+ * Executes a companion turn.
+ * If interlocutor is guest or tools circuit-breaker is OFF, runs the historical
+ * single chat(messages, [], tool_choice: 'none') call.
+ * If authorized, runs up to 3 tool turns and delivers media automatically.
+ */
 export declare function runCompanionChannelTurn(input: CompanionChannelTurnInput): Promise<CompanionChannelTurnResult>;

package/dist/channels/companion-channel-turn.js

@@ -1,38 +1,240 @@
 /**
- * Companion channel generation: a single no-tools chat() call.
+ * Companion channel generation: single chat() call when without tools,
+ * or bounded tool loop (<= 3 rounds) when the speaker is identified.
  *
  * Failover seam: this goes through CodeBuddyClient.chat so
  * feat/provider-fallback-2026-09-06 (`CODEBUDDY_PROVIDER_FALLBACK`) takes
  * over when that lane is merged. Do not reimplement a fallback chain here.
+ *
+ * @module channels/companion-channel-turn
  */
 import { CodeBuddyClient } from '../codebuddy/client.js';
 import { logger } from '../utils/logger.js';
+import { isCompanionToolsEnabled, getCompanionToolDefinitions, getCompanionToolWaitingWord, executeCompanionTool, extractImagePathFromToolResult, } from '../companion/companion-toolset.js';
 export const COMPANION_CHANNEL_FAILOVER_SEAM = 'CodeBuddyClient.chat';
+export const MAX_COMPANION_TOOL_ROUNDS = 3;
+/**
+ * Executes a companion turn.
+ * If interlocutor is guest or tools circuit-breaker is OFF, runs the historical
+ * single chat(messages, [], tool_choice: 'none') call.
+ * If authorized, runs up to 3 tool turns and delivers media automatically.
+ */
 export async function runCompanionChannelTurn(input) {
+    const env = input.env ?? process.env;
+    const identity = input.identity;
+    const toolsEnabled = isCompanionToolsEnabled(env) && Boolean(identity && identity.role !== 'guest');
     const chat = input.chat ??
         (async (messages, tools, opts) => {
             const client = new CodeBuddyClient(input.apiKey, input.model, input.baseUrl);
             return client.chat(messages, tools, opts);
         });
-    const response = await chat(input.messages, [], {
-        model: input.model,
-        maxTokens: input.maxTokens ?? 512,
-        ...(input.signal ? { signal: input.signal } : {}),
-        tool_choice: 'none',
-    });
-    const text = response.choices[0]?.message?.content?.trim() ?? '';
-    if (!text) {
-        logger.warn('Companion channel turn returned empty content', {
+    // Resolve tool definitions if tools are allowed
+    let toolDefs = [];
+    if (toolsEnabled && identity) {
+        try {
+            toolDefs = await getCompanionToolDefinitions(identity, {
+                env,
+                registry: input.registry,
+            });
+        }
+        catch (err) {
+            logger.warn('[companion-channel-turn] Failed to resolve companion tool definitions', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            toolDefs = [];
+        }
+    }
+    // 1. FAST / HISTORICAL PATH: No tools allowed or no tools registered
+    if (!toolsEnabled || toolDefs.length === 0) {
+        const response = await chat(input.messages, [], {
             model: input.model,
-            seam: COMPANION_CHANNEL_FAILOVER_SEAM,
+            maxTokens: input.maxTokens ?? 512,
+            ...(input.signal ? { signal: input.signal } : {}),
+            tool_choice: 'none',
         });
+        const text = response.choices[0]?.message?.content?.trim() ?? '';
+        if (!text) {
+            logger.warn('Companion channel turn returned empty content', {
+                model: input.model,
+                seam: COMPANION_CHANNEL_FAILOVER_SEAM,
+            });
+        }
+        return {
+            text,
+            model: response.model ?? input.model,
+            ...(response.usage?.prompt_tokens !== undefined
+                ? { promptTokens: response.usage.prompt_tokens }
+                : {}),
+        };
+    }
+    // 2. TOOL-ENABLED BOUNDED LOOP (<= 3 rounds)
+    const defaultTimeout = env.CODEBUDDY_CHANNEL_TURN_TIMEOUT_MS
+        ? parseInt(env.CODEBUDDY_CHANNEL_TURN_TIMEOUT_MS, 10)
+        : 120_000;
+    const effectiveTimeout = input.timeoutMs ?? defaultTimeout;
+    // Signal management: propagate caller abort or timeout
+    let combinedSignal = input.signal;
+    let timeoutId;
+    if (!combinedSignal && effectiveTimeout > 0) {
+        const controller = new AbortController();
+        timeoutId = setTimeout(() => controller.abort(), effectiveTimeout);
+        combinedSignal = controller.signal;
+    }
+    const activeMessages = [...input.messages];
+    const mediaProduced = [];
+    const executedTools = [];
+    const historyNotes = [];
+    let finalText = '';
+    let finalModel = input.model;
+    let totalPromptTokens;
+    try {
+        for (let round = 0; round < MAX_COMPANION_TOOL_ROUNDS; round += 1) {
+            const response = await chat(activeMessages, toolDefs, {
+                model: input.model,
+                maxTokens: input.maxTokens ?? 512,
+                ...(combinedSignal ? { signal: combinedSignal } : {}),
+                tool_choice: 'auto',
+            });
+            finalModel = response.model ?? finalModel;
+            if (response.usage?.prompt_tokens !== undefined) {
+                totalPromptTokens = (totalPromptTokens ?? 0) + response.usage.prompt_tokens;
+            }
+            const assistantMsg = response.choices[0]?.message;
+            if (!assistantMsg) {
+                break;
+            }
+            const content = assistantMsg.content?.trim() ?? '';
+            const toolCalls = assistantMsg.tool_calls;
+            // If no tool calls, this is the final conversational reply
+            if (!toolCalls || toolCalls.length === 0) {
+                finalText = content;
+                break;
+            }
+            // Add assistant response with tool_calls to conversation history
+            activeMessages.push(assistantMsg);
+            // Execute each tool call
+            for (const toolCall of toolCalls) {
+                const toolName = toolCall.function.name;
+                let args = {};
+                try {
+                    args = JSON.parse(toolCall.function.arguments || '{}');
+                }
+                catch {
+                    args = {};
+                }
+                // Notify waiting word immediately before running long tools
+                const waitingWord = getCompanionToolWaitingWord(toolName);
+                if (waitingWord && input.onWaitingWord) {
+                    try {
+                        await input.onWaitingWord(waitingWord);
+                    }
+                    catch (waitErr) {
+                        logger.debug('[companion-channel-turn] onWaitingWord error', { error: String(waitErr) });
+                    }
+                }
+                // Execute tool safely
+                const execFn = input.executeTool ?? executeCompanionTool;
+                let toolRes;
+                try {
+                    toolRes = await execFn(toolName, args, {
+                        identity: identity,
+                        env,
+                        cwd: input.cwd,
+                        signal: combinedSignal,
+                        registry: input.registry,
+                        confirmationService: input.confirmationService,
+                    });
+                }
+                catch (toolErr) {
+                    toolRes = {
+                        success: false,
+                        error: toolErr instanceof Error ? toolErr.message : String(toolErr),
+                    };
+                }
+                // Check if an image was produced
+                const imagePath = extractImagePathFromToolResult(toolRes, input.cwd);
+                if (imagePath) {
+                    mediaProduced.push({ type: 'image', imagePath });
+                    historyNotes.push(`[Image générée : ${imagePath}]`);
+                }
+                // Record reminder in history notes
+                if (toolName === 'remind' && toolRes.success) {
+                    const label = typeof args.label === 'string' ? args.label.trim() : 'rappel';
+                    const time = typeof args.time === 'string' ? args.time.trim() : '';
+                    historyNotes.push(`[Rappel créé : ${label}${time ? ` à ${time}` : ''}]`);
+                }
+                executedTools.push({
+                    name: toolName,
+                    success: toolRes.success,
+                    output: toolRes.output ?? toolRes.error,
+                    ...(imagePath ? { imagePath } : {}),
+                });
+                // Add tool response message for LLM
+                activeMessages.push({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: toolRes.success
+                        ? (toolRes.output ?? 'Succès')
+                        : `Erreur outil ${toolName} : ${toolRes.error ?? 'inconnue'}`,
+                });
+            }
+        }
+    }
+    finally {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    }
+    // Fallback text if model left content blank after tool calls
+    if (!finalText && executedTools.length > 0) {
+        const hasImage = mediaProduced.length > 0;
+        if (hasImage) {
+            finalText = 'Voilà, j’ai créé l’image pour toi !';
+        }
+        else {
+            finalText = 'C’est fait !';
+        }
+    }
+    // Deliver media (Telegram / PWA / Voice)
+    if (mediaProduced.length > 0) {
+        const surface = (input.surface ?? '').toLowerCase();
+        for (const media of mediaProduced) {
+            media.caption = finalText;
+            if (input.deliverMedia) {
+                try {
+                    await input.deliverMedia(media);
+                }
+                catch (delivErr) {
+                    logger.warn('[companion-channel-turn] deliverMedia failed', {
+                        error: delivErr instanceof Error ? delivErr.message : String(delivErr),
+                    });
+                }
+            }
+            else if (surface === 'voice') {
+                // Voice surface: alert owner on Telegram with the photo and announce it
+                try {
+                    const { sendTelegramAlert } = await import('../sensory/alert.js');
+                    await sendTelegramAlert(finalText, media.imagePath);
+                    if (!/téléphone|telegram|envoie/i.test(finalText)) {
+                        finalText = `${finalText} Je te l'envoie sur ton téléphone.`.trim();
+                    }
+                }
+                catch (voiceSendErr) {
+                    logger.warn('[companion-channel-turn] Voice media telegram delivery skipped', {
+                        error: voiceSendErr instanceof Error ? voiceSendErr.message : String(voiceSendErr),
+                    });
+                }
+            }
+        }
     }
+    const historySuffix = historyNotes.length > 0 ? `\n${historyNotes.join('\n')}` : undefined;
     return {
-        text,
-        model: response.model ?? input.model,
-        ...(response.usage?.prompt_tokens !== undefined
-            ? { promptTokens: response.usage.prompt_tokens }
-            : {}),
+        text: finalText,
+        model: finalModel,
+        ...(totalPromptTokens !== undefined ? { promptTokens: totalPromptTokens } : {}),
+        ...(mediaProduced.length > 0 ? { media: mediaProduced } : {}),
+        ...(executedTools.length > 0 ? { executedTools } : {}),
+        ...(historySuffix ? { historySuffix } : {}),
     };
 }
 //# sourceMappingURL=companion-channel-turn.js.map

package/dist/channels/slash-parity.d.ts

@@ -70,12 +70,10 @@ export interface SlashParityManifest {
     platforms: PlatformSlashParityReport[];
 }
 /**
- * The canonical set of slash commands expected on each platform.
- *
- * These represent the Code Buddy bot commands that users should be
- * able to invoke from each messaging platform. The manifest is
- * intentionally conservative — platforms may support additional
- * commands beyond what is listed here.
+ * The canonical set of slash commands expected on each platform, derived from
+ * the single surface declaration `CHANNEL_SLASH_SURFACES`
+ * (src/commands/slash/surfaces.ts) shared with the CLI catalog, Cowork and the
+ * slash wiki. Platforms may support additional commands beyond this list.
  */
 export declare const EXPECTED_SLASH_COMMANDS: Record<string, SlashCommandSpec[]>;
 /**

package/dist/channels/slash-parity.js

@@ -6,55 +6,20 @@
  * Returns a machine-readable readiness report for each platform.
  */
 import { getChannelManager } from './core.js';
+import { CHANNEL_SLASH_SURFACES } from '../commands/slash/surfaces.js';
 // ============================================================================
 // Expected Commands Manifest
 // ============================================================================
 /**
- * The canonical set of slash commands expected on each platform.
- *
- * These represent the Code Buddy bot commands that users should be
- * able to invoke from each messaging platform. The manifest is
- * intentionally conservative — platforms may support additional
- * commands beyond what is listed here.
+ * The canonical set of slash commands expected on each platform, derived from
+ * the single surface declaration `CHANNEL_SLASH_SURFACES`
+ * (src/commands/slash/surfaces.ts) shared with the CLI catalog, Cowork and the
+ * slash wiki. Platforms may support additional commands beyond this list.
  */
-export const EXPECTED_SLASH_COMMANDS = {
-    discord: [
-        { name: 'ask', description: 'Ask Code Buddy a question' },
-        { name: 'status', description: 'Show bot and channel status' },
-        { name: 'clear', description: 'Clear conversation history' },
-        { name: 'help', description: 'Show available commands' },
-        { name: 'model', description: 'Switch or show current model' },
-        { name: 'think', description: 'Set reasoning depth', required: false },
-        { name: 'compact', description: 'Compact conversation context', required: false },
-        { name: 'repo', description: 'Show repository info', required: false },
-    ],
-    telegram: [
-        { name: 'ask', description: 'Ask Code Buddy a question' },
-        { name: 'status', description: 'Show bot and channel status' },
-        { name: 'clear', description: 'Clear conversation history' },
-        { name: 'help', description: 'Show available commands' },
-        { name: 'model', description: 'Switch or show current model' },
-        { name: 'yolo', description: 'Toggle YOLO mode', required: false },
-        { name: 'repo', description: 'Show repository info', required: false },
-        { name: 'branch', description: 'Show branch info', required: false },
-    ],
-    slack: [
-        { name: 'ask', description: 'Ask Code Buddy a question' },
-        { name: 'status', description: 'Show bot and channel status' },
-        { name: 'clear', description: 'Clear conversation history' },
-        { name: 'help', description: 'Show available commands' },
-        { name: 'model', description: 'Switch or show current model' },
-        { name: 'compact', description: 'Compact conversation context', required: false },
-        { name: 'think', description: 'Set reasoning depth', required: false },
-    ],
-    matrix: [
-        { name: 'ask', description: 'Ask Code Buddy a question' },
-        { name: 'status', description: 'Show bot and channel status' },
-        { name: 'clear', description: 'Clear conversation history' },
-        { name: 'help', description: 'Show available commands' },
-        { name: 'model', description: 'Switch or show current model', required: false },
-    ],
-};
+export const EXPECTED_SLASH_COMMANDS = Object.fromEntries(Object.entries(CHANNEL_SLASH_SURFACES).map(([platform, specs]) => [
+    platform,
+    specs.map(({ name, description, required }) => ({ name, description, ...(required === false ? { required } : {}) })),
+]));
 /**
  * Check if a channel adapter implements SlashCommandProvider.
  */

package/dist/cli/session-commands.d.ts

@@ -16,6 +16,15 @@ export declare function resumeLastSession(): Promise<void>;
  * Resume a specific session by ID (--resume flag)
  */
 export declare function resumeSessionById(sessionId: string): Promise<void>;
+/**
+ * Offer recent sessions without requiring an ID (P6). Non-interactive stdio:
+ * print the list and set exit code 1 (never waits for input). Returns the
+ * chosen session id, or null.
+ */
+export declare function pickRecentSession(limit?: number, streams?: {
+    input: NodeJS.ReadStream;
+    output: NodeJS.WriteStream;
+}): Promise<string | null>;
 /**
  * List recent sessions
  */

package/dist/cli/session-commands.js

@@ -97,10 +97,19 @@ export function registerSessionCommands(program) {
     });
     session
         .command('resume')
-        .description('Resume a saved session by ID or partial ID')
-        .argument('<sessionId>', 'session ID or unique prefix')
-        .action(async (sessionId) => {
-        await resumeSessionById(sessionId);
+        .description('Resume a saved session by ID or partial ID; without an ID, pick among recent sessions')
+        .argument('[sessionId]', 'session ID or unique prefix (omit to pick interactively)')
+        .option('--limit <count>', 'recent sessions offered by the picker', parsePositiveInteger, 20)
+        .action(async (sessionId, options) => {
+        if (sessionId) {
+            await resumeSessionById(sessionId);
+            return;
+        }
+        const picked = await pickRecentSession(options.limit);
+        if (!picked)
+            return;
+        await resumeSessionById(picked);
+        console.log(`Continue it in the terminal with: buddy --resume ${picked.slice(0, 8)}`);
     });
     session
         .command('last')
@@ -142,7 +151,38 @@ export async function resumeSessionById(sessionId) {
     }
     await sessionStore.resumeSession(session.id);
     console.log(`Resuming session: ${session.name} (${session.id.slice(0, 8)})`);
-    console.log(`   ${session.messages.length} messages, last accessed: ${session.lastAccessedAt.toLocaleString()}\n`);
+    console.log(`   ${session.messages.length} messages, last accessed: ${session.lastAccessedAt.toLocaleString()}`);
+    const { buildSessionRecap, formatSessionRecap } = await import('./session-picker.js');
+    console.log(`${formatSessionRecap(buildSessionRecap(session)).join('\n')}\n`);
+}
+/**
+ * Offer recent sessions without requiring an ID (P6). Non-interactive stdio:
+ * print the list and set exit code 1 (never waits for input). Returns the
+ * chosen session id, or null.
+ */
+export async function pickRecentSession(limit = 20, streams = { input: process.stdin, output: process.stdout }) {
+    const { getSessionStore } = await import('../persistence/session-store.js');
+    const sessions = await getSessionStore().getRecentSessions(limit);
+    if (sessions.length === 0) {
+        console.log('No sessions found.');
+        process.exitCode = 1;
+        return null;
+    }
+    if (!streams.input.isTTY || !streams.output.isTTY) {
+        console.log(`Recent sessions (${sessions.length}):\n`);
+        sessions.forEach((session) => printSessionSummary(session));
+        console.log('\nNo interactive terminal: pass an ID, e.g. `buddy session resume <id>` or `buddy --resume <id>`.');
+        process.exitCode = 1;
+        return null;
+    }
+    const { pickSession } = await import('./session-picker.js');
+    const picked = await pickSession(sessions, streams);
+    if (!picked) {
+        console.log('Cancelled.');
+        process.exitCode = 1;
+        return null;
+    }
+    return picked.id;
 }
 /**
  * List recent sessions