@phuetz/code-buddy 2.0.0 → 2.2.0

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));

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

@@ -1595,6 +1595,8 @@ export async function registerAIMessageHandler(manager) {
                 let successfulLisaSelfieToolResult = false;
                 let shouldPersistChannelSession = Boolean(agent);
                 let telegramWidget;
+                let companionMediaResult;
+                let companionHistorySuffix;
                 if (prefetchedDirectResponse) {
                     response = prefetchedDirectResponse;
                     if (agent && !agent.recordTrustedExternalConversationTurn(agentInput, response)) {
@@ -1632,16 +1634,34 @@ export async function registerAIMessageHandler(manager) {
                         sharedPhotos: companionPhotos?.photos.length ?? 0,
                     });
                     try {
+                        let companionIdentity;
+                        if (channel.type === 'telegram') {
+                            const { resolveCompanionIdentity } = await import('../../companion/companion-identity.js');
+                            const telegramChannel = channel;
+                            companionIdentity = resolveCompanionIdentity({
+                                channel: 'telegram',
+                                chatId: message.channel.id,
+                                senderId: message.sender?.id,
+                                senderUsername: message.sender?.username,
+                                allowedUsers: telegramChannel.config?.allowedUsers ?? [],
+                                env: process.env,
+                            });
+                        }
                         const generated = await runCompanionChannelTurn({
                             apiKey: effectiveRuntime.apiKey,
                             baseUrl: effectiveRuntime.baseUrl,
                             model: effectiveRuntime.model,
                             messages: companionMessages,
                             signal: turn.signal,
+                            ...(companionIdentity ? { identity: companionIdentity } : {}),
+                            surface: channel.type,
+                            env: process.env,
                         });
                         turn.throwIfAborted();
                         response = generated.text;
                         hasGeneratedResponse = response.trim() !== '';
+                        companionMediaResult = generated.media;
+                        companionHistorySuffix = generated.historySuffix;
                         if (hasSharedPhotos && companionPhotos) {
                             // The album write is deliberately after the reply: a full disk must
                             // cost the memory, never the reaction.
@@ -1860,7 +1880,35 @@ export async function registerAIMessageHandler(manager) {
                 turn.throwIfAborted();
                 turn.phase('delivery');
                 deliveryState = 'started';
-                if (channel.type === 'telegram' && response.trim() && telegramWidget) {
+                if (channel.type === 'telegram' && response.trim() && companionMediaResult && companionMediaResult.length > 0) {
+                    const media = companionMediaResult[0];
+                    if (media) {
+                        const pathMod = await import('path');
+                        const ext = pathMod.extname(media.imagePath).slice(1) || 'png';
+                        const result = await channel.send({
+                            channelId: message.channel.id,
+                            content: response,
+                            replyTo: message.id,
+                            attachments: [
+                                {
+                                    type: 'image',
+                                    filePath: media.imagePath,
+                                    fileName: pathMod.basename(media.imagePath),
+                                    mimeType: ext === 'jpg' || ext === 'jpeg' ? 'image/jpeg' : `image/${ext}`,
+                                },
+                            ],
+                        });
+                        delivered = result?.success === true;
+                        deliveredChunks = delivered ? 1 : 0;
+                        if (delivered)
+                            deliveredAssistantContent = response;
+                        if (delivered)
+                            deliveryMode = 'telegram-photo';
+                        else
+                            deliveryMode = 'failed';
+                    }
+                }
+                else if (channel.type === 'telegram' && response.trim() && telegramWidget) {
                     const result = await channel.send({
                         channelId: message.channel.id,
                         content: response,
@@ -2070,7 +2118,10 @@ export async function registerAIMessageHandler(manager) {
                 turn.throwIfAborted();
                 turn.phase('persistence');
                 if (useCompanionProfile && response.trim()) {
-                    rememberCompanionChannelTurn(sessionKey, message.content, response);
+                    const recordedResponse = companionHistorySuffix
+                        ? `${response}${companionHistorySuffix}`
+                        : response;
+                    rememberCompanionChannelTurn(sessionKey, message.content, recordedResponse);
                 }
                 if (shouldPersistChannelSession && agent)
                     await persistChannelSession(agent, sessionKey);

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

@@ -3,12 +3,13 @@
  *
  * Handlers for exporting sessions, conversations, and tool results
  */
+import type { ChatEntry } from '../../agent/types.js';
 import { CommandHandlerResult } from './branch-handlers.js';
 /**
  * Handle /export command
- * Export current or specified session to file
+ * Export the current conversation, or a saved session with session:<id>
  */
-export declare function handleExport(args: string[]): Promise<CommandHandlerResult>;
+export declare function handleExport(args: string[], conversationHistory?: ChatEntry[], currentModel?: string): Promise<CommandHandlerResult>;
 /**
  * Handle /export-list command
  * List all exported files

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

@@ -3,54 +3,81 @@
  *
  * Handlers for exporting sessions, conversations, and tool results
  */
+import { initializeDatabase } from '../../database/database-manager.js';
 import { getExportManager } from '../../utils/export-manager.js';
-import { getSessionRepository } from '../../database/repositories/session-repository.js';
+function reply(content) {
+    return { handled: true, entry: { type: 'assistant', content, timestamp: new Date() } };
+}
+/** Map the visible transcript to export messages; UI-only entries are skipped. */
+function chatEntriesToMessages(history) {
+    const messages = [];
+    for (const entry of history) {
+        if (entry.type === 'user' || entry.type === 'assistant') {
+            messages.push({ role: entry.type, content: entry.content, timestamp: entry.timestamp });
+        }
+        else if (entry.type === 'tool_result') {
+            messages.push({
+                role: 'tool',
+                content: entry.content,
+                timestamp: entry.timestamp,
+                toolName: entry.toolCall?.function?.name ?? 'tool',
+                toolCallId: entry.toolCall?.id,
+            });
+        }
+    }
+    return messages;
+}
 /**
  * Handle /export command
- * Export current or specified session to file
+ * Export the current conversation, or a saved session with session:<id>
  */
-export async function handleExport(args) {
+export async function handleExport(args, conversationHistory = [], currentModel) {
     const exportManager = getExportManager();
-    const sessionRepo = getSessionRepository();
     // Parse arguments
     const format = args.find(a => ['json', 'markdown', 'html', 'text'].includes(a)) || 'markdown';
     const sessionIdArg = args.find(a => a.startsWith('session:'))?.split(':')[1];
     const includeSecrets = args.includes('--include-secrets');
     const noToolCalls = args.includes('--no-tools');
     const noMetadata = args.includes('--no-metadata');
-    // Get session to export
-    let sessionId;
+    const options = {
+        redactSecrets: !includeSecrets,
+        includeToolCalls: !noToolCalls,
+        includeMetadata: !noMetadata,
+    };
+    let result;
     if (sessionIdArg) {
-        sessionId = sessionIdArg;
+        // Saved sessions live in the SQLite session database, which the
+        // interactive CLI does not open at startup.
+        try {
+            await initializeDatabase();
+        }
+        catch (error) {
+            return reply(`Failed to export session ${sessionIdArg}: session database unavailable (${error instanceof Error ? error.message : String(error)}).`);
+        }
+        result = await exportManager.exportSession(sessionIdArg, format, options);
     }
     else {
-        // Get most recent session
-        const sessions = sessionRepo.findSessions({ limit: 1 });
-        const mostRecent = sessions[0];
-        if (!mostRecent) {
-            return {
-                handled: true,
-                entry: {
-                    type: 'assistant',
-                    content: 'No sessions found to export.',
-                    timestamp: new Date(),
-                },
-            };
+        // The current session is the conversation on screen, not the most recent
+        // database row (which may belong to another project).
+        const messages = chatEntriesToMessages(conversationHistory);
+        if (messages.length === 0) {
+            return reply('Nothing to export yet: the current conversation is empty.\n\nSend a message first, or export a saved session with /export <format> session:<id>.');
         }
-        sessionId = mostRecent.id;
+        result = await exportManager.exportConversationData({
+            title: 'Code Buddy conversation',
+            model: currentModel,
+            startTime: messages[0]?.timestamp,
+            endTime: messages[messages.length - 1]?.timestamp,
+            messages,
+            metadata: { projectPath: process.cwd(), messageCount: messages.length },
+        }, format, options);
     }
-    // Export session
-    const result = await exportManager.exportSession(sessionId, format, {
-        redactSecrets: !includeSecrets,
-        includeToolCalls: !noToolCalls,
-        includeMetadata: !noMetadata,
-    });
     if (result.success && result.filePath) {
         return {
             handled: true,
             entry: {
                 type: 'assistant',
-                content: `Session exported successfully!
+                content: `${sessionIdArg ? `Session ${sessionIdArg}` : 'Current conversation'} exported successfully!
 
 **Format:** ${format}
 **File:** ${result.filePath}
@@ -68,7 +95,7 @@ cat "${result.filePath}"
             handled: true,
             entry: {
                 type: 'assistant',
-                content: `Failed to export session: ${result.error}`,
+                content: `Failed to export ${sessionIdArg ? `session ${sessionIdArg}` : 'the current conversation'}: ${result.error}`,
                 timestamp: new Date(),
             },
         };

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

@@ -311,7 +311,10 @@ export async function handleSearch(args) {
     try {
         const cwd = process.cwd();
         let output = '';
-        const rgResult = runCommand('rg', ['--line-number', '--no-heading', '--color=never', '--max-count=20', '--', query], { cwd, timeoutMs: 10000 });
+        // Explicit `.` path: without one, ripgrep searches stdin whenever stdin is
+        // not a TTY (every non-interactive spawn), so real matches were reported as
+        // "No matches" (status 1).
+        const rgResult = runCommand('rg', ['--line-number', '--no-heading', '--color=never', '--max-count=20', '--', query, '.'], { cwd, timeoutMs: 10000 });
         if (rgResult.success) {
             output = rgResult.output;
         }
@@ -586,6 +589,7 @@ function createProgressBar(percent, width) {
 function runCommand(command, args, { cwd, timeoutMs, env }) {
     const result = spawnSync(command, args, {
         cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
         encoding: 'utf-8',
         maxBuffer: 5 * 1024 * 1024,
         timeout: timeoutMs,

package/dist/commands/handlers/grill-me-handler.js

@@ -1,32 +1,40 @@
+// Written as the user's own request about their own work. The previous wording
+// (role orders addressed to the assistant: "Mène un interrogatoire", "Exige",
+// "Ne flatte pas l'auteur", "ce qui ment") made qwen3:4b answer the injection
+// refusal sentence in the real CLI (recette 2026-09-14), without any tool call.
 function buildPrompt(target, yolo) {
     const scope = target
-        ? `Sujet ciblé par l'utilisateur : ${target}`
-        : 'Sujet par défaut : le travail récent du dépôt.';
+        ? `Sujet ciblé : ${target}`
+        : 'Sujet par défaut : mon travail récent dans ce dépôt.';
+    // The recent work includes uncommitted changes, and HEAD~1 does not exist in
+    // a single-commit repository: inspect the working tree first.
+    const gitInspection = 'git status --short, git diff (modifications non indexées), git diff --cached (modifications indexées) et git log -5 --oneline ; git diff HEAD~1 seulement si le dépôt compte au moins deux commits';
     const baseInstructions = target
-        ? `Examine d'abord ce sujet précis avec les outils disponibles : ${target}. Utilise aussi le contexte git pertinent si nécessaire, notamment git log -5, git diff HEAD~1 et les fichiers modifiés.`
-        : 'Examine d\'abord le travail récent avec les outils disponibles : git log -5, git diff HEAD~1 et la liste des fichiers modifiés.';
+        ? `Examine d'abord ce sujet avec les outils disponibles : ${target}. Utilise aussi le contexte git utile et la liste des fichiers modifiés : ${gitInspection}.`
+        : `Examine d'abord mon travail récent et la liste des fichiers modifiés avec les outils disponibles : ${gitInspection}.`;
     if (yolo) {
-        return `${scope}
+        return `J'ai lancé /grill-me --yolo : je veux une revue technique de mon propre travail en mode ROAST intégral.
+
+${scope}
 
 ${baseInstructions}
 
-Tu es en mode ROAST intégral pour /grill-me --yolo.
-Interroge techniquement l'auteur sans aucune complaisance : brutal, sarcastique, aucune politesse, aucun coussin diplomatique.
-Chaque pique DOIT rester techniquement exacte, vérifiable et actionnable : cite les fichiers, diffs, noms, tests ou choix qui justifient l'attaque.
-Grille l'auteur sur les choix discutables, la dette introduite, les tests manquants, les cas limites ignorés, la sécurité, les abstractions inutiles et les noms mensongers.
-Exige des réponses concrètes, pas des excuses : pour chaque accusation, demande quelle preuve, quel test ou quel correctif va fermer le sujet.
-Si une critique n'est pas étayée par le dépôt ou le diff, ne la formule pas.`;
+Ensuite, sois brutal et sarcastique avec moi, sans politesse ni précautions diplomatiques.
+Chaque critique doit rester techniquement exacte, vérifiable et actionnable : cite les fichiers, diffs, noms, tests ou choix qui la justifient.
+Vise mes choix discutables, la dette introduite, les tests manquants, les cas limites ignorés, la sécurité, les abstractions inutiles et les noms trompeurs.
+Pour chaque critique, demande-moi quelle preuve, quel test ou quel correctif fermera le sujet.
+N'invente rien : une critique que le dépôt ou le diff ne prouve pas ne doit pas être formulée.`;
     }
-    return `${scope}
+    return `J'ai lancé /grill-me : je veux une revue technique exigeante de mon propre travail.
+
+${scope}
 
 ${baseInstructions}
 
-Mène un interrogatoire technique ferme mais constructif.
-Après examen, pose 5 à 7 questions dures et précises sur les choix discutables, la dette introduite, les tests manquants, les cas limites ignorés, la sécurité et les noms mensongers.
-Les questions doivent viser des lignes, fichiers, comportements ou décisions observables, pas des généralités.
-Exige des réponses et des preuves concrètes, pas des excuses.
-Ajoute ensuite 3 risques classés par sévérité, avec pour chacun l'impact, la probabilité et l'action minimale pour le réduire.
-Ne flatte pas l'auteur : aide-le à voir ce qui casse, ce qui ment et ce qui manque.`;
+Ensuite, pose-moi 5 à 7 questions difficiles et précises sur mes choix discutables, la dette introduite, les tests manquants, les cas limites ignorés, la sécurité et les noms trompeurs.
+Chaque question doit viser des lignes, fichiers, comportements ou décisions observables, pas des généralités, et me demander une preuve concrète.
+Termine par 3 risques classés par sévérité, avec pour chacun l'impact, la probabilité et l'action minimale pour le réduire.
+Reste franc et constructif, sans compliments inutiles : aide-moi à voir ce qui casse, ce qui est inexact et ce qui manque.`;
 }
 export async function handleGrillMe(args) {
     const remainingArgs = args.filter(arg => arg !== '--yolo');

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

@@ -1,4 +1,8 @@
 import { ChatEntry } from "../../agent/codebuddy-agent.js";
+export interface MemoryCommandContext {
+    cwd?: string;
+    botId?: string;
+}
 export interface CommandHandlerResult {
     handled: boolean;
     entry?: ChatEntry;
@@ -9,11 +13,11 @@ export interface CommandHandlerResult {
 /**
  * Memory - Manage persistent memory using PersistentMemoryManager (Markdown) and EnhancedMemory (SQLite/Vector)
  */
-export declare function handleMemory(args: string[]): Promise<CommandHandlerResult>;
+export declare function handleMemory(args: string[], context?: MemoryCommandContext): Promise<CommandHandlerResult>;
 /**
  * Remember - Quick memory store using PersistentMemoryManager and EnhancedMemory
  */
-export declare function handleRemember(args: string[]): Promise<CommandHandlerResult>;
+export declare function handleRemember(args: string[], context?: MemoryCommandContext): Promise<CommandHandlerResult>;
 /**
  * Scan Todos - Find AI-directed comments
  */