@pellux/goodvibes-agent 0.1.9 → 0.1.11

package/src/input/commands/platform-services-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 { requireSecretsManager, requireShellPaths } from './runtime-services.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 interface SecureStorageBundle {
   readonly version: 1;
@@ -58,11 +59,13 @@ export function registerPlatformServicesRuntimeCommands(registry: CommandRegistr
   registry.register({
     name: 'storage',
     description: 'Review secure storage posture and export portable storage metadata bundles',
-    usage: '[review|list|delete <key>|bundle export <path>|bundle inspect <path>]',
+    usage: '[review|list|delete <key> --yes|bundle export <path> --yes|bundle inspect <path>]',
     async handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
       const shellPaths = requireShellPaths(ctx);
       const manager = requireSecretsManager(ctx);
-      const sub = args[0] ?? 'review';
+      const sub = commandArgs[0] ?? 'review';
       const review = await manager.inspect();
       const storedKeys = await manager.list();
       const detailedKeys = await manager.listDetailed();
@@ -88,9 +91,13 @@ export function registerPlatformServicesRuntimeCommands(registry: CommandRegistr
         return;
       }
       if (sub === 'delete') {
-        const key = args[1];
+        const key = commandArgs[1];
         if (!key) {
-          ctx.print('Usage: /storage delete <key>');
+          ctx.print('Usage: /storage delete <key> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `delete secure storage key ${key}`, '/storage delete <key> --yes');
           return;
         }
         await manager.delete(key);
@@ -98,14 +105,18 @@ export function registerPlatformServicesRuntimeCommands(registry: CommandRegistr
         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: /storage bundle ${mode} <path>`);
+          ctx.print(`Usage: /storage bundle ${mode} <path>${mode === 'export' ? ' --yes' : ''}`);
           return;
         }
-        const targetPath = shellPaths.resolveWorkspacePath(pathArg!);
         if (mode === 'export') {
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `export secure storage metadata bundle to ${pathArg}`, '/storage bundle export <path> --yes');
+            return;
+          }
+          const targetPath = shellPaths.resolveWorkspacePath(pathArg!);
           const bundle: SecureStorageBundle = {
             version: 1,
             exportedAt: Date.now(),
@@ -118,12 +129,13 @@ export function registerPlatformServicesRuntimeCommands(registry: CommandRegistr
           return;
         }
         if (mode === 'inspect') {
+          const targetPath = shellPaths.resolveWorkspacePath(pathArg!);
           const bundle = JSON.parse(readFileSync(targetPath, 'utf-8')) as SecureStorageBundle;
           ctx.print(inspectStorageBundle(bundle));
           return;
         }
       }
-      ctx.print('Usage: /storage [review|list|delete <key>|bundle export <path>|bundle inspect <path>]');
+      ctx.print('Usage: /storage [review|list|delete <key> --yes|bundle export <path> --yes|bundle inspect <path>]');
     },
   });
 
@@ -131,10 +143,12 @@ export function registerPlatformServicesRuntimeCommands(registry: CommandRegistr
     name: 'helpers',
     aliases: ['integration-api'],
     description: 'Review local integration helper API surfaces for remote clients and future web frontends',
-    usage: '[review|bundle export <path>|bundle inspect <path>]',
+    usage: '[review|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';
+      const sub = commandArgs[0] ?? 'review';
       const review = ctx.extensions.integrationHelpers?.buildReview();
       if (!review) {
         ctx.print('Integration helper service unavailable in this runtime.');
@@ -156,14 +170,18 @@ export function registerPlatformServicesRuntimeCommands(registry: CommandRegistr
         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: /helpers bundle ${mode} <path>`);
+          ctx.print(`Usage: /helpers bundle ${mode} <path>${mode === 'export' ? ' --yes' : ''}`);
           return;
         }
-        const targetPath = shellPaths.resolveWorkspacePath(pathArg!);
         if (mode === 'export') {
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `export integration helper bundle to ${pathArg}`, '/helpers bundle export <path> --yes');
+            return;
+          }
+          const targetPath = shellPaths.resolveWorkspacePath(pathArg!);
           const bundle: IntegrationHelperBundle = {
             version: 1,
             exportedAt: Date.now(),
@@ -176,12 +194,13 @@ export function registerPlatformServicesRuntimeCommands(registry: CommandRegistr
           return;
         }
         if (mode === 'inspect') {
+          const targetPath = shellPaths.resolveWorkspacePath(pathArg!);
           const bundle = JSON.parse(readFileSync(targetPath, 'utf-8')) as IntegrationHelperBundle;
           ctx.print(inspectIntegrationHelperBundle(bundle));
           return;
         }
       }
-      ctx.print('Usage: /helpers [review|bundle export <path>|bundle inspect <path>]');
+      ctx.print('Usage: /helpers [review|bundle export <path> --yes|bundle inspect <path>]');
     },
   });
 
