@pellux/goodvibes-agent 0.1.9 → 0.1.11

package/src/input/commands/eval.ts

@@ -4,9 +4,9 @@
  * Implements the Evaluation Harness commands:
  *
  *   /eval list                    — List all available eval suites
- *   /eval run <suite>             — Run a named suite (or 'all')
+ *   /eval run <suite> --yes       — Run a named suite (or 'all')
  *   /eval compare <baseline-file> — Compare last run against a baseline file
- *   /eval gate <suite>            — Run suite and apply CI gate (exits 1 on regression)
+ *   /eval gate <suite> --yes      — Run suite and apply CI gate (exits 1 on regression)
  */
 
 import type { SlashCommand, CommandContext } from '../command-registry.ts';
@@ -18,6 +18,7 @@ import type { EvalRegistry } from '../../panels/eval-panel.ts';
 import { formatSuiteResult, formatGateResult } from '@/runtime/index.ts';
 import { requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 // ── Subcommand helpers ────────────────────────────────────────────────────────
 
@@ -29,7 +30,7 @@ function printSuiteList(context: CommandContext): void {
       context.print(`    - ${s.id}: ${s.name}`);
     }
   }
-  context.print('[eval] Usage: /eval run <suite>  or  /eval run all');
+  context.print('[eval] Usage: /eval run <suite> --yes  or  /eval run all --yes');
 }
 
 function getRegistry(context: CommandContext): EvalRegistry | undefined {
@@ -45,7 +46,8 @@ function handleList(_args: string[], context: CommandContext): void {
 // ── /eval run ────────────────────────────────────────────────────────────────
 
 async function handleRun(args: string[], context: CommandContext): Promise<void> {
-  const suiteName = args[0] ?? 'all';
+  const { rest, yes } = stripYesFlag(args);
+  const suiteName = rest[0] ?? 'all';
   const registry = getRegistry(context);
 
   const suitesToRun =
@@ -59,6 +61,10 @@ async function handleRun(args: string[], context: CommandContext): Promise<void>
     context.print(`[eval] Unknown suite: "${suiteName}". Run /eval list to see available suites.`);
     return;
   }
+  if (!yes) {
+    requireYesFlag(context, `run eval suite ${suiteName}`, '/eval run <suite|all> --yes');
+    return;
+  }
 
   const runner = new EvalRunner();
   registry?.setRunning(true);
@@ -90,14 +96,14 @@ async function handleCompare(args: string[], context: CommandContext): Promise<v
   const suiteResults = registry?.getSuiteResults() ?? [];
 
   if (suiteResults.length === 0) {
-    context.print('[eval] No suite results to compare. Run /eval run <suite> first.');
+    context.print('[eval] No suite results to compare. Run /eval run <suite> --yes first.');
     return;
   }
 
   const baseline = await loadBaseline(baselineFile, projectRoot);
   if (!baseline) {
     context.print(`[eval] Baseline file not found: ${baselineFile}`);
-    context.print('[eval] Tip: run /eval gate <suite> to create a baseline.');
+    context.print('[eval] Tip: run /eval gate <suite> [baseline-file] --save-baseline --yes to create a baseline.');
     return;
   }
 
@@ -109,13 +115,15 @@ async function handleCompare(args: string[], context: CommandContext): Promise<v
 // ── /eval gate ────────────────────────────────────────────────────────────────
 
 async function handleGate(args: string[], context: CommandContext): Promise<void> {
-  const suiteName = args[0];
-  const baselineFile = args[1] ?? '.goodvibes/eval/baseline.json';
-  const saveFlag = args.includes('--save-baseline');
+  const { rest, yes } = stripYesFlag(args);
+  const positional = rest.filter((arg) => arg !== '--save-baseline');
+  const suiteName = positional[0];
+  const baselineFile = positional[1] ?? '.goodvibes/eval/baseline.json';
+  const saveFlag = rest.includes('--save-baseline');
   const projectRoot = requireShellPaths(context).workingDirectory;
 
   if (!suiteName) {
-    context.print('[eval] Usage: /eval gate <suite> [baseline-file] [--save-baseline]');
+    context.print('[eval] Usage: /eval gate <suite> [baseline-file] [--save-baseline] --yes');
     return;
   }
 
@@ -124,6 +132,10 @@ async function handleGate(args: string[], context: CommandContext): Promise<void
     context.print(`[eval] Unknown suite: "${suiteName}". Run /eval list to see available suites.`);
     return;
   }
+  if (!yes) {
+    requireYesFlag(context, `run eval gate ${suiteName}`, '/eval gate <suite> [baseline-file] [--save-baseline] --yes');
+    return;
+  }
 
   const registry = getRegistry(context);
   const runner = new EvalRunner();
@@ -141,7 +153,7 @@ async function handleGate(args: string[], context: CommandContext): Promise<void
   context.print(formatGateResult(gate));
 
   if (saveFlag || !baseline) {
-    const label = args[0] ?? 'latest';
+    const label = suiteName ?? 'latest';
     const newBaseline = captureBaseline(label, [fresh]);
     try {
       await writeBaseline(baselineFile, newBaseline, projectRoot);
@@ -164,7 +176,7 @@ export const evalCommand: SlashCommand = {
   name: 'eval',
   description: 'Evaluation harness: run benchmark suites, compare baselines, and gate regressions.',
   usage: '<subcommand> [args]',
-  argsHint: 'list|run <suite>|compare <baseline>|gate <suite>',
+  argsHint: 'list|run <suite> --yes|compare <baseline>|gate <suite> --yes',
   handler: async (args: string[], context: CommandContext): Promise<void> => {
     const [sub, ...rest] = args;
 
@@ -191,9 +203,10 @@ export const evalCommand: SlashCommand = {
         const usage = [
           'Usage: /eval <subcommand>',
           '  list                           — List all available eval suites',
-          '  run <suite|all>                — Run a named suite (or all suites)',
+          '  run <suite|all> --yes          — Run a named suite (or all suites)',
           '  compare [baseline-file]        — Compare last results against baseline',
-          '  gate <suite> [baseline-file]   — Run suite and apply regression gate',
+          '  gate <suite> [baseline-file] --yes',
+          '                                 — Run suite and apply regression gate',
           '    --save-baseline              — Save fresh run as new baseline',
         ].join('\n');
         context.print(usage);

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

@@ -2,6 +2,7 @@ import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import type { CommandRegistry } from '../command-registry.ts';
 import { requirePanelManager, requireShellPaths } from './runtime-services.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 interface VoiceBundle {
   readonly version: 1;
@@ -23,21 +24,27 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
   registry.register({
     name: 'remote-setup',
     description: 'Dedicated front-door for remote setup review and portable setup bundles',
-    usage: '[review|export <path>]',
+    usage: '[review|export <path> --yes]',
     async handler(args, ctx) {
-      const sub = (args[0] ?? 'review').toLowerCase();
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
+      const sub = (commandArgs[0] ?? 'review').toLowerCase();
       if (ctx.executeCommand) {
         if (sub === 'review') {
           await ctx.executeCommand('remote', ['setup']);
           return;
         }
         if (sub === 'export') {
-          const pathArg = args[1];
+          const pathArg = commandArgs[1];
           if (!pathArg) {
-            ctx.print('Usage: /remote-setup export <path>');
+            ctx.print('Usage: /remote-setup export <path> --yes');
             return;
           }
-          await ctx.executeCommand('remote', ['setup', 'export', pathArg]);
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `export remote setup bundle to ${pathArg}`, '/remote-setup export <path> --yes');
+            return;
+          }
+          await ctx.executeCommand('remote', ['setup', 'export', pathArg, '--yes']);
           return;
         }
       }
@@ -48,21 +55,27 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
   registry.register({
     name: 'remote-env',
     description: 'Dedicated front-door for remote environment snippets and portable env exports',
-    usage: '[review|export <path>]',
+    usage: '[review|export <path> --yes]',
     async handler(args, ctx) {
-      const sub = (args[0] ?? 'review').toLowerCase();
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
+      const sub = (commandArgs[0] ?? 'review').toLowerCase();
       if (ctx.executeCommand) {
         if (sub === 'review') {
           await ctx.executeCommand('remote', ['env']);
           return;
         }
         if (sub === 'export') {
-          const pathArg = args[1];
+          const pathArg = commandArgs[1];
           if (!pathArg) {
-            ctx.print('Usage: /remote-env export <path>');
+            ctx.print('Usage: /remote-env export <path> --yes');
+            return;
+          }
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `export remote environment snippet to ${pathArg}`, '/remote-env export <path> --yes');
             return;
           }
-          await ctx.executeCommand('remote', ['env', 'export', pathArg]);
+          await ctx.executeCommand('remote', ['env', 'export', pathArg, '--yes']);
           return;
         }
       }
@@ -73,21 +86,27 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
   registry.register({
     name: 'tunnel',
     description: 'Dedicated front-door for remote tunnel review and export flows',
-    usage: '[review|export <path>]',
+    usage: '[review|export <path> --yes]',
     async handler(args, ctx) {
-      const sub = (args[0] ?? 'review').toLowerCase();
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
+      const sub = (commandArgs[0] ?? 'review').toLowerCase();
       if (ctx.executeCommand) {
         if (sub === 'review') {
           await ctx.executeCommand('remote', ['tunnel', 'review']);
           return;
         }
         if (sub === 'export') {
-          const pathArg = args[1];
+          const pathArg = commandArgs[1];
           if (!pathArg) {
-            ctx.print('Usage: /tunnel export <path>');
+            ctx.print('Usage: /tunnel export <path> --yes');
             return;
           }
-          await ctx.executeCommand('remote', ['tunnel', 'export', pathArg]);
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `export remote tunnel review to ${pathArg}`, '/tunnel export <path> --yes');
+            return;
+          }
+          await ctx.executeCommand('remote', ['tunnel', 'export', pathArg, '--yes']);
           return;
         }
       }
@@ -98,19 +117,29 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
   registry.register({
     name: 'bootstrap',
     description: 'Dedicated front-door for remote bootstrap bundle export and inspection',
-    usage: '[export <path>|inspect <path>]',
+    usage: '[export <path> --yes|inspect <path>]',
     async handler(args, ctx) {
-      const sub = (args[0] ?? '').toLowerCase();
-      const pathArg = args[1];
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
+      const sub = (commandArgs[0] ?? '').toLowerCase();
+      const pathArg = commandArgs[1];
       if (!ctx.executeCommand) {
         ctx.print('Bootstrap controls are not available in this runtime.');
         return;
       }
-      if ((sub === 'export' || sub === 'inspect') && pathArg) {
+      if (sub === 'export' && pathArg) {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `export remote bootstrap bundle to ${pathArg}`, '/bootstrap export <path> --yes');
+          return;
+        }
+        await ctx.executeCommand('remote', ['bootstrap', sub, pathArg, '--yes']);
+        return;
+      }
+      if (sub === 'inspect' && pathArg) {
         await ctx.executeCommand('remote', ['bootstrap', sub, pathArg]);
         return;
       }
-      ctx.print('Usage: /bootstrap [export <path>|inspect <path>]');
+      ctx.print('Usage: /bootstrap [export <path> --yes|inspect <path>]');
     },
   });
 
@@ -165,7 +194,7 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
         ['shell', 'Shell execution approval with side-effect and credential review.'],
         ['file', 'File mutation approval with config/notebook differentiation.'],
         ['network', 'Network access approval with host/scope review.'],
-        ['delegate', 'Agent spawn/delegation approval with recursion ceilings.'],
+        ['delegate', 'Explicit GoodVibes TUI build delegation approval; local Agent spawn is blocked.'],
         ['mcp', 'MCP trust escalation approval with host/path review.'],
         ['remote', 'Remote dispatch approval with trust/artifact review.'],
         ['hook', 'Hook execution approval with deny/mutate authority review.'],
@@ -223,10 +252,12 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
   registry.register({
     name: 'voice',
     description: 'Review voice posture and package portable voice-surface metadata',
-    usage: '[review|enable|disable|bundle export <path>|bundle inspect <path>]',
+    usage: '[review|enable --yes|disable --yes|bundle export <path> --yes|bundle inspect <path>]',
     handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
       const shellPaths = requireShellPaths(ctx);
-      const sub = (args[0] ?? 'review').toLowerCase();
+      const sub = (commandArgs[0] ?? 'review').toLowerCase();
       if (sub === 'review') {
         const enabled = Boolean(ctx.platform.configManager.get('ui.voiceEnabled') ?? false);
         ctx.print([
@@ -238,20 +269,28 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
         return;
       }
       if (sub === 'enable' || sub === 'disable') {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `${sub} voice surface`, `/voice ${sub} --yes`);
+          return;
+        }
         const next = sub === 'enable';
         ctx.platform.configManager.setDynamic('ui.voiceEnabled', next);
         ctx.print(`Voice surface ${next ? 'enabled' : 'disabled'} for this runtime.`);
         return;
       }
       if (sub === 'bundle') {
-        const mode = args[1];
-        const pathArg = args[2];
+        const mode = commandArgs[1];
+        const pathArg = commandArgs[2];
         if ((mode === 'export' || mode === 'inspect') && !pathArg) {
-          ctx.print(`Usage: /voice bundle ${mode} <path>`);
+          ctx.print(`Usage: /voice bundle ${mode} <path>${mode === 'export' ? ' --yes' : ''}`);
           return;
         }
         const targetPath = shellPaths.resolveWorkspacePath(pathArg!);
         if (mode === 'export') {
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `export voice bundle to ${pathArg}`, '/voice bundle export <path> --yes');
+            return;
+          }
           const bundle: VoiceBundle = {
             version: 1,
             exportedAt: Date.now(),
@@ -272,7 +311,7 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
           return;
         }
       }
-      ctx.print('Usage: /voice [review|enable|disable|bundle export <path>|bundle inspect <path>]');
+      ctx.print('Usage: /voice [review|enable --yes|disable --yes|bundle export <path> --yes|bundle inspect <path>]');
     },
   });
 }

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

@@ -299,7 +299,7 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
           lines.push('  domain: auth');
           lines.push(...(
             auth.bootstrapCredentialPresent
-              ? ['  /auth local review', '  /auth local rotate-password admin <password>', '  /auth local clear-bootstrap-file']
+              ? ['  /auth local review', '  /auth local rotate-password admin <password> --yes', '  /auth local clear-bootstrap-file --yes']
               : ['  /auth local review']
           ));
           lines.push('  verify: /health auth');

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

@@ -1,34 +1,69 @@
+import { readFileSync } from 'node:fs';
 import type { CommandRegistry } from '../command-registry.ts';
 import { requireHookApi } from './runtime-services.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function containsAgentHookType(value: unknown): boolean {
+  if (Array.isArray(value)) return value.some((entry) => containsAgentHookType(entry));
+  if (!isRecord(value)) return false;
+  if (value.type === 'agent') return true;
+  return Object.values(value).some((entry) => containsAgentHookType(entry));
+}
+
+function fileContainsAgentHookType(path: string): boolean {
+  try {
+    return containsAgentHookType(JSON.parse(readFileSync(path, 'utf-8')) as unknown);
+  } catch {
+    return false;
+  }
+}
 
 export function registerHooksRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'hooks',
     aliases: [],
     description: 'Inspect, author, simulate, and reload managed hook workflows',
-    usage: '[contracts [filter] | reload | scaffold <name> <match> <type> | chain <name> <event1,event2,...> | remove <name> | enable <name> | disable <name> | simulate <eventPath> | inspect <path> | import <path> [merge|replace] | export [path]]',
+    usage: '[contracts [filter] | reload --yes | scaffold <name> <match> <type> --yes | chain <name> <event1,event2,...> --yes | remove <name> --yes | enable <name> --yes | disable <name> --yes | simulate <eventPath> | inspect <path> | import <path> [merge|replace] --yes | export [path] --yes]',
     argsHint: '[subcommand]',
     async handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
       const hookApi = requireHookApi(ctx);
       const workbench = hookApi.workbench;
-      if (args.length === 0 && ctx.openHooksPanel) {
+      if (commandArgs.length === 0 && ctx.openHooksPanel) {
         ctx.openHooksPanel();
         return;
       }
 
-      const subcommand = (args[0] ?? 'contracts').toLowerCase();
+      const subcommand = (commandArgs[0] ?? 'contracts').toLowerCase();
       if (subcommand === 'reload') {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, 'reload managed hook workflows', '/hooks reload --yes');
+          return;
+        }
         await workbench.reload();
         ctx.print(`Reloaded managed hooks from ${workbench.getFilePath()}`);
         return;
       }
       if (subcommand === 'scaffold') {
-        const [name, match, type] = args.slice(1);
+        const [name, match, type] = commandArgs.slice(1);
         if (!name || !match || !type) {
-          ctx.print('Usage: /hooks scaffold <name> <match> <command|prompt|agent|http|ts>');
+          ctx.print('Usage: /hooks scaffold <name> <match> <command|prompt|http|ts> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `scaffold managed hook ${name}`, '/hooks scaffold <name> <match> <command|prompt|http|ts> --yes');
+          return;
+        }
+        if (type === 'agent') {
+          ctx.print('Blocked: GoodVibes Agent does not author local agent-spawning hooks. Use command, prompt, http, or ts hooks, or delegate explicit build work to GoodVibes TUI.');
           return;
         }
-        if (!['command', 'prompt', 'agent', 'http', 'ts'].includes(type)) {
+        if (!['command', 'prompt', 'http', 'ts'].includes(type)) {
           ctx.print(`Unknown hook type: ${type}`);
           return;
         }
@@ -37,10 +72,14 @@ export function registerHooksRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
       if (subcommand === 'chain') {
-        const name = args[1];
-        const matches = args[2]?.split(',').map((entry) => entry.trim()).filter(Boolean) ?? [];
+        const name = commandArgs[1];
+        const matches = commandArgs[2]?.split(',').map((entry) => entry.trim()).filter(Boolean) ?? [];
         if (!name || matches.length === 0) {
-          ctx.print('Usage: /hooks chain <name> <event1,event2,...>');
+          ctx.print('Usage: /hooks chain <name> <event1,event2,...> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `scaffold managed hook chain ${name}`, '/hooks chain <name> <event1,event2,...> --yes');
           return;
         }
         const chain = await workbench.scaffoldChain(name, matches);
@@ -48,9 +87,13 @@ export function registerHooksRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
       if (subcommand === 'remove') {
-        const name = args[1];
+        const name = commandArgs[1];
         if (!name) {
-          ctx.print('Usage: /hooks remove <name>');
+          ctx.print('Usage: /hooks remove <name> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `remove managed hook workflow ${name}`, '/hooks remove <name> --yes');
           return;
         }
         const removed = await workbench.remove(name);
@@ -62,9 +105,13 @@ export function registerHooksRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
       if (subcommand === 'enable' || subcommand === 'disable') {
-        const name = args[1];
+        const name = commandArgs[1];
         if (!name) {
-          ctx.print(`Usage: /hooks ${subcommand} <name>`);
+          ctx.print(`Usage: /hooks ${subcommand} <name> --yes`);
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `${subcommand} managed hook ${name}`, `/hooks ${subcommand} <name> --yes`);
           return;
         }
         const changed = await workbench.toggle(name, subcommand === 'enable');
@@ -76,7 +123,7 @@ export function registerHooksRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
       if (subcommand === 'simulate') {
-        const eventPath = args[1];
+        const eventPath = commandArgs[1];
         if (!eventPath) {
           ctx.print('Usage: /hooks simulate <eventPath>');
           return;
@@ -92,12 +139,16 @@ export function registerHooksRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
       if (subcommand === 'export') {
-        const path = await workbench.export(args[1] ?? workbench.getFilePath());
+        if (!parsed.yes) {
+          requireYesFlag(ctx, 'export managed hook workflows', '/hooks export [path] --yes');
+          return;
+        }
+        const path = await workbench.export(commandArgs[1] ?? workbench.getFilePath());
         ctx.print(`Exported managed hooks to ${path}`);
         return;
       }
       if (subcommand === 'inspect') {
-        const path = args[1];
+        const path = commandArgs[1];
         if (!path) {
           ctx.print('Usage: /hooks inspect <path>');
           return;
@@ -112,10 +163,18 @@ export function registerHooksRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
       if (subcommand === 'import') {
-        const path = args[1];
-        const strategy = args[2] === 'replace' ? 'replace' : 'merge';
+        const path = commandArgs[1];
+        const strategy = commandArgs[2] === 'replace' ? 'replace' : 'merge';
         if (!path) {
-          ctx.print('Usage: /hooks import <path> [merge|replace]');
+          ctx.print('Usage: /hooks import <path> [merge|replace] --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `import managed hook workflows from ${path}`, '/hooks import <path> [merge|replace] --yes');
+          return;
+        }
+        if (fileContainsAgentHookType(path)) {
+          ctx.print('Blocked: hook bundle contains type=agent entries. GoodVibes Agent does not import local agent-spawning hooks.');
           return;
         }
         await workbench.import(path, strategy);
@@ -123,7 +182,7 @@ export function registerHooksRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
-      const filter = (subcommand === 'contracts' ? args.slice(1) : args).join(' ').trim().toLowerCase();
+      const filter = (subcommand === 'contracts' ? commandArgs.slice(1) : commandArgs).join(' ').trim().toLowerCase();
       const contracts = hookApi.contracts(filter);
 
       if (contracts.length === 0) {

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

@@ -4,16 +4,19 @@ import type { CommandRegistry } from '../command-registry.ts';
 import { buildIncidentMemoryAddOptions } from '@pellux/goodvibes-sdk/platform/state';
 import { requireShellPaths } from './runtime-services.ts';
 import { getMemoryApi } from './recall-query.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 export function registerIncidentRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'incident',
     aliases: [],
     description: 'Open, export, and capture incident review bundles',
-    usage: '[open | latest | show <id|latest> | export <id|latest> <path> | capture <id|latest>]',
+    usage: '[open | latest | show <id|latest> | export <id|latest> <path> --yes | capture <id|latest> --yes]',
     async handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
       const shellPaths = requireShellPaths(ctx);
-      const subcommand = (args[0] ?? 'open').toLowerCase();
+      const subcommand = (commandArgs[0] ?? 'open').toLowerCase();
       const forensicRegistry = ctx.extensions.forensicsRegistry;
       if (subcommand === 'open') {
         if (ctx.openIncidentPanel) {
@@ -27,7 +30,7 @@ export function registerIncidentRuntimeCommands(registry: CommandRegistry): void
         ctx.print('Forensics registry is not available in this runtime.');
         return;
       }
-      const requestedId = args[1];
+      const requestedId = commandArgs[1];
       const report = !requestedId || requestedId === 'latest'
         ? forensicRegistry.latest()
         : forensicRegistry.getById(requestedId);
@@ -53,9 +56,13 @@ export function registerIncidentRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (subcommand === 'export') {
-        const pathArg = args[2];
+        const pathArg = commandArgs[2];
         if (!requestedId || !pathArg) {
-          ctx.print('Usage: /incident export <id|latest> <path>');
+          ctx.print('Usage: /incident export <id|latest> <path> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `export incident bundle ${requestedId}`, '/incident export <id|latest> <path> --yes');
           return;
         }
         if (!report) {
@@ -74,6 +81,10 @@ export function registerIncidentRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (subcommand === 'capture') {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `capture incident ${requestedId ?? 'latest'} into durable memory`, '/incident capture <id|latest> --yes');
+          return;
+        }
         const memory = getMemoryApi(ctx);
         if (!memory) return;
         if (!report) {
@@ -89,7 +100,7 @@ export function registerIncidentRuntimeCommands(registry: CommandRegistry): void
         ctx.print(`Captured incident ${report.id} into durable memory as ${record.id}`);
         return;
       }
-      ctx.print('Usage: /incident [open | latest | show <id|latest> | export <id|latest> <path> | capture <id|latest>]');
+      ctx.print('Usage: /incident [open | latest | show <id|latest> | export <id|latest> <path> --yes | capture <id|latest> --yes]');
     },
   });
 }