@phuetz/code-buddy 2.0.0 → 2.1.0

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
  */

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

@@ -27,17 +27,37 @@ function formatTimeAgo(date, now = new Date()) {
     const yr = Math.floor(day / 365);
     return `${yr} year${yr === 1 ? "" : "s"} ago`;
 }
+/**
+ * Report a remember operation honestly: the persistent write is the primary
+ * result; fact reconciliation and the semantic index are secondary and their
+ * failures are shown without hiding (or overstating) the saved memory.
+ */
+async function describeRememberOutcome(write, requestedKey, scope, storeSemantic) {
+    const lines = [`✅ Remembered: "${write?.key ?? requestedKey}" in persistent ${scope} memory.`];
+    if (write?.reconciliation?.status === "failed") {
+        lines.push(`⚠️ Fact reconciliation failed (${write.reconciliation.reason ?? "unknown error"}); the memory was saved directly and existing memories were kept unchanged.`);
+    }
+    try {
+        await storeSemantic();
+        lines.push("Semantic index updated.");
+    }
+    catch (error) {
+        lines.push(`⚠️ Semantic index not updated: ${getErrorMessage(error)}`);
+    }
+    return lines.join("\n");
+}
 function clip(text, max = 180) {
     return text.length > max ? text.slice(0, max - 1) + "…" : text;
 }
 /**
  * Memory - Manage persistent memory using PersistentMemoryManager (Markdown) and EnhancedMemory (SQLite/Vector)
  */