@@ -189,10 +208,12 @@ export function registerPlatformServicesRuntimeCommands(registry: CommandRegistr
     name: 'deeplink',
     aliases: ['link'],
     description: 'Review and package deep-link entrypoints for setup and operator surfaces',
-    usage: '[review|open <surface> [target]|bundle export <path>|bundle inspect <path>]',
+    usage: '[review|open <surface> [target]|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';
+      const sub = commandArgs[0] ?? 'review';
       const links = [
         buildSetupLink('cockpit'),
         buildSetupLink('security'),
@@ -206,8 +227,8 @@ export function registerPlatformServicesRuntimeCommands(registry: CommandRegistr
         return;
       }
       if (sub === 'open') {
-        const surface = args[1];
-        const target = args[2];
+        const surface = commandArgs[1];
+        const target = commandArgs[2];
         if (!surface) {
           ctx.print('Usage: /deeplink open <surface> [target]');
           return;
@@ -216,14 +237,18 @@ export function registerPlatformServicesRuntimeCommands(registry: CommandRegistr
         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: /deeplink bundle ${mode} <path>`);
+          ctx.print(`Usage: /deeplink bundle ${mode} <path>${mode === 'export' ? ' --yes' : ''}`);
           return;
         }
-        const targetPath = shellPaths.resolveWorkspacePath(pathArg!);
         if (mode === 'export') {
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `export deep link bundle to ${pathArg}`, '/deeplink bundle export <path> --yes');
+            return;
+          }
+          const targetPath = shellPaths.resolveWorkspacePath(pathArg!);
           const bundle: DeepLinkBundle = {
             version: 1,
             exportedAt: Date.now(),
@@ -235,12 +260,13 @@ export function registerPlatformServicesRuntimeCommands(registry: CommandRegistr
           return;
         }
         if (mode === 'inspect') {
+          const targetPath = shellPaths.resolveWorkspacePath(pathArg!);
           const bundle = JSON.parse(readFileSync(targetPath, 'utf-8')) as DeepLinkBundle;
           ctx.print(inspectDeepLinkBundle(bundle));
           return;
         }
       }
-      ctx.print('Usage: /deeplink [review|open <surface> [target]|bundle export <path>|bundle inspect <path>]');
+      ctx.print('Usage: /deeplink [review|open <surface> [target]|bundle export <path> --yes|bundle inspect <path>]');
     },
   });
 }

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

@@ -4,6 +4,7 @@ import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { listInstalledEcosystemEntries, loadEcosystemCatalog } from '@/runtime/index.ts';
 import { BUILTIN_SUITES } from '@/runtime/index.ts';
 import { requireEcosystemCatalogPaths, requireReadModels, requireSecretsManager, requireServiceRegistry, requireShellPaths } from './runtime-services.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 interface TrustReviewBundle {
   readonly version: 1;
@@ -155,23 +156,29 @@ export function registerProductRuntimeCommands(registry: CommandRegistry): void
   registry.register({
     name: 'trust',
     description: 'Review trust posture and export portable trust bundles',
-    usage: '[review|bundle export <path>|bundle inspect <path>]',
+    usage: '[review|bundle export <path> --yes|bundle inspect <path>]',
     async handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
       const shellPaths = requireShellPaths(ctx);
-      const sub = args[0] ?? 'review';
+      const sub = commandArgs[0] ?? 'review';
       if (sub === 'review') {
         const bundle = await buildTrustReviewBundle(ctx);
         ctx.print(formatTrustReview(bundle));
         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: /trust bundle ${mode} <path>`);
+          ctx.print(`Usage: /trust bundle ${mode} <path>${mode === 'export' ? ' --yes' : ''}`);
           return;
         }
         if (mode === 'export') {
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `export trust bundle to ${pathArg}`, '/trust bundle export <path> --yes');
+            return;
+          }
           const bundle = await buildTrustReviewBundle(ctx);
           const targetPath = shellPaths.resolveWorkspacePath(pathArg!);
           mkdirSync(dirname(targetPath), { recursive: true });
@@ -184,21 +191,23 @@ export function registerProductRuntimeCommands(registry: CommandRegistry): void
           return;
         }
       }
