@pellux/goodvibes-agent 0.1.0

package/src/input/commands/session.ts

@@ -0,0 +1,375 @@
+/**
+ * /session command handler — Multi-session Orchestration.
+ *
+ * Implements session and workflow commands:
+ *
+ *   /session link-task <taskId> [--session <sessionId>] [--depends-on <ref>] [--label <label>]
+ *     — Register a task as a global cross-session ref, optionally linking it to a
+ *       dependency.
+ *
+ *   /session handoff <taskId> --to <sessionId> [--session <sessionId>] [--reason <reason>]
+ *     — Initiate a task handoff from the current session to another.
+ *
+ *   /session graph [--session <sessionId>] [--format text|json]
+ *     — Display the cross-session task dependency graph.
+ *
+ *   /session cancel <taskId|--scope session> [--session <sessionId>] [--scope task|subtree|session]
+ *     — Cancel tasks with configurable scope semantics.
+ */
+
+import type { SlashCommand, CommandContext } from '../command-registry.ts';
+import type { CancellationScope, CrossSessionTaskRef } from '@pellux/goodvibes-sdk/platform/sessions';
+import { VALID_SCOPES } from '@pellux/goodvibes-sdk/platform/sessions';
+import { handleSessionWorkflowCommand } from './session-workflow.ts';
+import { requireSessionOrchestration } from './runtime-services.ts';
+
+// ── Argument parsing helpers ──────────────────────────────────────────────────
+
+/**
+ * Extract a named flag value from args (e.g. `--to <value>`).
+ * Returns undefined if the flag is not present.
+ */
+function flagValue(args: string[], flag: string): string | undefined {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return undefined;
+  return args[idx + 1];
+}
+
+/**
+ * Parse a cross-session task ref from a string of the form
+ * `<sessionId>:<taskId>` or just `<taskId>` (uses currentSessionId as owner).
+ */
+function parseRef(
+  raw: string,
+  currentSessionId: string,
+): { sessionId: string; taskId: string } {
+  const parts = raw.split(':', 2);
+  if (parts.length === 2) {
+    return { sessionId: parts[0]!, taskId: parts[1]! };
+  }
+  return { sessionId: currentSessionId, taskId: raw };
+}
+
+// ── Formatting helpers ────────────────────────────────────────────────────────
+
+/** Status badge for display. */
+function statusBadge(status: string): string {
+  switch (status) {
+    case 'queued':    return '[ ]';
+    case 'running':   return '[>]';
+    case 'blocked':   return '[~]';
+    case 'completed': return '[+]';
+    case 'failed':    return '[!]';
+    case 'cancelled': return '[x]';
+    default:          return '[?]';
+  }
+}
+
+/** Format a ref as a compact one-line string. */
+function fmtRef(ref: CrossSessionTaskRef): string {
+  const key = `${ref.sessionId.slice(0, 8)}...:${ref.taskId.slice(0, 8)}...`;
+  const label = ref.label ? ` [${ref.label}]` : '';
+  return `${statusBadge(ref.status)} ${key}${label}  "${ref.title}"`;
+}
+
+// ── /session link-task ────────────────────────────────────────────────────────
+
+function handleLinkTask(args: string[], context: CommandContext): void {
+  const taskId = args[0];
+  if (!taskId) {
+    context.print(
+      '[session] Usage: /session link-task <taskId> [--session <sessionId>] ' +
+      '[--depends-on <sessionId:taskId>] [--label <label>]',
+    );
+    return;
+  }
+
+  // Defense-in-depth: parser splits on whitespace but guard against future changes
+  if (!taskId.trim()) {
+    context.print('Error: taskId cannot be empty or whitespace.');
+    return;
+  }
+
+  if (taskId.includes(':')) {
+    context.print('Error: taskId cannot contain ":" — it conflicts with the composite key format.');
+    return;
+  }
+
+  const sessionId = flagValue(args, '--session') ?? context.session.runtime.sessionId;
+  const dependsOnRaw = flagValue(args, '--depends-on');
+  const label = flagValue(args, '--label');
+
+  const orchestration = requireSessionOrchestration(context);
+
+  const ref: CrossSessionTaskRef = {
+    sessionId,
+    taskId,
+    title: label ?? taskId,
+    status: 'queued',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    label,
+  };
+
+  const dependsOn = dependsOnRaw ? parseRef(dependsOnRaw, sessionId) : undefined;
+
+  const result = orchestration.linkTask(ref, dependsOn);
+
+  if (!result.ok) {
+    context.print(`[session] link-task failed: ${result.error}`);
+    return;
+  }
+
+  context.print(
+    `[session] Task linked: ${sessionId.slice(0, 8)}...:${taskId}` +
+    (label ? ` [${label}]` : '') +
+    (dependsOn ? ` → depends on ${dependsOnRaw}` : ''),
+  );
+}
+
+// ── /session handoff ──────────────────────────────────────────────────────────
+
+function handleHandoff(args: string[], context: CommandContext): void {
+  const taskId = args[0];
+  const toSessionId = flagValue(args, '--to');
+  const fromSessionId = flagValue(args, '--session') ?? context.session.runtime.sessionId;
+  const reason = flagValue(args, '--reason');
+
+  if (!taskId || !toSessionId) {
+    context.print(
+      '[session] Usage: /session handoff <taskId> --to <sessionId> ' +
+      '[--session <fromSessionId>] [--reason <reason>]',
+    );
+    return;
+  }
+
+  const orchestration = requireSessionOrchestration(context);
+
+  const result = orchestration.initiateHandoff(
+    { sessionId: fromSessionId, taskId },
+    fromSessionId,
+    toSessionId,
+    reason,
+  );
+
+  if (!result.ok) {
+    context.print(`[session] handoff failed: ${result.error}`);
+    return;
+  }
+
+  context.print(
+    `[session] Handoff initiated: ${taskId} (${fromSessionId.slice(0, 8)}...) → (${toSessionId.slice(0, 8)}...)` +
+    (reason ? `  reason: ${reason}` : '') +
+    `\n[session] handoffId: ${result.handoffId}`,
+  );
+  context.print(
+    '[session] The task is now blocked pending acknowledgement from the destination session.',
+  );
+}
+
+// ── /session graph ────────────────────────────────────────────────────────────
+
+function handleGraph(args: string[], context: CommandContext): void {
+  const filterSession = flagValue(args, '--session');
+  const format = flagValue(args, '--format') ?? 'text';
+
+  const orchestration = requireSessionOrchestration(context);
+  const snap = orchestration.snapshot();
+
+  const refs = Object.values(snap.refs);
+  const filteredRefs = filterSession
+    ? refs.filter((r) => r.sessionId === filterSession)
+    : refs;
+
+  if (format === 'json') {
+    context.print(JSON.stringify(snap, null, 2));
+    return;
+  }
+
+  // ── Text display ─────────────────────────────────────────────────────────────
+
+  if (filteredRefs.length === 0) {
+    if (filterSession) {
+      context.print(`[session] No tasks registered for session ${filterSession.slice(0, 8)}...`);
+    } else {
+      context.print('[session] Task graph is empty. Use /session link-task to register tasks.');
+    }
+    return;
+  }
+
+  const lines: string[] = [
+    `[session] Cross-session task graph (${filteredRefs.length} task${filteredRefs.length !== 1 ? 's' : ''}):`,
+  ];
+
+  // Group by session for readability
+  const bySession = new Map<string, CrossSessionTaskRef[]>();
+  for (const ref of filteredRefs) {
+    const group = bySession.get(ref.sessionId) ?? [];
+    group.push(ref);
+    bySession.set(ref.sessionId, group);
+  }
+
+  for (const [sid, sessionRefs] of bySession) {
+    lines.push(`  Session ${sid.slice(0, 16)}...`);
+    for (const ref of sessionRefs) {
+      lines.push(`    ${fmtRef(ref)}`);
+
+      // Show dependencies
+      const deps = orchestration.getDependencies(ref.sessionId, ref.taskId);
+      for (const dep of deps) {
+        lines.push(
+          `      depends-on: ${statusBadge(dep.status)} ${dep.sessionId.slice(0, 8)}...:${dep.taskId.slice(0, 8)}...  "${dep.title}"`,
+        );
+      }
+
+      // Show dependents
+      const dependents = orchestration.getDependents(ref.sessionId, ref.taskId);
+      for (const d of dependents) {
+        lines.push(
+          `      depended-by: ${statusBadge(d.status)} ${d.sessionId.slice(0, 8)}...:${d.taskId.slice(0, 8)}...  "${d.title}"`,
+        );
+      }
+    }
+  }
+
+  // Handoffs summary
+  const handoffs = orchestration.getHandoffs();
+  const filteredHandoffs = filterSession
+    ? handoffs.filter((h) => h.fromSessionId === filterSession || h.toSessionId === filterSession)
+    : handoffs;
+
+  if (filteredHandoffs.length > 0) {
+    lines.push(`  Handoffs (${filteredHandoffs.length}):`);
+    for (const h of filteredHandoffs) {
+      const ack = h.acknowledged ? 'ack' : 'pending';
+      lines.push(
+        `    ${h.handoffId.slice(0, 8)}...  ` +
+        `${h.fromSessionId.slice(0, 8)}... → ${h.toSessionId.slice(0, 8)}...  ` +
+        `task:${h.taskRef.taskId.slice(0, 8)}...  [${ack}]` +
+        (h.reason ? `  reason: ${h.reason}` : ''),
+      );
+    }
+  }
+
+  context.print(lines.join('\n'));
+}
+
+// ── /session cancel ───────────────────────────────────────────────────────────
+
+function handleCancel(args: string[], context: CommandContext): void {
+  const scopeRaw = flagValue(args, '--scope');
+  if (scopeRaw && !VALID_SCOPES.includes(scopeRaw as CancellationScope)) {
+    context.print(`Invalid --scope: "${scopeRaw}". Valid: ${VALID_SCOPES.join(', ')}`);
+    return;
+  }
+  const scope: CancellationScope = (scopeRaw as CancellationScope) ?? 'task';
+  const sessionId = flagValue(args, '--session') ?? context.session.runtime.sessionId;
+  const reason = flagValue(args, '--reason');
+
+  // For session scope, taskId is not required
+  const taskId = scope === 'session' ? undefined : args[0];
+
+  if (scope !== 'session' && !taskId) {
+    context.print(
+      '[session] Usage: /session cancel <taskId> [--scope task|subtree|session] ' +
+      '[--session <sessionId>] [--reason <reason>]\n' +
+      '  --scope task     Cancel only this task (default)\n' +
+      '  --scope subtree  Cancel this task and all tasks that transitively depend on it\n' +
+      '  --scope session  Cancel all tasks in the session',
+    );
+    return;
+  }
+
+  const orchestration = requireSessionOrchestration(context);
+
+  const result = orchestration.cancel({
+    sessionId,
+    taskId,
+    scope,
+    reason,
+    requestedAt: Date.now(),
+  });
+
+  if (!result.ok) {
+    context.print(`[session] cancel failed: ${result.error}`);
+    return;
+  }
+
+  const lines: string[] = [
+    `[session] Cancelled ${result.cancelled.length} task${result.cancelled.length !== 1 ? 's' : ''} ` +
+    `(scope=${scope}):`,
+  ];
+
+  for (const t of result.cancelled) {
+    lines.push(`  [x] ${t.sessionId.slice(0, 8)}...:${t.taskId.slice(0, 8)}...  "${t.title}"`);
+  }
+
+  if (result.skipped.length > 0) {
+    lines.push(`  Skipped ${result.skipped.length} (already terminal):`);
+    for (const s of result.skipped) {
+      lines.push(`  [-] ${s.sessionId.slice(0, 8)}...:${s.taskId.slice(0, 8)}...  "${s.title}"  (${s.reason})`);
+    }
+  }
+
+  context.print(lines.join('\n'));
+}
+
+// ── Top-level command definition ───────────────────────────────────────────────
+
+/**
+ * sessionCommand — The `/session` slash command.
+ *
+ * Routes to multi-session orchestration subcommand handlers based on args[0].
+ */
+export const sessionCommand: SlashCommand = {
+  name: 'session',
+  aliases: ['sess'],
+  description: 'Multi-session orchestration: link tasks, handoff, view graph, and cancel across sessions.',
+  usage: '<subcommand> [args]',
+  argsHint: 'link-task|handoff|graph|cancel',
+  handler: async (args: string[], context: CommandContext): Promise<void> => {
+    const [sub, ...rest] = args;
+
+    switch (sub) {
+      case 'link-task':
+      case 'link':
+        handleLinkTask(rest, context);
+        break;
+
+      case 'handoff':
+      case 'ho':
+        handleHandoff(rest, context);
+        break;
+
+      case 'graph':
+      case 'g':
+        handleGraph(rest, context);
+        break;
+
+      case 'cancel':
+        handleCancel(rest, context);
+        break;
+
+      default: {
+        const handled = await handleSessionWorkflowCommand(args, context);
+        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>',
+            '                                 — Session continuity, export, resume, and pruning',
+            '  link-task <taskId> [--session <sid>] [--depends-on <sid:taskId>] [--label <label>]',
+            '                                 — Register a task in the cross-session graph',
+            '  handoff <taskId> --to <sid>  [--session <sid>] [--reason <reason>]',
+            '                                 — Hand a task off to another session',
+            '  graph [--session <sid>] [--format text|json]',
+            '                                 — Display the cross-session task dependency graph',
+            '  cancel <taskId> [--scope task|subtree|session] [--session <sid>] [--reason <reason>]',
+            '                                 — Cancel tasks with scoped semantics',
+          ].join('\n');
+          context.print(usage);
+        }
+        break;
+      }
+    }
+  },
+};

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