-export async function handleMemory(args) {
+export async function handleMemory(args, context) {
     const enhancedMemory = getEnhancedMemory();
-    const persistentMemory = getMemoryManager();
+    const persistentMemory = getMemoryManager(undefined, context?.botId, context?.cwd);
     const action = args[0]?.toLowerCase() || 'list';
     try {
+        await persistentMemory.initialize();
         let content;
         switch (action) {
             case "recall":
@@ -151,14 +171,13 @@ export async function handleMemory(args) {
                         : "project";
                     const value = args.slice(2).join(" ");
                     // Store in both for redundancy and better retrieval
-                    await persistentMemory.remember(key, value, { scope, category: "custom" });
-                    await enhancedMemory.store({
+                    const write = await persistentMemory.remember(key, value, { scope, category: "custom" });
+                    content = await describeRememberOutcome(write, key, scope, () => enhancedMemory.store({
                         type: 'fact',
                         content: `${key}: ${value}`,
                         tags: [key, scope],
                         importance: 0.8
-                    });
-                    content = `✅ Remembered: "${key}" in persistent ${scope} memory and semantic index.`;
+                    }));
                 }
                 else {
                     content = `Usage: /memory remember <key> <content> [project|user]`;
@@ -231,7 +250,7 @@ export async function handleMemory(args) {
                     : undefined;
                 const rawLimit = parseInt(args[status ? 2 : 1] ?? "20", 10);
                 const limit = Math.min(50, Math.max(1, Number.isFinite(rawLimit) ? rawLimit : 20));
-                const candidates = getMemoryCandidateQueue(process.cwd()).list(status).slice(0, limit);
+                const candidates = getMemoryCandidateQueue(context?.cwd ?? process.cwd(), context?.botId).list(status).slice(0, limit);
                 if (candidates.length === 0) {
                     content = status ? `No ${status} memory candidates.` : "No memory candidates yet.";
                 }
@@ -268,7 +287,7 @@ export async function handleMemory(args) {
                 }
                 const reviewedBy = args.slice(2).join(" ").trim() || "user";
                 const { getMemoryCandidateQueue } = await import("../../memory/memory-candidate-queue.js");
-                const { candidate, write } = await getMemoryCandidateQueue(process.cwd()).accept(id, { reviewedBy });
+                const { candidate, write } = await getMemoryCandidateQueue(context?.cwd ?? process.cwd(), context?.botId).accept(id, { reviewedBy });
                 content = `✅ Accepted ${candidate.id} into ${candidate.scope} memory as "${candidate.key}".\n` +
                     `Write status: ${write.status}. Capacity: ${write.usage.used}/${write.usage.limit} chars (${write.usage.percent}%).`;
                 break;
@@ -282,7 +301,7 @@ export async function handleMemory(args) {
                 }
                 const reason = args.slice(2).join(" ").trim();
                 const { getMemoryCandidateQueue } = await import("../../memory/memory-candidate-queue.js");
-                const candidate = getMemoryCandidateQueue(process.cwd()).reject(id, {
+                const candidate = getMemoryCandidateQueue(context?.cwd ?? process.cwd(), context?.botId).reject(id, {
                     reviewedBy: "user",
                     ...(reason ? { reason } : {}),
                 });
@@ -319,7 +338,7 @@ export async function handleMemory(args) {
 /**
  * Remember - Quick memory store using PersistentMemoryManager and EnhancedMemory
  */
-export async function handleRemember(args) {
+export async function handleRemember(args, context) {
     if (args.length < 2) {
         return {
             handled: true,
@@ -346,20 +365,21 @@ export async function handleRemember(args) {
         : "project";
     const value = args.slice(1).join(" ");
     try {
-        const persistentMemory = getMemoryManager();
+        const persistentMemory = getMemoryManager(undefined, context?.botId, context?.cwd);
         const enhancedMemory = getEnhancedMemory();
-        await persistentMemory.remember(key, value, { scope, category: "custom" });
-        await enhancedMemory.store({
+        await persistentMemory.initialize();
+        const write = await persistentMemory.remember(key, value, { scope, category: "custom" });
+        const content = await describeRememberOutcome(write, key, scope, () => enhancedMemory.store({
             type: 'fact',
             content: `${key}: ${value}`,
             tags: [key, scope],
             importance: 0.8
-        });
+        }));
         return {
             handled: true,
             entry: {
                 type: "assistant",
-                content: `✅ Remembered: "${key}" in persistent ${scope} memory and semantic index.`,
+                content,
                 timestamp: new Date(),
             },
         };

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

@@ -14,7 +14,7 @@
  * - __RESTORE_CHECKPOINT__ - /restore
  */
 import type { CommandHandlerResult } from './branch-handlers.js';
-export declare function handleChangeModel(args: string[]): Promise<CommandHandlerResult>;
+export declare function handleChangeModel(args: string[], activeModel?: string): Promise<CommandHandlerResult>;
 export declare function handleChangeMode(args: string[]): Promise<CommandHandlerResult>;
 export declare function handleClearChat(): CommandHandlerResult;
 export declare function handleColab(args: string[]): Promise<CommandHandlerResult>;
@@ -24,5 +24,5 @@ export declare function handleListCheckpoints(_args: string[]): Promise<CommandH
 export declare function handleRestoreCheckpoint(args: string[]): Promise<CommandHandlerResult>;
 export declare function handleInitGrok(args?: string[]): Promise<CommandHandlerResult>;
 export declare function handleReinitGrok(): Promise<CommandHandlerResult>;
-export declare function handleStatus(): Promise<CommandHandlerResult>;
+export declare function handleStatus(activeModel?: string): Promise<CommandHandlerResult>;
 export declare function handleNew(args: string[]): Promise<CommandHandlerResult>;

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

@@ -17,14 +17,14 @@ import { handleColabCommand } from './colab-handler.js';
 // ============================================================================
 // /model - Change Model
 // ============================================================================
-export async function handleChangeModel(args) {
+export async function handleChangeModel(args, activeModel) {
     const { getSupportedModels, getModelInfo, suggestModel } = await import('../../utils/model-utils.js');
     const { getSettingsManager } = await import('../../utils/settings-manager.js');
     const modelName = args[0];
     const settingsManager = getSettingsManager();
     // If no model specified, show current model and list available models
     if (!modelName || modelName === 'list') {
-        const currentModel = process.env.GROK_MODEL || 'grok-beta';
+        const currentModel = activeModel ?? settingsManager.getCurrentModel();
         const supportedModels = getSupportedModels();
         // Group models by provider
         const modelsByProvider = {};
@@ -803,13 +803,13 @@ function formatStatusTimeAgo(date, now = new Date()) {
     const day = Math.floor(hr / 24);
     return `${day}d ago`;
 }
-export async function handleStatus() {
+export async function handleStatus(activeModel) {
     const lines = [];
     lines.push('Status Dashboard');
     lines.push('='.repeat(50));
     lines.push('');
     // Current model
-    const currentModel = process.env.GROK_MODEL || 'grok-beta';
+    const currentModel = activeModel ?? (await import('../../utils/settings-manager.js')).getSettingsManager().getCurrentModel();
     lines.push(`  Model:           ${currentModel}`);
     // Agent mode
     try {

package/dist/commands/handlers/resources-handler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * /resources — read-only view of the explicit resource catalog (P8).
+ *
+ * Reads ~/.codebuddy/resources/catalog.json through ResourceCatalog.list():
+ * no probe, no network, no write, no dispatch. Shows endpoint REFERENCES
+ * (environment variable names), never resolved URLs or fingerprints.
+ */
+import type { CommandHandlerResult } from './branch-handlers.js';
+import { ResourceCatalog, type PublicResourceStatus } from '../../fleet/resource-catalog.js';
+export declare const RESOURCES_EMPTY_HINT: string;
+export declare function formatResourcesTable(resources: PublicResourceStatus[], now?: number): string;
+export declare function handleResources(catalog?: ResourceCatalog, now?: () => number): Promise<CommandHandlerResult>;

package/dist/commands/handlers/resources-handler.js

@@ -0,0 +1,52 @@
+/**
+ * /resources — read-only view of the explicit resource catalog (P8).
+ *
+ * Reads ~/.codebuddy/resources/catalog.json through ResourceCatalog.list():
+ * no probe, no network, no write, no dispatch. Shows endpoint REFERENCES
+ * (environment variable names), never resolved URLs or fingerprints.
+ */
+import fs from 'node:fs';
+import { publicResourceStatus, ResourceCatalog } from '../../fleet/resource-catalog.js';
+export const RESOURCES_EMPTY_HINT = 'No resource catalog yet. Declare one with `buddy resources add <file.json>` (fields: `buddy resources schema`), '
+    + 'then refresh its health explicitly with `buddy resources probe <id>`.';
+function textResult(content) {
+    return { handled: true, entry: { type: 'assistant', content, timestamp: new Date() } };
+}
+function age(from, now) {
+    if (from === null)
+        return 'never';
+    const minutes = Math.max(0, Math.round((now - from) / 60_000));
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 120)
+        return `${minutes} min ago`;
+    return `${Math.round(minutes / 60)} h ago`;
+}
+export function formatResourcesTable(resources, now = Date.now()) {
+    const lines = [`Resources (${resources.length}) — read-only, no probe`, ''];
+    for (const entry of resources) {
+        const r = entry.resource;
+        const use = r.permissions.use ? 'use' : 'no-use';
+        const probe = r.permissions.probe ? 'probe' : 'no-probe';
+        lines.push(`  ${r.id}  [${r.kind}] on ${r.hostId}`);
+        lines.push(`    state: ${entry.state} (${entry.reason}), checked ${age(entry.checkedAt, now)}`);
+        lines.push(`    capabilities: ${r.declaredCapabilities.join(', ')} · endpoint ref: ${r.endpointRef} · ${use}, ${probe}`);
+    }
+    lines.push('', 'Health is not proof of usage and load is unknown. Refresh with `buddy resources probe <id>`.');
+    return lines.join('\n');
+}
+export async function handleResources(catalog = new ResourceCatalog(), now = Date.now) {
+    let resources;
+    try {
+        resources = (await catalog.list()).map(publicResourceStatus);
+    }
+    catch (error) {
+        const code = error instanceof Error ? error.message : 'INVALID_CATALOG';
+        return textResult(`Resource catalog unreadable (${code}). Nothing was changed; inspect ${catalog.filename}.`);
+    }
+    if (resources.length === 0) {
+        return textResult(fs.existsSync(catalog.filename) ? `The resource catalog is empty. ${RESOURCES_EMPTY_HINT.replace(/^No resource catalog yet\. /, '')}` : RESOURCES_EMPTY_HINT);
+    }
+    return textResult(formatResourcesTable(resources, now()));
+}
+//# sourceMappingURL=resources-handler.js.map

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

@@ -1,7 +1,7 @@
 /**
  * Starter Pack Slash Command Handler
  *
- * /starter              - List all starter packs grouped by language
+ * /starter, /starter list - List all starter packs grouped by language
  * /starter <name>       - Activate a specific starter pack (name or alias)
  * /starter search <q>   - Search starters by keyword
  */

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

@@ -1,7 +1,7 @@
 /**
  * Starter Pack Slash Command Handler
  *
- * /starter              - List all starter packs grouped by language
+ * /starter, /starter list - List all starter packs grouped by language
  * /starter <name>       - Activate a specific starter pack (name or alias)
  * /starter search <q>   - Search starters by keyword
  */
@@ -25,7 +25,16 @@ const LANGUAGE_FAMILIES = {
 function formatStarterList() {
     const starters = getStarterPacks();
     if (starters.length === 0) {
-        return 'No starter packs found. Ensure bundled skills are loaded.';
+        // No starter pack ships with the package today: say where packs are found
+        // instead of implying a loading failure.
+        return [
+            'No starter packs are installed.',
+            '',
+            'Starter packs are SKILL.md skills tagged "starter", discovered in:',
+            '  .codebuddy/skills/        (this project)',
+            '  ~/.codebuddy/skills/      (user)',
+            '  the bundled skills directory shipped with Code Buddy',
+        ].join('\n');
     }
     const lines = [
         `Starter Packs (${starters.length} available)`,
@@ -82,6 +91,27 @@ export async function handleStarter(args) {
         };
     }
     const action = first.toLowerCase();
+    // /starter list — documented alias of the bare command
+    if (action === 'list' && args.length === 1) {
+        return {
+            handled: true,
+            entry: {
+                type: 'assistant',
+                content: formatStarterList(),
+                timestamp: new Date(),
+            },
+        };
+    }
+    if (action === 'search' && args.length === 1) {
+        return {
+            handled: true,
+            entry: {
+                type: 'assistant',
+                content: 'Usage: /starter search <query>',
+                timestamp: new Date(),
+            },
+        };
+    }
     // /starter search <query>
     if (action === 'search' && args.length > 1) {
         const query = args.slice(1).join(' ');