@pellux/goodvibes-agent 0.1.10 → 0.1.12

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

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

@@ -1,10 +1,12 @@
 import type { CommandRegistry } from '../command-registry.ts';
+import type { ProfileData } from '@pellux/goodvibes-sdk/platform/profiles';
 import { ToolContractVerifier } from '@/runtime/index.ts';
 import type { ReplaySnapshotInput } from '@/runtime/index.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { registerOperatorPanelCommand } from './operator-panel-runtime.ts';
 import { requireProfileManager, requireReplayEngine } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 function printOpsMutationBlocked(print: (text: string) => void, target: string): void {
   print([
@@ -76,15 +78,71 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
   registry.register({
     name: 'profiles',
     aliases: ['profile'],
-    description: 'Browse and load config profiles',
-    handler(_args, ctx) {
-      if (ctx.openProfilePicker) {
-        ctx.openProfilePicker();
-      } else {
-        const profiles = requireProfileManager(ctx).list();
-        if (profiles.length === 0) ctx.print('No profiles saved. Open /profiles and press s to save the current settings as a profile.');
+    description: 'Browse, save, and delete config profiles',
+    usage: '[list|open|save <name> --yes|delete <name> --yes]',
+    argsHint: '[list|open|save --yes|delete --yes]',
+    handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const sub = parsed.rest[0] ?? 'open';
+      const profileManager = requireProfileManager(ctx);
+      if (sub === 'open') {
+        if (ctx.openProfilePicker) {
+          ctx.openProfilePicker();
+        } else {
+          const profiles = profileManager.list();
+          if (profiles.length === 0) ctx.print('No profiles saved. Use /profiles save <name> --yes to save the current settings as a profile.');
+          else ctx.print(['Saved profiles:', ...profiles.map(p => `  ${p.name}`)].join('\n'));
+        }
+        return;
+      }
+      if (sub === 'list') {
+        const profiles = profileManager.list();
+        if (profiles.length === 0) ctx.print('No profiles saved. Use /profiles save <name> --yes to save the current settings as a profile.');
         else ctx.print(['Saved profiles:', ...profiles.map(p => `  ${p.name}`)].join('\n'));
+        return;
+      }
+      if (sub === 'save') {
+        const name = parsed.rest[1];
+        if (!name) {
+          ctx.print('Usage: /profiles save <name> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `save config profile ${name}`, '/profiles save <name> --yes');
+          return;
+        }
+        const all = ctx.platform.configManager.getAll();
+        const data: ProfileData = {
+          display: { ...all.display },
+          provider: {
+            model: all.provider.model,
+            reasoningEffort: all.provider.reasoningEffort,
+          },
+          behavior: { ...all.behavior },
+        };
+        profileManager.save(name, data);
+        ctx.print(`Profile saved: ${name}`);
+        return;
+      }
+      if (sub === 'delete' || sub === 'remove') {
+        const name = parsed.rest[1];
+        if (!name) {
+          ctx.print('Usage: /profiles delete <name> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `delete config profile ${name}`, '/profiles delete <name> --yes');
+          return;
+        }
+        const deleted = profileManager.delete(name);
+        ctx.print(deleted ? `Profile deleted: ${name}` : `Profile not found: ${name}`);
+        return;
       }
+      if (args.length === 0 && ctx.openProfilePicker) {
+        ctx.openProfilePicker();
+        return;
+      }
+      ctx.print('Usage: /profiles [list|open|save <name> --yes|delete <name> --yes]');
     },
   });
 
@@ -103,7 +161,7 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
     name: 'mode',
     aliases: ['hitl'],
     description: 'Manage HITL UX notification mode (quiet/balanced/operator)',
-    usage: '[quiet|balanced|operator|show|set-domain <domain> <verbosity>]',
+    usage: '[quiet|balanced|operator --yes|show|set-domain <domain> <verbosity> --yes]',
     argsHint: '[preset|show|set-domain]',
     handler(args, ctx) {
       const mgr = ctx.ops.modeManager;
@@ -111,9 +169,15 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
         ctx.print('Interaction mode manager is not available in this runtime.');
         return;
       }
-      const sub = args[0] ?? 'show';
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
+      const sub = commandArgs[0] ?? 'show';
 
       if (sub === 'quiet' || sub === 'balanced' || sub === 'operator') {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `set HITL mode to ${sub}`, '/mode <quiet|balanced|operator> --yes');
+          return;
+        }
         const newMode = sub as 'quiet' | 'balanced' | 'operator';
         mgr.setHITLMode(newMode);
         try {
@@ -156,29 +220,33 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
       }
 
       if (sub === 'set-domain') {
-        const domain = args[1];
-        const verbosity = args[2];
+        const domain = commandArgs[1];
+        const verbosity = commandArgs[2];
         if (!domain || !verbosity) {
-          ctx.print('Usage: /mode set-domain <domain> <minimal|normal|verbose>');
+          ctx.print('Usage: /mode set-domain <domain> <minimal|normal|verbose> --yes');
           return;
         }
         if (verbosity !== 'minimal' && verbosity !== 'normal' && verbosity !== 'verbose') {
           ctx.print(`Invalid verbosity "${verbosity}". Valid values: minimal, normal, verbose`);
           return;
         }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `set HITL verbosity for ${domain}`, '/mode set-domain <domain> <minimal|normal|verbose> --yes');
+          return;
+        }
         mgr.setDomainVerbosity(domain, verbosity as 'minimal' | 'normal' | 'verbose');
         ctx.print(`Domain "${domain}" verbosity set to: ${verbosity}`);
         return;
       }
 
       ctx.print(
-        'Usage: /mode [quiet|balanced|operator|show|set-domain <domain> <verbosity>]\n'
+        'Usage: /mode [quiet|balanced|operator --yes|show|set-domain <domain> <verbosity> --yes]\n'
         + '  /mode                          — show current mode and settings\n'
         + '  /mode show                     — show current mode and settings\n'
-        + '  /mode quiet                    — suppress all non-critical notifications\n'
-        + '  /mode balanced                 — surface warnings, batch info noise (default)\n'
-        + '  /mode operator                 — full verbosity, no suppression\n'
-        + '  /mode set-domain <d> <v>       — per-domain verbosity override (minimal|normal|verbose)'
+        + '  /mode quiet --yes              — suppress all non-critical notifications\n'
+        + '  /mode balanced --yes           — surface warnings, batch info noise (default)\n'
+        + '  /mode operator --yes           — full verbosity, no suppression\n'
+        + '  /mode set-domain <d> <v> --yes — per-domain verbosity override (minimal|normal|verbose)'
       );
     },
   });

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

