@pellux/goodvibes-agent 0.1.9 → 0.1.11

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

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',