@pellux/goodvibes-agent 0.1.111 → 0.1.112

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

@@ -7,7 +7,6 @@ import { buildProviderAccountSnapshot } from '@/runtime/index.ts';
 import { getSettingsControlPlaneSnapshot } from '@/runtime/index.ts';
 import { checkRecoveryFile, readLastSessionPointer } from '@/runtime/index.ts';
 import {
-  openCommandPanel,
   requireOperatorClient,
   requireProviderApi,
   requireReadModels,
@@ -22,16 +21,37 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
     name: 'health',
     aliases: ['doctor'],
     description: 'Health workspace for startup posture, service readiness, provider health, and Agent continuity',
-    usage: '[open|review|setup|services|provider|accounts|auth|settings|remote|mcp|continuity|maintenance|repair [domain]]',
+    usage: '[review|setup|services|provider|accounts|auth|settings|remote|mcp|continuity|maintenance|repair [domain]]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'review').toLowerCase();
-      const readModels = requireReadModels(ctx);
 
-      if (sub === 'open' || sub === 'panel' || sub === 'provider') {
-        openCommandPanel(ctx, 'provider-health');
+      if (sub === 'open' || sub === 'panel') {
+        ctx.print('Health panels are not part of the Agent workspace. Use /health review.');
         return;
       }
 
+      if (sub === 'provider') {
+        const providerApi = requireProviderApi(ctx);
+        const currentModel = await providerApi.getCurrentModel().catch(() => null);
+        const accounts = await requireOperatorClient(ctx).providers.accountSnapshot();
+        ctx.print([
+          'Health Review: Provider',
+          `  selected model: ${currentModel?.registryKey ?? 'unknown'}`,
+          `  providers: ${providerApi.listProviderIds().length}`,
+          `  configured accounts: ${accounts.configuredCount}`,
+          `  account issues: ${accounts.issueCount}`,
+          ...(accounts.issueCount > 0
+            ? accounts.providers.flatMap((provider) => provider.issues.map((issue) => `  ${provider.providerId}: ${issue}`))
+            : ['  no provider account issues detected']),
+          '  next: /model',
+          '  next: /provider',
+          '  next: /accounts review',
+        ].join('\n'));
+        return;
+      }
+
+      const readModels = requireReadModels(ctx);
+
       if (sub === 'services') {
         const registry = requireServiceRegistry(ctx);
         const all = registry.getAll();
@@ -318,7 +338,7 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
         ...(snapshot.serviceIssues.length > 0 ? ['', ...snapshot.serviceIssues.map((issue) => `  service: ${issue}`)] : []),
         '',
         'Next steps:',
-        '  /health open',
+        '  /health review',
         '  /health services',
         '  /health accounts',
         '  /health auth',

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

@@ -137,8 +137,8 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
     name: 'mcp',
     aliases: [],
     description: 'Manage MCP servers and their tools',
-    usage: '[add|remove|reload|config|review|tools [<server>]|auth-review|repair [server]]',
-    argsHint: '[review|tools|config|add --yes|remove --yes]',
+    usage: '[servers|review|tools [<server>]|config|add|remove|reload|auth-review|repair [server]]',
+    argsHint: '[servers|review|tools|config|add --yes|remove --yes]',
     async handler(args, ctx) {
       const mcpApi = requireMcpApi(ctx);
       const listServerSecurity = () => mcpApi.listServerSecurity();
@@ -163,6 +163,25 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
         ].join('\n'));
         return;
       }
+      if (subcommand === 'servers') {
+        const servers = listServerSecurity();
+        if (servers.length === 0) {
+          ctx.print(
+            'No MCP servers configured.\n'
+            + 'Add servers to one of these locations (scanned in order):\n'
+            + '  ~/.config/mcp/mcp.json               (global XDG)\n'
+            + '  ~/.mcp/mcp.json                      (global dotdir)\n'
+            + '  ~/.config/claude/claude_desktop_config.json  (Claude Desktop)\n'
+            + '  .mcp/mcp.json                        (project-local)\n'
+            + '  .goodvibes/mcp.json                  (goodvibes project)\n'
+            + '\nAdd one from inside Agent with explicit confirmation:\n'
+            + '  /mcp add filesystem npx -y @modelcontextprotocol/server-filesystem . --scope project --role filesystem --yes'
+          );
+          return;
+        }
+        ctx.print(formatMcpServerList(servers));
+        return;
+      }
       if (subcommand === 'tools') {
         const filterServer = commandArgs[1];
         ctx.print('Fetching MCP tool list...');
@@ -434,30 +453,36 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
-      const connected = servers.filter(s => s.connected);
-      const disconnected = servers.filter(s => !s.connected);
-      const lines: string[] = [`MCP Servers (${connected.length}/${servers.length} connected):`];
-      for (const s of servers) {
-        const pathScope = s.allowedPaths.length > 0 ? ` paths=${s.allowedPaths.length}` : '';
-        const hostScope = s.allowedHosts.length > 0 ? ` hosts=${s.allowedHosts.length}` : '';
-        const freshness = ` freshness=${s.schemaFreshness}`;
-        const quarantine = s.schemaFreshness === 'quarantined' ? ` quarantine=${s.quarantineReason ?? 'unknown'}` : '';
-        lines.push(`  ${s.connected ? '[connected]   ' : '[disconnected]'}  ${s.name}  trust=${s.trustMode}  role=${s.role}${freshness}${quarantine}${pathScope}${hostScope}`);
-      }
-      if (connected.length > 0) {
-        lines.push('');
-        lines.push('Run "/mcp tools" to list all tools, or "/mcp tools <server>" for a specific server.');
-        lines.push('Run "/mcp" to open the fullscreen MCP workspace, or "/mcp add <name> <command> [args...] [--scope project|global] --yes" to add/update.');
-        lines.push('Run "/mcp reload --yes" after editing MCP config outside Agent.');
-        lines.push('Run "/mcp trust <server> <mode> --yes" to change trust mode, or "/mcp role <server> <role> --yes" to change its coherence role.');
-        lines.push('Run "/mcp quarantine <server> [detail] --yes" to block a server, or "/mcp quarantine <server> approve [operatorId] --yes" to approve a temporary override.');
-        lines.push('Use /settings → MCP to explicitly enable allow-all for a server.');
-      }
-      if (disconnected.length > 0) {
-        lines.push('');
-        lines.push(`${disconnected.length} server(s) failed to connect. Check server command and args in your config.`);
-      }
-      ctx.print(lines.join('\n'));
+      ctx.print(formatMcpServerList(servers));
     },
   });
 }
