@pellux/goodvibes-agent 0.1.10 → 0.1.12

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

package/src/input/commands/remote-runtime-setup.ts

@@ -4,6 +4,7 @@ import { getDefaultAcpAgentCommand } from '@pellux/goodvibes-sdk/platform/acp';
 import type { CommandContext, RemoteCommandService } from '../command-registry.ts';
 import type { RemoteSessionBundle } from '@/runtime/index.ts';
 import { requireShellPaths } from './runtime-services.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 type RemoteRegistryLike = Pick<RemoteCommandService, 'listContracts' | 'exportSessionBundle' | 'importSessionBundle'>;
 
@@ -33,7 +34,9 @@ export async function handleRemoteSetupCommand(
   activeConnections: ActiveConnectionLike[],
   remoteRegistry: RemoteRegistryLike,
 ): Promise<boolean> {
-  const subcommand = args[0]?.toLowerCase() ?? 'show';
+  const parsed = stripYesFlag(args);
+  const commandArgs = [...parsed.rest];
+  const subcommand = commandArgs[0]?.toLowerCase() ?? 'show';
   if (subcommand === 'setup') {
     const command = getDefaultAcpAgentCommand();
     const danger = ctx.platform.configManager.getCategory('danger');
@@ -50,10 +53,14 @@ export async function handleRemoteSetupCommand(
       '    - use /remote env to export a reusable shell snippet',
       '    - enable danger.daemon / danger.httpListener only when you actually need those remote surfaces',
     ];
-    if (args[1]?.toLowerCase() === 'export') {
-      const pathArg = args[2];
+    if (commandArgs[1]?.toLowerCase() === 'export') {
+      const pathArg = commandArgs[2];
       if (!pathArg) {
-        ctx.print('Usage: /remote setup export <path>');
+        ctx.print('Usage: /remote setup export <path> --yes');
+        return true;
+      }
+      if (!parsed.yes) {
+        requireYesFlag(ctx, `export remote setup bundle to ${pathArg}`, '/remote setup export <path> --yes');
         return true;
       }
       const shellPaths = requireShellPaths(ctx);
@@ -79,10 +86,14 @@ export async function handleRemoteSetupCommand(
       `export ACP_AGENT_CMD='${command.join(' ')}'`,
       `export GOODVIBES_REMOTE_SESSION='${ctx.session.runtime.sessionId}'`,
     ].join('\n');
-    if (args[1]?.toLowerCase() === 'export') {
-      const pathArg = args[2];
+    if (commandArgs[1]?.toLowerCase() === 'export') {
+      const pathArg = commandArgs[2];
       if (!pathArg) {
-        ctx.print('Usage: /remote env export <path>');
+        ctx.print('Usage: /remote env export <path> --yes');
+        return true;
+      }
+      if (!parsed.yes) {
+        requireYesFlag(ctx, `export remote environment snippet to ${pathArg}`, '/remote env export <path> --yes');
         return true;
       }
       const shellPaths = requireShellPaths(ctx);
@@ -97,7 +108,7 @@ export async function handleRemoteSetupCommand(
   }
 
   if (subcommand === 'tunnel') {
-    const mode = args[1]?.toLowerCase() ?? 'review';
+    const mode = commandArgs[1]?.toLowerCase() ?? 'review';
     const lines = [
       'Remote Tunnel Review',
       '  transport: self-hosted ACP / daemon relay',
@@ -106,9 +117,13 @@ export async function handleRemoteSetupCommand(
       '  guidance: forward ACP agent traffic through your chosen self-hosted tunnel or SSH transport',
     ];
     if (mode === 'export') {
-      const pathArg = args[2];
+      const pathArg = commandArgs[2];
       if (!pathArg) {
-        ctx.print('Usage: /remote tunnel export <path>');
+        ctx.print('Usage: /remote tunnel export <path> --yes');
+        return true;
+      }
+      if (!parsed.yes) {
+        requireYesFlag(ctx, `export remote tunnel review to ${pathArg}`, '/remote tunnel export <path> --yes');
         return true;
       }
       const shellPaths = requireShellPaths(ctx);
@@ -123,7 +138,7 @@ export async function handleRemoteSetupCommand(
   }
 
   if (subcommand === 'bootstrap') {
-    const mode = args[1]?.toLowerCase() ?? 'export';
+    const mode = commandArgs[1]?.toLowerCase() ?? 'export';
     const payload = {
       exportedAt: Date.now(),
       sessionId: ctx.session.runtime.sessionId,
@@ -138,7 +153,7 @@ export async function handleRemoteSetupCommand(
       ],
     };
     if (mode === 'inspect') {
-      const pathArg = args[2];
+      const pathArg = commandArgs[2];
       if (!pathArg) {
         ctx.print('Usage: /remote bootstrap inspect <path>');
         return true;
@@ -154,9 +169,13 @@ export async function handleRemoteSetupCommand(
       ].join('\n'));
       return true;
     }
-    const pathArg = args[2] ?? args[1];
+    const pathArg = commandArgs[2] ?? commandArgs[1];
     if (!pathArg || mode !== 'export') {
-      ctx.print('Usage: /remote bootstrap export <path> | /remote bootstrap inspect <path>');
+      ctx.print('Usage: /remote bootstrap export <path> --yes | /remote bootstrap inspect <path>');
+      return true;
+    }
+    if (!parsed.yes) {
+      requireYesFlag(ctx, `export remote bootstrap bundle to ${pathArg}`, '/remote bootstrap export <path> --yes');
       return true;
     }
     const shellPaths = requireShellPaths(ctx);
@@ -168,15 +187,19 @@ export async function handleRemoteSetupCommand(
   }
 
   if (subcommand === 'session') {
-    const mode = args[1]?.toLowerCase();
-    const pathArg = args[2];
+    const mode = commandArgs[1]?.toLowerCase();
+    const pathArg = commandArgs[2];
     if (!mode || !pathArg) {
-      ctx.print('Usage: /remote session <export|inspect|import> <path>');
+      ctx.print('Usage: /remote session <export|inspect|import> <path> [--yes]');
       return true;
     }
     const shellPaths = requireShellPaths(ctx);
     const targetPath = shellPaths.resolveWorkspacePath(pathArg);
     if (mode === 'export') {
+      if (!parsed.yes) {
+        requireYesFlag(ctx, `export remote session bundle to ${pathArg}`, '/remote session export <path> --yes');
+        return true;
+      }
       const exported = await remoteRegistry.exportSessionBundle(targetPath);
       ctx.print(`Exported remote session bundle ${exported.bundle.sessionId} to ${exported.path}`);
       return true;
@@ -187,11 +210,15 @@ export async function handleRemoteSetupCommand(
       return true;
     }
     if (mode === 'import') {
+      if (!parsed.yes) {
+        requireYesFlag(ctx, `import remote session bundle from ${pathArg}`, '/remote session import <path> --yes');
+        return true;
+      }
       const bundle = await remoteRegistry.importSessionBundle(targetPath);
       ctx.print(`Imported remote session bundle ${bundle.sessionId} with ${bundle.contracts.length} contracts.`);
       return true;
     }
-    ctx.print('Usage: /remote session <export|inspect|import> <path>');
+    ctx.print('Usage: /remote session <export|inspect|import> <path> [--yes]');
     return true;
   }