@@ -0,0 +1,174 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import {
+  applySettingsSyncBundle,
+  clearManagedSettingLock,
+  exportSettingsSyncBundle,
+  formatResolvedSettingReview,
+  resolveSettingsSyncConflict,
+  formatStagedManagedBundleReview,
+  formatSettingsControlPlaneReview,
+  getSettingsControlPlaneSnapshot,
+  inspectSettingsSyncBundle,
+  recordSettingsSyncEvent,
+  recordSettingsSyncFailure,
+  setManagedSettingLock,
+  type SettingsSyncBundle,
+} from '@/runtime/index.ts';
+import { getProviderIdFromModel } from '../../config/provider-model.ts';
+import { type ConfigKey } from '../../config/index.ts';
+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';
+
+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>]',
+    handler(args, ctx) {
+      const shellPaths = requireShellPaths(ctx);
+      const controlPlaneConfigDir = ctx.platform.configManager.getControlPlaneConfigDir();
+      const sub = (args[0] ?? 'review').toLowerCase();
+      if (sub === 'panel' || sub === 'open') {
+        openCommandPanel(ctx, 'settings-sync');
+        return;
+      }
+      if (sub === 'show') {
+        const key = args[1] as ConfigKey | undefined;
+        if (!key || !CONFIG_KEYS.has(key)) {
+          ctx.print('Usage: /settingssync show <config-key>');
+          return;
+        }
+        ctx.print(formatResolvedSettingReview(ctx.platform.configManager, key));
+        return;
+      }
+      if (sub === 'staged') {
+        ctx.print(formatStagedManagedBundleReview(ctx.platform.configManager));
+        return;
+      }
+      if (sub === 'conflicts') {
+        const snapshot = getSettingsControlPlaneSnapshot(ctx.platform.configManager);
+        ctx.print(snapshot.conflicts.length > 0
+          ? [
+              'Settings Sync Conflicts',
+              ...snapshot.conflicts.map((conflict) => `  ${conflict.key}  source=${conflict.source}  path=${conflict.path}`),
+            ].join('\n')
+          : 'Settings Sync Conflicts\n  No settings conflicts recorded.');
+        return;
+      }
+      if (sub === 'resolve') {
+        const key = args[1] as ConfigKey | undefined;
+        const resolution = (args[2] ?? '').toLowerCase();
+        if (!key || !CONFIG_KEYS.has(key) || (resolution !== 'local' && resolution !== 'synced')) {
+          ctx.print('Usage: /settingssync resolve <config-key> <local|synced>');
+          return;
+        }
+        const changed = resolveSettingsSyncConflict(ctx.platform.configManager, key, resolution);
+        if (!changed) {
+          ctx.print(`No synced conflict found for ${key}.`);
+          return;
+        }
+        ctx.session.runtime.model = String(ctx.platform.configManager.get('provider.model'));
+        ctx.session.runtime.provider = getProviderIdFromModel(ctx.platform.configManager.get('provider.model'));
+        ctx.session.runtime.reasoningEffort = ctx.platform.configManager.get('provider.reasoningEffort') as string;
+        ctx.print(`Resolved synced conflict for ${key} using the ${resolution} value.`);
+        return;
+      }
+      if (sub === 'failures') {
+        const snapshot = getSettingsControlPlaneSnapshot(ctx.platform.configManager);
+        ctx.print(snapshot.recentFailures.length > 0
+          ? [
+              'Settings Sync Failures',
+              ...snapshot.recentFailures.map((failure) => `  ${failure.surface}  ${failure.message}`),
+            ].join('\n')
+          : 'Settings Sync Failures\n  No recent sync or managed-setting failures recorded.');
+        return;
+      }
+      if (sub === 'rollback-history') {
+        const snapshot = getSettingsControlPlaneSnapshot(ctx.platform.configManager);
+        ctx.print(snapshot.rollbackHistory.length > 0
+          ? [
+              'Managed Rollback History',
+              ...snapshot.rollbackHistory.map((entry) => (
+                `  ${entry.token}  ${entry.profileName}  restored=${entry.restoredKeys.length}  ${new Date(entry.appliedAt).toLocaleString()}`
+              )),
+            ].join('\n')
+          : 'Managed Rollback History\n  No managed apply rollback records yet.');
+        return;
+      }
+      if (sub === 'export' || sub === 'push') {
+        const pathArg = args[1];
+        if (!pathArg) {
+          ctx.print(`Usage: /settingssync ${sub} <path>`);
+          return;
+        }
+        const targetPath = shellPaths.resolveWorkspacePath(pathArg);
+        const bundle = exportSettingsSyncBundle(ctx.platform.configManager);
+        mkdirSync(dirname(targetPath), { recursive: true });
+        writeFileSync(targetPath, JSON.stringify(bundle, null, 2) + '\n', 'utf-8');
+        recordSettingsSyncEvent({
+          surface: 'settings-sync',
+          direction: sub === 'push' ? 'push' : 'export',
+          path: targetPath,
+          timestamp: Date.now(),
+          detail: `${Object.keys(bundle.settings).length} settings exported`,
+        }, controlPlaneConfigDir);
+        ctx.print(`Settings sync bundle exported to ${targetPath}`);
+        return;
+      }
+      if (sub === 'inspect') {
+        const pathArg = args[1];
+        if (!pathArg) {
+          ctx.print('Usage: /settingssync inspect <path>');
+          return;
+        }
+        const sourcePath = shellPaths.resolveWorkspacePath(pathArg);
+        const bundle = JSON.parse(readFileSync(sourcePath, 'utf-8')) as SettingsSyncBundle;
+        ctx.print(inspectSettingsSyncBundle(bundle));
+        return;
+      }
+      if (sub === 'pull') {
+        const pathArg = args[1];
+        if (!pathArg) {
+          ctx.print('Usage: /settingssync pull <path>');
+          return;
+        }
+        const sourcePath = shellPaths.resolveWorkspacePath(pathArg);
+        try {
+          const bundle = JSON.parse(readFileSync(sourcePath, 'utf-8')) as SettingsSyncBundle;
+          const result = applySettingsSyncBundle(ctx.platform.configManager, bundle, sourcePath);
+          ctx.print(`Settings sync bundle pulled from ${sourcePath} (${result.appliedCount} applied, ${result.conflictCount} conflicts).`);
+        } catch (error) {
+          recordSettingsSyncFailure('settings-sync', summarizeError(error), controlPlaneConfigDir);
+          ctx.print(summarizeError(error));
+        }
+        return;
+      }
+      if (sub === 'lock') {
+        const key = args[1] as ConfigKey | undefined;
+        const source = args[2];
+        const reason = args.slice(3).join(' ').trim();
+        if (!key || !source || !reason || !CONFIG_KEYS.has(key)) {
+          ctx.print('Usage: /settingssync lock <config-key> <source> <reason...>');
+          return;
+        }
+        setManagedSettingLock(key, source, reason, controlPlaneConfigDir);
+        ctx.print(`Managed lock recorded for ${key}.`);
+        return;
+      }
+      if (sub === 'unlock') {
+        const key = args[1] as ConfigKey | undefined;
+        if (!key || !CONFIG_KEYS.has(key)) {
+          ctx.print('Usage: /settingssync unlock <config-key>');
+          return;
+        }
+        ctx.print(clearManagedSettingLock(key, controlPlaneConfigDir) ? `Managed lock cleared for ${key}.` : `No managed lock found for ${key}.`);
+        return;
+      }
+      ctx.print(formatSettingsControlPlaneReview(ctx.platform.configManager).join('\n'));
+    },
+  });
+}

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

