@pellux/goodvibes-agent 0.1.9 → 0.1.11

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;

package/src/input/commands/shell-core.ts

@@ -127,7 +127,7 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
           { id: '/clear', label: '/clear', detail: 'Clear display (keep context)', category: 'Conversation' },
           { id: '/reset', label: '/reset', detail: 'Clear display + context', category: 'Conversation' },
           { id: '/compact', label: '/compact', detail: 'Summarize to free context', category: 'Conversation' },
-          { id: '/export', label: '/export [file]', detail: 'Export as markdown', category: 'Conversation' },
+          { id: '/export', label: '/export [file] --yes', detail: 'Export as markdown', category: 'Conversation' },
           { id: '/title', label: '/title [text]', detail: 'Show or set title', category: 'Conversation' },
           { id: '/save', label: '/save [name]', detail: 'Save session', category: 'Conversation' },
           { id: '/load', label: '/load <name>', detail: 'Load session', category: 'Conversation' },
@@ -141,7 +141,7 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
           { id: '/session info', label: '/session info [id]', detail: 'Show session details', category: 'Conversation' },
           { id: '/session export', label: '/session export <id> [format]', detail: 'Export session as markdown/text', category: 'Conversation' },
           { id: '/session search', label: '/session search <query>', detail: 'Search across all sessions', category: 'Conversation' },
-          { id: '/session delete', label: '/session delete <id>', detail: 'Delete a session', category: 'Conversation' },
+          { id: '/session delete', label: '/session delete <id> --yes', detail: 'Delete a session', category: 'Conversation' },
           { id: '/undo', label: '/undo', detail: 'Remove last turn', category: 'Conversation' },
           { id: '/redo', label: '/redo', detail: 'Restore undone turn', category: 'Conversation' },
           { id: '/retry', label: '/retry [text]', detail: 'Re-send last message', category: 'Conversation' },
@@ -149,7 +149,7 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
           { id: '/branch', label: '/branch [name]', detail: 'List branches or switch to one', category: 'Conversation' },
           { id: '/merge', label: '/merge <name>', detail: 'Append messages from a branch', category: 'Conversation' },
           { id: '/template', label: '/template', detail: 'Browse templates', category: 'Templates' },
-          { id: '/template save', label: '/template save <name>', detail: 'Save prompt as template', category: 'Templates' },
+          { id: '/template save', label: '/template save <name> --yes', detail: 'Save prompt as template', category: 'Templates' },
           { id: '/template use', label: '/template use <name>', detail: 'Execute template', category: 'Templates' },
           { id: '/tools', label: '/tools', detail: 'List available tools', category: 'Tools & System' },
           { id: '/paste', label: '/paste', detail: 'Insert clipboard text or image into the prompt', category: 'Tools & System' },

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

