@pellux/goodvibes-agent 0.1.70 → 0.1.72

package/src/input/commands/provider.ts

@@ -1,363 +0,0 @@
-/**
- * /provider command handler.
- *
- * Implements the Provider Optimizer panel commands:
- *
- *   /provider route auto|manual  — Set optimizer routing mode
- *   /provider explain-route      — Print current route explanation
- *   /provider pin <provider:model> — Pin routing to a specific provider/model
- *   /provider fallback test      — Simulate the fallback chain
- *
- * When the optimizer is disabled, commands report its status and
- * explain-route still works (reads current model capabilities).
- */
-
-import type { SlashCommand, CommandContext } from '../command-registry.ts';
-import type { RouteExplanation } from '@pellux/goodvibes-sdk/platform/providers';
-import type { FallbackTestResult, FallbackTransition } from '@pellux/goodvibes-sdk/platform/providers';
-import type { ProviderApiModelRecord } from '@pellux/goodvibes-sdk/platform/providers';
-import { requireProviderApi } from './runtime-services.ts';
-
-// ---------------------------------------------------------------------------
-// Formatting helpers
-// ---------------------------------------------------------------------------
-
-function fmtBool(value: boolean): string {
-  return value ? 'yes' : 'no';
-}
-
-function fmtTs(epochMs: number): string {
-  return new Date(epochMs).toISOString().replace('T', ' ').slice(0, 19);
-}
-
-function requireProviderOptimizer(context: CommandContext) {
-  if (!context.provider.providerOptimizer) {
-    context.print('[provider] Provider optimizer is not wired into this runtime.');
-    return null;
-  }
-  return context.provider.providerOptimizer;
-}
-
-function fmtExplanation(expl: RouteExplanation, context: CommandContext): void {
-  const status = expl.accepted ? '[accepted]' : '[rejected]';
-  context.print(`  ${status} ${expl.providerId}/${expl.modelId}`);
-  context.print(`    ${expl.summary}`);
-  if (!expl.accepted && expl.rejections.length > 0) {
-    context.print('    Unmet requirements:');
-    for (const r of expl.rejections) {
-      context.print(
-        `      - ${r.code}: ${r.reason} (actual=${r.actual}, required=${r.required})`,
-      );
-    }
-  }
-  if (expl.accepted) {
-    const c = expl.capability;
-    context.print(
-      `    Capabilities: streaming=${fmtBool(c.streaming)}, tools=${fmtBool(c.toolCalling)}, ` +
-      `parallel=${fmtBool(c.parallelTools)}, json=${fmtBool(c.jsonMode)}, ` +
-      `reasoning=${fmtBool(c.reasoningControls)}`,
-    );
-    context.print(
-      `    Context=${c.maxContextTokens.toLocaleString()} tokens, ` +
-      `output=${c.maxOutputTokens.toLocaleString()} tokens, ` +
-      `timeout=${c.timeoutMs}ms, caching=${c.caching}`,
-    );
-  }
-}
-
-// ---------------------------------------------------------------------------
-// /provider route auto|manual
-// ---------------------------------------------------------------------------
-
-function handleRoute(
-  args: string[],
-  context: CommandContext,
-): void {
-  const optimizer = requireProviderOptimizer(context);
-  if (!optimizer) return;
-  const sub = args[0];
-
-  if (sub !== 'auto' && sub !== 'manual') {
-    context.print('[provider] Usage: /provider route auto|manual');
-    context.print(`  Current mode: ${optimizer.mode} (optimizer ${optimizer.enabled ? 'on' : 'off'})`);
-    return;
-  }
-
-  if (!optimizer.enabled) {
-    context.print(
-      '[provider] Optimizer is currently disabled. Enable it with the provider-optimizer feature flag.',
-    );
-    context.print(`  Routing mode set to: ${sub} (no-op until optimizer is enabled)`);
-  }
-
-  optimizer.setMode(sub);
-  context.print(`[provider] Routing mode → ${sub}`);
-
-  if (sub === 'auto') {
-    context.print(
-      '  Auto mode: optimizer selects the best capable provider for each request profile.',
-    );
-  } else {
-    context.print(
-      '  Manual mode: optimizer is advisory only; provider selection is caller-driven.',
-    );
-  }
-}
-
-// ---------------------------------------------------------------------------
-// /provider explain-route
-// ---------------------------------------------------------------------------
-
-async function handleExplainRoute(
-  _args: string[],
-  context: CommandContext,
-): Promise<void> {
-  const optimizer = requireProviderOptimizer(context);
-  if (!optimizer) return;
-  const providerApi = requireProviderApi(context);
-
-  let currentModel: ProviderApiModelRecord;
-  try {
-    currentModel = await providerApi.getCurrentModel();
-  } catch {
-    context.print('[provider] No current model selected.');
-    return;
-  }
-
-  context.print(
-    `[provider] Route explanation for current model: ${currentModel.providerId}/${currentModel.modelId}`,
-  );
-
-  // Always explain current route regardless of optimizer enabled state
-  const expl = optimizer.explainCurrentRoute();
-  fmtExplanation(expl, context);
-
-  // Show optimizer status
-  context.print(`
-  Optimizer: ${optimizer.enabled ? 'enabled' : 'disabled'}, mode=${optimizer.mode}`);
-  if (optimizer.pinnedTarget) {
-    context.print(
-      `  Pinned to: ${optimizer.pinnedTarget.providerId}/${optimizer.pinnedTarget.modelId}`,
-    );
-  }
-
-  // Show recent fallback transitions
-  const log = optimizer.fallbackLog;
-  if (log.length > 0) {
-    const recent = log.slice(-5); // last 5 transitions
-    context.print(`  Fallback log (last ${recent.length} of ${log.length}):`);
-    for (const t of recent) {
-      context.print(
-        `    ${fmtTs(t.ts)}  ${t.from} → ${t.to}  (${t.reason})`,
-      );
-    }
-  } else {
-    context.print('  Fallback log: empty');
-  }
-}
-
-// ---------------------------------------------------------------------------
-// /provider pin <provider:model>
-// ---------------------------------------------------------------------------
-
-async function handlePin(
-  args: string[],
-  context: CommandContext,
-): Promise<void> {
-  const optimizer = requireProviderOptimizer(context);
-  if (!optimizer) return;
-  const target = args[0];
-
-  if (!target) {
-    // Show current pin status
-    if (optimizer.pinnedTarget) {
-      context.print(
-        `[provider] Currently pinned to: ${optimizer.pinnedTarget.providerId}/${optimizer.pinnedTarget.modelId}`,
-      );
-      context.print('  Use "/provider pin <provider:model>" to change, or "/provider route manual" to unpin.');
-    } else {
-      context.print('[provider] No pin active. Usage: /provider pin <provider:model>');
-      context.print('  Example: /provider pin anthropic:claude-opus-4-5');
-    }
-    return;
-  }
-
-  // Parse provider:model format
-  const colonIdx = target.indexOf(':');
-  if (colonIdx === -1) {
-    context.print(`[provider] Invalid format "${target}". Expected: <provider>:<model>`);
-    context.print('  Example: /provider pin anthropic:claude-opus-4-5');
-    return;
-  }
-
-  const providerId = target.slice(0, colonIdx);
-  const modelId = target.slice(colonIdx + 1);
-
-  if (!providerId || !modelId) {
-    context.print(`[provider] Invalid format "${target}". Both provider and model must be non-empty.`);
-    return;
-  }
-
-  // Validate that the model exists in registry
-  const providerApi = requireProviderApi(context);
-  const models = await providerApi.listModels();
-  const currentModel = await providerApi.getCurrentModel();
-  const match = models.find(
-    (m) => m.providerId === providerId && (m.modelId === modelId || m.registryKey === target),
-  ) ?? (
-    currentModel.providerId === providerId
-      && (currentModel.modelId === modelId || currentModel.registryKey === target)
-      ? currentModel
-      : undefined
-  );
-
-  if (!match) {
-    context.print(
-      `[provider] Model not found in registry: ${providerId}/${modelId}`,
-    );
-    context.print('  Use "/model" to see available models, or check the provider and model ID.');
-    return;
-  }
-
-  // Enable optimizer if it's off
-  if (!optimizer.enabled) {
-    optimizer.setEnabled(true);
-    context.print('⚠ Optimizer was disabled — enabling it for pin to take effect.');
-  }
-
-  optimizer.pin(match.providerId, match.modelId);
-  context.print(`[provider] Pinned → ${match.providerId}/${match.modelId}`);
-  context.print('  All routed requests will target this provider/model.');
-  context.print('  Unpin with: /provider route manual');
-}
-
-// ---------------------------------------------------------------------------
-// /provider fallback test
-// ---------------------------------------------------------------------------
-
-function handleFallbackTest(
-  args: string[],
-  context: CommandContext,
-): void {
-  const optimizer = requireProviderOptimizer(context);
-  if (!optimizer) return;
-  const sub = args[0];
-
-  if (sub !== 'test') {
-    context.print('[provider] Usage: /provider fallback test');
-    return;
-  }
-
-  context.print('[provider] Simulating fallback chain (empty request profile — no requirements)...');
-
-  const result: FallbackTestResult = optimizer.testFallback();
-
-  context.print(
-    `[provider] Fallback chain: ${result.viableCount} capable / ${result.totalCount} total providers`,
-  );
-
-  // Show first capable then rejected
-  const capable = result.chain.filter((n) => n.capable);
-  const rejected = result.chain.filter((n) => !n.capable);
-
-  if (capable.length > 0) {
-    context.print('  Capable providers (would succeed):');
-    for (const node of capable.slice(0, 10)) {
-      context.print(`    [${node.position}] ${node.providerId}/${node.modelId}`);
-    }
-    if (capable.length > 10) {
-      context.print(`    ... and ${capable.length - 10} more`);
-    }
-  } else {
-    context.print('  No capable providers found for this profile.');
-  }
-
-  if (rejected.length > 0) {
-    context.print(`  Rejected providers (${rejected.length}):`);
-    for (const node of rejected.slice(0, 5)) {
-      const reasons = !node.explanation.accepted
-        ? node.explanation.rejections.map((r) => r.code).join(', ')
-        : '';
-      context.print(
-        `    [${node.position}] ${node.providerId}/${node.modelId} — ${reasons || 'unknown'}`,
-      );
-    }
-    if (rejected.length > 5) {
-      context.print(`    ... and ${rejected.length - 5} more`);
-    }
-  }
-
-  // Show fallback log
-  const log = optimizer.fallbackLog;
-  if (log.length > 0) {
-    context.print(`  Logged transitions (${log.length} total):`);
-    const recent: readonly FallbackTransition[] = log.slice(-5);
-    for (const t of recent) {
-      context.print(
-        `    ${fmtTs(t.ts)}  ${t.from} → ${t.to}  (${t.reason})`,
-      );
-    }
-  } else {
-    context.print('  No fallback transitions logged this session.');
-  }
-
-  context.print(`  Test completed at: ${fmtTs(result.testedAt)}`);
-}
-
-// ---------------------------------------------------------------------------
-// Top-level command definition
-// ---------------------------------------------------------------------------
-
-/**
- * providerCommand — The `/provider` slash command.
- *
- * Routes to subcommand handlers based on args[0].
- */
-export const providerCommand: SlashCommand = {
-  name: 'provider-opt',
-  aliases: ['prov-opt'],
-  description: 'Manage provider routing optimizer (route, pin, explain, fallback).',
-  usage: '<subcommand> [args]',
-  argsHint: 'route|explain-route|pin|fallback',
-  handler: async (args: string[], context: CommandContext): Promise<void> => {
-    const [sub, ...rest] = args;
-
-    switch (sub) {
-      case 'route':
-        handleRoute(rest, context);
-        break;
-
-      case 'explain-route':
-      case 'explain':
-        await handleExplainRoute(rest, context);
-        break;
-
-      case 'pin':
-        await handlePin(rest, context);
-        break;
-
-      case 'fallback':
-        handleFallbackTest(rest, context);
-        break;
-
-      default: {
-        const optimizer = requireProviderOptimizer(context);
-        if (!optimizer) return;
-        const lines = [
-          'Usage: /provider <subcommand>',
-          '  route auto|manual              — Set optimizer routing mode',
-          '  explain-route                  — Show current route explanation',
-          '  pin <provider:model>           — Pin routing to specific provider/model',
-          '  fallback test                  — Simulate the full fallback chain',
-          '',
-          `  Optimizer: ${optimizer.enabled ? 'enabled' : 'disabled'}  mode=${optimizer.mode}`,
-        ];
-        if (optimizer.pinnedTarget) {
-          lines.push(`  Pinned: ${optimizer.pinnedTarget.providerId}/${optimizer.pinnedTarget.modelId}`);
-        }
-        context.print(lines.join('\n'));
-        break;
-      }
-    }
-  },
-};

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

