@pellux/goodvibes-agent 0.1.9 → 0.1.11

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

@@ -2,6 +2,7 @@ import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import type { McpConfigScope, McpReloadResult, McpServerConfig } from '@pellux/goodvibes-sdk/platform/mcp';
 import { requireMcpApi, requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 const MCP_ROLES = ['general', 'docs', 'filesystem', 'git', 'database', 'browser', 'automation', 'ops', 'remote'] as const;
 const MCP_TRUST_MODES = ['constrained', 'ask-on-risk', 'allow-all', 'blocked'] as const;
@@ -137,11 +138,13 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
     aliases: [],
     description: 'Manage MCP servers and their tools',
     usage: '[add|remove|reload|config|review|tools [<server>]|auth-review|repair [server]]',
-    argsHint: '[add|remove|reload|config|review|tools [server]]',
+    argsHint: '[review|tools|config|add --yes|remove --yes]',
     async handler(args, ctx) {
       const mcpApi = requireMcpApi(ctx);
       const listServerSecurity = () => mcpApi.listServerSecurity();
-      const subcommand = args[0];
+      const confirmation = stripYesFlag(args);
+      const commandArgs = [...confirmation.rest];
+      const subcommand = commandArgs[0];
       if (!subcommand && ctx.openMcpWorkspace) {
         ctx.openMcpWorkspace();
         return;
@@ -161,7 +164,7 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
       if (subcommand === 'tools') {
-        const filterServer = args[1];
+        const filterServer = commandArgs[1];
         ctx.print('Fetching MCP tool list...');
         let allTools;
         try {
@@ -207,7 +210,7 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (subcommand === 'repair') {
-        const serverName = args[1];
+        const serverName = commandArgs[1];
         const servers = listServerSecurity();
         const selected = serverName ? servers.find((server) => server.name === serverName) : servers.find((server) => !server.connected || server.schemaFreshness === 'quarantined');
         if (!selected) {
@@ -218,7 +221,7 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
         }
         const nextSteps = [
           selected.schemaFreshness === 'quarantined'
-            ? `/mcp quarantine ${selected.name} approve operator`
+            ? `/mcp quarantine ${selected.name} approve operator --yes`
             : null,
           !selected.connected ? '/services auth-review' : null,
           '/mcp review',
@@ -239,14 +242,18 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (subcommand === 'trust') {
-        const serverName = args[1];
-        const mode = args[2] as 'constrained' | 'ask-on-risk' | 'allow-all' | 'blocked' | undefined;
+        const serverName = commandArgs[1];
+        const mode = commandArgs[2] as 'constrained' | 'ask-on-risk' | 'allow-all' | 'blocked' | undefined;
         if (serverName && mode) {
           if (mode === 'allow-all') {
             ctx.print(`Use /settings → MCP to explicitly enable allow-all for ${serverName}. Direct CLI escalation is blocked.`);
             ctx.openSettingsModal?.();
             return;
           }
+          if (!confirmation.yes) {
+            requireYesFlag(ctx, `change MCP trust mode for ${serverName}`, '/mcp trust <server> <constrained|ask-on-risk|blocked> --yes');
+            return;
+          }
           mcpApi.setServerTrustMode(serverName, mode);
           ctx.print(`Updated MCP trust mode for ${serverName} to ${mode}.`);
           return;
@@ -258,9 +265,13 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (subcommand === 'role') {
-        const serverName = args[1];
-        const role = args[2] as 'general' | 'docs' | 'filesystem' | 'git' | 'database' | 'browser' | 'automation' | 'ops' | 'remote' | undefined;
+        const serverName = commandArgs[1];
+        const role = commandArgs[2] as 'general' | 'docs' | 'filesystem' | 'git' | 'database' | 'browser' | 'automation' | 'ops' | 'remote' | undefined;
         if (serverName && role) {
+          if (!confirmation.yes) {
+            requireYesFlag(ctx, `change MCP role for ${serverName}`, '/mcp role <server> <general|docs|filesystem|git|database|browser|automation|ops|remote> --yes');
+            return;
+          }
           mcpApi.setServerRole(serverName, role);
           ctx.print(`Updated MCP role for ${serverName} to ${role}.`);
           return;
@@ -272,21 +283,25 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (subcommand === 'add') {
-        let parsed: ParsedMcpAddArgs;
+        if (!confirmation.yes) {
+          requireYesFlag(ctx, 'add or update an MCP server config', '/mcp add <name> <command> [args...] [--scope project|global] [--role <role>] [--trust <mode>] --yes');
+          return;
+        }
+        let parsedAdd: ParsedMcpAddArgs;
         try {
-          parsed = parseAddServerArgs(args);
+          parsedAdd = parseAddServerArgs(commandArgs);
         } catch (error) {
           ctx.print(summarizeError(error));
           return;
         }
         const shellPaths = requireShellPaths(ctx);
         try {
-          const result = await mcpApi.upsertServerConfig(shellPaths, parsed.scope, parsed.server);
-          const connected = listServerSecurity().find((entry) => entry.name === parsed.server.name)?.connected ?? false;
+          const result = await mcpApi.upsertServerConfig(shellPaths, parsedAdd.scope, parsedAdd.server);
+          const connected = listServerSecurity().find((entry) => entry.name === parsedAdd.server.name)?.connected ?? false;
           ctx.print([
-            `MCP server "${parsed.server.name}" saved to ${parsed.scope} config: ${result.path}.`,
+            `MCP server "${parsedAdd.server.name}" saved to ${parsedAdd.scope} config: ${result.path}.`,
             `Runtime reload: ${connected ? 'connected' : 'server saved; connection needs attention'} (+${result.reload.added} ~${result.reload.changed} -${result.reload.removed}, unchanged ${result.reload.unchanged}).`,
-            `Command: ${parsed.server.command}${parsed.server.args?.length ? ` ${parsed.server.args.join(' ')}` : ''}`,
+            `Command: ${parsedAdd.server.command}${parsedAdd.server.args?.length ? ` ${parsedAdd.server.args.join(' ')}` : ''}`,
             'Next: /mcp tools',
           ].join('\n'));
         } catch (error) {
@@ -296,16 +311,20 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (subcommand === 'remove') {
-        const serverName = args[1]?.trim();
+        const serverName = commandArgs[1]?.trim();
         if (!serverName) {
-          ctx.print('Usage: /mcp remove <server> [--scope project|global]');
+          ctx.print('Usage: /mcp remove <server> [--scope project|global] --yes');
+          return;
+        }
+        if (!confirmation.yes) {
+          requireYesFlag(ctx, `remove MCP server ${serverName}`, '/mcp remove <server> [--scope project|global] --yes');
           return;
         }
         let scope: McpConfigScope = 'project';
         try {
-          for (let index = 2; index < args.length; index += 1) {
-            if (args[index] === '--scope') {
-              const value = readFlagValue(args, index, '--scope');
+          for (let index = 2; index < commandArgs.length; index += 1) {
+            if (commandArgs[index] === '--scope') {
+              const value = readFlagValue(commandArgs, index, '--scope');
               if (!isMcpScope(value)) {
                 ctx.print(`Invalid MCP scope "${value}". Expected project or global.`);
                 return;
@@ -331,6 +350,10 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (subcommand === 'reload') {
+        if (!confirmation.yes) {
+          requireYesFlag(ctx, 'reload the MCP runtime from config', '/mcp reload --yes');
+          return;
+        }
         try {
           const result = await reloadMcpRuntime(ctx);
           const servers = listServerSecurity();
@@ -356,10 +379,10 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
               return `  - ${server.name}: ${server.command}${server.args?.length ? ` ${server.args.join(' ')}` : ''}  source=${entry.source.scope}/${entry.source.kind}${envKeys.length ? ` envKeys=${envKeys.join(',')}` : ''}`;
             }),
             '',
-            'Add or update from inside the TUI:',
-            '  /mcp add <name> <command> [args...] [--scope project|global] [--role <role>] [--trust <mode>]',
+            'Add or update from inside Agent with explicit confirmation:',
+            '  /mcp add <name> <command> [args...] [--scope project|global] [--role <role>] [--trust <mode>] --yes',
             'Example:',
-            '  /mcp add filesystem npx -y @modelcontextprotocol/server-filesystem . --scope project --role filesystem --trust constrained',
+            '  /mcp add filesystem npx -y @modelcontextprotocol/server-filesystem . --scope project --role filesystem --trust constrained --yes',
           ].join('\n'));
         } catch (error) {
           ctx.print(`MCP config read failed: ${summarizeError(error)}`);
@@ -368,19 +391,27 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (subcommand === 'quarantine') {
-        const serverName = args[1];
-        const action = args[2];
+        const serverName = commandArgs[1];
+        const action = commandArgs[2];
         if (!serverName) {
-          ctx.print('Usage: /mcp quarantine <server> [detail]\n       /mcp quarantine <server> approve [operatorId]');
+          ctx.print('Usage: /mcp quarantine <server> [detail] --yes\n       /mcp quarantine <server> approve [operatorId] --yes');
           return;
         }
         if (action === 'approve') {
-          const operatorId = args[3] || 'operator';
+          if (!confirmation.yes) {
+            requireYesFlag(ctx, `approve MCP schema quarantine override for ${serverName}`, '/mcp quarantine <server> approve [operatorId] --yes');
+            return;
+          }
+          const operatorId = commandArgs[3] || 'operator';
           mcpApi.approveSchemaQuarantine(serverName, operatorId);
           ctx.print(`Approved MCP schema quarantine override for ${serverName} as ${operatorId}. Refresh is still recommended.`);
           return;
         }
-        const detail = args.slice(2).join(' ') || 'quarantined by operator';
+        if (!confirmation.yes) {
+          requireYesFlag(ctx, `quarantine MCP server ${serverName}`, '/mcp quarantine <server> [detail] --yes');
+          return;
+        }
+        const detail = commandArgs.slice(2).join(' ') || 'quarantined by operator';
         mcpApi.quarantineSchema(serverName, 'operator_flagged', detail);
         ctx.print(`Quarantined MCP schema for ${serverName}.\nReason: ${detail}`);
         return;
@@ -396,8 +427,8 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
           + '  ~/.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 the TUI:\n'
-          + '  /mcp add filesystem npx -y @modelcontextprotocol/server-filesystem . --scope project --role filesystem\n'
+          + '\nAdd one from inside Agent with explicit confirmation:\n'
+          + '  /mcp add filesystem npx -y @modelcontextprotocol/server-filesystem . --scope project --role filesystem --yes\n'
           + '\nFormat: { "servers": [{ "name": "my-server", "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"] }] }'
         );
         return;
@@ -416,10 +447,10 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
       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]" to add/update without restarting.');
-        lines.push('Run "/mcp reload" after editing MCP config outside the TUI.');
-        lines.push('Run "/mcp trust <server> <mode>" to change trust mode, or "/mcp role <server> <role>" to change its coherence role.');
-        lines.push('Run "/mcp quarantine <server> [detail]" to block a server, or "/mcp quarantine <server> approve [operatorId]" to approve a temporary override.');
+        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) {

package/src/input/commands/memory-product-runtime.ts

@@ -1,111 +1,148 @@
 import type { CommandRegistry } from '../command-registry.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 export function registerMemoryProductRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'memory-sync',
     aliases: ['memsync'],
     description: 'Dedicated front-door for durable memory export/import and bundle exchange',
-    usage: '[export <path> [scope] | import <path>]',
+    usage: '[export <path> [scope] --yes | import <path> --yes]',
     async handler(args, ctx) {
-      const sub = (args[0] ?? '').toLowerCase();
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
+      const sub = (commandArgs[0] ?? '').toLowerCase();
       if (!ctx.executeCommand) {
         ctx.print('Memory sync controls are not available in this runtime.');
         return;
       }
-      if (sub === 'export' && args[1]) {
-        const scope = args[2];
-        const recallArgs = ['export', args[1], ...(scope ? ['--scope', scope] : [])];
+      if (sub === 'export' && commandArgs[1]) {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `export durable memory bundle to ${commandArgs[1]}`, '/memory-sync export <path> [scope] --yes');
+          return;
+        }
+        const scope = commandArgs[2];
+        const recallArgs = ['export', commandArgs[1], ...(scope ? ['--scope', scope] : []), '--yes'];
         await ctx.executeCommand('recall', recallArgs);
         return;
       }
-      if (sub === 'import' && args[1]) {
-        await ctx.executeCommand('recall', ['import', args[1]]);
+      if (sub === 'import' && commandArgs[1]) {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `import durable memory bundle from ${commandArgs[1]}`, '/memory-sync import <path> --yes');
+          return;
+        }
+        await ctx.executeCommand('recall', ['import', commandArgs[1], '--yes']);
         return;
       }
-      ctx.print('Usage: /memory-sync [export <path> [scope] | import <path>]');
+      ctx.print('Usage: /memory-sync [export <path> [scope] --yes | import <path> --yes]');
     },
   });
 
   registry.register({
     name: 'handoff',
     description: 'Dedicated front-door for reviewable memory handoff bundles',
-    usage: '[export <path> [scope] | inspect <path> | import <path>]',
+    usage: '[export <path> [scope] --yes | inspect <path> | import <path> --yes]',
     async handler(args, ctx) {
-      const sub = (args[0] ?? '').toLowerCase();
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
+      const sub = (commandArgs[0] ?? '').toLowerCase();
       if (!ctx.executeCommand) {
         ctx.print('Handoff controls are not available in this runtime.');
         return;
       }
-      if (sub === 'export' && args[1]) {
-        const scope = args[2];
-        await ctx.executeCommand('recall', ['handoff-export', args[1], ...(scope ? ['--scope', scope] : [])]);
+      if (sub === 'export' && commandArgs[1]) {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `export memory handoff bundle to ${commandArgs[1]}`, '/handoff export <path> [scope] --yes');
+          return;
+        }
+        const scope = commandArgs[2];
+        await ctx.executeCommand('recall', ['handoff-export', commandArgs[1], ...(scope ? ['--scope', scope] : []), '--yes']);
         return;
       }
-      if (sub === 'inspect' && args[1]) {
-        await ctx.executeCommand('recall', ['handoff-inspect', args[1]]);
+      if (sub === 'inspect' && commandArgs[1]) {
+        await ctx.executeCommand('recall', ['handoff-inspect', commandArgs[1]]);
         return;
       }
-      if (sub === 'import' && args[1]) {
-        await ctx.executeCommand('recall', ['handoff-import', args[1]]);
+      if (sub === 'import' && commandArgs[1]) {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `import memory handoff bundle from ${commandArgs[1]}`, '/handoff import <path> --yes');
+          return;
+        }
+        await ctx.executeCommand('recall', ['handoff-import', commandArgs[1], '--yes']);
         return;
       }
-      ctx.print('Usage: /handoff [export <path> [scope] | inspect <path> | import <path>]');
+      ctx.print('Usage: /handoff [export <path> [scope] --yes | inspect <path> | import <path> --yes]');
     },
   });
 
   registry.register({
     name: 'session-memory',
     description: 'Dedicated front-door for session-scoped memory capture and review',
-    usage: '[queue [limit] | export <path> | add <class> <summary...>]',
+    usage: '[queue [limit] | export <path> --yes | add <class> <summary...>]',
     async handler(args, ctx) {
-      const sub = (args[0] ?? 'queue').toLowerCase();
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
+      const sub = (commandArgs[0] ?? 'queue').toLowerCase();
       if (!ctx.executeCommand) {
         ctx.print('Session memory controls are not available in this runtime.');
         return;
       }
       if (sub === 'queue') {
-        await ctx.executeCommand('recall', ['queue', ...(args[1] ? [args[1]] : [])]);
+        await ctx.executeCommand('recall', ['queue', ...(commandArgs[1] ? [commandArgs[1]] : [])]);
         return;
       }
-      if (sub === 'export' && args[1]) {
-        await ctx.executeCommand('recall', ['export', args[1], '--scope', 'session']);
+      if (sub === 'export' && commandArgs[1]) {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `export session memory bundle to ${commandArgs[1]}`, '/session-memory export <path> --yes');
+          return;
+        }
+        await ctx.executeCommand('recall', ['export', commandArgs[1], '--scope', 'session', '--yes']);
         return;
       }
-      if (sub === 'add' && args.length >= 3) {
-        await ctx.executeCommand('recall', ['add', args[1], ...args.slice(2), '--scope', 'session']);
+      if (sub === 'add' && commandArgs.length >= 3) {
+        await ctx.executeCommand('recall', ['add', commandArgs[1], ...commandArgs.slice(2), '--scope', 'session']);
         return;
       }
-      ctx.print('Usage: /session-memory [queue [limit] | export <path> | add <class> <summary...>]');
+      ctx.print('Usage: /session-memory [queue [limit] | export <path> --yes | add <class> <summary...>]');
     },
   });
 
   registry.register({
     name: 'team-memory',
     description: 'Dedicated front-door for team/shared memory review and exchange',
-    usage: '[queue [limit] | export <path> | import <path> | capture policy]',
+    usage: '[queue [limit] | export <path> --yes | import <path> --yes | capture policy]',
     async handler(args, ctx) {
-      const sub = (args[0] ?? 'queue').toLowerCase();
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
+      const sub = (commandArgs[0] ?? 'queue').toLowerCase();
       if (!ctx.executeCommand) {
         ctx.print('Team memory controls are not available in this runtime.');
         return;
       }
       if (sub === 'queue') {
-        await ctx.executeCommand('recall', ['queue', ...(args[1] ? [args[1]] : [])]);
+        await ctx.executeCommand('recall', ['queue', ...(commandArgs[1] ? [commandArgs[1]] : [])]);
         return;
       }
-      if (sub === 'export' && args[1]) {
-        await ctx.executeCommand('recall', ['handoff-export', args[1], '--scope', 'team']);
+      if (sub === 'export' && commandArgs[1]) {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `export team memory handoff bundle to ${commandArgs[1]}`, '/team-memory export <path> --yes');
+          return;
+        }
+        await ctx.executeCommand('recall', ['handoff-export', commandArgs[1], '--scope', 'team', '--yes']);
         return;
       }
-      if (sub === 'import' && args[1]) {
-        await ctx.executeCommand('recall', ['handoff-import', args[1]]);
+      if (sub === 'import' && commandArgs[1]) {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `import team memory handoff bundle from ${commandArgs[1]}`, '/team-memory import <path> --yes');
+          return;
+        }
+        await ctx.executeCommand('recall', ['handoff-import', commandArgs[1], '--yes']);
         return;
       }
-      if (sub === 'capture' && args[1]?.toLowerCase() === 'policy') {
+      if (sub === 'capture' && commandArgs[1]?.toLowerCase() === 'policy') {
         await ctx.executeCommand('recall', ['capture', 'policy']);
         return;
       }
-      ctx.print('Usage: /team-memory [queue [limit] | export <path> | import <path> | capture policy]');
+      ctx.print('Usage: /team-memory [queue [limit] | export <path> --yes | import <path> --yes | capture policy]');
     },
   });
 }

package/src/input/commands/memory.ts

@@ -7,10 +7,10 @@
  *   /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> — Link two records
+ *   /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>                     — Delete a record
+ *   /recall remove <id> --yes               — Delete a record
  */
 
 import type { SlashCommand, CommandContext } from '../command-registry.ts';
@@ -128,20 +128,20 @@ export const recallCommand: SlashCommand = {
           '  search [query] [--semantic] [--cls <class>] [--scope <scope>] [--limit <n>]  — Full-text or sqlite-vec semantic search',
           '  vector [status|doctor|rebuild]                  — Inspect or rebuild the sqlite-vec memory index',
           '  get <id>                                       — Show record with provenance + links',
-          '  link <fromId> <toId> <relation>               — Create a directed relation between records',
+          '  link <fromId> <toId> <relation> --yes         — Create a directed relation between records',
           '  queue [limit]                                  — Show the operator review queue',
           '  review <id> <state> [--confidence <n>] [--by <name>] [--reason <text>]',
           '  stale <id> [reason...]                          — Mark a record stale with an operator reason',
           '  contradict <id> [reason...]                     — Mark a record contradicted with an operator reason',
           '  explain <task...> [--scope <path> ...]         — Show the knowledge records that would be injected for a task',
-          '  promote <id> <scope>                           — Promote a memory record into session|project|team scope',
-          '  export <path> [--scope <scope>] [--cls <class>] — Export a durable knowledge bundle',
-          '  import <path>                                  — Import a durable knowledge bundle',
-          '  handoff-export <path> [--scope <scope>]        — Export a reviewable handoff bundle for team/shared use',
+          '  promote <id> <scope> --yes                     — Promote a memory record into session|project|team scope',
+          '  export <path> [--scope <scope>] [--cls <class>] --yes — Export a durable knowledge bundle',
+          '  import <path> --yes                             — Import a durable knowledge bundle',
+          '  handoff-export <path> [--scope <scope>] --yes   — Export a reviewable handoff bundle for team/shared use',
           '  handoff-inspect <path>                         — Inspect a handoff bundle before import',
-          '  handoff-import <path>                          — Import a handoff bundle into durable memory',
+          '  handoff-import <path> --yes                     — Import a handoff bundle into durable memory',
           '  list [class] [--scope <scope>]                 — List all records grouped by class',
-          '  remove <id>                                    — Delete a record',
+          '  remove <id> --yes                              — Delete a record',
         ].join('\n');
         context.print(usage);
         break;

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

@@ -1,18 +1,21 @@
 import type { CommandRegistry } from '../command-registry.ts';
 import { requireWebhookNotifier } from './runtime-services.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 export function registerNotifyRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'notify',
     aliases: [],
     description: 'Manage webhook notification URLs (ntfy.sh format)',
-    usage: 'add <url> | remove <url> | list | clear | test',
-    argsHint: 'add|remove|list|clear|test',
+    usage: 'add <url> --yes | remove <url> --yes | list | clear --yes | test --yes',
+    argsHint: 'list|add --yes|remove --yes|test --yes',
     async handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
       const notifications = ctx.platform.configManager.getCategory('notifications');
       const urls: string[] = Array.isArray(notifications.webhookUrls) ? [...notifications.webhookUrls] : [];
       const notifier = requireWebhookNotifier(ctx);
-      const sub = args[0];
+      const sub = commandArgs[0];
 
       if (!sub || sub === 'list') {
         if (urls.length === 0) ctx.print('No webhook URLs configured.\nUse: /notify add <url>');
@@ -21,9 +24,13 @@ export function registerNotifyRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (sub === 'add') {
-        const url = args[1];
+        const url = commandArgs[1];
         if (!url) {
-          ctx.print('Usage: /notify add <url>\nExample: /notify add https://ntfy.sh/my-topic');
+          ctx.print('Usage: /notify add <url> --yes\nExample: /notify add https://ntfy.sh/my-topic --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `add webhook notification URL ${url}`, '/notify add <url> --yes');
           return;
         }
         try { new URL(url); } catch {
@@ -42,9 +49,13 @@ export function registerNotifyRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (sub === 'remove') {
-        const url = args[1];
+        const url = commandArgs[1];
         if (!url) {
-          ctx.print('Usage: /notify remove <url>');
+          ctx.print('Usage: /notify remove <url> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `remove webhook notification URL ${url}`, '/notify remove <url> --yes');
           return;
         }
         const next = urls.filter((u) => u !== url);
@@ -59,6 +70,10 @@ export function registerNotifyRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (sub === 'clear') {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, 'clear all webhook notification URLs', '/notify clear --yes');
+          return;
+        }
         ctx.platform.configManager.mergeCategory('notifications', { webhookUrls: [] });
         notifier.setUrls([]);
         ctx.print('All webhook URLs cleared.');
@@ -66,6 +81,10 @@ export function registerNotifyRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (sub === 'test') {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, 'send webhook notification test requests', '/notify test --yes');
+          return;
+        }
         if (urls.length === 0) {
           ctx.print('No webhook URLs configured. Use: /notify add <url>');
           return;
@@ -77,7 +96,7 @@ export function registerNotifyRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
-      ctx.print('Usage: /notify add <url> | remove <url> | list | clear | test');
+      ctx.print('Usage: /notify add <url> --yes | remove <url> --yes | list | clear --yes | test --yes');
     },
   });
 }