@@ -9,6 +9,7 @@ import { inspectProviderAuth } from '@/runtime/index.ts';
 import { openExternalUrl } from '@pellux/goodvibes-sdk/platform/utils';
 import { requireSecretsManager, requireServiceRegistry, requireShellPaths, requireSubscriptionManager } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 interface SubscriptionBundle {
   readonly version: 1;
@@ -76,14 +77,16 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
     name: 'subscription',
     aliases: ['subs'],
     description: 'Manage provider subscription sessions and, when supported, let them override ambient API keys for matching providers',
-    usage: '[review|list|providers|inspect <provider>|login <provider> start [--no-browser] [--manual]|finish <code-or-url>|logout <provider>|bundle export <path>|bundle inspect <path>]',
+    usage: '[review|list|providers|inspect <provider>|login <provider> start [--no-browser] [--manual] --yes|login <provider> finish <code-or-url> --yes|logout <provider> --yes|bundle export <path> --yes|bundle inspect <path>]',
     async handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
       const shellPaths = requireShellPaths(ctx);
       if (args.length === 0 && ctx.openSubscriptionPanel) {
         ctx.openSubscriptionPanel();
         return;
       }
-      const sub = (args[0] ?? 'review').toLowerCase();
+      const sub = (commandArgs[0] ?? 'review').toLowerCase();
       const manager = requireSubscriptionManager(ctx);
       const services = requireServiceRegistry(ctx);
 
@@ -108,7 +111,7 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
       }
 
       if (sub === 'inspect') {
-        const provider = args[1];
+        const provider = commandArgs[1];
         if (!provider) {
           ctx.print('Usage: /subscription inspect <provider>');
           return;
@@ -153,10 +156,14 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
       }
 
       if (sub === 'login') {
-        const provider = args[1];
-        const mode = args[2]?.toLowerCase();
+        const provider = commandArgs[1];
+        const mode = commandArgs[2]?.toLowerCase();
         if (!provider || !mode) {
-          ctx.print('Usage: /subscription login <provider> start|finish <code>');
+          ctx.print('Usage: /subscription login <provider> start|finish <code> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `${mode} provider subscription login for ${provider}`, '/subscription login <provider> start|finish <code> --yes');
           return;
         }
         const service = services.get(provider);
@@ -170,7 +177,7 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
           return;
         }
         if (mode === 'start') {
-          const flags = new Set(args.slice(3));
+          const flags = new Set(commandArgs.slice(3));
           const openBrowser = !flags.has('--no-browser');
           const useManualMode = flags.has('--manual');
           if (provider === 'openai' && resolved.source === 'builtin') {
@@ -240,7 +247,7 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
                   `  state: ${started.state}`,
                   `  redirectUri: ${started.redirectUri}`,
                   `  browser: ${openBrowser ? (browserOpened ? 'opened' : 'open failed') : 'skipped'}`,
-                  `  next: /subscription login ${provider} finish <code-or-url>`,
+                  `  next: /subscription login ${provider} finish <code-or-url> --yes`,
                   `  listener: ${summarizeError(error)}`,
                   '  authorizationUrl:',
                   `  ${started.authorizationUrl}`,
@@ -256,7 +263,7 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
               `  state: ${started.state}`,
               `  redirectUri: ${started.redirectUri}`,
               `  browser: ${openBrowser ? (browserOpened ? 'opened' : 'open failed') : 'skipped'}`,
-              `  next: /subscription login ${provider} finish <code-or-url>`,
+              `  next: /subscription login ${provider} finish <code-or-url> --yes`,
               '  authorizationUrl:',
               `  ${started.authorizationUrl}`,
             ].join('\n'));
@@ -316,7 +323,7 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
                 `  state: ${started.pending.state}`,
                 `  redirectUri: ${activeConfig.redirectUri}`,
                 `  browser: ${openBrowser ? (browserOpened ? 'opened' : 'open failed') : 'skipped'}`,
-                `  next: /subscription login ${provider} finish <code-or-url>`,
+                `  next: /subscription login ${provider} finish <code-or-url> --yes`,
                 `  listener: ${summarizeError(error)}`,
                 '  authorizationUrl:',
                 `  ${started.authorizationUrl}`,
@@ -333,23 +340,23 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
             `  state: ${started.pending.state}`,
             `  redirectUri: ${activeConfig.redirectUri}`,
             `  browser: ${openBrowser ? (browserOpened ? 'opened' : 'open failed') : 'skipped'}`,
-            `  next: /subscription login ${provider} finish <code-or-url>`,
+            `  next: /subscription login ${provider} finish <code-or-url> --yes`,
             '  authorizationUrl:',
             `  ${started.authorizationUrl}`,
           ].join('\n'));
           return;
         }
         if (mode === 'finish') {
-          const codeInput = args[3];
+          const codeInput = commandArgs[3];
           if (!codeInput) {
-            ctx.print(`Usage: /subscription login ${provider} finish <code-or-url>`);
+            ctx.print(`Usage: /subscription login ${provider} finish <code-or-url> --yes`);
             return;
           }
           const code = extractAuthorizationCode(codeInput) ?? codeInput;
           if (provider === 'openai' && resolved.source === 'builtin') {
             const pending = manager.getPending(provider);
             if (!pending) {
-              ctx.print(`No pending OAuth login for ${provider}. Start with /subscription login ${provider} start.`);
+              ctx.print(`No pending OAuth login for ${provider}. Start with /subscription login ${provider} start --yes.`);
               return;
             }
             const token = await exchangeOpenAICodexCode(code, pending.verifier);
@@ -384,14 +391,18 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
           ].join('\n'));
           return;
         }
-        ctx.print('Usage: /subscription login <provider> start|finish <code-or-url>');
+        ctx.print('Usage: /subscription login <provider> start|finish <code-or-url> --yes');
         return;
       }
 
       if (sub === 'logout') {
-        const provider = args[1];
+        const provider = commandArgs[1];
         if (!provider) {
-          ctx.print('Usage: /subscription logout <provider>');
+          ctx.print('Usage: /subscription logout <provider> --yes');
+          return;
+        }
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `log out provider subscription ${provider}`, '/subscription logout <provider> --yes');
           return;
         }
         const removed = manager.logout(provider);