@@ -1,89 +0,0 @@
-import type { CommandContext } from '../command-registry.ts';
-
-type RemotePoolLike = {
-  id: string;
-  label: string;
-  trustClass: string;
-  preferredTemplate?: string;
-  maxRunners?: number;
-  runnerIds: readonly string[];
-  description?: string;
-};
-
-type RemoteRegistryLike = {
-  listPools(): readonly RemotePoolLike[];
-  getPool(id: string): RemotePoolLike | null | undefined;
-};
-
-export function handleRemotePoolCommand(
-  args: string[],
-  ctx: Pick<CommandContext, 'print'>,
-  remoteRegistry: RemoteRegistryLike,
-): boolean {
-  const subcommand = args[0]?.toLowerCase() ?? 'show';
-  if (subcommand !== 'pool') return false;
-  const mode = args[1]?.toLowerCase() ?? 'list';
-  if (mode === 'list') {
-    const pools = remoteRegistry.listPools();
-    if (pools.length === 0) {
-      ctx.print('No remote worker pools defined yet.');
-      return true;
-    }
-    ctx.print([
-      `Remote Worker Pools (${pools.length})`,
-      ...pools.map((pool) => `  ${pool.id}  ${pool.runnerIds.length} workers  trust=${pool.trustClass}  template=${pool.preferredTemplate ?? '(none)'}`),
-    ].join('\n'));
-    return true;
-  }
-  if (mode === 'show') {
-    const poolId = args[2];
-    if (!poolId) {
-      ctx.print('Usage: /remote pool show <poolId>');
-      return true;
-    }
-    const pool = remoteRegistry.getPool(poolId);
-    if (!pool) {
-      ctx.print(`Unknown remote worker pool: ${poolId}`);
-      return true;
-    }
-    ctx.print([
-      `Remote Worker Pool ${pool.id}`,
-      `  label: ${pool.label}`,
-      `  trustClass: ${pool.trustClass}`,
-      `  preferredTemplate: ${pool.preferredTemplate ?? '(none)'}`,
-      `  maxWorkers: ${pool.maxRunners ?? '(unbounded)'}`,
-      `  workers: ${pool.runnerIds.join(', ') || '(none)'}`,
-      `  description: ${pool.description ?? '(none)'}`,
-    ].join('\n'));
-    return true;
-  }
-  if (mode === 'create') {
-    ctx.print([
-      'Remote worker pool mutation is blocked in GoodVibes Agent.',
-      '  requested: /remote pool create',
-      '  policy: Agent inspects remote worker pools but does not manage worker topology',
-      '  next: use the owning GoodVibes runtime or delegated build environment for worker-pool administration',
-    ].join('\n'));
-    return true;
-  }
-  if (mode === 'assign') {
-    ctx.print([
-      'Remote worker pool mutation is blocked in GoodVibes Agent.',
-      '  requested: /remote pool assign',
-      '  policy: Agent inspects remote worker pools but does not manage worker topology',
-      '  next: use the owning GoodVibes runtime or delegated build environment for worker-pool administration',
-    ].join('\n'));
-    return true;
-  }
-  if (mode === 'unassign') {
-    ctx.print([
-      'Remote worker pool mutation is blocked in GoodVibes Agent.',
-      '  requested: /remote pool unassign',
-      '  policy: Agent inspects remote worker pools but does not manage worker topology',
-      '  next: use the owning GoodVibes runtime or delegated build environment for worker-pool administration',
-    ].join('\n'));
-    return true;
-  }
-  ctx.print('Usage: /remote pool <list|show|create|assign|unassign> ...');
-  return true;
-}

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