+
+type McpSecurityServer = ReturnType<NonNullable<NonNullable<CommandContext['clients']>['mcpApi']>['listServerSecurity']>[number];
+
+function formatMcpServerList(servers: readonly McpSecurityServer[]): string {
+  const connected = servers.filter(s => s.connected);
+  const disconnected = servers.filter(s => !s.connected);
+  const lines: string[] = [`MCP Servers (${connected.length}/${servers.length} connected):`];
+  for (const s of servers) {
+    const pathScope = s.allowedPaths.length > 0 ? ` paths=${s.allowedPaths.length}` : '';
+    const hostScope = s.allowedHosts.length > 0 ? ` hosts=${s.allowedHosts.length}` : '';
+    const freshness = ` freshness=${s.schemaFreshness}`;
+    const quarantine = s.schemaFreshness === 'quarantined' ? ` quarantine=${s.quarantineReason ?? 'unknown'}` : '';
+    lines.push(`  ${s.connected ? '[connected]   ' : '[disconnected]'}  ${s.name}  trust=${s.trustMode}  role=${s.role}${freshness}${quarantine}${pathScope}${hostScope}`);
+  }
+  if (connected.length > 0) {
+    lines.push('');
+    lines.push('Run "/mcp tools" to list all tools, or "/mcp tools <server>" for a specific server.');
+    lines.push('Run "/mcp" to open the fullscreen MCP workspace, or "/mcp add <name> <command> [args...] [--scope project|global] --yes" to add/update.');
+    lines.push('Run "/mcp reload --yes" after editing MCP config outside Agent.');
+    lines.push('Run "/mcp trust <server> <mode> --yes" to change trust mode, or "/mcp role <server> <role> --yes" to change its coherence role.');
+    lines.push('Run "/mcp quarantine <server> [detail] --yes" to block a server, or "/mcp quarantine <server> approve [operatorId] --yes" to approve a temporary override.');
+    lines.push('Use /settings -> MCP to explicitly enable allow-all for a server.');
+  }
+  if (disconnected.length > 0) {
+    lines.push('');
+    lines.push(`${disconnected.length} server(s) failed to connect. Check server command and args in your config.`);
+  }
+  return lines.join('\n');
+}

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