@pellux/goodvibes-tui 0.20.3 → 0.21.0

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

@@ -55,7 +55,7 @@ export function registerMemoryProductRuntimeCommands(registry: CommandRegistry):
 
   registry.register({
     name: 'session-memory',
-    description: 'Dedicated front-door for session-scoped memory capture and review',
+    description: 'Dedicated front-door for session-scoped memory capture and review. All subcommands are filtered to scope=session.',
     usage: '[queue [limit] | export <path> | add <class> <summary...>]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'queue').toLowerCase();
@@ -64,7 +64,8 @@ export function registerMemoryProductRuntimeCommands(registry: CommandRegistry):
         return;
       }
       if (sub === 'queue') {
-        await ctx.executeCommand('recall', ['queue', ...(args[1] ? [args[1]] : [])]);
+        // Pass --scope session so only session-scoped records appear in the queue.
+        await ctx.executeCommand('recall', ['queue', '--scope', 'session', ...(args[1] ? [args[1]] : [])]);
         return;
       }
       if (sub === 'export' && args[1]) {
@@ -75,13 +76,13 @@ export function registerMemoryProductRuntimeCommands(registry: CommandRegistry):
         await ctx.executeCommand('recall', ['add', args[1], ...args.slice(2), '--scope', 'session']);
         return;
       }
-      ctx.print('Usage: /session-memory [queue [limit] | export <path> | add <class> <summary...>]');
+      ctx.print('Usage: /session-memory [queue [limit] | export <path> | add <class> <summary...>]\nAll subcommands are scoped to session records only.');
     },
   });
 
   registry.register({
     name: 'team-memory',
-    description: 'Dedicated front-door for team/shared memory review and exchange',
+    description: 'Dedicated front-door for team/shared memory review and exchange. The queue and export subcommands are filtered to scope=team.',
     usage: '[queue [limit] | export <path> | import <path> | capture policy]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'queue').toLowerCase();
@@ -90,7 +91,8 @@ export function registerMemoryProductRuntimeCommands(registry: CommandRegistry):
         return;
       }
       if (sub === 'queue') {
-        await ctx.executeCommand('recall', ['queue', ...(args[1] ? [args[1]] : [])]);
+        // Pass --scope team so only team-scoped records appear in the queue.
+        await ctx.executeCommand('recall', ['queue', '--scope', 'team', ...(args[1] ? [args[1]] : [])]);
         return;
       }
       if (sub === 'export' && args[1]) {
@@ -105,7 +107,7 @@ export function registerMemoryProductRuntimeCommands(registry: CommandRegistry):
         await ctx.executeCommand('recall', ['capture', 'policy']);
         return;
       }
-      ctx.print('Usage: /team-memory [queue [limit] | export <path> | import <path> | capture policy]');
+      ctx.print('Usage: /team-memory [queue [limit] | export <path> | import <path> | capture policy]\nqueue and export are scoped to team records; import applies the bundle\'s own scopes and capture policy is global.');
     },
   });
 }

package/src/input/commands/operator-panel-runtime.ts