@@ -402,14 +413,18 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
       }
 
       if (sub === 'bundle') {
-        const mode = args[1]?.toLowerCase();
-        const pathArg = args[2];
+        const mode = commandArgs[1]?.toLowerCase();
+        const pathArg = commandArgs[2];
         if (!mode || !pathArg) {
           ctx.print('Usage: /subscription bundle <export|inspect> <path>');
           return;
         }
         const targetPath = shellPaths.resolveWorkspacePath(pathArg);
         if (mode === 'export') {
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `export subscription bundle to ${pathArg}`, '/subscription bundle export <path> --yes');
+            return;
+          }
           const bundle: SubscriptionBundle = {
             version: 1,
             exportedAt: Date.now(),
@@ -428,7 +443,7 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
         return;
       }
 
-      ctx.print('Usage: /subscription [review|list|providers|inspect <provider>|login <provider> start [--no-browser] [--manual]|finish <code-or-url>|logout <provider>|bundle export <path>|bundle inspect <path>]');
+      ctx.print('Usage: /subscription [review|list|providers|inspect <provider>|login <provider> start [--no-browser] [--manual] --yes|login <provider> finish <code-or-url> --yes|logout <provider> --yes|bundle export <path> --yes|bundle inspect <path>]');
     },
   });
 }

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

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import type { CommandRegistry } from '../command-registry.ts';
 import type { RemoteSessionBundle } from '@/runtime/index.ts';
 import { requirePeerClient, requireShellPaths } from './runtime-services.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 function inspectRemoteSessionBundle(bundle: RemoteSessionBundle): string {
   return [
@@ -19,13 +20,15 @@ export function registerTeleportRuntimeCommands(registry: CommandRegistry): void
   registry.register({
     name: 'teleport',
     description: 'Package, inspect, and import portable remote-session handoff bundles',
-    usage: '[export <path>|inspect <path>|import <path>]',
+    usage: '[export <path> --yes|inspect <path>|import <path> --yes]',
     async handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
       const shellPaths = requireShellPaths(ctx);
-      const mode = (args[0] ?? 'export').toLowerCase();
-      const pathArg = args[1];
+      const mode = (commandArgs[0] ?? 'export').toLowerCase();
+      const pathArg = commandArgs[1];
       if (!pathArg) {
-        ctx.print('Usage: /teleport [export <path>|inspect <path>|import <path>]');
+        ctx.print('Usage: /teleport [export <path> --yes|inspect <path>|import <path> --yes]');
         return;
       }
       let peerClient;
@@ -37,6 +40,10 @@ export function registerTeleportRuntimeCommands(registry: CommandRegistry): void
       }
       const targetPath = shellPaths.resolveWorkspacePath(pathArg);
       if (mode === 'export') {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `export teleport bundle to ${pathArg}`, '/teleport export <path> --yes');
+          return;
+        }
         const exported = await peerClient.runners.exportSessionBundle(targetPath);
         ctx.print(`Teleport bundle exported for session ${exported.bundle.sessionId} to ${exported.path}`);
         return;
@@ -47,11 +54,15 @@ export function registerTeleportRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (mode === 'import') {
+        if (!parsed.yes) {
+          requireYesFlag(ctx, `import teleport bundle from ${pathArg}`, '/teleport import <path> --yes');
+          return;
+        }
         const bundle = await peerClient.runners.importSessionBundle(targetPath);
         ctx.print(`Imported teleport bundle ${bundle.sessionId} with ${bundle.contracts.length} contracts.`);
         return;
       }
-      ctx.print('Usage: /teleport [export <path>|inspect <path>|import <path>]');
+      ctx.print('Usage: /teleport [export <path> --yes|inspect <path>|import <path> --yes]');
     },
   });
 }

package/src/input/commands/work-plan-runtime.ts