-      ctx.print('Usage: /trust [review|bundle export <path>|bundle inspect <path>]');
+      ctx.print('Usage: /trust [review|bundle export <path> --yes|bundle inspect <path>]');
     },
   });
   registry.register({
     name: 'bridge',
     description: 'Review and operate self-hosted bridge and remote runner flows',
-    usage: '[status|pools|assign <pool> <runner>|runner <id>|review <artifactId>|export <artifactId> [path]|import <path>]',
+    usage: '[status|pools|assign <pool> <runner> --yes|runner <id>|review <artifactId>|export <artifactId> [path] --yes|import <path> --yes]',
     async handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
       const shellPaths = requireShellPaths(ctx);
       if (!ctx.ops.remoteRuntime) {
         ctx.print('Remote runner registry is not available in this runtime.');
         return;
       }
       const remoteRegistry = ctx.ops.remoteRuntime;
-      const sub = args[0] ?? 'status';
+      const sub = commandArgs[0] ?? 'status';
       if (sub === 'status') {
         const remote = requireReadModels(ctx).remote.getSnapshot();
         ctx.print([
@@ -217,10 +226,14 @@ export function registerProductRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (sub === 'assign') {
-        const poolId = args[1];
-        const runnerId = args[2];
+        const poolId = commandArgs[1];
+        const runnerId = commandArgs[2];
         if (!poolId || !runnerId) {
-          ctx.print('Usage: /bridge assign <pool> <runner>');
+          ctx.print('Usage: /bridge assign <pool> <runner> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `assign bridge runner ${runnerId} to pool ${poolId}`, '/bridge assign <pool> <runner> --yes');
           return;
         }
         const pool = remoteRegistry.assignRunnerToPool(poolId, runnerId);
@@ -232,7 +245,7 @@ export function registerProductRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (sub === 'runner') {
-        const runnerId = args[1];
+        const runnerId = commandArgs[1];
         if (!runnerId) {
           ctx.print('Usage: /bridge runner <id>');
           return;
@@ -253,7 +266,7 @@ export function registerProductRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (sub === 'review') {
-        const artifactId = args[1];
+        const artifactId = commandArgs[1];
         if (!artifactId) {
           ctx.print('Usage: /bridge review <artifactId>');
           return;
@@ -263,14 +276,18 @@ export function registerProductRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (sub === 'export') {
-        const artifactId = args[1];
+        const artifactId = commandArgs[1];
         if (!artifactId) {
-          ctx.print('Usage: /bridge export <artifactId> [path]');
+          ctx.print('Usage: /bridge export <artifactId> [path] --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `export bridge artifact ${artifactId}`, '/bridge export <artifactId> [path] --yes');
           return;
         }
         const exported = await remoteRegistry.exportArtifact(
           artifactId,
-          args[2] ? shellPaths.resolveWorkspacePath(args[2]) : undefined,
+          commandArgs[2] ? shellPaths.resolveWorkspacePath(commandArgs[2]) : undefined,
         );
         if (!exported) {
           ctx.print(`Unknown remote artifact: ${artifactId}`);
@@ -280,26 +297,32 @@ export function registerProductRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (sub === 'import') {
-        const pathArg = args[1];
+        const pathArg = commandArgs[1];
         if (!pathArg) {
-          ctx.print('Usage: /bridge import <path>');
+          ctx.print('Usage: /bridge import <path> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `import bridge artifact from ${pathArg}`, '/bridge import <path> --yes');
           return;
         }
         const artifact = await remoteRegistry.importArtifact(shellPaths.resolveWorkspacePath(pathArg));
         ctx.print(`Imported remote bridge artifact ${artifact.id} for runner ${artifact.runnerId}.`);
         return;
       }
-      ctx.print('Usage: /bridge [status|pools|assign <pool> <runner>|runner <id>|review <artifactId>|export <artifactId> [path]|import <path>]');
+      ctx.print('Usage: /bridge [status|pools|assign <pool> <runner> --yes|runner <id>|review <artifactId>|export <artifactId> [path] --yes|import <path> --yes]');
     },
   });
 
   registry.register({
     name: 'release',
     description: 'Package certification and release-readiness operations',
-    usage: '[review|checklist|bundle export <path>|bundle inspect <path>]',
+    usage: '[review|checklist|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';
+      const sub = commandArgs[0] ?? 'review';
       if (sub === 'review') {
         const bundle = buildReleaseBundle(ctx);
         ctx.print([
@@ -319,20 +342,24 @@ export function registerProductRuntimeCommands(registry: CommandRegistry): void
           '  1. Run /setup review and /setup doctor',
           '  2. Run /security review and /trust review',
           '  3. Run /policy preflight and /policy simulate',
-          '  4. Run /eval gate <suite> for required certification suites',
+          '  4. Run /eval gate <suite> --yes for required certification suites',
           '  5. Review /incident latest and /bridge status',
-          '  6. Export /release bundle export <path> for release evidence',
+          '  6. Export /release bundle export <path> --yes for release evidence',
         ].join('\n'));
         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: /release bundle ${mode} <path>`);
+          ctx.print(`Usage: /release bundle ${mode} <path>${mode === 'export' ? ' --yes' : ''}`);
           return;
         }
         if (mode === 'export') {
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `export release bundle to ${pathArg}`, '/release bundle export <path> --yes');
+            return;
+          }
           const bundle = buildReleaseBundle(ctx);
           const targetPath = shellPaths.resolveWorkspacePath(pathArg!);
           mkdirSync(dirname(targetPath), { recursive: true });
@@ -345,7 +372,7 @@ export function registerProductRuntimeCommands(registry: CommandRegistry): void
           return;
         }
       }
-      ctx.print('Usage: /release [review|checklist|bundle export <path>|bundle inspect <path>]');
+      ctx.print('Usage: /release [review|checklist|bundle export <path> --yes|bundle inspect <path>]');
     },
   });
 }

package/src/input/commands/profile-sync-runtime.ts

@@ -4,6 +4,7 @@ import type { CommandRegistry } from '../command-registry.ts';
 import type { ProfileBundleEntry, ProfileSyncBundle } from '@/runtime/index.ts';
 import { recordSettingsSyncEvent, recordSettingsSyncFailure } from '@/runtime/index.ts';
 import { requireProfileManager, requireShellPaths } from './runtime-services.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 function inspectProfileSyncBundle(bundle: ProfileSyncBundle): string {
   return [
@@ -18,11 +19,13 @@ export function registerProfileSyncRuntimeCommands(registry: CommandRegistry): v
   registry.register({
     name: 'profilesync',
     description: 'Export, import, and inspect profile sync bundles',
-    usage: '[list|export <path>|inspect <path>|import <path> [prefix]]',
+    usage: '[list|export <path> --yes|inspect <path>|import <path> [prefix] --yes]',
     handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
       const shellPaths = requireShellPaths(ctx);
       const controlPlaneConfigDir = ctx.platform.configManager.getControlPlaneConfigDir();
-      const sub = args[0] ?? 'list';
+      const sub = commandArgs[0] ?? 'list';
       const pm = requireProfileManager(ctx);
       if (sub === 'list') {
         const profiles = pm.list();
@@ -34,14 +37,18 @@ export function registerProfileSyncRuntimeCommands(registry: CommandRegistry): v
         return;
       }
 
-      const pathArg = args[1];
+      const pathArg = commandArgs[1];
       if (!pathArg) {
-        ctx.print(`Usage: /profilesync ${sub} <path>${sub === 'import' ? ' [prefix]' : ''}`);
+        ctx.print(`Usage: /profilesync ${sub} <path>${sub === 'import' ? ' [prefix]' : ''}${sub === 'export' || sub === 'import' ? ' --yes' : ''}`);
         return;
       }
       const targetPath = shellPaths.resolveWorkspacePath(pathArg);
 
       if (sub === 'export') {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `export profile sync bundle to ${pathArg}`, '/profilesync export <path> --yes');
+          return;
+        }
         const profiles = pm.list().map((profile) => {
           const loaded = pm.load(profile.name);
           return {
@@ -75,8 +82,12 @@ export function registerProfileSyncRuntimeCommands(registry: CommandRegistry): v
       }
 
       if (sub === 'import') {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `import profile sync bundle from ${pathArg}`, '/profilesync import <path> [prefix] --yes');
+          return;
+        }
         const bundle = JSON.parse(readFileSync(targetPath, 'utf-8')) as ProfileSyncBundle;
-        const prefix = args[2]?.trim() ?? '';
+        const prefix = commandArgs[2]?.trim() ?? '';
         for (const entry of bundle.profiles) {
           const name = prefix ? `${prefix}-${entry.name}` : entry.name;
           pm.save(name, entry.data);
@@ -93,7 +104,7 @@ export function registerProfileSyncRuntimeCommands(registry: CommandRegistry): v
       }
 
       recordSettingsSyncFailure('profiles', `unsupported subcommand: ${sub}`, controlPlaneConfigDir);
-      ctx.print('Usage: /profilesync [list|export <path>|inspect <path>|import <path> [prefix]]');
+      ctx.print('Usage: /profilesync [list|export <path> --yes|inspect <path>|import <path> [prefix] --yes]');
     },
   });
 }

package/src/input/commands/recall-bundle.ts

@@ -6,23 +6,30 @@ import { VALID_CLASSES, VALID_SCOPES, isValidClass, isValidScope, resolveBundleP
 import { requireShellPaths } from './runtime-services.ts';
 import { getMemoryApi } from './recall-query.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 export function handleRecallExport(args: string[], context: CommandContext): void {
+  const parsed = stripYesFlag(args);
+  const commandArgs = [...parsed.rest];
   const memory = getMemoryApi(context);
   if (!memory) {
     return;
   }
 
-  const pathArg = args[0];
+  const pathArg = commandArgs[0];
   if (!pathArg) {
-    context.print('[recall] Usage: /recall export <path> [--scope <scope>] [--cls <class>]');
+    context.print('[recall] Usage: /recall export <path> [--scope <scope>] [--cls <class>] --yes');
+    return;
+  }
+  if (!parsed.yes) {
+    requireYesFlag(context, `export durable memory bundle to ${pathArg}`, '/recall export <path> [--scope <scope>] [--cls <class>] --yes');
     return;
   }
 
   const filter: MemorySearchFilter = {};
-  const scopeIdx = args.indexOf('--scope');
-  if (scopeIdx !== -1 && args[scopeIdx + 1]) {
-    const scope = args[scopeIdx + 1];
+  const scopeIdx = commandArgs.indexOf('--scope');
+  if (scopeIdx !== -1 && commandArgs[scopeIdx + 1]) {
+    const scope = commandArgs[scopeIdx + 1];
     if (!isValidScope(scope)) {
       context.print(`[recall] Unknown scope "${scope}". Valid: ${VALID_SCOPES.join(', ')}`);
       return;
@@ -30,9 +37,9 @@ export function handleRecallExport(args: string[], context: CommandContext): voi
     filter.scope = scope;
   }
 
-  const clsIdx = args.indexOf('--cls');
-  if (clsIdx !== -1 && args[clsIdx + 1]) {
-    const cls = args[clsIdx + 1];
+  const clsIdx = commandArgs.indexOf('--cls');
+  if (clsIdx !== -1 && commandArgs[clsIdx + 1]) {
+    const cls = commandArgs[clsIdx + 1];
     if (!isValidClass(cls)) {
       context.print(`[recall] Unknown class "${cls}". Valid: ${VALID_CLASSES.join(', ')}`);
       return;
@@ -48,14 +55,20 @@ export function handleRecallExport(args: string[], context: CommandContext): voi
 }
 
 export async function handleRecallImport(args: string[], context: CommandContext): Promise<void> {
+  const parsed = stripYesFlag(args);
+  const commandArgs = [...parsed.rest];
   const memory = getMemoryApi(context);
   if (!memory) {
     return;
   }
 
-  const pathArg = args[0];
+  const pathArg = commandArgs[0];
   if (!pathArg) {
-    context.print('[recall] Usage: /recall import <path>');
+    context.print('[recall] Usage: /recall import <path> --yes');
+    return;
+  }
+  if (!parsed.yes) {
+    requireYesFlag(context, `import durable memory bundle from ${pathArg}`, '/recall import <path> --yes');
     return;
   }
 
@@ -85,17 +98,23 @@ function inspectBundle(bundle: MemoryBundle): string {
 }
 
 export function handleRecallHandoffExport(args: string[], context: CommandContext): void {
+  const parsed = stripYesFlag(args);
+  const commandArgs = [...parsed.rest];
   const memory = getMemoryApi(context);
   if (!memory) {
     return;
   }
-  const pathArg = args[0];
+  const pathArg = commandArgs[0];
   if (!pathArg) {
-    context.print('[recall] Usage: /recall handoff-export <path> [--scope <scope>]');
+    context.print('[recall] Usage: /recall handoff-export <path> [--scope <scope>] --yes');
     return;
   }
-  const scopeIdx = args.indexOf('--scope');
-  const scopeRaw = scopeIdx !== -1 ? args[scopeIdx + 1] : 'team';
+  if (!parsed.yes) {
+    requireYesFlag(context, `export memory handoff bundle to ${pathArg}`, '/recall handoff-export <path> [--scope <scope>] --yes');
+    return;
+  }
+  const scopeIdx = commandArgs.indexOf('--scope');
+  const scopeRaw = scopeIdx !== -1 ? commandArgs[scopeIdx + 1] : 'team';
   if (!scopeRaw || !isValidScope(scopeRaw)) {
     context.print(`[recall] Unknown scope "${scopeRaw ?? ''}". Valid: ${VALID_SCOPES.join(', ')}`);
     return;
@@ -123,10 +142,12 @@ export function handleRecallHandoffInspect(args: string[], context: CommandConte
 }
 
 export async function handleRecallHandoffImport(args: string[], context: CommandContext): Promise<void> {
-  const pathArg = args[0];
+  const parsed = stripYesFlag(args);
+  const commandArgs = [...parsed.rest];
+  const pathArg = commandArgs[0];
   if (!pathArg) {
-    context.print('[recall] Usage: /recall handoff-import <path>');
+    context.print('[recall] Usage: /recall handoff-import <path> --yes');
     return;
   }
-  await handleRecallImport([pathArg], context);
+  await handleRecallImport([pathArg, ...(parsed.yes ? ['--yes'] : [])], context);
 }

package/src/input/commands/recall-query.ts

@@ -2,6 +2,7 @@ import type { CommandContext } from '../command-registry.ts';
 import type { MemoryApi } from '@pellux/goodvibes-sdk/platform/knowledge';
 import type { MemorySearchFilter } from '@pellux/goodvibes-sdk/platform/state';
 import { VALID_CLASSES, VALID_SCOPES, isValidClass, isValidScope } from './recall-shared.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 export function getMemoryApi(context: CommandContext): MemoryApi | null {
   const memoryApi = context.clients?.agentKnowledgeApi?.memory;
@@ -159,9 +160,14 @@ export async function handleRecallLink(args: string[], context: CommandContext):
   if (!memory) {
     return;
   }
-  const [fromId, toId, relation] = args;
+  const parsed = stripYesFlag(args);
+  const [fromId, toId, relation] = parsed.rest;
   if (!fromId || !toId || !relation) {
-    context.print('[recall] Usage: /recall link <fromId> <toId> <relation>');
+    context.print('[recall] Usage: /recall link <fromId> <toId> <relation> --yes');
+    return;
+  }
+  if (!parsed.yes) {
+    requireYesFlag(context, `link memory records ${fromId} and ${toId}`, '/recall link <fromId> <toId> <relation> --yes');
     return;
   }
   const link = await memory.link(fromId, toId, relation);
@@ -177,9 +183,14 @@ export function handleRecallRemove(args: string[], context: CommandContext): voi
   if (!memory) {
     return;
   }
-  const id = args[0];
+  const parsed = stripYesFlag(args);
+  const id = parsed.rest[0];
   if (!id) {
-    context.print('[recall] Usage: /recall remove <id>');
+    context.print('[recall] Usage: /recall remove <id> --yes');
+    return;
+  }
+  if (!parsed.yes) {
+    requireYesFlag(context, `delete durable memory record ${id}`, '/recall remove <id> --yes');
     return;
   }
   const removed = memory.delete(id);

package/src/input/commands/recall-review.ts

@@ -1,6 +1,7 @@
 import type { CommandContext } from '../command-registry.ts';
 import { VALID_REVIEW_STATES, VALID_SCOPES, isValidReviewState, isValidScope } from './recall-shared.ts';
 import { getMemoryApi } from './recall-query.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 export function handleRecallQueue(args: string[], context: CommandContext): void {
   const memory = getMemoryApi(context);
@@ -83,10 +84,15 @@ export function handleRecallPromote(args: string[], context: CommandContext): vo
   if (!memory) {
     return;
   }
-  const id = args[0];
-  const scope = args[1];
+  const parsed = stripYesFlag(args);
+  const id = parsed.rest[0];
+  const scope = parsed.rest[1];
   if (!id || !scope || !isValidScope(scope)) {
-    context.print(`[recall] Usage: /recall promote <id> <${VALID_SCOPES.join('|')}>`);
+    context.print(`[recall] Usage: /recall promote <id> <${VALID_SCOPES.join('|')}> --yes`);
+    return;
+  }
+  if (!parsed.yes) {
+    requireYesFlag(context, `promote durable memory record ${id} to ${scope} scope`, '/recall promote <id> <scope> --yes');
     return;
   }
   const record = memory.update(id, { scope });