@@ -5,7 +5,7 @@ import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 export function registerOperatorPanelCommand(registry: CommandRegistry): void {
   registry.register({
     name: 'panel',
-    aliases: ['panels', 'p'],
+    aliases: ['panels'],
     description: 'Open, place, resize, or list panels. Usage: /panel [open <id> [top|bottom]|close <id>|list|toggle|move|focus|split|width|height]',
     usage: '[open <id> [top|bottom]|close <id>|list|toggle|move <top|bottom|other> [id]|focus <top|bottom|toggle>|split [show|hide|toggle]|width <left|right|reset>|height <up|down|reset>]',
     argsHint: '<open|close|list|toggle|move|focus|split|width|height> [id]',

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

@@ -5,6 +5,7 @@ import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { registerOperatorPanelCommand } from './operator-panel-runtime.ts';
 import { requireOpsApi, requireProfileManager, requireReplayEngine } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { estimateConversationTokens } from '@pellux/goodvibes-sdk/platform/core';
 
 export function registerOperatorRuntimeCommands(registry: CommandRegistry): void {
   registerOperatorPanelCommand(registry);
@@ -32,18 +33,10 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
           ctx.print('[context] No messages in conversation.');
           return;
         }
-        const estimateTokens = (text: string): number => Math.ceil(text.length / 4);
-        let total = 0;
+        const total = estimateConversationTokens(msgs);
         const lines: string[] = ['Context breakdown:'];
         for (const m of msgs) {
-          const text = typeof m.content === 'string'
-            ? m.content
-            : (m.content as Array<{ type: string; text?: string }>)
-              .filter((p) => p.type === 'text')
-              .map((p) => p.text ?? '')
-              .join('');
-          const t = estimateTokens(text);
-          total += t;
+          const t = estimateConversationTokens([m]);
           lines.push(`  ${m.role.padEnd(12)} ~${t.toLocaleString()} tokens`);
         }
         lines.push(`  ${'Total'.padEnd(12)} ~${total.toLocaleString()} tokens (${msgs.length} messages)`);

package/src/input/commands/{integration-runtime.ts → plugin-runtime.ts}

@@ -15,7 +15,7 @@ import {
 } from '@/runtime/index.ts';
 import { requireEcosystemCatalogPaths, requirePluginPathOptions } from './runtime-services.ts';
 
-export function registerIntegrationRuntimeCommands(registry: CommandRegistry): void {
+export function registerPluginRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'plugin',
     aliases: [],

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

@@ -7,8 +7,32 @@ export function handleRecallQueue(args: string[], context: CommandContext): void
   if (!memory) {
     return;
   }
-  const limit = Math.max(1, parseInt(args[0] ?? '10', 10) || 10);
-  const queue = memory.reviewQueue(limit);
+
+  // Extract optional --scope filter before parsing the positional limit argument.
+  const scopeIdx = args.indexOf('--scope');
+  let scopeFilter: string | undefined;
+  let remainingArgs = args;
+  if (scopeIdx !== -1 && args[scopeIdx + 1]) {
+    const candidateScope = args[scopeIdx + 1];
+    if (!isValidScope(candidateScope)) {
+      context.print(`[recall] Unknown scope "${candidateScope}". Valid: ${VALID_SCOPES.join(', ')}`);
+      return;
+    }
+    scopeFilter = candidateScope;
+    remainingArgs = args.filter((_, i) => i !== scopeIdx && i !== scopeIdx + 1);
+  }
+
+  const limitRaw = remainingArgs.find((a) => !a.startsWith('--'));
+  const limit = Math.max(1, parseInt(limitRaw ?? '10', 10) || 10);
+
+  // When a scope filter is requested, fetch a larger pool then slice to the
+  // requested limit so scope-sparse queues still return meaningful results.
+  const fetchLimit = scopeFilter ? 1000 : limit;
+  const rawQueue = memory.reviewQueue(fetchLimit);
+  const queue = scopeFilter
+    ? rawQueue.filter((record) => record.scope === scopeFilter).slice(0, limit)
+    : rawQueue;
+
   if (!queue.length) {
     context.print('[recall] Review queue is empty.');
     return;

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

@@ -1,5 +1,6 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
+import { atomicWriteFileSync } from '../../config/atomic-write.ts';
 import type { CommandRegistry } from '../command-registry.ts';
 import type { SelectionAction, SelectionItem } from '../selection-modal.ts';
 import { openCommandPanel, requireServiceRegistry, requireShellPaths } from './runtime-services.ts';
@@ -161,8 +162,7 @@ export function registerServicesRuntimeCommands(registry: CommandRegistry): void
         try {
           const parsed = JSON.parse(readFileSync(sourcePath, 'utf-8')) as Record<string, unknown>;
           const targetPath = shellPaths.resolveProjectPath('tui', 'services.json');
-          mkdirSync(dirname(targetPath), { recursive: true });
-          writeFileSync(targetPath, JSON.stringify(parsed, null, 2) + '\n', 'utf-8');
+          atomicWriteFileSync(targetPath, JSON.stringify(parsed, null, 2) + '\n', { mkdirp: true });
           ctx.print(`Imported services config from ${sourcePath}`);
         } catch (error) {
           ctx.print(`Failed to import services config: ${summarizeError(error)}`);

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

@@ -443,15 +443,15 @@ export async function handleSessionWorkflowCommand(args: string[], ctx: CommandC
 
 export function registerSessionWorkflowCommands(registry: CommandRegistry): void {
   registry.register({
-    name: 'session',
-    aliases: ['sess'],
+    name: 'session-mgmt',
+    aliases: ['smgmt'],
     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>]',
     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-mgmt [list | rename <name> | resume <id> | fork [name] | save [name] | info [id] | events [kind] | groups [kind] | hotspots | export <id> [format] | search <query> | delete <id>]');
       }
     },
   });

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

@@ -1,5 +1,4 @@
 import { writeFile } from 'node:fs/promises';
-import { resolve } from 'path';
 import type { CommandRegistry } from '../command-registry.ts';
 import {
   type ExportMessage,
@@ -11,13 +10,21 @@ import {
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { calcSessionCost } from '../../export/cost-utils.ts';
+import {
+  GistUploadTarget,
+  NO_TOKEN_GUIDANCE,
+  resolveGithubToken,
+} from '../../export/gist-uploader.ts';
+import { copyToClipboard } from '../../utils/clipboard.ts';
+import { openBrowser } from '../../cli/management.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] [--upload] [--copy] [--open]',
     argsHint: '<html|json|md> [path]',
     async handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
@@ -27,20 +34,28 @@ export function registerShareRuntimeCommands(registry: CommandRegistry): void {
       const format = args[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] [--upload] [--copy] [--open]\n'
           + '  html  — self-contained HTML with syntax highlighting\n'
           + '  json  — structured JSON (machine-readable)\n'
           + '  md    — Markdown\n\n'
           + 'Options:\n'
-          + '  --redact  Redact API keys and personal paths from output\n\n'
+          + '  --redact  Redact API keys and personal paths from output\n'
+          + '  --upload  Upload export as a secret GitHub Gist and print the share link\n'
+          + '  --copy    Copy the export file path to the clipboard\n'
+          + '  --open    Open HTML export in the default browser\n\n'
           + 'Default path: ~/goodvibes-exports/session-<timestamp>.<ext>',
         );
         return;
       }
 
       const remainingArgs = args.slice(1);
-      const redact = remainingArgs.includes('--redact');
-      const pathArgs = remainingArgs.filter(a => a !== '--redact');
+      const redact  = remainingArgs.includes('--redact');
+      const upload  = remainingArgs.includes('--upload');
+      const doCopy  = remainingArgs.includes('--copy');
+      const doOpen  = remainingArgs.includes('--open');
+      const pathArgs = remainingArgs.filter(
+        (a) => a !== '--redact' && a !== '--upload' && a !== '--copy' && a !== '--open',
+      );
       const outputPath = pathArgs.length > 0
         ? shellPaths.resolveWorkspacePath(pathArgs[0])
         : defaultExportPath(format, shellPaths.homeDirectory);
@@ -69,7 +84,7 @@ export function registerShareRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
-      const messages: ExportMessage[] = convData.messages.map(m => ({
+      const messages: ExportMessage[] = convData.messages.map((m) => ({
         role: m.role as ExportMessage['role'],
         content: m.content as string,
         toolCalls: m.toolCalls,
@@ -80,13 +95,32 @@ export function registerShareRuntimeCommands(registry: CommandRegistry): void {
         usage: m.usage,
         cancelled: m.cancelled,
       }));
+
+      // Accumulate per-message usage totals for session cost calculation.
+      let totalInput = 0;
+      let totalOutput = 0;
+      let totalCacheRead = 0;
+      let totalCacheWrite = 0;
+      for (const m of convData.messages) {
+        if (m.usage) {
+          totalInput      += m.usage.inputTokens ?? 0;
+          totalOutput     += m.usage.outputTokens ?? 0;
+          totalCacheRead  += m.usage.cacheReadTokens ?? 0;
+          totalCacheWrite += m.usage.cacheWriteTokens ?? 0;
+        }
+      }
+      const sessionModel = ctx.session.runtime.model;
+      const sessionCostUsd = calcSessionCost(
+        totalInput, totalOutput, totalCacheRead, totalCacheWrite, sessionModel,
+      );
+
       const metadata = {
-        model: ctx.session.runtime.model,
+        model: sessionModel,
         provider: ctx.session.runtime.provider,
         sessionId: ctx.session.runtime.sessionId,
         title: ctx.session.conversationManager.title || undefined,
       };
-      const options = { redact };
+      const options = { redact, cost: sessionCostUsd };
 
       let outputContent: string;
       try {
@@ -99,11 +133,14 @@ export function registerShareRuntimeCommands(registry: CommandRegistry): void {
       }
 
       const { mkdirSync } = await import('node:fs');
-      const { dirname } = await import('node:path');
+      const { dirname, basename } = await import('node:path');
       try {
         mkdirSync(dirname(outputPath), { recursive: true });
       } catch (mkdirErr) {
-        logger.warn(`[share] mkdir failed for ${dirname(outputPath)}:`, mkdirErr instanceof Error ? { message: mkdirErr.message } : undefined);
+        logger.warn(
+          `[share] mkdir failed for ${dirname(outputPath)}:`,
+          mkdirErr instanceof Error ? { message: mkdirErr.message } : undefined,
+        );
       }
 
       try {
@@ -113,7 +150,57 @@ export function registerShareRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
-      ctx.print(`Exported ${format.toUpperCase()} session to ${outputPath}${redact ? ' (sensitive data redacted)' : ''}`);
+      // Optional Gist upload: resolve auth token then push content as a secret gist.
+      let shareLink: string | undefined;
+      if (upload) {
+        let authHeaders: Record<string, string> | null = null;
+        try {
+          const svcRegistry = ctx.platform.serviceRegistry;
+          if (svcRegistry) {
+            authHeaders = await svcRegistry.resolveAuth('github').catch(() => null);
+          }
+        } catch {
+          // serviceRegistry absent or resolveAuth threw — fall through to env var
+        }
+
+        const token = resolveGithubToken(authHeaders ?? undefined);
+        if (!token) {
+          ctx.print(NO_TOKEN_GUIDANCE);
+        } else {
+          const gistFilename = basename(outputPath);
+          const description = metadata.title
+            ? `GoodVibes session: ${metadata.title}`
+            : 'GoodVibes session export';
+          const uploader = new GistUploadTarget(token, description);
+          const result = await uploader.upload(outputContent, gistFilename);
+          if (result.ok) {
+            shareLink = result.url;
+          } else {
+            ctx.print(`Upload failed: ${result.error}`);
+          }
+        }
+      }
+
+      // Copy export path to clipboard if requested.
+      if (doCopy) {
+        copyToClipboard(outputPath);
+      }
+
+      // Open the exported HTML in the default browser if requested.
+      if (doOpen && format === 'html') {
+        openBrowser(`file://${outputPath}`);
+      }
+
+      // Emit the summary line, with all post-export hints inline.
+      const hints: string[] = [];
+      if (redact) hints.push('(sensitive data redacted)');
+      if (shareLink) hints.push(`Share link: ${shareLink}`);
+      if (doCopy) hints.push('(path copied to clipboard)');
+      if (doOpen && format === 'html') hints.push('(opened in browser)');
+      if (doOpen && format !== 'html') hints.push('(--open ignored: only applies to html)');
+
+      const hint = hints.length > 0 ? '  ' + hints.join('  ') : '';
+      ctx.print(`Exported ${format.toUpperCase()} session to ${outputPath}${hint}`);
     },
   });
 }

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

@@ -3,19 +3,46 @@ import type { CommandRegistry } from '../command-registry.ts';
 export function registerTtsRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'tts',
-    description: 'Submit a normal prompt and play the assistant response through live TTS',
-    usage: '<prompt>|stop',
+    description: 'Submit a prompt for live TTS playback, or control always-speak mode',
+    usage: '<prompt>|stop|on|off',
     handler(args, ctx) {
       const first = (args[0] ?? '').toLowerCase();
+
+      // /tts stop — cancel active playback
       if (first === 'stop' || first === 'cancel') {
         ctx.stopSpokenOutput?.();
         ctx.print('Live TTS playback stopped.');
         return;
       }
 
+      // /tts on — enable always-speak mode (every turn spoken automatically)
+      if (first === 'on') {
+        if (!ctx.platform.voiceService) {
+          ctx.print('Live TTS is not available in this runtime.');
+          return;
+        }
+        ctx.platform.configManager.setDynamic('ui.voiceEnabled', true);
+        ctx.platform.configManager.save();
+        ctx.print('Always-speak mode enabled. Every submitted turn will be played through live TTS.');
+        ctx.renderRequest();
+        return;
+      }
+
+      // /tts off — disable always-speak mode
+      if (first === 'off') {
+        ctx.platform.configManager.setDynamic('ui.voiceEnabled', false);
+        ctx.platform.configManager.save();
+        ctx.print('Always-speak mode disabled. Use /tts <prompt> to speak individual turns.');
+        ctx.renderRequest();
+        return;
+      }
+
+      // /tts <prompt> — mark this prompt for spoken output
       const prompt = args.join(' ').trim();
       if (!prompt) {
-        ctx.print('Usage: /tts <prompt> or /tts stop');
+        const enabled = ctx.platform.configManager.get('ui.voiceEnabled');
+        ctx.print(`Usage: /tts <prompt>, /tts stop, /tts on, /tts off
+Always-speak mode is currently ${enabled ? 'on' : 'off'}.`);
         return;
       }
       if (!ctx.submitSpokenInput) {
@@ -25,5 +52,4 @@ export function registerTtsRuntimeCommands(registry: CommandRegistry): void {
       ctx.submitSpokenInput(prompt);
     },
   });
-
 }

package/src/input/commands.ts

@@ -13,7 +13,7 @@ import { registerPlanningRuntimeCommands } from './commands/planning-runtime.ts'
 import { registerScheduleRuntimeCommands } from './commands/schedule-runtime.ts';
 import { registerBranchRuntimeCommands } from './commands/branch-runtime.ts';
 import { registerOperatorRuntimeCommands } from './commands/operator-runtime.ts';
-import { registerIntegrationRuntimeCommands } from './commands/integration-runtime.ts';
+import { registerPluginRuntimeCommands } from './commands/plugin-runtime.ts';
 import { registerDiffRuntimeCommands } from './commands/diff-runtime.ts';
 import { registerGitRuntimeCommands } from './commands/git-runtime.ts';
 import { registerNotifyRuntimeCommands } from './commands/notify-runtime.ts';
@@ -65,7 +65,7 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerShellCoreCommands(registry);
   registerConfigCommand(registry);
   registerOperatorRuntimeCommands(registry);
-  registerIntegrationRuntimeCommands(registry);
+  registerPluginRuntimeCommands(registry);
   registerDiffRuntimeCommands(registry);
   registerGitRuntimeCommands(registry);
   registerNotifyRuntimeCommands(registry);

package/src/input/delete-key-policy.ts

@@ -0,0 +1,46 @@
+// ---------------------------------------------------------------------------
+// Delete-key policy — single source of truth for text-editing key semantics
+//
+// In text-editing contexts:
+//   'backspace'  → delete one character backward (the character before cursor /
+//                  the last character in an end-anchored buffer)
+//   'delete'     → forward-delete (the character after cursor) when a moveable
+//                  cursor exists; a no-op in cursorless/end-anchored contexts,
+//                  EXCEPT where it opens a confirmation-gated clear action
+//                  (see planning panel: Delete opens the ConfirmState gate that
+//                  lets the user clear their entire draft answer).
+//
+// Consequences for each surface:
+//   Panel search filters (end-anchored, no cursor)
+//     'backspace' → remove last char   ✓
+//     'delete'    → no-op              ✓ (no cursor; nothing is "forward")
+//
+//   Selection modal filters (end-anchored, no cursor)
+//     'backspace' → remove last char   ✓
+//     'delete'    → no-op              ✓
+//
+//   Planning panel draft answer (end-anchored, no cursor)
+//     'backspace' → remove last char   ✓
+//     'delete'    → open ConfirmState gate (y/Enter confirms clear; n/Esc cancels)
+//                   The draft is NOT wiped until the user confirms.
+//
+// NEVER assign bulk-destructive actions (clear / wipe) to the Delete key
+// without an explicit confirmation gate.
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true when `key` should perform a backward-delete (remove the
+ * character before the cursor / at end of an end-anchored buffer).
+ */
+export function isTextBackspace(key: string): boolean {
+  return key === 'backspace';
+}
+
+/**
+ * Returns true when `key` should perform a forward-delete (remove the
+ * character after the cursor). Only meaningful when a moveable cursor
+ * exists; callers should treat this as a no-op when there is no cursor.
+ */
+export function isTextForwardDelete(key: string): boolean {
+  return key === 'delete';
+}

package/src/input/feed-context-factory.ts

@@ -161,6 +161,8 @@ export interface FeedContextClosures {
   openProviderModelPickerWithTarget: (target: ModelPickerTarget, source?: 'settings' | 'onboarding') => boolean;
   onModelPickerCommit: () => boolean;
   onOnboardingAction: (action: import('./onboarding/onboarding-wizard.ts').OnboardingWizardAction) => void;
+  /** Called after any wizard step navigation so the handler can persist progress. */
+  onStepChange?: () => void;
 }
 
 /**

package/src/input/handler-feed.ts

@@ -162,6 +162,8 @@ export interface InputFeedContext {
   readonly openProviderModelPickerWithTarget: (target: ModelPickerTarget, source?: 'settings' | 'onboarding') => boolean;
   readonly onModelPickerCommit: () => boolean;
   readonly onOnboardingAction: (action: OnboardingWizardAction) => void;
+  /** Called after any wizard step navigation so the handler can persist progress. */
+  readonly onStepChange?: () => void;
   readonly exitApp: () => void;
 }
 
@@ -228,6 +230,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
       openProviderModelPickerWithTarget: context.openProviderModelPickerWithTarget,
       onModelPickerCommit: context.onModelPickerCommit,
       onOnboardingAction: context.onOnboardingAction,
+      onStepChange: context.onStepChange,
     }, token);
     context.selectionCallback = modalRoute.selectionCallback;
     context.helpOverlayActive = modalRoute.helpOverlayActive;

package/src/input/handler-interactions.ts

@@ -1,29 +1,16 @@
 import { buildProviderAccountSnapshot } from '@/runtime/index.ts';
 import type { OnboardingWizardMode } from './onboarding/onboarding-wizard.ts';
-import { collectOnboardingSnapshot, readOnboardingCheckMarker, writeOnboardingCheckMarker } from '../runtime/onboarding/index.ts';
+import { collectOnboardingSnapshot } from '../runtime/onboarding/index.ts';
 import { cleanupMarkerRegistry, expandPrompt, findMarkerAtPos, handleBlockCopy, handleBlockRerun, handleBlockSave, handleBlockToggle, handleBookmark, handleClipboardPaste, handleCopy, handleCtrlC, handleDiffApply, registerPaste } from './handler-content-actions.ts';
 import { clearModalStack, handleEscape, modalOpened } from './handler-modal-stack.ts';
 import { openOnboardingWizardState, type OpenOnboardingWizardOptions } from './handler-ui-state.ts';
-import type { InputHandler } from './handler.ts';
+import type { InputHandlerLike as InputHandler } from './handler-types.ts';
 
 export function openOnboardingWizardForHandler(
   handler: InputHandler,
     modeOrOptions: OnboardingWizardMode | OpenOnboardingWizardOptions = 'new',
   ): void {
     const options = typeof modeOrOptions === 'string' ? { mode: modeOrOptions } : modeOrOptions;
-    const userMarker = readOnboardingCheckMarker(handler.uiServices.environment.shellPaths, 'user');
-    if (!userMarker.payload) {
-      try {
-        writeOnboardingCheckMarker(handler.uiServices.environment.shellPaths, {
-          scope: 'user',
-          source: 'wizard',
-          mode: options.mode ?? 'new',
-        });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        handler.commandContext?.print?.(`Onboarding check marker could not be written: ${message}`);
-      }
-    }
     if (!handler.modalStack.includes('onboarding')) handler.modalOpened('onboarding');
     handler.clearOnboardingModelPickerCancelState();
     openOnboardingWizardState(handler.onboardingWizard, options);