@pellux/goodvibes-agent 0.1.111 → 0.1.113

package/src/input/commands/memory.ts

@@ -1,16 +1,16 @@
 /**
- * /recall command handler.
+ * /memory command handler.
  *
  * Implements the Project Memory Substrate commands:
  *
- *   /recall add <class> <summary>           — Add a new memory record
- *   /recall add <class> <summary> --detail <text> --tags <tag,tag>
- *   /recall search [query]                  — Search memory records
- *   /recall search --cls <class>            — Filter by class
- *   /recall link <fromId> <toId> <relation> --yes — Link two records
- *   /recall get <id>                        — Show a single record with provenance
- *   /recall list [class]                    — List all records (optionally by class)
- *   /recall remove <id> --yes               — Delete a record
+ *   /memory add <class> <summary>           — Add a new memory record
+ *   /memory add <class> <summary> --detail <text> --tags <tag,tag>
+ *   /memory search [query]                  — Search memory records
+ *   /memory search --cls <class>            — Filter by class
+ *   /memory link <fromId> <toId> <relation> --yes — Link two records
+ *   /memory get <id>                        — Show a single record with provenance
+ *   /memory list [class]                    — List all records (optionally by class)
+ *   /memory remove <id> --yes               — Delete a record
  */
 
 import type { SlashCommand, CommandContext } from '../command-registry.ts';