@@ -6,6 +6,7 @@ import type {
 } from '@pellux/goodvibes-sdk/platform/knowledge';
 import type { CommandRegistry } from '../command-registry.ts';
 import { requirePlanManager, requireSessionLineageTracker } from './runtime-services.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 function recordNextQuestion(
   state: Partial<ProjectPlanningState>,
@@ -51,15 +52,21 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
   registry.register({
     name: 'plan',
     description: 'Inspect or seed Agent workspace planning state',
-    usage: '[panel | approve | list | show <id> | mode | explain | override <strategy> | status | clear | <planning goal>]',
+    usage: '[panel | approve --yes | list | show <id> | mode | explain | override <strategy> --yes | status | clear --yes | <planning goal>]',
     argsHint: '[panel|approve|status|<goal>]',
     async handler(args, ctx) {
       const planManager = requirePlanManager(ctx);
       const sessionLineageTracker = requireSessionLineageTracker(ctx);
       const plannerSubs = ['mode', 'explain', 'override', 'status', 'clear'];
       if (args.length > 0 && plannerSubs.includes(args[0].toLowerCase())) {
+        const parsed = stripYesFlag(args);
+        const subcommand = parsed.rest[0]?.toLowerCase() ?? '';
+        if ((subcommand === 'override' || subcommand === 'clear') && !parsed.yes) {
+          requireYesFlag(ctx, `${subcommand} planner runtime state`, `/plan ${subcommand}${subcommand === 'override' ? ' <strategy>' : ''} --yes`);
+          return;
+        }
         const result = ctx.ops.planRuntime
-          ? ctx.ops.planRuntime(args[0], args.slice(1))
+          ? ctx.ops.planRuntime(parsed.rest[0] ?? args[0], parsed.rest.slice(1))
           : { ok: false, output: 'Plan runtime bridge is not available in this runtime.' };
         ctx.print(result.output);
         return;
@@ -109,6 +116,11 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
       }
 
       if (args[0] === 'approve') {
+        const parsed = stripYesFlag(args);
+        if (!parsed.yes) {
+          requireYesFlag(ctx, 'approve project planning state for execution', '/plan approve --yes');
+          return;
+        }
         if (!projectPlanningService || !projectId) {
           ctx.print('Project planning service is not available in this runtime.');
           return;