@@ -3,6 +3,7 @@ import type { WorkPlanItemStatus, WorkPlanStore } from '../../work-plans/work-pl
 import { WORK_PLAN_STATUSES } from '../../work-plans/work-plan-store.ts';
 import { requirePanelManager } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 const STATUS_COMMANDS: Record<string, WorkPlanItemStatus> = {
   pending: 'pending',
@@ -81,15 +82,17 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
     name: 'workplan',
     aliases: ['wp', 'todo'],
     description: 'Track a persistent workspace-scoped work plan',
-    usage: '[panel|list|show|add <title> [--owner name] [--source label] [--notes text]|done <id>|start <id>|block <id>|fail <id>|cancel <id>|pending <id>|remove <id>|clear-done]',
+    usage: '[panel|list|show|add <title> [--owner name] [--source label] [--notes text]|done <id>|start <id>|block <id>|fail <id>|cancel <id>|pending <id>|remove <id> --yes|clear-done --yes]',
     argsHint: '[panel|add|list|done]',
     handler(args, ctx) {
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
       const store = getStore(ctx);
       if (!store) {
         ctx.print('Work plan store is not available in this runtime.');
         return;
       }
-      const subcommand = (args[0] ?? 'panel').toLowerCase();
+      const subcommand = (commandArgs[0] ?? 'panel').toLowerCase();
       try {
         if (subcommand === 'panel' || subcommand === 'open') {
           openPanel(ctx);
@@ -105,25 +108,29 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
           return;
         }
         if (subcommand === 'add') {
-          const parsed = parseAddArgs(args.slice(1));
-          if (!parsed.title) {
+          const addArgs = parseAddArgs(commandArgs.slice(1));
+          if (!addArgs.title) {
             ctx.print('Usage: /workplan add <title> [--owner name] [--source label] [--notes text]');
             return;
           }
           const addOptions = {
-            ...(parsed.owner ? { owner: parsed.owner } : {}),
-            source: parsed.source ?? 'manual',
-            ...(parsed.notes ? { notes: parsed.notes } : {}),
+            ...(addArgs.owner ? { owner: addArgs.owner } : {}),
+            source: addArgs.source ?? 'manual',
+            ...(addArgs.notes ? { notes: addArgs.notes } : {}),
           };
-          const item = store.addItem(parsed.title, addOptions);
+          const item = store.addItem(addArgs.title, addOptions);
           openPanel(ctx);
           ctx.print(`Added work plan item ${item.id}.`);
           return;
         }
         if (subcommand === 'remove' || subcommand === 'delete' || subcommand === 'rm') {
-          const id = args[1];
+          const id = commandArgs[1];
           if (!id) {
-            ctx.print(`Usage: /workplan ${subcommand} <id>`);
+            ctx.print(`Usage: /workplan ${subcommand} <id> --yes`);
+            return;
+          }
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `remove work plan item ${id}`, `/workplan ${subcommand} <id> --yes`);
             return;
           }
           const item = store.removeItem(id);
@@ -131,12 +138,16 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
           return;
         }
         if (subcommand === 'clear-done' || subcommand === 'clear-completed') {
+          if (!parsed.yes) {
+            requireYesFlag(ctx, 'clear completed work plan items', `/workplan ${subcommand} --yes`);
+            return;
+          }
           const count = store.clearCompleted();
           ctx.print(`Cleared ${count} completed/cancelled work plan item${count === 1 ? '' : 's'}.`);
           return;
         }
         if (subcommand === 'cycle' || subcommand === 'toggle') {
-          const id = args[1];
+          const id = commandArgs[1];
           if (!id) {
             ctx.print(`Usage: /workplan ${subcommand} <id>`);
             return;
@@ -147,7 +158,7 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
         }
         const status = STATUS_COMMANDS[subcommand];
         if (status) {
-          const id = args[1];
+          const id = commandArgs[1];
           if (!id) {
             ctx.print(`Usage: /workplan ${subcommand} <id>`);
             return;

package/src/input/handler-content-actions.ts

@@ -1,4 +1,4 @@
-import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync } from 'node:fs';
 import { copyToClipboard, pasteFromClipboard, pasteImageFromClipboard } from '../utils/clipboard.ts';
 import type { InfiniteBuffer } from '../core/history.ts';
 import type { ConversationManager } from '../core/conversation';
@@ -7,7 +7,6 @@ import type { ContentPart } from '@pellux/goodvibes-sdk/platform/providers';
 import type { CommandContext } from './command-registry.ts';
 import type { BookmarkManager } from '@pellux/goodvibes-sdk/platform/bookmarks';
 import { resolveAndValidatePath } from '@pellux/goodvibes-sdk/platform/utils';
-import { analyzePermissionRequest } from '@pellux/goodvibes-sdk/platform/permissions';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import type { SelectionManager } from './selection.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
@@ -296,6 +295,7 @@ export function handleBlockSave(
   requestRender: () => void,
   bookmarkManager: BookmarkManager,
 ): void {
+  void bookmarkManager;
   if (!conversationManager) return;
   const lineIndex = getScrollTop();
   const content = conversationManager.getBlockContentAtLine(lineIndex);
@@ -304,17 +304,7 @@ export function handleBlockSave(
     requestRender();
     return;
   }
-  const nearest = conversationManager.findNearestBlock(lineIndex);
-  const label = nearest?.type ?? 'block';
-  try {
-    const filePath = bookmarkManager.saveToFile(content, label);
-    const homePath = process.env.HOME || process.env.USERPROFILE || '';
-    const displayPath = homePath ? filePath.replace(homePath, '~') : filePath;
-    conversationManager.log(`[Saved to: ${displayPath}]`, { fg: '#22c55e' });
-  } catch (err) {
-    const msg = summarizeError(err);
-    conversationManager.log(`[Save failed: ${msg}]`, { fg: '#ef4444' });
-  }
+  conversationManager.log('[Block save blocked in GoodVibes Agent: use /share <html|json|md> <path> --yes or copy the block explicitly.]', { fg: '#f59e0b' });
   requestRender();
 }
 
@@ -355,59 +345,18 @@ export function handleDiffApply(
   getCallId: () => string,
   category: PermissionCategory,
 ): boolean {
+  void commandContext;
+  void getCallId;
+  void category;
   if (!conversationManager) return false;
   const lineIndex = getScrollTop();
   const diff = conversationManager.getDiffAtLine(lineIndex);
   if (!diff || !diff.filePath) return false;
-  const projectRoot = commandContext?.workspace.shellPaths?.workingDirectory
-    ?? commandContext?.platform.configManager.getWorkingDirectory();
-
-  commandContext?.requestPermission?.({
-    callId: getCallId(),
-    tool: 'edit',
-    args: { path: diff.filePath, original: diff.original, updated: diff.updated },
-    category,
-    analysis: analyzePermissionRequest(
-      'edit',
-      { path: diff.filePath, original: diff.original, updated: diff.updated },
-      category,
-    ),
-  }).then(({ approved }) => {
-    if (!approved) return;
-    if (!projectRoot) {
-      conversationManager.log('[Diff apply failed: missing working directory]', { fg: '#ef4444' });
-      return;
-    }
-    let resolvedPath: string;
-    try {
-      resolvedPath = resolveAndValidatePath(diff.filePath!, projectRoot);
-    } catch (err) {
-      conversationManager.log(`[Diff apply failed: ${err instanceof Error ? err.message : err}]`, { fg: '#ef4444' });
-      return;
-    }
-    try {
-      const content = readFileSync(resolvedPath, 'utf-8');
-      if (diff.original && content.includes(diff.original)) {
-        const occurrenceCount = content.split(diff.original).length - 1;
-        if (occurrenceCount > 1) {
-          conversationManager.log(`[Diff apply failed: pattern found ${occurrenceCount} times in ${diff.filePath} - ambiguous]`, { fg: '#ef4444' });
-        } else {
-          const newContent = content.replace(diff.original, diff.updated);
-          writeFileSync(resolvedPath, newContent, 'utf-8');
-          conversationManager.log(`[Applied diff to ${diff.filePath}]`, { fg: '#22c55e' });
-        }
-      } else {
-        conversationManager.log(`[Diff apply failed: original text not found in ${diff.filePath}]`, { fg: '#ef4444' });
-      }
-    } catch (err) {
-      const msg = summarizeError(err);
-      conversationManager.log(`[Diff apply error: ${msg}]`, { fg: '#ef4444' });
-    }
-    requestRender();
-  }).catch((err) => {
-    conversationManager.log(`[Diff apply error: ${summarizeError(err)}]`, { fg: '#ef4444' });
-    requestRender();
-  });
+  conversationManager.log(
+    `[Diff apply blocked in GoodVibes Agent: ${diff.filePath}. Delegate build/fix work to GoodVibes TUI with /delegate <task>.]`,
+    { fg: '#f59e0b' },
+  );
+  requestRender();
   return true;
 }
 

package/src/input/handler-interactions.ts

@@ -137,7 +137,7 @@ export function handleBookmarkForHandler(handler: InputHandler): void {
   }
 
   /**
-   * handleBlockSave - Ctrl+S: Save nearest block content to a file.
+   * handleBlockSave - Ctrl+S: Explain that implicit block file saves are blocked.
    */
 export function handleBlockSaveForHandler(handler: InputHandler): void {
     handleBlockSave(handler.conversationManager, handler.getScrollTop, handler.requestRender, handler.uiServices.shell.bookmarkManager);