@@ -1,226 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-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'>;
-
-type ActiveConnectionLike = {
-  agentId: string;
-  transportState: string;
-  messageCount: number;
-  errorCount: number;
-  label: string;
-};
-
-export function inspectRemoteSessionBundle(bundle: RemoteSessionBundle): string {
-  return [
-    'Remote Session Bundle Review',
-    `  session: ${bundle.sessionId}`,
-    `  exportedAt: ${new Date(bundle.exportedAt).toISOString()}`,
-    `  active connections: ${bundle.activeConnectionIds.length}`,
-    `  pools: ${bundle.pools.length}`,
-    `  contracts: ${bundle.contracts.length}`,
-    `  artifacts: ${bundle.artifacts.length}`,
-  ].join('\n');
-}
-
-export async function handleRemoteSetupCommand(
-  args: string[],
-  ctx: CommandContext,
-  activeConnections: ActiveConnectionLike[],
-  remoteRegistry: RemoteRegistryLike,
-): Promise<boolean> {
-  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');
-    const lines = [
-      'Remote Setup Review',
-      `  acp agent command: ${command.join(' ')}`,
-      `  runtime host enabled: ${danger.daemon ? 'yes' : 'no'}`,
-      `  inbound listener enabled: ${danger.httpListener ? 'yes' : 'no'}`,
-      `  remote worker contracts: ${remoteRegistry.listContracts().length}`,
-      `  active acp connections: ${activeConnections.length}`,
-      '',
-      '  guidance:',
-      '    - set ACP_AGENT_CMD to override the spawned remote agent command',
-      '    - use /remote env to export a reusable shell snippet',
-      '    - runtime-host and inbound-listener posture belongs to the runtime owner, not Agent onboarding',
-    ];
-    if (commandArgs[1]?.toLowerCase() === 'export') {
-      const pathArg = commandArgs[2];
-      if (!pathArg) {
-        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);
-      const targetPath = shellPaths.resolveWorkspacePath(pathArg);
-      mkdirSync(dirname(targetPath), { recursive: true });
-      writeFileSync(targetPath, `${JSON.stringify({
-        exportedAt: Date.now(),
-        acpAgentCommand: command,
-        runtimeHostEnabled: Boolean(danger.daemon),
-        inboundListenerEnabled: Boolean(danger.httpListener),
-        remoteRunnerContracts: remoteRegistry.listContracts().length,
-      }, null, 2)}\n`, 'utf-8');
-      ctx.print(`Exported remote setup bundle to ${targetPath}`);
-      return true;
-    }
-    ctx.print(lines.join('\n'));
-    return true;
-  }
-
-  if (subcommand === 'env') {
-    const command = getDefaultAcpAgentCommand();
-    const shellSnippet = [
-      `export ACP_AGENT_CMD='${command.join(' ')}'`,
-      `export GOODVIBES_REMOTE_SESSION='${ctx.session.runtime.sessionId}'`,
-    ].join('\n');
-    if (commandArgs[1]?.toLowerCase() === 'export') {
-      const pathArg = commandArgs[2];
-      if (!pathArg) {
-        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);
-      const targetPath = shellPaths.resolveWorkspacePath(pathArg);
-      mkdirSync(dirname(targetPath), { recursive: true });
-      writeFileSync(targetPath, `${shellSnippet}\n`, 'utf-8');
-      ctx.print(`Exported remote environment snippet to ${targetPath}`);
-      return true;
-    }
-    ctx.print(['Remote Environment', shellSnippet].join('\n'));
-    return true;
-  }
-
-  if (subcommand === 'tunnel') {
-    const mode = commandArgs[1]?.toLowerCase() ?? 'review';
-    const lines = [
-      'Remote Tunnel Review',
-      '  transport: self-hosted ACP / runtime relay',
-      `  session: ${ctx.session.runtime.sessionId}`,
-      `  active remote connections: ${activeConnections.length}`,
-      '  guidance: forward ACP agent traffic through your chosen self-hosted tunnel or SSH transport',
-    ];
-    if (mode === 'export') {
-      const pathArg = commandArgs[2];
-      if (!pathArg) {
-        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);
-      const targetPath = shellPaths.resolveWorkspacePath(pathArg);
-      mkdirSync(dirname(targetPath), { recursive: true });
-      writeFileSync(targetPath, `${lines.join('\n')}\n`, 'utf-8');
-      ctx.print(`Exported remote tunnel review to ${targetPath}`);
-      return true;
-    }
-    ctx.print(lines.join('\n'));
-    return true;
-  }
-
-  if (subcommand === 'bootstrap') {
-    const mode = commandArgs[1]?.toLowerCase() ?? 'export';
-    const payload = {
-      exportedAt: Date.now(),
-      sessionId: ctx.session.runtime.sessionId,
-      acpAgentCommand: getDefaultAcpAgentCommand(),
-      env: {
-        ACP_AGENT_CMD: getDefaultAcpAgentCommand().join(' '),
-        GOODVIBES_REMOTE_SESSION: ctx.session.runtime.sessionId,
-      },
-      links: [
-        'goodvibes://open/remote',
-        'goodvibes://open/cockpit?target=remote',
-      ],
-    };
-    if (mode === 'inspect') {
-      const pathArg = commandArgs[2];
-      if (!pathArg) {
-        ctx.print('Usage: /remote bootstrap inspect <path>');
-        return true;
-      }
-      const shellPaths = requireShellPaths(ctx);
-      const targetPath = shellPaths.resolveWorkspacePath(pathArg);
-      const parsed = JSON.parse(readFileSync(targetPath, 'utf-8')) as typeof payload;
-      ctx.print([
-        'Remote Bootstrap Bundle Review',
-        `  session: ${parsed.sessionId}`,
-        `  acp agent command: ${parsed.acpAgentCommand.join(' ')}`,
-        `  links: ${parsed.links.length}`,
-      ].join('\n'));
-      return true;
-    }
-    const pathArg = commandArgs[2] ?? commandArgs[1];
-    if (!pathArg || mode !== 'export') {
-      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);
-    const targetPath = shellPaths.resolveWorkspacePath(pathArg);
-    mkdirSync(dirname(targetPath), { recursive: true });
-    writeFileSync(targetPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf-8');
-    ctx.print(`Exported remote bootstrap bundle to ${targetPath}`);
-    return true;
-  }
-
-  if (subcommand === 'session') {
-    const mode = commandArgs[1]?.toLowerCase();
-    const pathArg = commandArgs[2];
-    if (!mode || !pathArg) {
-      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;
-    }
-    if (mode === 'inspect') {
-      const bundle = JSON.parse(readFileSync(targetPath, 'utf-8')) as RemoteSessionBundle;
-      ctx.print(inspectRemoteSessionBundle(bundle));
-      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> [--yes]');
-    return true;
-  }
-
-  return false;
-}