@@ -0,0 +1,119 @@
+import { writeFile } from 'node:fs/promises';
+import { resolve } from 'path';
+import type { CommandRegistry } from '../command-registry.ts';
+import {
+  type ExportMessage,
+  defaultExportPath,
+  exportToHTML,
+  exportToJSON,
+  exportToMarkdownExtended,
+} from '@pellux/goodvibes-sdk/platform/export';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireShellPaths } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+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]',
+    argsHint: '<html|json|md> [path]',
+    async handler(args, ctx) {
+      const shellPaths = requireShellPaths(ctx);
+      const FORMATS = ['html', 'json', 'md'] as const;
+      type Format = typeof FORMATS[number];
+
+      const format = args[0]?.toLowerCase() as Format | undefined;
+      if (!format || !FORMATS.includes(format)) {
+        ctx.print(
+          'Usage: /share <html|json|md> [path] [--redact]\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'
+          + '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 outputPath = pathArgs.length > 0
+        ? shellPaths.resolveWorkspacePath(pathArgs[0])
+        : defaultExportPath(format, shellPaths.homeDirectory);
+
+      const convData = ctx.session.conversationManager.toJSON() as {
+        messages: Array<{
+          role: string;
+          content: unknown;
+          toolCalls?: Array<{ id: string; name: string; arguments: Record<string, unknown> }>;
+          callId?: string;
+          toolName?: string;
+          reasoningContent?: string;
+          reasoningSummary?: string;
+          usage?: {
+            inputTokens: number;
+            outputTokens: number;
+            cacheReadTokens?: number;
+            cacheWriteTokens?: number;
+          };
+          cancelled?: boolean;
+        }>;
+      };
+
+      if (!convData.messages || convData.messages.length === 0) {
+        ctx.print('Nothing to export — conversation is empty.');
+        return;
+      }
+
+      const messages: ExportMessage[] = convData.messages.map(m => ({
+        role: m.role as ExportMessage['role'],
+        content: m.content as string,
+        toolCalls: m.toolCalls,
+        callId: m.callId,
+        toolName: m.toolName,
+        reasoningContent: m.reasoningContent,
+        reasoningSummary: m.reasoningSummary,
+        usage: m.usage,
+        cancelled: m.cancelled,
+      }));
+      const metadata = {
+        model: ctx.session.runtime.model,
+        provider: ctx.session.runtime.provider,
+        sessionId: ctx.session.runtime.sessionId,
+        title: ctx.session.conversationManager.title || undefined,
+      };
+      const options = { redact };
+
+      let outputContent: string;
+      try {
+        if (format === 'html') outputContent = exportToHTML(messages, metadata, options);
+        else if (format === 'json') outputContent = exportToJSON(messages, metadata, options);
+        else outputContent = exportToMarkdownExtended(messages, metadata, options);
+      } catch (err) {
+        ctx.print(`Export failed: ${summarizeError(err)}`);
+        return;
+      }
+
+      const { mkdirSync } = await import('node:fs');
+      const { dirname } = 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);
+      }
+
+      try {
+        await writeFile(outputPath, outputContent, 'utf-8');
+      } catch (err) {
+        ctx.print(`Failed to write export: ${summarizeError(err)}`);
+        return;
+      }
+
+      ctx.print(`Exported ${format.toUpperCase()} session to ${outputPath}${redact ? ' (sensitive data redacted)' : ''}`);
+    },
+  });
+}