@pellux/goodvibes-tui 0.18.4

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

@@ -0,0 +1,207 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import type { CommandRegistry } from '../command-registry.ts';
+import type { SelectionAction, SelectionItem } from '../selection-modal.ts';
+import { openCommandPanel, requireServiceRegistry, requireShellPaths } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+
+export function registerServicesRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'services',
+    aliases: ['svc'],
+    description: 'Manage API service configurations',
+    usage: '[open|list|inspect <name>|test <name>|resolve <name>|auth <name>|auth-review|doctor|export <path>|import <path>]',
+    async handler(args, ctx) {
+      const sub = args[0] ?? 'open';
+      const shellPaths = requireShellPaths(ctx);
+      if (sub === 'open' || sub === 'panel') {
+        openCommandPanel(ctx, 'services');
+        return;
+      }
+      const svcRegistry = requireServiceRegistry(ctx);
+      const all = svcRegistry.getAll();
+      const keys = Object.keys(all);
+      if (sub === 'inspect') {
+        const name = args[1];
+        if (!name) {
+          ctx.print('Usage: /services inspect <name>');
+          return;
+        }
+        const inspection = await svcRegistry.inspect(name);
+        if (!inspection) {
+          ctx.print(`Unknown service: ${name}`);
+          return;
+        }
+        ctx.print([
+          `Service ${name}`,
+          `  authType: ${inspection.config.authType}`,
+          `  baseUrl: ${inspection.config.baseUrl ?? '(none)'}`,
+          `  primaryCredential: ${inspection.hasPrimaryCredential ? 'present' : 'missing'}`,
+          `  passwordCredential: ${inspection.hasPasswordCredential ? 'present' : 'missing'}`,
+          `  webhookUrl: ${inspection.hasWebhookUrl ? 'present' : 'missing'}`,
+          `  signingSecret: ${inspection.hasSigningSecret ? 'present' : 'missing'}`,
+          `  publicKey: ${inspection.hasPublicKey ? 'present' : 'missing'}`,
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'test') {
+        const name = args[1];
+        if (!name) {
+          ctx.print('Usage: /services test <name>');
+          return;
+        }
+        const result = await svcRegistry.testConnection(name);
+        ctx.print([
+          `Service test ${name}`,
+          `  ok: ${result.ok ? 'yes' : 'no'}`,
+          `  status: ${result.status ?? 'n/a'}`,
+          `  url: ${result.testedUrl ?? 'n/a'}`,
+          `  error: ${result.error ?? 'none'}`,
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'resolve') {
+        const name = args[1];
+        if (!name) {
+          ctx.print('Usage: /services resolve <name>');
+          return;
+        }
+        const headers = await svcRegistry.resolveAuth(name);
+        if (!headers) {
+          ctx.print(`Service ${name} has no resolvable auth headers right now.`);
+          return;
+        }
+        ctx.print([
+          `Resolved auth headers for ${name}`,
+          ...Object.keys(headers).map((key) => `  ${key}: <redacted>`),
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'auth') {
+        const name = args[1];
+        if (!name) {
+          ctx.print('Usage: /services auth <name>');
+          return;
+        }
+        const headers = await svcRegistry.resolveAuth(name);
+        if (!headers) {
+          ctx.print(`Service ${name} has no resolvable auth headers right now.`);
+          return;
+        }
+        ctx.print([
+          `Service auth ${name}`,
+          ...Object.keys(headers).map((key) => `  ${key}: <resolved>`),
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'doctor') {
+        const inspections = await Promise.all(keys.map((name) => svcRegistry.inspect(name)));
+        const issues = inspections
+          .filter((inspection): inspection is NonNullable<typeof inspection> => inspection !== null)
+          .flatMap((inspection) => {
+            const findings: string[] = [];
+            if (!inspection.hasPrimaryCredential) findings.push(`${inspection.config.name}: missing primary credential`);
+            if (inspection.config.authType === 'basic' && !inspection.hasPasswordCredential) findings.push(`${inspection.config.name}: missing password credential`);
+            if (!inspection.config.baseUrl) findings.push(`${inspection.config.name}: no baseUrl configured`);
+            return findings;
+          });
+        ctx.print([
+          'Service Doctor',
+          `  configured: ${keys.length}`,
+          `  issues: ${issues.length}`,
+          ...(issues.length > 0 ? issues.map((issue) => `  ${issue}`) : ['  all configured services passed readiness checks']),
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'auth-review') {
+        const inspections = await Promise.all(keys.map((name) => svcRegistry.inspect(name)));
+        const authCounts = new Map<string, number>();
+        const issues = inspections
+          .filter((inspection): inspection is NonNullable<typeof inspection> => inspection !== null)
+          .flatMap((inspection) => {
+            authCounts.set(inspection.config.authType, (authCounts.get(inspection.config.authType) ?? 0) + 1);
+            const findings: string[] = [];
+            if (!inspection.config.baseUrl) findings.push(`${inspection.config.name}: missing baseUrl`);
+            if ((inspection.config.authType === 'bearer' || inspection.config.authType === 'api-key') && !inspection.hasPrimaryCredential) {
+              findings.push(`${inspection.config.name}: missing primary credential`);
+            }
+            if (inspection.config.authType === 'basic' && !inspection.hasPasswordCredential) {
+              findings.push(`${inspection.config.name}: missing password credential`);
+            }
+            return findings;
+          });
+        ctx.print([
+          'Service Auth Review',
+          `  configured: ${keys.length}`,
+          ...[...authCounts.entries()].map(([authType, count]) => `  ${authType}: ${count}`),
+          ...(issues.length > 0 ? ['', ...issues.map((issue) => `  issue: ${issue}`)] : ['', '  all configured services have a complete auth posture']),
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'export') {
+        const pathArg = args[1];
+        if (!pathArg) {
+          ctx.print('Usage: /services export <path>');
+          return;
+        }
+        const targetPath = shellPaths.resolveWorkspacePath(pathArg);
+        mkdirSync(dirname(targetPath), { recursive: true });
+        writeFileSync(targetPath, JSON.stringify(all, null, 2) + '\n', 'utf-8');
+        ctx.print(`Exported services config to ${targetPath}`);
+        return;
+      }
+      if (sub === 'import') {
+        const pathArg = args[1];
+        if (!pathArg) {
+          ctx.print('Usage: /services import <path>');
+          return;
+        }
+        const sourcePath = shellPaths.resolveWorkspacePath(pathArg);
+        try {
+          const parsed = JSON.parse(readFileSync(sourcePath, 'utf-8')) as Record<string, unknown>;
+          const targetPath = shellPaths.resolveProjectPath('tui', 'services.json');
+          mkdirSync(dirname(targetPath), { recursive: true });
+          writeFileSync(targetPath, JSON.stringify(parsed, null, 2) + '\n', 'utf-8');
+          ctx.print(`Imported services config from ${sourcePath}`);
+        } catch (error) {
+          ctx.print(`Failed to import services config: ${summarizeError(error)}`);
+        }
+        return;
+      }
+      if (ctx.openSelection) {
+        const testAction = new Map<string, SelectionAction>([['t', 'select' as const]]);
+        const items: SelectionItem[] = keys.length === 0
+          ? [{ id: '_empty', label: 'No services configured', detail: '.goodvibes/tui/services.json' }]
+          : keys.map((key) => ({ id: key, label: all[key].name ?? key, detail: `${all[key].authType}  ${all[key].baseUrl ?? '(no url)'}`, actions: '[t] test' }));
+        ctx.openSelection('Services', items, { allowSearch: true, customActions: testAction }, (result) => {
+          if (!result || result.item.id === '_empty') return;
+          const svc = all[result.item.id];
+          if (!svc) return;
+          if (result.action === 'select') {
+            void svcRegistry.testConnection(result.item.id).then((testResult) => {
+              ctx.print([
+                `Service test ${result.item.id}`,
+                `  ok: ${testResult.ok ? 'yes' : 'no'}`,
+                `  status: ${testResult.status ?? 'n/a'}`,
+                `  url: ${testResult.testedUrl ?? 'n/a'}`,
+                `  error: ${testResult.error ?? 'none'}`,
+              ].join('\n'));
+            });
+            return;
+          }
+          ctx.print([
+            `Service ${result.item.id}`,
+            `  authType: ${svc.authType}`,
+            `  baseUrl: ${svc.baseUrl ?? '(none)'}`,
+          ].join('\n'));
+        });
+        return;
+      }
+      if (keys.length === 0) {
+        ctx.print('[services] No services configured. Add entries to .goodvibes/tui/services.json');
+        return;
+      }
+      ctx.print(['Services:', '', ...keys.map((key) => `  ${key.padEnd(20)} ${all[key].authType.padEnd(10)} ${all[key].baseUrl ?? '(no url)'}`)].join('\n'));
+    },
+  });
+}

package/src/input/commands/session-content.ts

@@ -0,0 +1,408 @@
+import { join, resolve } from 'path';
+import { existsSync, mkdirSync, unlinkSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import type { CommandRegistry } from '../command-registry.ts';
+import type { SelectionItem } from '../selection-modal.ts';
+import { exportToMarkdown } from '../../export/markdown.ts';
+import { TemplateManager, parseTemplateArgs } from '../../templates/manager.ts';
+import { requireSessionManager, requireSessionMemoryStore, requireShellPaths } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+
+export function registerSessionContentCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'export',
+    description: 'Export conversation to a Markdown file',
+    usage: '[format] [path]',
+    argsHint: '[markdown] [path]',
+    async handler(args, ctx) {
+      const shellPaths = requireShellPaths(ctx);
+      let format = 'markdown';
+      let outPath: string | undefined;
+      for (const arg of args) {
+        if (arg === 'markdown' || arg === 'md' || arg === 'text' || arg === 'txt') {
+          format = arg === 'md' ? 'markdown' : arg === 'txt' ? 'text' : arg;
+        } else {
+          outPath = arg;
+        }
+      }
+      if (!outPath) {
+        const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        outPath = `./conversation-${ts}.${format === 'markdown' ? 'md' : 'txt'}`;
+      }
+      const resolvedPath = shellPaths.resolveWorkspacePath(outPath);
+      if (!shellPaths.isWithinWorkingDirectory(resolvedPath)) {
+        ctx.print('Error: Export path must be within the current directory.');
+        return;
+      }
+
+      try {
+        const data = ctx.session.conversationManager.toJSON() as { messages: Array<Record<string, unknown>> };
+        const msgs = data.messages ?? [];
+        let fileContent: string;
+        if (format === 'markdown') {
+          const exportMsgs = msgs.map(m => ({
+            role: String(m.role ?? 'user') as 'user' | 'assistant' | 'system' | 'tool',
+            content: Array.isArray(m.content)
+              ? m.content as import('../../providers/interface.ts').ContentPart[]
+              : String(m.content ?? ''),
+            toolCalls: m.toolCalls as import('@pellux/goodvibes-sdk/platform/types/tools').ToolCall[] | undefined,
+            callId: m.callId as string | undefined,
+            toolName: m.toolName as string | undefined,
+            reasoningContent: m.reasoningContent as string | undefined,
+            reasoningSummary: m.reasoningSummary as string | undefined,
+            usage: m.usage as { inputTokens: number; outputTokens: number; cacheReadTokens?: number; cacheWriteTokens?: number } | undefined,
+          }));
+          fileContent = exportToMarkdown(exportMsgs, {
+            model: ctx.session.runtime.model,
+            provider: ctx.session.runtime.provider,
+            sessionId: ctx.session.runtime.sessionId,
+            title: ctx.session.conversationManager.title || undefined,
+          });
+        } else {
+          const lines: string[] = [];
+          for (const m of msgs) {
+            const role = String(m.role ?? 'unknown').toUpperCase();
+            const content = typeof m.content === 'string' ? m.content : '';
+            if (!content.trim()) continue;
+            lines.push(`[${role}]`);
+            lines.push(content);
+            lines.push('');
+          }
+          fileContent = lines.join('\n');
+        }
+        const { dirname } = await import('node:path');
+        const dir = dirname(resolvedPath);
+        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+        await writeFile(resolvedPath, fileContent, 'utf-8');
+        ctx.print(`Exported ${msgs.length} messages to: ${resolvedPath}`);
+      } catch (err) {
+        ctx.print(`Export failed: ${summarizeError(err)}`);
+      }
+    },
+  });
+
+  registry.register({
+    name: 'title',
+    description: 'Show or set the conversation title',
+    usage: '[text]',
+    argsHint: '[text]',
+    handler(args, ctx) {
+      if (args.length === 0) ctx.print(ctx.session.conversationManager.title ? `Conversation title: ${ctx.session.conversationManager.title}` : 'No title set.');
+      else {
+        ctx.session.conversationManager.title = args.join(' ');
+        ctx.print(`Title set to: ${ctx.session.conversationManager.title}`);
+        ctx.renderRequest();
+      }
+    },
+  });
+
+  registry.register({
+    name: 'save',
+    description: 'Save current session to .goodvibes/tui/sessions/',
+    usage: '[name]',
+    argsHint: '[name]',
+    handler(args, ctx) {
+      const sessionManager = requireSessionManager(ctx);
+      const rawName = args[0] || ctx.session.conversationManager.title || `session-${Date.now()}`;
+      const exportData = ctx.session.conversationManager.toJSON() as { messages: object[] };
+      const messages = exportData.messages ?? [];
+      const meta = {
+        title: ctx.session.conversationManager.title,
+        model: ctx.session.runtime.model,
+        provider: ctx.session.runtime.provider,
+        timestamp: Date.now(),
+      };
+      try {
+        const agentManager = ctx.ops.agentManager;
+        if (!agentManager) {
+          ctx.print('Agent manager is not available in this runtime.');
+          return;
+        }
+        const agentRecords = agentManager.exportState();
+        const { filePath, sanitizedName } = sessionManager.save(rawName, messages, meta, agentRecords);
+        ctx.print(`Session saved: ${rawName}${sanitizedName !== rawName ? ` (saved as "${sanitizedName}")` : ''}${agentRecords.length > 0 ? ` [${agentRecords.length} agent records]` : ''}\n  → ${filePath}`);
+      } catch (e) {
+        ctx.print(`Failed to save session: ${summarizeError(e)}`);
+      }
+    },
+  });
+
+  registry.register({
+    name: 'load',
+    description: 'Load a saved session',
+    usage: '<name>',
+    argsHint: '<name>',
+    handler(args, ctx) {
+      if (!args[0]) {
+        ctx.print('Usage: /load <session-name>\nRun /sessions to list available sessions.');
+        return;
+      }
+      const sessionManager = requireSessionManager(ctx);
+      try {
+        const { meta, messages, agentRecords } = sessionManager.load(args[0]);
+        const agentManager = ctx.ops.agentManager;
+        if (!agentManager) {
+          ctx.print('Agent manager is not available in this runtime.');
+          return;
+        }
+        ctx.session.conversationManager.resetAll();
+        ctx.session.conversationManager.fromJSON({ messages: messages as never[] });
+        if (meta.title) ctx.session.conversationManager.title = meta.title;
+        ctx.session.conversationManager.rebuildHistory();
+        agentManager.clear();
+        if (agentRecords.length > 0) agentManager.importState(agentRecords);
+        ctx.renderRequest();
+        ctx.print(`Session loaded: ${args[0]} (${messages.length} messages)${agentRecords.length > 0 ? ` [${agentRecords.length} agent records restored]` : ''}`);
+      } catch (e) {
+        ctx.print(`Failed to load session: ${summarizeError(e)}`);
+      }
+    },
+  });
+
+  registry.register({
+    name: 'undo',
+    aliases: ['u'],
+    description: 'Undo last action. /undo file — revert last file write/edit. /undo — remove last conversation turn.',
+    usage: '[file]',
+    argsHint: '[file]',
+    handler(args, ctx) {
+      if (args[0] === 'file') {
+        if (!ctx.workspace.fileUndoManager) {
+          ctx.print('File undo not available.');
+          return;
+        }
+        try {
+          const result = ctx.workspace.fileUndoManager.undo();
+          ctx.print(result ? `File reverted: ${result.path} (${result.tool} tool). Use /redo file to re-apply.` : 'Nothing to undo. No file operations recorded.');
+        } catch (err) {
+          ctx.print(`File undo failed: ${summarizeError(err)}`);
+        }
+        return;
+      }
+      const success = ctx.session.conversationManager.undo();
+      if (success) {
+        ctx.print('Last turn undone. Use /redo to restore. Tip: /undo file to revert a file write/edit.');
+        ctx.renderRequest();
+      } else {
+        ctx.print('Nothing to undo. Tip: use /undo file to revert the last file write/edit.');
+      }
+    },
+  });
+
+  registry.register({
+    name: 'redo',
+    description: 'Redo last undone action. /redo file — re-apply last reverted file. /redo — restore conversation turn.',
+    usage: '[file]',
+    argsHint: '[file]',
+    handler(args, ctx) {
+      if (args[0] === 'file') {
+        if (!ctx.workspace.fileUndoManager) {
+          ctx.print('File redo not available.');
+          return;
+        }
+        try {
+          const result = ctx.workspace.fileUndoManager.redo();
+          ctx.print(result ? `File re-applied: ${result.path} (${result.tool} tool).` : 'Nothing to redo.');
+        } catch (err) {
+          ctx.print(`File redo failed: ${summarizeError(err)}`);
+        }
+        return;
+      }
+      const success = ctx.session.conversationManager.redo();
+      if (success) {
+        ctx.print('Turn restored. Tip: /redo file to re-apply a reverted file.');
+        ctx.renderRequest();
+      } else {
+        ctx.print('Nothing to redo. Tip: use /redo file to re-apply the last reverted file.');
+      }
+    },
+  });
+
+  registry.register({
+    name: 'retry',
+    aliases: ['r'],
+    description: 'Re-send the last user message',
+    usage: '[modified text]',
+    argsHint: '[modified text]',
+    handler(args, ctx) {
+      const lastMsg = ctx.session.conversationManager.getLastUserMessage();
+      if (!lastMsg) {
+        ctx.print('No message to retry.');
+        return;
+      }
+      ctx.session.conversationManager.undo();
+      ctx.submitInput?.(args.length > 0 ? args.join(' ') : lastMsg);
+    },
+  });
+
+  registry.register({
+    name: 'sessions',
+    description: 'List saved sessions',
+    async handler(_args, ctx) {
+      const sessionManager = requireSessionManager(ctx);
+      const sessions = sessionManager.list();
+      if (ctx.openSelection) {
+        const deleteAction = new Map([['d', 'delete' as const]]);
+        const items: SelectionItem[] = sessions.length === 0
+          ? [{ id: '_empty', label: 'No saved sessions', detail: 'Use /save [name] to save' }]
+          : sessions.map(s => ({ id: s.name, label: s.name, detail: s.title || '(untitled)', actions: '[d] delete' }));
+        ctx.openSelection('Sessions', items, { allowSearch: true, customActions: deleteAction }, (result) => {
+          if (!result) return;
+          if (result.action === 'delete') {
+            try {
+              const sessionInfo = sessions.find(s => s.name === result.item.id);
+              if (sessionInfo) {
+                unlinkSync(sessionInfo.filePath);
+                ctx.print(`Session deleted: ${result.item.id}`);
+              }
+            } catch (e) {
+              ctx.print(`Failed to delete session: ${summarizeError(e)}`);
+            }
+          } else {
+            try {
+              const { meta, messages } = sessionManager.load(result.item.id);
+              ctx.session.conversationManager.resetAll();
+              ctx.session.conversationManager.fromJSON({ messages: messages as never[] });
+              if (meta.title) ctx.session.conversationManager.title = meta.title;
+              ctx.session.conversationManager.rebuildHistory();
+              ctx.renderRequest();
+              ctx.print(`Session loaded: ${result.item.id} (${messages.length} messages)`);
+            } catch (e) {
+              ctx.print(`Failed to load session: ${summarizeError(e)}`);
+            }
+          }
+        });
+        return;
+      }
+      const lines = ['Saved sessions:', ''];
+      for (const s of sessions) lines.push(`  ${s.name.padEnd(30)} ${(s.title || '(untitled)').padEnd(24)} ${new Date(s.timestamp).toLocaleString()}  (${s.messageCount} msgs)`);
+      ctx.print(lines.join('\n'));
+    },
+  });
+
+  registry.register({
+    name: 'template',
+    aliases: ['tmpl'],
+    description: 'Manage and use prompt templates',
+    usage: 'save <name> | use <name> [args] | list | edit <name> | delete <name>',
+    argsHint: '<save|use|list|edit|delete> [name]',
+    handler(args, ctx) {
+      const shellPaths = requireShellPaths(ctx);
+      const templateManager = new TemplateManager({
+        projectRoot: shellPaths.workingDirectory,
+        homeDirectory: shellPaths.homeDirectory,
+      });
+      const sub = args[0];
+      const rest = args.slice(1);
+      if (!sub || sub === 'list') {
+        const templates = templateManager.list();
+        if (ctx.openSelection) {
+          const actions = new Map([['d', 'delete' as const], ['e', 'edit' as const]]);
+          const items: SelectionItem[] = templates.length === 0
+            ? [{ id: '_empty', label: 'No templates saved', detail: 'Use /template save <name>' }]
+            : templates.map(t => ({ id: t.name, label: t.name, detail: t.preview, category: t.scope === 'project' ? 'project' : 'global', actions: '[d] delete  [e] edit' }));
+          ctx.openSelection('Templates', items, { allowSearch: true, customActions: actions }, (result) => {
+            if (!result) return;
+            if (result.action === 'delete') {
+              const deleted = templateManager.delete(result.item.id);
+              ctx.print(deleted ? `Template deleted: ${result.item.id}` : `Template not found: ${result.item.id}`);
+            } else {
+              const content = templateManager.load(result.item.id);
+              if (content !== null) {
+                if (result.action === 'edit') ctx.print(`Template: ${result.item.id}\n\n${content}`);
+                else ctx.submitInput?.(content);
+              } else {
+                ctx.print(`Template not found: ${result.item.id}`);
+              }
+            }
+          });
+          return;
+        }
+        ctx.print(['Templates:', '', ...templates.map(t => `  ${t.scope === 'project' ? '[project]' : '[global] '} ${t.name.padEnd(28)} ${t.preview}`)].join('\n'));
+        return;
+      }
+      if (sub === 'save') {
+        const name = rest[0];
+        if (!name) {
+          ctx.print('Usage: /template save <name>');
+          return;
+        }
+        try {
+          templateManager.save(name, ctx.session.conversationManager.getLastUserMessage() || '# Template\n\nReplace this with your template content.\n');
+          ctx.print(`Template saved: ${name}`);
+        } catch (e) {
+          ctx.print(`Failed to save template: ${summarizeError(e)}`);
+        }
+        return;
+      }
+      if (sub === 'use') {
+        const name = rest[0];
+        if (!name) {
+          ctx.print('Usage: /template use <name> [args...]');
+          return;
+        }
+        const templateContent = templateManager.load(name);
+        if (templateContent === null) {
+          ctx.print(`Template not found: ${name}\nRun /template list to see available templates.`);
+          return;
+        }
+        ctx.submitInput?.(templateManager.expand(templateContent, parseTemplateArgs(rest.slice(1))));
+        return;
+      }
+      if (sub === 'edit') {
+        const name = rest[0];
+        if (!name) {
+          ctx.print('Usage: /template edit <name>');
+          return;
+        }
+        const content = templateManager.load(name);
+        ctx.print(content === null ? `Template not found: ${name}` : `Template: ${name}\n\n${content}`);
+        return;
+      }
+      if (sub === 'delete') {
+        const name = rest[0];
+        if (!name) {
+          ctx.print('Usage: /template delete <name>');
+          return;
+        }
+        ctx.print(templateManager.delete(name) ? `Template deleted: ${name}` : `Template not found: ${name}`);
+        return;
+      }
+      ctx.print(`Unknown subcommand: ${sub}\nUsage: /template save|use|list|edit|delete`);
+    },
+  });
+
+  registry.register({
+    name: 'memory',
+    description: 'Manage session memories (pinned across context compaction)',
+    usage: '[list|add <text>|remove <id>]',
+    argsHint: '[list|add|remove]',
+    handler(args, ctx) {
+      const sub = args[0] ?? 'list';
+      if (sub === 'list' || args.length === 0) {
+        const memories = requireSessionMemoryStore(ctx).list();
+        ctx.print(memories.length === 0
+          ? 'No session memories. Use !# prefix or /memory add <text> to create one.'
+          : [`Session Memories (${memories.length}):`, ...memories.map(m => `  [${m.id}] ${m.text}`)].join('\n'));
+      } else if (sub === 'add') {
+        const text = args.slice(1).join(' ').trim();
+        if (!text) {
+          ctx.print('Usage: /memory add <text>');
+          return;
+        }
+        const id = requireSessionMemoryStore(ctx).add(text);
+        ctx.print(`Memory added: [${id}] ${text}`);
+      } else if (sub === 'remove') {
+        const id = args[1];
+        if (!id) {
+          ctx.print('Usage: /memory remove <id>');
+          return;
+        }
+        const store = requireSessionMemoryStore(ctx);
+        ctx.print(store.remove(id) ? `Memory removed: [${id}]` : `Memory not found: ${id}`);
+      } else {
+        ctx.print('Usage: /memory [list|add <text>|remove <id>]\n  /memory              — list all session memories\n  /memory list         — list all session memories\n  /memory add <text>   — add a memory without sending a message\n  /memory remove <id>  — remove a specific memory');
+      }
+    },
+  });
+}