@@ -118,7 +118,7 @@ export const recallCommand: SlashCommand = {
 
       default: {
         const usage = [
-          'Usage: /recall <subcommand>',
+          'Usage: /memory <subcommand>',
           '  add <class> <summary> [--scope <session|project|team>] [--detail <text>] [--tags <t,t>] [--session <id>] [--task <id>] [--file <path>]',
           `       classes: ${VALID_CLASSES.join(', ')}`,
           '  capture incident <id|latest>                    — Capture a forensics incident as durable memory',

package/src/input/commands/planning-runtime.ts

@@ -44,7 +44,7 @@ function formatNextQuestion(question: ProjectPlanningQuestion | undefined): stri
   if (!question) return 'No next question recorded.';
   const lines = [`Next question: ${question.prompt}`];
   if (question.recommendedAnswer) lines.push(`Recommended answer: ${question.recommendedAnswer}`);
-  lines.push('Answer in the prompt, or focus the Planning workspace to choose/type an answer.');
+  lines.push('Answer in the main prompt or review planning state with /plan status.');
   return lines.join('\n');
 }
 
@@ -52,8 +52,8 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
   registry.register({
     name: 'plan',
     description: 'Inspect or seed Agent workspace planning state',
-    usage: '[panel | approve --yes | list | show <id> | mode | explain | override <strategy> --yes | status | clear --yes | <planning goal>]',
-    argsHint: '[panel|approve|status|<goal>]',
+    usage: '[approve --yes | list | show <id> | mode | explain | override <strategy> --yes | status | clear --yes | <planning goal>]',
+    argsHint: '[approve|status|list|<goal>]',
     async handler(args, ctx) {
       const planManager = requirePlanManager(ctx);
       const sessionLineageTracker = requireSessionLineageTracker(ctx);
@@ -74,7 +74,6 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
 
       const projectPlanningService = ctx.workspace.projectPlanningService;
       const projectId = ctx.workspace.projectPlanningProjectId;
-      const openProjectPlanningPanel = () => ctx.showPanel?.('project-planning');
 
       if (args.length === 0) {
         if (projectPlanningService && projectId) {
@@ -92,7 +91,6 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
           const planningNamespace = String(
             status[['knowledge', 'SpaceId'].join('') as keyof typeof status] ?? `project:${status.projectId}`,
           );
-          openProjectPlanningPanel();
           ctx.print(
             `Project planning: ${evaluation.readiness}\n` +
             `Project: ${status.projectId}\n` +
@@ -113,8 +111,7 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
       }
 
       if (args[0] === 'panel') {
-        openProjectPlanningPanel();
-        ctx.print('Opened project planning panel.');
+        ctx.print('Planning panels are not part of the Agent workspace. Use /plan status or /plan list.');
         return;
       }
 
@@ -146,7 +143,6 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
           },
         });
         const evaluation = await projectPlanningService.evaluate({ projectId });
-        openProjectPlanningPanel();
         ctx.print(`Project planning approved. Readiness: ${evaluation.readiness}. State: ${result.state?.id ?? 'current'}.`);
         return;
       }
@@ -208,7 +204,6 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
         ? await persistEvaluatedNextQuestion(projectPlanningService, projectId, result.state, initialEvaluation)
         : { state: result.state, evaluation: initialEvaluation };
       sessionLineageTracker.setOriginalTask(taskDescription.slice(0, 200));
-      openProjectPlanningPanel();
 
       ctx.print(
         `Project planning seeded: "${state?.goal ?? taskDescription}"\n` +

package/src/input/commands/provider-accounts-runtime.ts

@@ -4,7 +4,6 @@ import type {
   ProviderAccountSnapshot,
 } from '@/runtime/index.ts';
 import {
-  openCommandPanel,
   requireOperatorClient,
 } from './runtime-services.ts';
 
@@ -25,11 +24,11 @@ export function registerProviderAccountsRuntimeCommands(registry: CommandRegistr
     name: 'accounts',
     aliases: ['account'],
     description: 'Review provider auth routes, subscription windows, and billing-path safety',
-    usage: '[review|panel|show <provider>|routes <provider>|repair <provider>]',
+    usage: '[review|show <provider>|routes <provider>|repair <provider>]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'review').toLowerCase();
       if (sub === 'panel' || sub === 'open') {
-        openCommandPanel(ctx, 'accounts');
+        ctx.print('Provider account panels are not part of the Agent workspace. Use /accounts review.');
         return;
       }
       const snapshot = await loadProviderAccountSnapshot(ctx);

package/src/input/commands/qrcode-runtime.ts

@@ -1,20 +1,59 @@
 import type { CommandRegistry } from '../command-registry.ts';
-import { openCommandPanel } from './runtime-services.ts';
+import { join } from 'node:path';
+import { networkInterfaces } from 'node:os';
+import {
+  buildCompanionConnectionInfo,
+  encodeConnectionPayload,
+  formatConnectionBlock,
+  generateQrMatrix,
+  getOrCreateCompanionToken,
+  renderQrToString,
+} from '@pellux/goodvibes-sdk/platform/pairing';
+import { GOODVIBES_AGENT_PAIRING_SURFACE } from '../../config/surface.ts';
+import { resolveRuntimeEndpointBinding } from '../../cli/endpoints.ts';
+import { requirePlatform, requireShellPaths } from './runtime-services.ts';
+
+function getLocalNetworkIp(): string {
+  try {
+    const nets = networkInterfaces();
+    for (const name of Object.keys(nets)) {
+      for (const netInfo of nets[name] ?? []) {
+        if (netInfo.family === 'IPv4' && !netInfo.internal) return netInfo.address;
+      }
+    }
+  } catch {
+    return '127.0.0.1';
+  }
+  return '127.0.0.1';
+}
+
+function urlHostForBindHost(host: string): string {
+  if (host === '0.0.0.0' || host === '::') return getLocalNetworkIp();
+  return host || '127.0.0.1';
+}
 
-/**
- * Register the /qrcode command.
- *
- * Opens the QR Code panel which displays a scannable QR code for
- * companion app pairing, along with connection URL, token, and username.
- */
 export function registerQrcodeRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'qrcode',
     aliases: ['qr', 'pair'],
-    description: 'Open the QR code panel for companion app pairing',
+    description: 'Print companion pairing details and a QR code',
     usage: '',
     handler(_args, ctx) {
-      openCommandPanel(ctx, 'qr-code');
+      const shellPaths = requireShellPaths(ctx);
+      const configManager = requirePlatform(ctx).configManager;
+      const daemonHomeDir = join(shellPaths.homeDirectory, '.goodvibes', 'daemon');
+      const tokenRecord = getOrCreateCompanionToken(GOODVIBES_AGENT_PAIRING_SURFACE, { daemonHomeDir });
+      const binding = resolveRuntimeEndpointBinding(configManager, 'controlPlane');
+      const daemonUrl = `http://${urlHostForBindHost(binding.host)}:${binding.port}`;
+      const info = buildCompanionConnectionInfo({
+        daemonUrl,
+        token: tokenRecord.token,
+        username: 'admin',
+        surface: GOODVIBES_AGENT_PAIRING_SURFACE,
+      });
+      const payload = encodeConnectionPayload(info);
+      const qr = renderQrToString(generateQrMatrix(payload));
+      ctx.print([formatConnectionBlock(info, payload), '', qr].join('\n'));
     },
   });
 }

package/src/input/commands/recall-bundle.ts

@@ -18,11 +18,11 @@ export function handleRecallExport(args: string[], context: CommandContext): voi
 
   const pathArg = commandArgs[0];
   if (!pathArg) {
-    context.print('[recall] Usage: /recall export <path> [--scope <scope>] [--cls <class>] --yes');
+    context.print('[memory] Usage: /memory export <path> [--scope <scope>] [--cls <class>] --yes');
     return;
   }
   if (!parsed.yes) {
-    requireYesFlag(context, `export durable memory bundle to ${pathArg}`, '/recall export <path> [--scope <scope>] [--cls <class>] --yes');
+    requireYesFlag(context, `export durable memory bundle to ${pathArg}`, '/memory export <path> [--scope <scope>] [--cls <class>] --yes');
     return;
   }
 
@@ -31,7 +31,7 @@ export function handleRecallExport(args: string[], context: CommandContext): voi
   if (scopeIdx !== -1 && commandArgs[scopeIdx + 1]) {
     const scope = commandArgs[scopeIdx + 1];
     if (!isValidScope(scope)) {
-      context.print(`[recall] Unknown scope "${scope}". Valid: ${VALID_SCOPES.join(', ')}`);
+      context.print(`[memory] Unknown scope "${scope}". Valid: ${VALID_SCOPES.join(', ')}`);
       return;
     }
     filter.scope = scope;
@@ -41,7 +41,7 @@ export function handleRecallExport(args: string[], context: CommandContext): voi
   if (clsIdx !== -1 && commandArgs[clsIdx + 1]) {
     const cls = commandArgs[clsIdx + 1];
     if (!isValidClass(cls)) {
-      context.print(`[recall] Unknown class "${cls}". Valid: ${VALID_CLASSES.join(', ')}`);
+      context.print(`[memory] Unknown class "${cls}". Valid: ${VALID_CLASSES.join(', ')}`);
       return;
     }
     filter.cls = cls;
@@ -51,7 +51,7 @@ export function handleRecallExport(args: string[], context: CommandContext): voi
   const targetPath = resolveBundlePath(pathArg, requireShellPaths(context));
   mkdirSync(dirname(targetPath), { recursive: true });
   writeFileSync(targetPath, JSON.stringify(bundle, null, 2) + '\n', 'utf-8');
-  context.print(`[recall] Exported ${bundle.recordCount} record(s) and ${bundle.linkCount} link(s) to ${targetPath}`);
+  context.print(`[memory] Exported ${bundle.recordCount} record(s) and ${bundle.linkCount} link(s) to ${targetPath}`);
 }
 
 export async function handleRecallImport(args: string[], context: CommandContext): Promise<void> {
@@ -64,11 +64,11 @@ export async function handleRecallImport(args: string[], context: CommandContext
 
   const pathArg = commandArgs[0];
   if (!pathArg) {
-    context.print('[recall] Usage: /recall import <path> --yes');
+    context.print('[memory] Usage: /memory import <path> --yes');
     return;
   }
   if (!parsed.yes) {
-    requireYesFlag(context, `import durable memory bundle from ${pathArg}`, '/recall import <path> --yes');
+    requireYesFlag(context, `import durable memory bundle from ${pathArg}`, '/memory import <path> --yes');
     return;
   }
 
@@ -77,12 +77,12 @@ export async function handleRecallImport(args: string[], context: CommandContext
   try {
     bundle = JSON.parse(readFileSync(targetPath, 'utf-8')) as MemoryBundle;
   } catch (error) {
-    context.print(`[recall] Failed to read memory bundle: ${summarizeError(error)}`);
+    context.print(`[memory] Failed to read memory bundle: ${summarizeError(error)}`);
     return;
   }
 
   const result = await memory.importBundle(bundle);
-  context.print(`[recall] Imported bundle from ${targetPath}`);
+  context.print(`[memory] Imported bundle from ${targetPath}`);
   context.print(`  Records: imported=${result.importedRecords} skipped=${result.skippedRecords}`);
   context.print(`  Links:   imported=${result.importedLinks}`);
 }
@@ -106,30 +106,30 @@ export function handleRecallHandoffExport(args: string[], context: CommandContex
   }
   const pathArg = commandArgs[0];
   if (!pathArg) {
-    context.print('[recall] Usage: /recall handoff-export <path> [--scope <scope>] --yes');
+    context.print('[memory] Usage: /memory handoff-export <path> [--scope <scope>] --yes');
     return;
   }
   if (!parsed.yes) {
-    requireYesFlag(context, `export memory handoff bundle to ${pathArg}`, '/recall handoff-export <path> [--scope <scope>] --yes');
+    requireYesFlag(context, `export memory handoff bundle to ${pathArg}`, '/memory handoff-export <path> [--scope <scope>] --yes');
     return;
   }
   const scopeIdx = commandArgs.indexOf('--scope');
   const scopeRaw = scopeIdx !== -1 ? commandArgs[scopeIdx + 1] : 'team';
   if (!scopeRaw || !isValidScope(scopeRaw)) {
-    context.print(`[recall] Unknown scope "${scopeRaw ?? ''}". Valid: ${VALID_SCOPES.join(', ')}`);
+    context.print(`[memory] Unknown scope "${scopeRaw ?? ''}". Valid: ${VALID_SCOPES.join(', ')}`);
     return;
   }
   const bundle = memory.exportBundle({ scope: scopeRaw });
   const targetPath = resolveBundlePath(pathArg, requireShellPaths(context));
   mkdirSync(dirname(targetPath), { recursive: true });
   writeFileSync(targetPath, JSON.stringify(bundle, null, 2) + '\n', 'utf-8');
-  context.print(`[recall] Exported ${scopeRaw} handoff bundle to ${targetPath}`);
+  context.print(`[memory] Exported ${scopeRaw} handoff bundle to ${targetPath}`);
 }
 
 export function handleRecallHandoffInspect(args: string[], context: CommandContext): void {
   const pathArg = args[0];
   if (!pathArg) {
-    context.print('[recall] Usage: /recall handoff-inspect <path>');
+    context.print('[memory] Usage: /memory handoff-inspect <path>');
     return;
   }
   const targetPath = resolveBundlePath(pathArg, requireShellPaths(context));
@@ -137,7 +137,7 @@ export function handleRecallHandoffInspect(args: string[], context: CommandConte
     const bundle = JSON.parse(readFileSync(targetPath, 'utf-8')) as MemoryBundle;
     context.print(inspectBundle(bundle));
   } catch (error) {
-    context.print(`[recall] Failed to inspect handoff bundle: ${summarizeError(error)}`);
+    context.print(`[memory] Failed to inspect handoff bundle: ${summarizeError(error)}`);
   }
 }
 
@@ -146,7 +146,7 @@ export async function handleRecallHandoffImport(args: string[], context: Command
   const commandArgs = [...parsed.rest];
   const pathArg = commandArgs[0];
   if (!pathArg) {
-    context.print('[recall] Usage: /recall handoff-import <path> --yes');
+    context.print('[memory] Usage: /memory handoff-import <path> --yes');
     return;
   }
   await handleRecallImport([pathArg, ...(parsed.yes ? ['--yes'] : [])], context);

package/src/input/commands/recall-capture.ts

@@ -17,7 +17,7 @@ export async function handleRecallAdd(args: string[], context: CommandContext):
 
   const cls = args[0];
   if (!cls || !isValidClass(cls)) {
-    context.print(`[recall] Invalid class "${cls ?? ''}". Valid: ${VALID_CLASSES.join(', ')}`);
+    context.print(`[memory] Invalid class "${cls ?? ''}". Valid: ${VALID_CLASSES.join(', ')}`);
     return;
   }
 
@@ -36,7 +36,7 @@ export async function handleRecallAdd(args: string[], context: CommandContext):
   const scope = scopeRaw && isValidScope(scopeRaw) ? scopeRaw : 'project';
 
   if (scopeRaw && !isValidScope(scopeRaw)) {
-    context.print(`[recall] Invalid scope "${scopeRaw}". Valid: ${VALID_SCOPES.join(', ')}`);
+    context.print(`[memory] Invalid scope "${scopeRaw}". Valid: ${VALID_SCOPES.join(', ')}`);
     return;
   }
 
@@ -55,12 +55,12 @@ export async function handleRecallAdd(args: string[], context: CommandContext):
   }
   const summary = summaryTokens.join(' ');
   if (!summary.trim()) {
-    context.print('[recall] Usage: /recall add <class> <summary> [--detail <text>] [--tags <t1,t2>]');
+    context.print('[memory] Usage: /memory add <class> <summary> [--detail <text>] [--tags <t1,t2>]');
     return;
   }
 
   const record = await memory.add({ scope, cls, summary, detail, tags, provenance });
-  context.print(`[recall] Added ${cls}: ${record.id}`);
+  context.print(`[memory] Added ${cls}: ${record.id}`);
   context.print(`  Scope:   ${record.scope}`);
   context.print(`  Summary: ${record.summary}`);
   if (record.tags.length) context.print(`  Tags: ${record.tags.join(', ')}`);
@@ -76,7 +76,7 @@ export async function handleRecallCapture(args: string[], context: CommandContex
     return;
   }
   if (!context.extensions.forensicsRegistry) {
-    context.print('[recall] Forensics registry not available.');
+    context.print('[memory] Forensics registry not available.');
     return;
   }
 
@@ -87,66 +87,66 @@ export async function handleRecallCapture(args: string[], context: CommandContex
       ? context.extensions.forensicsRegistry.latest()
       : context.extensions.forensicsRegistry.getById(requestedId);
     if (!report) {
-      context.print(`[recall] Incident not found: ${requestedId ?? 'latest'}`);
+      context.print(`[memory] Incident not found: ${requestedId ?? 'latest'}`);
       return;
     }
     const bundle = context.extensions.forensicsRegistry.buildBundle(report.id);
     if (!bundle) {
-      context.print(`[recall] Failed to build incident bundle: ${report.id}`);
+      context.print(`[memory] Failed to build incident bundle: ${report.id}`);
       return;
     }
     const record = await memory.add(buildIncidentMemoryAddOptions(bundle));
-    context.print(`[recall] Captured incident ${report.id} into memory as ${record.id}`);
+    context.print(`[memory] Captured incident ${report.id} into memory as ${record.id}`);
     return;
   }
 
   if (target === 'policy') {
     const review = context.extensions.policyRuntimeState?.getSnapshot().lastPreflightReview;
     if (!review) {
-      context.print('[recall] No policy preflight review is available to capture.');
+      context.print('[memory] No policy preflight review is available to capture.');
       return;
     }
     const record = await memory.add(buildPolicyPreflightMemoryAddOptions(review));
-    context.print(`[recall] Captured policy preflight into memory as ${record.id}`);
+    context.print(`[memory] Captured policy preflight into memory as ${record.id}`);
     return;
   }
 
   if (target === 'mcp') {
     const serverName = args[1];
     if (!serverName) {
-      context.print('[recall] Usage: /recall capture mcp <server>');
+      context.print('[memory] Usage: /memory capture mcp <server>');
       return;
     }
     const server = context.extensions.mcpRegistry.listServerSecurity().find((entry) => entry.name === serverName);
     if (!server) {
-      context.print(`[recall] MCP server not found: ${serverName}`);
+      context.print(`[memory] MCP server not found: ${serverName}`);
       return;
     }
     const record = await memory.add(buildMcpSecurityMemoryAddOptions(server));
-    context.print(`[recall] Captured MCP server ${server.name} into memory as ${record.id}`);
+    context.print(`[memory] Captured MCP server ${server.name} into memory as ${record.id}`);
     return;
   }
 
   if (target === 'plugin') {
     if (!pluginManager) {
-      context.print('[recall] Plugin manager not available.');
+      context.print('[memory] Plugin manager not available.');
       return;
     }
     const pluginName = args[1];
     if (!pluginName) {
-      context.print('[recall] Usage: /recall capture plugin <name>');
+      context.print('[memory] Usage: /memory capture plugin <name>');
       return;
     }
     const plugin = pluginManager.list().find((entry) => entry.name === pluginName);
     if (!plugin) {
-      context.print(`[recall] Plugin not found: ${pluginName}`);
+      context.print(`[memory] Plugin not found: ${pluginName}`);
       return;
     }
     const quarantineReason = pluginManager.getQuarantineRecord(plugin.name)?.reason;
     const record = await memory.add(buildPluginSecurityMemoryAddOptions(plugin, quarantineReason));
-    context.print(`[recall] Captured plugin ${plugin.name} into memory as ${record.id}`);
+    context.print(`[memory] Captured plugin ${plugin.name} into memory as ${record.id}`);
     return;
   }
 
-  context.print('[recall] Usage: /recall capture incident <id|latest> | /recall capture policy | /recall capture mcp <server> | /recall capture plugin <name>');
+  context.print('[memory] Usage: /memory capture incident <id|latest> | /memory capture policy | /memory capture mcp <server> | /memory capture plugin <name>');
 }

package/src/input/commands/recall-query.ts

@@ -7,8 +7,8 @@ import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 export function getMemoryApi(context: CommandContext): MemoryApi | null {
   const memoryApi = context.clients?.agentKnowledgeApi?.memory;
   if (!memoryApi) {
-    context.print('[recall] Agent Memory API is not available in this runtime.');
-    context.print('[recall] Refusing to use default Knowledge/Wiki or non-Agent knowledge fallback.');
+    context.print('[memory] Agent Memory API is not available in this runtime.');
+    context.print('[memory] Refusing to use default Knowledge/Wiki or non-Agent knowledge fallback.');
     return null;
   }
   return memoryApi;
@@ -29,7 +29,7 @@ export function handleRecallSearch(args: string[], context: CommandContext): voi
     const cls = args[clsIdx + 1];
     if (isValidClass(cls)) filter.cls = cls;
     else {
-      context.print(`[recall] Unknown class "${cls}". Valid: ${VALID_CLASSES.join(', ')}`);
+      context.print(`[memory] Unknown class "${cls}". Valid: ${VALID_CLASSES.join(', ')}`);
       return;
     }
   }
@@ -39,7 +39,7 @@ export function handleRecallSearch(args: string[], context: CommandContext): voi
     const scope = args[scopeIdx + 1];
     if (isValidScope(scope)) filter.scope = scope;
     else {
-      context.print(`[recall] Unknown scope "${scope}". Valid: ${VALID_SCOPES.join(', ')}`);
+      context.print(`[memory] Unknown scope "${scope}". Valid: ${VALID_SCOPES.join(', ')}`);
       return;
     }
   }
@@ -59,11 +59,11 @@ export function handleRecallSearch(args: string[], context: CommandContext): voi
   const semanticResults = semantic ? memory.searchSemantic(filter) : [];
   const results = semantic ? semanticResults.map((entry) => entry.record) : memory.search(filter);
   if (!results.length) {
-    context.print('[recall] No records found.');
+    context.print('[memory] No records found.');
     return;
   }
 
-  context.print(`[recall] ${results.length} ${semantic ? 'semantic ' : ''}record(s):`);
+  context.print(`[memory] ${results.length} ${semantic ? 'semantic ' : ''}record(s):`);
   for (const record of results) {
     const semanticEntry = semanticResults.find((entry) => entry.record.id === record.id);
     const ts = new Date(record.createdAt).toISOString().slice(0, 16).replace('T', ' ');
@@ -93,7 +93,7 @@ export function handleRecallVector(args: string[], context: CommandContext): voi
     context.print(formatVectorStats(memory.vectorStats(), sub));
     return;
   }
-  context.print('[recall] Usage: /recall vector [status|doctor|rebuild]');
+  context.print('[memory] Usage: /memory vector [status|doctor|rebuild]');
 }
 
 function formatVectorStats(
@@ -101,7 +101,7 @@ function formatVectorStats(
   label: string,
 ): string {
   return [
-    `[recall] Vector index ${label}`,
+    `[memory] Vector index ${label}`,
     `  backend: ${stats.backend}`,
     `  enabled: ${stats.enabled ? 'yes' : 'no'}`,
     `  available: ${stats.available ? 'yes' : 'no'}`,
@@ -119,16 +119,16 @@ export function handleRecallGet(args: string[], context: CommandContext): void {
   }
   const id = args[0];
   if (!id) {
-    context.print('[recall] Usage: /recall get <id>');
+    context.print('[memory] Usage: /memory get <id>');
     return;
   }
   const record = memory.get(id);
   if (!record) {
-    context.print(`[recall] Record not found: ${id}`);
+    context.print(`[memory] Record not found: ${id}`);
     return;
   }
   const ts = new Date(record.createdAt).toISOString().slice(0, 19).replace('T', ' ');
-  context.print(`[recall] ${record.id}`);
+  context.print(`[memory] ${record.id}`);
   context.print(`  Scope:   ${record.scope}`);
   context.print(`  Class:   ${record.cls}`);
   context.print(`  Summary: ${record.summary}`);
@@ -163,19 +163,19 @@ export async function handleRecallLink(args: string[], context: CommandContext):
   const parsed = stripYesFlag(args);
   const [fromId, toId, relation] = parsed.rest;
   if (!fromId || !toId || !relation) {
-    context.print('[recall] Usage: /recall link <fromId> <toId> <relation> --yes');
+    context.print('[memory] Usage: /memory link <fromId> <toId> <relation> --yes');
     return;
   }
   if (!parsed.yes) {
-    requireYesFlag(context, `link memory records ${fromId} and ${toId}`, '/recall link <fromId> <toId> <relation> --yes');
+    requireYesFlag(context, `link memory records ${fromId} and ${toId}`, '/memory link <fromId> <toId> <relation> --yes');
     return;
   }
   const link = await memory.link(fromId, toId, relation);
   if (!link) {
-    context.print('[recall] Link failed — check that both IDs exist.');
+    context.print('[memory] Link failed — check that both IDs exist.');
     return;
   }
-  context.print(`[recall] Linked: ${fromId} -> ${toId} [${relation}]`);
+  context.print(`[memory] Linked: ${fromId} -> ${toId} [${relation}]`);
 }
 
 export function handleRecallRemove(args: string[], context: CommandContext): void {
@@ -186,19 +186,19 @@ export function handleRecallRemove(args: string[], context: CommandContext): voi
   const parsed = stripYesFlag(args);
   const id = parsed.rest[0];
   if (!id) {
-    context.print('[recall] Usage: /recall remove <id> --yes');
+    context.print('[memory] Usage: /memory remove <id> --yes');
     return;
   }
   if (!parsed.yes) {
-    requireYesFlag(context, `delete durable memory record ${id}`, '/recall remove <id> --yes');
+    requireYesFlag(context, `delete durable memory record ${id}`, '/memory remove <id> --yes');
     return;
   }
   const removed = memory.delete(id);
   if (!removed) {
-    context.print(`[recall] Record not found: ${id}`);
+    context.print(`[memory] Record not found: ${id}`);
     return;
   }
-  context.print(`[recall] Deleted: ${id}`);
+  context.print(`[memory] Deleted: ${id}`);
 }
 
 export function handleRecallList(args: string[], context: CommandContext): void {
@@ -213,7 +213,7 @@ export function handleRecallList(args: string[], context: CommandContext): void
   if (scopeIdx !== -1 && args[scopeIdx + 1]) {
     const scope = args[scopeIdx + 1];
     if (!isValidScope(scope)) {
-      context.print(`[recall] Unknown scope "${scope}". Valid: ${VALID_SCOPES.join(', ')}`);
+      context.print(`[memory] Unknown scope "${scope}". Valid: ${VALID_SCOPES.join(', ')}`);
       return;
     }
     filter.scope = scope;
@@ -221,7 +221,7 @@ export function handleRecallList(args: string[], context: CommandContext): void
 
   const records = memory.search(filter);
   if (!records.length) {
-    context.print('[recall] No records.');
+    context.print('[memory] No records.');
     return;
   }
 
@@ -232,7 +232,7 @@ export function handleRecallList(args: string[], context: CommandContext): void
   }
 
   for (const [clsName, group] of Object.entries(grouped)) {
-    context.print(`\n[recall] ${clsName.toUpperCase()} (${group.length}):`);
+    context.print(`\n[memory] ${clsName.toUpperCase()} (${group.length}):`);
     for (const record of group) {
       const tagStr = record.tags.length ? ` [${record.tags.join(', ')}]` : '';
       context.print(`  ${record.id} [${record.scope}]${tagStr}  ${record.summary}`);