@pellux/goodvibes-agent 0.1.10 → 0.1.12

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

@@ -4,6 +4,7 @@ import { AGENT_TEMPLATES } from '@pellux/goodvibes-sdk/platform/tools';
 import { handleRemoteSetupCommand } from './remote-runtime-setup.ts';
 import { handleRemotePoolCommand } from './remote-runtime-pool.ts';
 import { requirePeerClient } from './runtime-services.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 type RemoteConnectionLike = { agentId: string };
 type RemoteCancelContext = Pick<CommandContext, 'print'>;
@@ -45,7 +46,7 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
     name: 'remote',
     aliases: [],
     description: 'Inspect, dispatch, and review self-hosted remote runners and artifacts',
-    usage: '[list | show [agentId] | supervisor [runnerId] | capabilities [runnerId] | recover [runnerId] | setup [export <path>] | env [export <path>] | tunnel [review|export <path>] | bootstrap [export <path>|inspect <path>] | session <export|inspect|import> <path> | pool <list|show|create|assign|unassign> ... | dispatch [template] <description> | dispatch-pool <pool> [template] <description> | contract [agentId] | cancel <agentId> | export <agentId> [path] | artifact list | artifact show <id> | artifact export <id> [path] | review <id> | rerun-local <id> | import <path>]',
+    usage: '[list | show [agentId] | supervisor [runnerId] | capabilities [runnerId] | recover [runnerId] | setup [export <path> --yes] | env [export <path> --yes] | tunnel [review|export <path> --yes] | bootstrap [export <path> --yes|inspect <path>] | session <export|inspect|import> <path> [--yes] | pool <list|show|create|assign|unassign> ... | dispatch [template] <description> | dispatch-pool <pool> [template] <description> | contract [agentId] | cancel <agentId> | export <agentId> [path] --yes | artifact list | artifact show <id> | artifact export <id> [path] --yes | review <id> | rerun-local <id> | import <path> --yes]',
     async handler(args, ctx) {
       if (args.length === 0) {
         if (ctx.openRemotePanel) {
@@ -310,9 +311,14 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (subcommand === 'export') {
-        const agentId = args[1];
+        const { rest, yes } = stripYesFlag(args);
+        const agentId = rest[1];
         if (!agentId) {
-          ctx.print('Usage: /remote export <agentId> [path]');
+          ctx.print('Usage: /remote export <agentId> [path] --yes');
+          return;
+        }
+        if (!yes) {
+          requireYesFlag(ctx, `export remote review artifact for ${agentId}`, '/remote export <agentId> [path] --yes');
           return;
         }
         const artifact = remoteRunners.captureArtifactForRunner(agentId);
@@ -320,7 +326,7 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
           ctx.print(`Remote artifact export failed for ${agentId}.`);
           return;
         }
-        const exported = await remoteRunners.exportArtifact(artifact.id, args[2]);
+        const exported = await remoteRunners.exportArtifact(artifact.id, rest[2]);
         if (!exported) {
           ctx.print(`Remote artifact export failed for ${agentId}.`);
           return;
@@ -356,12 +362,17 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
           return;
         }
         if (mode === 'export') {
-          const artifactId = args[2];
+          const { rest, yes } = stripYesFlag(args);
+          const artifactId = rest[2];
           if (!artifactId) {
-            ctx.print('Usage: /remote artifact export <artifactId> [path]');
+            ctx.print('Usage: /remote artifact export <artifactId> [path] --yes');
             return;
           }
-          const exported = await remoteRunners.exportArtifact(artifactId, args[3]);
+          if (!yes) {
+            requireYesFlag(ctx, `export remote review artifact ${artifactId}`, '/remote artifact export <artifactId> [path] --yes');
+            return;
+          }
+          const exported = await remoteRunners.exportArtifact(artifactId, rest[3]);
           if (!exported) {
             ctx.print(`Unknown remote artifact: ${artifactId}`);
             return;
@@ -400,9 +411,14 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (subcommand === 'import') {
-        const path = args[1];
+        const { rest, yes } = stripYesFlag(args);
+        const path = rest[1];
         if (!path) {
-          ctx.print('Usage: /remote import <path>');
+          ctx.print('Usage: /remote import <path> --yes');
+          return;
+        }
+        if (!yes) {
+          requireYesFlag(ctx, `import remote review artifact from ${path}`, '/remote import <path> --yes');
           return;
         }
         const artifact = await remoteRunners.importArtifact(path);

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

@@ -1,17 +1,24 @@
 import type { CommandRegistry } from '../command-registry.ts';
 import { handleReplayCommand } from '@pellux/goodvibes-sdk/platform/core';
 import { requireReplayEngine } from './runtime-services.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 export function registerReplayRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'replay',
     aliases: ['rep'],
     description: 'Deterministic replay: load, step, seek, diff, and export recorded runs',
-    usage: '[load [runId] | step [n] | seek <rev> | diff | export <path>]',
+    usage: '[load [runId] | step [n] | seek <rev> | diff | export <path> --yes]',
     argsHint: '[load|step|seek|diff|export]',
     handler(args, ctx) {
+      const command = args[0] ?? 'help';
+      const { rest, yes } = stripYesFlag(args);
+      if (command === 'export' && !yes) {
+        requireYesFlag(ctx, `export replay run to ${args[1] ?? '<path>'}`, '/replay export <path> --yes');
+        return;
+      }
       const replayEngine = requireReplayEngine(ctx);
-      const result = handleReplayCommand({ replayEngine }, args[0] ?? 'help', args.slice(1));
+      const result = handleReplayCommand({ replayEngine }, command, rest.slice(1));
       ctx.print(result.output);
     },
   });

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

@@ -5,15 +5,18 @@ import type { SelectionAction, SelectionItem } from '../selection-modal.ts';
 import { openCommandPanel, requireServiceRegistry, requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../../config/surface.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 export function registerServicesRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'services',
     aliases: ['svc'],
     description: 'Manage API service configurations',
-    usage: '[open|list|inspect <name>|test <name>|resolve <name>|auth <name>|auth-review|doctor|export <path>|import <path>]',
+    usage: '[open|list|inspect <name>|test <name>|resolve <name>|auth <name>|auth-review|doctor|export <path> --yes|import <path> --yes]',
     async handler(args, ctx) {
-      const sub = args[0] ?? 'open';
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
+      const sub = commandArgs[0] ?? 'open';
       const shellPaths = requireShellPaths(ctx);
       if (sub === 'open' || sub === 'panel') {
         openCommandPanel(ctx, 'services');
@@ -23,7 +26,7 @@ export function registerServicesRuntimeCommands(registry: CommandRegistry): void
       const all = svcRegistry.getAll();
       const keys = Object.keys(all);
       if (sub === 'inspect') {
-        const name = args[1];
+        const name = commandArgs[1];
         if (!name) {
           ctx.print('Usage: /services inspect <name>');
           return;
@@ -47,7 +50,7 @@ export function registerServicesRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (sub === 'test') {
-        const name = args[1];
+        const name = commandArgs[1];
         if (!name) {
           ctx.print('Usage: /services test <name>');
           return;
@@ -63,7 +66,7 @@ export function registerServicesRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (sub === 'resolve') {
-        const name = args[1];
+        const name = commandArgs[1];
         if (!name) {
           ctx.print('Usage: /services resolve <name>');
           return;
@@ -80,7 +83,7 @@ export function registerServicesRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (sub === 'auth') {
-        const name = args[1];
+        const name = commandArgs[1];
         if (!name) {
           ctx.print('Usage: /services auth <name>');
           return;
@@ -141,9 +144,13 @@ export function registerServicesRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (sub === 'export') {
-        const pathArg = args[1];
+        const pathArg = commandArgs[1];
         if (!pathArg) {
-          ctx.print('Usage: /services export <path>');
+          ctx.print('Usage: /services export <path> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `export services config to ${pathArg}`, '/services export <path> --yes');
           return;
         }
         const targetPath = shellPaths.resolveWorkspacePath(pathArg);
@@ -153,9 +160,13 @@ export function registerServicesRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (sub === 'import') {
-        const pathArg = args[1];
+        const pathArg = commandArgs[1];
         if (!pathArg) {
-          ctx.print('Usage: /services import <path>');
+          ctx.print('Usage: /services import <path> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `import services config from ${pathArg}`, '/services import <path> --yes');
           return;
         }
         const sourcePath = shellPaths.resolveWorkspacePath(pathArg);

package/src/input/commands/session-content.ts

@@ -1,5 +1,5 @@
 import { join, resolve } from 'path';
-import { existsSync, mkdirSync, unlinkSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
 import type { CommandRegistry } from '../command-registry.ts';
 import type { SelectionItem } from '../selection-modal.ts';
@@ -7,18 +7,20 @@ import { exportToMarkdown } from '@pellux/goodvibes-sdk/platform/export';
 import { TemplateManager, parseTemplateArgs } from '@pellux/goodvibes-sdk/platform/templates';
 import { requireSessionManager, requireSessionMemoryStore, requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 export function registerSessionContentCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'export',
     description: 'Export conversation to a Markdown file',
-    usage: '[format] [path]',
+    usage: '[format] [path] --yes',
     argsHint: '[markdown] [path]',
     async handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
+      const { rest, yes } = stripYesFlag(args);
       let format = 'markdown';
       let outPath: string | undefined;
-      for (const arg of args) {
+      for (const arg of rest) {
         if (arg === 'markdown' || arg === 'md' || arg === 'text' || arg === 'txt') {
           format = arg === 'md' ? 'markdown' : arg === 'txt' ? 'text' : arg;
         } else {
@@ -34,6 +36,10 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
         ctx.print('Error: Export path must be within the current directory.');
         return;
       }
+      if (!yes) {
+        requireYesFlag(ctx, `export conversation to ${resolvedPath}`, '/export [format] [path] --yes');
+        return;
+      }
 
       try {
         const data = ctx.session.conversationManager.toJSON() as { messages: Array<Record<string, unknown>> };
@@ -229,34 +235,21 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
       const sessionManager = requireSessionManager(ctx);
       const sessions = sessionManager.list();
       if (ctx.openSelection) {
-        const deleteAction = new Map([['d', 'delete' as const]]);
         const items: SelectionItem[] = sessions.length === 0
           ? [{ id: '_empty', label: 'No saved sessions', detail: 'Use /save [name] to save' }]
-          : sessions.map(s => ({ id: s.name, label: s.name, detail: s.title || '(untitled)', actions: '[d] delete' }));
-        ctx.openSelection('Sessions', items, { allowSearch: true, customActions: deleteAction }, (result) => {
+          : sessions.map(s => ({ id: s.name, label: s.name, detail: s.title || '(untitled)', actions: 'Enter to load' }));
+        ctx.openSelection('Sessions', items, { allowSearch: true }, (result) => {
           if (!result) return;
-          if (result.action === 'delete') {
-            try {
-              const sessionInfo = sessions.find(s => s.name === result.item.id);
-              if (sessionInfo) {
-                unlinkSync(sessionInfo.filePath);
-                ctx.print(`Session deleted: ${result.item.id}`);
-              }
-            } catch (e) {
-              ctx.print(`Failed to delete session: ${summarizeError(e)}`);
-            }
-          } else {
-            try {
-              const { meta, messages } = sessionManager.load(result.item.id);
-              ctx.session.conversationManager.resetAll();
-              ctx.session.conversationManager.fromJSON({ messages: messages as never[] });
-              if (meta.title) ctx.session.conversationManager.title = meta.title;
-              ctx.session.conversationManager.rebuildHistory();
-              ctx.renderRequest();
-              ctx.print(`Session loaded: ${result.item.id} (${messages.length} messages)`);
-            } catch (e) {
-              ctx.print(`Failed to load session: ${summarizeError(e)}`);
-            }
+          try {
+            const { meta, messages } = sessionManager.load(result.item.id);
+            ctx.session.conversationManager.resetAll();
+            ctx.session.conversationManager.fromJSON({ messages: messages as never[] });
+            if (meta.title) ctx.session.conversationManager.title = meta.title;
+            ctx.session.conversationManager.rebuildHistory();
+            ctx.renderRequest();
+            ctx.print(`Session loaded: ${result.item.id} (${messages.length} messages)`);
+          } catch (e) {
+            ctx.print(`Failed to load session: ${summarizeError(e)}`);
           }
         });
         return;
@@ -271,7 +264,7 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
     name: 'template',
     aliases: ['tmpl'],
     description: 'Manage and use prompt templates',
-    usage: 'save <name> | use <name> [args] | list | edit <name> | delete <name>',
+    usage: 'save <name> --yes | use <name> [args] | list | edit <name> | delete <name> --yes',
     argsHint: '<save|use|list|edit|delete> [name]',
     handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
@@ -279,28 +272,24 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
         projectRoot: shellPaths.workingDirectory,
         homeDirectory: shellPaths.homeDirectory,
       });
-      const sub = args[0];
-      const rest = args.slice(1);
+      const parsed = stripYesFlag(args);
+      const sub = parsed.rest[0];
+      const rest = parsed.rest.slice(1);
       if (!sub || sub === 'list') {
         const templates = templateManager.list();
         if (ctx.openSelection) {
-          const actions = new Map([['d', 'delete' as const], ['e', 'edit' as const]]);
+          const actions = new Map([['e', 'edit' as const]]);
           const items: SelectionItem[] = templates.length === 0
-            ? [{ id: '_empty', label: 'No templates saved', detail: 'Use /template save <name>' }]
-            : templates.map(t => ({ id: t.name, label: t.name, detail: t.preview, category: t.scope === 'project' ? 'project' : 'global', actions: '[d] delete  [e] edit' }));
+            ? [{ id: '_empty', label: 'No templates saved', detail: 'Use /template save <name> --yes' }]
+            : templates.map(t => ({ id: t.name, label: t.name, detail: t.preview, category: t.scope === 'project' ? 'project' : 'global', actions: '[e] edit' }));
           ctx.openSelection('Templates', items, { allowSearch: true, customActions: actions }, (result) => {
             if (!result) return;
-            if (result.action === 'delete') {
-              const deleted = templateManager.delete(result.item.id);
-              ctx.print(deleted ? `Template deleted: ${result.item.id}` : `Template not found: ${result.item.id}`);
+            const content = templateManager.load(result.item.id);
+            if (content !== null) {
+              if (result.action === 'edit') ctx.print(`Template: ${result.item.id}\n\n${content}`);
+              else ctx.submitInput?.(content);
             } else {
-              const content = templateManager.load(result.item.id);
-              if (content !== null) {
-                if (result.action === 'edit') ctx.print(`Template: ${result.item.id}\n\n${content}`);
-                else ctx.submitInput?.(content);
-              } else {
-                ctx.print(`Template not found: ${result.item.id}`);
-              }
+              ctx.print(`Template not found: ${result.item.id}`);
             }
           });
           return;
@@ -311,7 +300,11 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
       if (sub === 'save') {
         const name = rest[0];
         if (!name) {
-          ctx.print('Usage: /template save <name>');
+          ctx.print('Usage: /template save <name> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `save prompt template ${name}`, '/template save <name> --yes');
           return;
         }
         try {
@@ -349,20 +342,24 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
       if (sub === 'delete') {
         const name = rest[0];
         if (!name) {
-          ctx.print('Usage: /template delete <name>');
+          ctx.print('Usage: /template delete <name> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `delete prompt template ${name}`, '/template delete <name> --yes');
           return;
         }
         ctx.print(templateManager.delete(name) ? `Template deleted: ${name}` : `Template not found: ${name}`);
         return;
       }
-      ctx.print(`Unknown subcommand: ${sub}\nUsage: /template save|use|list|edit|delete`);
+      ctx.print(`Unknown subcommand: ${sub}\nUsage: /template save <name> --yes | use <name> | list | edit <name> | delete <name> --yes`);
     },
   });
 
   registry.register({
     name: 'memory',
     description: 'Manage session memories (pinned across context compaction)',
-    usage: '[list|add <text>|remove <id>]',
+    usage: '[list|add <text>|remove <id> --yes]',
     argsHint: '[list|add|remove]',
     handler(args, ctx) {
       const sub = args[0] ?? 'list';
@@ -380,15 +377,20 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
         const id = requireSessionMemoryStore(ctx).add(text);
         ctx.print(`Memory added: [${id}] ${text}`);
       } else if (sub === 'remove') {
-        const id = args[1];
+        const parsed = stripYesFlag(args);
+        const id = parsed.rest[1];
         if (!id) {
-          ctx.print('Usage: /memory remove <id>');
+          ctx.print('Usage: /memory remove <id> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `remove session memory ${id}`, '/memory remove <id> --yes');
           return;
         }
         const store = requireSessionMemoryStore(ctx);
         ctx.print(store.remove(id) ? `Memory removed: [${id}]` : `Memory not found: ${id}`);
       } else {
-        ctx.print('Usage: /memory [list|add <text>|remove <id>]\n  /memory              — list all session memories\n  /memory list         — list all session memories\n  /memory add <text>   — add a memory without sending a message\n  /memory remove <id>  — remove a specific memory');
+        ctx.print('Usage: /memory [list|add <text>|remove <id> --yes]\n  /memory                    — list all session memories\n  /memory list               — list all session memories\n  /memory add <text>         — add a memory without sending a message\n  /memory remove <id> --yes  — remove a specific memory');
       }
     },
   });

package/src/input/commands/session-workflow.ts

@@ -8,6 +8,7 @@ import type { SessionReturnContextSummary } from '@/runtime/index.ts';
 import { formatReturnContextForDisplay, getReturnContextMode, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
 import { requirePanelManager, requireProviderApi, requireSessionManager } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 function parseTranscriptKind(raw: string | undefined): TranscriptEventKind | 'all' {
   const normalized = (raw ?? 'all').toLowerCase().replace(/-/g, '_');
@@ -414,9 +415,14 @@ export async function handleSessionWorkflowCommand(args: string[], ctx: CommandC
   }
 
   if (sub === 'delete') {
-    const target = args[1];
+    const parsed = stripYesFlag(args);
+    const target = parsed.rest[1];
     if (!target) {
-      ctx.print('Usage: /session delete <session-id>');
+      ctx.print('Usage: /session delete <session-id> --yes');
+      return true;
+    }
+    if (!parsed.yes) {
+      requireYesFlag(ctx, `delete saved session ${target}`, '/session delete <session-id> --yes');
       return true;
     }
     const sessions = sm.list();
@@ -446,12 +452,12 @@ export function registerSessionWorkflowCommands(registry: CommandRegistry): void
     name: 'session',
     aliases: ['sess'],
     description: 'Manage sessions, resume posture, and transcript structure',
-    usage: '[list | rename <name> | resume <id|name> | fork | save | info <id> | events [kind] | groups [kind] | hotspots | export <id> [format] | search <query> | delete <id>]',
+    usage: '[list | rename <name> | resume <id|name> | fork | save | info <id> | events [kind] | groups [kind] | hotspots | export <id> [format] | search <query> | delete <id> --yes]',
     argsHint: '<list|rename|resume|fork|save|info|events|groups|hotspots|export|search|delete>',
     async handler(args, ctx) {
       const handled = await handleSessionWorkflowCommand(args, ctx);
       if (!handled) {
-        ctx.print('Unknown subcommand: ' + (args[0] ?? '') + '\nUsage: /session [list | rename <name> | resume <id> | fork [name] | save [name] | info [id] | events [kind] | groups [kind] | hotspots | export <id> [format] | search <query> | delete <id>]');
+        ctx.print('Unknown subcommand: ' + (args[0] ?? '') + '\nUsage: /session [list | rename <name> | resume <id> | fork [name] | save [name] | info [id] | events [kind] | groups [kind] | hotspots | export <id> [format] | search <query> | delete <id> --yes]');
       }
     },
   });

package/src/input/commands/session.ts

@@ -352,7 +352,7 @@ export const sessionCommand: SlashCommand = {
         if (!handled) {
           const usage = [
             'Usage: /session <subcommand>',
-            '  list | rename <name> | resume <id|name> | fork [name] | save [name] | info [id] | export <id> [format] | search <query> | delete <id>',
+            '  list | rename <name> | resume <id|name> | fork [name] | save [name] | info [id] | export <id> [format] | search <query> | delete <id> --yes',
             '                                 — Session continuity, export, resume, and pruning',
             '  graph [--session <sid>] [--format text|json]',
             '                                 — Display the cross-session task dependency graph',

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

@@ -21,23 +21,26 @@ import { CONFIG_KEYS } from '@pellux/goodvibes-sdk/platform/config';
 import type { CommandRegistry } from '../command-registry.ts';
 import { openCommandPanel, requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 export function registerSettingsSyncRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'settingssync',
     aliases: ['settings-sync'],
     description: 'Review sync posture, export/import settings-sync bundles, and open the settings sync workspace',
-    usage: '[review|panel|show <key>|staged|conflicts|resolve <key> <local|synced>|failures|rollback-history|export <path>|inspect <path>|pull <path>|push <path>|lock <key> <source> <reason...>|unlock <key>]',
+    usage: '[review|panel|show <key>|staged|conflicts|resolve <key> <local|synced> --yes|failures|rollback-history|export <path> --yes|inspect <path>|pull <path> --yes|push <path> --yes|lock <key> <source> <reason...> --yes|unlock <key> --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] ?? 'review').toLowerCase();
+      const sub = (commandArgs[0] ?? 'review').toLowerCase();
       if (sub === 'panel' || sub === 'open') {
         openCommandPanel(ctx, 'settings-sync');
         return;
       }
       if (sub === 'show') {
-        const key = args[1] as ConfigKey | undefined;
+        const key = commandArgs[1] as ConfigKey | undefined;
         if (!key || !CONFIG_KEYS.has(key)) {
           ctx.print('Usage: /settingssync show <config-key>');
           return;
@@ -60,10 +63,14 @@ export function registerSettingsSyncRuntimeCommands(registry: CommandRegistry):
         return;
       }
       if (sub === 'resolve') {
-        const key = args[1] as ConfigKey | undefined;
-        const resolution = (args[2] ?? '').toLowerCase();
+        const key = commandArgs[1] as ConfigKey | undefined;
+        const resolution = (commandArgs[2] ?? '').toLowerCase();
         if (!key || !CONFIG_KEYS.has(key) || (resolution !== 'local' && resolution !== 'synced')) {
-          ctx.print('Usage: /settingssync resolve <config-key> <local|synced>');
+          ctx.print('Usage: /settingssync resolve <config-key> <local|synced> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `resolve synced conflict for ${key}`, '/settingssync resolve <config-key> <local|synced> --yes');
           return;
         }
         const changed = resolveSettingsSyncConflict(ctx.platform.configManager, key, resolution);
@@ -100,9 +107,13 @@ export function registerSettingsSyncRuntimeCommands(registry: CommandRegistry):
         return;
       }
       if (sub === 'export' || sub === 'push') {
-        const pathArg = args[1];
+        const pathArg = commandArgs[1];
         if (!pathArg) {
-          ctx.print(`Usage: /settingssync ${sub} <path>`);
+          ctx.print(`Usage: /settingssync ${sub} <path> --yes`);
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `${sub === 'push' ? 'push' : 'export'} settings sync bundle to ${pathArg}`, `/settingssync ${sub} <path> --yes`);
           return;
         }
         const targetPath = shellPaths.resolveWorkspacePath(pathArg);
@@ -120,7 +131,7 @@ export function registerSettingsSyncRuntimeCommands(registry: CommandRegistry):
         return;
       }
       if (sub === 'inspect') {
-        const pathArg = args[1];
+        const pathArg = commandArgs[1];
         if (!pathArg) {
           ctx.print('Usage: /settingssync inspect <path>');
           return;
@@ -131,9 +142,13 @@ export function registerSettingsSyncRuntimeCommands(registry: CommandRegistry):
         return;
       }
       if (sub === 'pull') {
-        const pathArg = args[1];
+        const pathArg = commandArgs[1];
         if (!pathArg) {
-          ctx.print('Usage: /settingssync pull <path>');
+          ctx.print('Usage: /settingssync pull <path> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `pull settings sync bundle from ${pathArg}`, '/settingssync pull <path> --yes');
           return;
         }
         const sourcePath = shellPaths.resolveWorkspacePath(pathArg);
@@ -148,11 +163,15 @@ export function registerSettingsSyncRuntimeCommands(registry: CommandRegistry):
         return;
       }
       if (sub === 'lock') {
-        const key = args[1] as ConfigKey | undefined;
-        const source = args[2];
-        const reason = args.slice(3).join(' ').trim();
+        const key = commandArgs[1] as ConfigKey | undefined;
+        const source = commandArgs[2];
+        const reason = commandArgs.slice(3).join(' ').trim();
         if (!key || !source || !reason || !CONFIG_KEYS.has(key)) {
-          ctx.print('Usage: /settingssync lock <config-key> <source> <reason...>');
+          ctx.print('Usage: /settingssync lock <config-key> <source> <reason...> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `lock managed setting ${key}`, '/settingssync lock <config-key> <source> <reason...> --yes');
           return;
         }
         setManagedSettingLock(key, source, reason, controlPlaneConfigDir);
@@ -160,9 +179,13 @@ export function registerSettingsSyncRuntimeCommands(registry: CommandRegistry):
         return;
       }
       if (sub === 'unlock') {
-        const key = args[1] as ConfigKey | undefined;
+        const key = commandArgs[1] as ConfigKey | undefined;
         if (!key || !CONFIG_KEYS.has(key)) {
-          ctx.print('Usage: /settingssync unlock <config-key>');
+          ctx.print('Usage: /settingssync unlock <config-key> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `unlock managed setting ${key}`, '/settingssync unlock <config-key> --yes');
           return;
         }
         ctx.print(clearManagedSettingLock(key, controlPlaneConfigDir) ? `Managed lock cleared for ${key}.` : `No managed lock found for ${key}.`);

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

@@ -11,23 +11,26 @@ import {
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 export function registerShareRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'share',
     aliases: [],
     description: 'Export the current session to a shareable format (html, json, md)',
-    usage: '<html|json|md> [path] [--redact]',
+    usage: '<html|json|md> [path] [--redact] --yes',
     argsHint: '<html|json|md> [path]',
     async handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
       const shellPaths = requireShellPaths(ctx);
       const FORMATS = ['html', 'json', 'md'] as const;
       type Format = typeof FORMATS[number];
 
-      const format = args[0]?.toLowerCase() as Format | undefined;
+      const format = commandArgs[0]?.toLowerCase() as Format | undefined;
       if (!format || !FORMATS.includes(format)) {
         ctx.print(
-          'Usage: /share <html|json|md> [path] [--redact]\n'
+          'Usage: /share <html|json|md> [path] [--redact] --yes\n'
           + '  html  — self-contained HTML with syntax highlighting\n'
           + '  json  — structured JSON (machine-readable)\n'
           + '  md    — Markdown\n\n'
@@ -38,13 +41,18 @@ export function registerShareRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
-      const remainingArgs = args.slice(1);
+      const remainingArgs = commandArgs.slice(1);
       const redact = remainingArgs.includes('--redact');
       const pathArgs = remainingArgs.filter(a => a !== '--redact');
       const outputPath = pathArgs.length > 0
         ? shellPaths.resolveWorkspacePath(pathArgs[0])
         : defaultExportPath(format, shellPaths.homeDirectory);
 
+      if (!parsed.yes) {
+        requireYesFlag(ctx, `export ${format.toUpperCase()} session to ${outputPath}`, '/share <html|json|md> [path] [--redact] --yes');
+        return;
+      }
+
       const convData = ctx.session.conversationManager.toJSON() as {
         messages: Array<{
           role: string;