@pellux/goodvibes-tui 0.19.52 → 0.19.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.52",
+  "version": "0.19.54",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",
@@ -91,7 +91,7 @@
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@ast-grep/napi": "^0.42.0",
     "@aws/bedrock-token-generator": "^1.1.0",
-    "@pellux/goodvibes-sdk": "0.26.7",
+    "@pellux/goodvibes-sdk": "0.28.0",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

package/src/audio/spoken-turn-controller.ts

@@ -80,7 +80,10 @@ export class SpokenTurnController {
       this.enqueueChunks(this.chunker?.push(event.content) ?? []);
       return;
     }
-    if (event.type === 'STREAM_END' || event.type === 'TURN_COMPLETED') {
+    if (event.type === 'STREAM_END') {
+      return;
+    }
+    if (event.type === 'TURN_COMPLETED') {
       this.finishTurn(event.turnId);
       return;
     }

package/src/input/command-args-hint.ts

@@ -0,0 +1,36 @@
+import type { CommandRegistry } from './command-registry.ts';
+
+const SUBCOMMAND_HINTS: Record<string, Record<string, string>> = {
+  session: { rename: '<name>', resume: '<id|name>', info: '<id>', export: '<id> [format]', search: '<query>', delete: '<id>' },
+  template: { save: '<name>', use: '<name> [args]', edit: '<name>', delete: '<name>' },
+  secrets: { set: '<KEY> <value>', get: '<KEY>', delete: '<KEY>' },
+  permissions: { tool: '<name> allow|prompt|deny' },
+  config: { reset: '<key>' },
+  danger: {},
+  plugin: { enable: '<name>', disable: '<name>', reload: '' },
+};
+
+export function buildCommandArgsHint(
+  prompt: string,
+  commandRegistry: Pick<CommandRegistry, 'get'>,
+): string | undefined {
+  if (!prompt.startsWith('/')) return undefined;
+
+  const spaceIdx = prompt.indexOf(' ');
+  if (spaceIdx === -1) {
+    const cmd = commandRegistry.get(prompt.slice(1));
+    return cmd?.argsHint ?? cmd?.usage;
+  }
+
+  const cmdName = prompt.slice(1, spaceIdx);
+  const cmd = commandRegistry.get(cmdName);
+  if (!cmd) return undefined;
+
+  const afterCmd = prompt.slice(spaceIdx + 1);
+  const subSpaceIdx = afterCmd.indexOf(' ');
+  if (subSpaceIdx !== -1) return undefined;
+
+  const subMap = SUBCOMMAND_HINTS[cmdName];
+  if (subMap && afterCmd in subMap) return subMap[afterCmd];
+  return undefined;
+}

package/src/input/command-registry.ts

@@ -93,7 +93,7 @@ export interface CommandShellUiOpeners {
     opts: { preSelectId?: string; allowSearch?: boolean; customActions?: Map<string, SelectionAction> } | undefined,
     callback: (result: SelectionResult | null) => void,
   ) => void;
-  openSettingsModal?: () => void;
+  openSettingsModal?: (target?: string) => void;
   openSessionPicker?: () => void;
   openProfilePicker?: () => void;
   openShortcutsOverlay?: () => void;
@@ -142,6 +142,8 @@ export interface CommandWorkspaceUiServices {
   panelManager?: PanelManager;
   profileManager?: import('@pellux/goodvibes-sdk/platform/profiles/manager').ProfileManager;
   bookmarkManager?: import('@pellux/goodvibes-sdk/platform/bookmarks/manager').BookmarkManager;
+  projectPlanningService?: import('@pellux/goodvibes-sdk/platform/knowledge/index').ProjectPlanningService;
+  projectPlanningProjectId?: string;
 }
 
 export interface CommandWorkspaceServices

package/src/input/commands/config.ts

@@ -1,532 +1,18 @@
 import type { CommandRegistry } from '../command-registry.ts';
-import { CONFIG_SCHEMA, type ConfigKey } from '../../config/index.ts';
-import { buildGoodVibesSecretKey, isSecretConfigKey, isSecretReferenceValue, persistSecretBackedConfigValue } from '../../config/secret-config.ts';
-import { configSnapshotToProfileData, profileDataToConfigSnapshot } from '@pellux/goodvibes-sdk/platform/profiles/shape';
-import { dirname, join, resolve } from 'node:path';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { requireProfileManager, requireProviderApi, requireSecretsManager, requireShellPaths } from './runtime-services.ts';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-interface ConfigBundle {
-  readonly schemaVersion: 'v1';
-  readonly exportedAt: number;
-  readonly config: Record<string, unknown>;
-  readonly services?: Record<string, unknown>;
-  readonly ecosystem?: {
-    readonly plugins?: Record<string, unknown>;
-    readonly skills?: Record<string, unknown>;
-  };
-}
-
-function roundToPrecision(value: number, precision: number): number {
-  const factor = 10 ** precision;
-  return Math.round(value * factor) / factor;
-}
-
-function getConfigSelectionAdjustmentMeta(schema: { key: ConfigKey; type: 'boolean' | 'number' | 'string' | 'enum' }) {
-  if (schema.type !== 'number') return {};
-  if (schema.key === 'wrfc.scoreThreshold') {
-    return {
-      adjustStep: 0.1,
-      adjustMin: 0,
-      adjustMax: 10,
-      adjustPrecision: 1,
-    };
-  }
-  return {
-    adjustStep: 1,
-  };
-}
-
-function inspectConfigBundle(bundle: ConfigBundle): string {
-  const ecosystemPluginCount = bundle.ecosystem?.plugins && Array.isArray((bundle.ecosystem.plugins as { entries?: unknown[] }).entries)
-    ? ((bundle.ecosystem.plugins as { entries: unknown[] }).entries.length)
-    : 0;
-  const ecosystemSkillCount = bundle.ecosystem?.skills && Array.isArray((bundle.ecosystem.skills as { entries?: unknown[] }).entries)
-    ? ((bundle.ecosystem.skills as { entries: unknown[] }).entries.length)
-    : 0;
-  return [
-    'Config Bundle Review',
-    `  schemaVersion: ${bundle.schemaVersion}`,
-    `  exportedAt: ${new Date(bundle.exportedAt).toISOString()}`,
-    `  config keys: ${Object.keys(bundle.config ?? {}).length}`,
-    `  includes services: ${bundle.services ? 'yes' : 'no'}`,
-    `  curated plugins: ${ecosystemPluginCount}`,
-    `  curated skills: ${ecosystemSkillCount}`,
-  ].join('\n');
-}
-
-function readOptionalJson(path: string): Record<string, unknown> | undefined {
-  if (!existsSync(path)) return undefined;
-  try {
-    return JSON.parse(readFileSync(path, 'utf-8')) as Record<string, unknown>;
-  } catch {
-    return undefined;
-  }
-}
-
-function buildConfigSnapshot(
-  manager: { get: (key: ConfigKey) => unknown },
-): Record<string, unknown> {
-  const snapshot: Record<string, unknown> = {};
-  for (const entry of CONFIG_SCHEMA) {
-    try {
-      snapshot[entry.key] = structuredClone(manager.get(entry.key));
-    } catch {
-      // ignore unreadable keys
-    }
-  }
-  return snapshot;
-}
-
-function formatConfigSchemaEntry(
-  manager: { get: (key: ConfigKey) => unknown },
-  schema: { readonly key: ConfigKey; readonly description: string },
-): string {
-  let value: unknown = '(unavailable)';
-  try {
-    value = manager.get(schema.key);
-  } catch {
-    // keep unavailable marker
-  }
-  const displayValue = typeof value === 'string' && isSecretConfigKey(schema.key) && !isSecretReferenceValue(value)
-    ? value.length === 0 ? '(empty)' : '[secret]'
-    : String(value);
-  return `  ${schema.key.padEnd(46)} ${displayValue} — ${schema.description}`;
-}
-
-function coerceValue(
-  raw: string,
-  type: 'boolean' | 'number' | 'string' | 'enum',
-  enumValues?: string[],
-): unknown {
-  switch (type) {
-    case 'boolean':
-      if (raw === 'true' || raw === '1' || raw === 'yes') return true;
-      if (raw === 'false' || raw === '0' || raw === 'no') return false;
-      throw new Error(`Expected true/false, got: ${raw}`);
-    case 'number': {
-      const n = Number(raw);
-      if (isNaN(n)) throw new Error(`Expected a number, got: ${raw}`);
-      return n;
-    }
-    case 'enum':
-      if (enumValues && !enumValues.includes(raw)) {
-        throw new Error(`Expected one of: ${enumValues.join(', ')}; got: ${raw}`);
-      }
-      return raw;
-    case 'string':
-    default:
-      return raw;
-  }
-}
 
 export function registerConfigCommand(registry: CommandRegistry): void {
   registry.register({
     name: 'config',
     aliases: ['cfg'],
-    description: 'Show or set config values',
-    usage: '[category|key] [value] | reset [key]',
-    argsHint: '<key> [value]',
-    async handler(args, ctx) {
-      const cm = ctx.platform.configManager;
-      const categories = ['display', 'ui', 'provider', 'behavior', 'storage', 'permissions', 'surfaces', 'cloudflare', 'batch', 'tts', 'danger', 'tools'] as const;
-
-      if (args[0] === 'profile') {
-        const sub = args[1];
-        const profileName = args[2];
-        const pm = requireProfileManager(ctx);
-        const currentConfig = cm.getAll();
-
-        if (!sub || sub === 'list') {
-          const profiles = pm.list();
-          if (profiles.length === 0) {
-            ctx.print('No saved profiles.\nUse /config profile save <name> to save current settings.');
-            return;
-          }
-          const lines = ['Saved profiles:', ''];
-          for (const p of profiles) {
-            const date = new Date(p.timestamp).toLocaleString();
-            lines.push(`  ${p.name.padEnd(28)} ${date}`);
-          }
-          ctx.print(lines.join('\n'));
-          return;
-        }
-
-        if (sub === 'save') {
-          if (!profileName) {
-            ctx.print('Usage: /config profile save <name>');
-            return;
-          }
-          try {
-            const data = configSnapshotToProfileData(currentConfig as Record<string, unknown>);
-            const filePath = pm.save(profileName, data);
-            ctx.print(`Profile saved: ${profileName}\n  → ${filePath}`);
-          } catch (e) {
-            ctx.print(`Failed to save profile: ${summarizeError(e)}`);
-          }
-          return;
-        }
-
-        if (sub === 'load') {
-          if (!profileName) {
-            ctx.print('Usage: /config profile load <name>');
-            return;
-          }
-          try {
-            const { data } = pm.load(profileName);
-            for (const [key, value] of Object.entries(profileDataToConfigSnapshot(data))) {
-              const schema = CONFIG_SCHEMA.find((entry) => entry.key === key as ConfigKey);
-              if (!schema) continue;
-              cm.setDynamic(key as ConfigKey, value);
-              if (key === 'provider.model') ctx.session.runtime.model = value as string;
-              if (key === 'provider.provider') ctx.session.runtime.provider = value as string;
-              if (key === 'provider.reasoningEffort') ctx.session.runtime.reasoningEffort = value as string;
-            }
-            ctx.print(`Profile loaded: ${profileName}`);
-            ctx.renderRequest();
-          } catch (e) {
-            ctx.print(`Failed to load profile: ${summarizeError(e)}`);
-          }
-          return;
-        }
-
-        if (sub === 'delete') {
-          if (!profileName) {
-            ctx.print('Usage: /config profile delete <name>');
-            return;
-          }
-          const deleted = pm.delete(profileName);
-          if (deleted) ctx.print(`Profile deleted: ${profileName}`);
-          else ctx.print(`Profile not found: ${profileName}`);
-          return;
-        }
-
-        ctx.print(`Unknown profile subcommand: ${sub}\nUsage: /config profile save|load|list|delete <name>`);
-        return;
-      }
-
-      if (args[0] === 'diff') {
-        const lines = ['Changed settings:'];
-        let changed = 0;
-        for (const setting of CONFIG_SCHEMA) {
-          try {
-            const value = cm.get(setting.key);
-            if (JSON.stringify(value) !== JSON.stringify(setting.default)) {
-              changed++;
-              lines.push(`  ${setting.key.padEnd(36)} ${String(value)}  (default: ${String(setting.default)})`);
-            }
-          } catch {
-            // ignore invalid reads
-          }
-        }
-        if (changed === 0) lines.push('  (none)');
-        ctx.print(lines.join('\n'));
-        return;
-      }
-
-      if (args[0] === 'bundle') {
-        const sub = args[1];
-        const bundlePath = args[2];
-        const shellPaths = requireShellPaths(ctx);
-        if (sub === 'export') {
-          if (!bundlePath) {
-            ctx.print('Usage: /config bundle export <path>');
-            return;
-          }
-          const targetPath = shellPaths.resolveWorkspacePath(bundlePath);
-          const servicesPath = shellPaths.resolveProjectPath('tui', 'services.json');
-          const pluginCatalogPath = shellPaths.resolveProjectPath('tui', 'ecosystem', 'plugins.json');
-          const skillCatalogPath = shellPaths.resolveProjectPath('tui', 'ecosystem', 'skills.json');
-          const bundle: ConfigBundle = {
-            schemaVersion: 'v1',
-            exportedAt: Date.now(),
-            config: buildConfigSnapshot(cm),
-            services: readOptionalJson(servicesPath),
-            ecosystem: {
-              plugins: readOptionalJson(pluginCatalogPath),
-              skills: readOptionalJson(skillCatalogPath),
-            },
-          };
-          mkdirSync(dirname(targetPath), { recursive: true });
-          writeFileSync(targetPath, JSON.stringify(bundle, null, 2) + '\n', 'utf-8');
-          ctx.print(`Config bundle exported to ${targetPath}`);
-          return;
-        }
-
-        if (sub === 'inspect') {
-          if (!bundlePath) {
-            ctx.print('Usage: /config bundle inspect <path>');
-            return;
-          }
-          const sourcePath = shellPaths.resolveWorkspacePath(bundlePath);
-          try {
-            const bundle = JSON.parse(readFileSync(sourcePath, 'utf-8')) as ConfigBundle;
-            ctx.print(`${inspectConfigBundle(bundle)}\n  path: ${sourcePath}`);
-          } catch (error) {
-            ctx.print(`Failed to read config bundle: ${summarizeError(error)}`);
-          }
-          return;
-        }
-
-        if (sub === 'import') {
-          if (!bundlePath) {
-            ctx.print('Usage: /config bundle import <path>');
-            return;
-          }
-          const sourcePath = shellPaths.resolveWorkspacePath(bundlePath);
-          let bundle: ConfigBundle;
-          try {
-            bundle = JSON.parse(readFileSync(sourcePath, 'utf-8')) as ConfigBundle;
-          } catch (error) {
-            ctx.print(`Failed to read config bundle: ${summarizeError(error)}`);
-            return;
-          }
-          for (const entry of CONFIG_SCHEMA) {
-            const value = (bundle.config as Record<string, unknown>)[entry.key];
-            if (value === undefined) continue;
-            cm.setDynamic(entry.key, value);
-            if (entry.key === 'provider.model') ctx.session.runtime.model = value as string;
-            if (entry.key === 'provider.provider') ctx.session.runtime.provider = value as string;
-            if (entry.key === 'provider.reasoningEffort') ctx.session.runtime.reasoningEffort = value as string;
-          }
-
-          const ecosystemDir = shellPaths.resolveProjectPath('tui', 'ecosystem');
-          if (bundle.services) {
-            const servicesPath = shellPaths.resolveProjectPath('tui', 'services.json');
-            mkdirSync(dirname(servicesPath), { recursive: true });
-            writeFileSync(servicesPath, JSON.stringify(bundle.services, null, 2) + '\n', 'utf-8');
-          }
-          if (bundle.ecosystem?.plugins) {
-            mkdirSync(ecosystemDir, { recursive: true });
-            writeFileSync(join(ecosystemDir, 'plugins.json'), JSON.stringify(bundle.ecosystem.plugins, null, 2) + '\n', 'utf-8');
-          }
-          if (bundle.ecosystem?.skills) {
-            mkdirSync(ecosystemDir, { recursive: true });
-            writeFileSync(join(ecosystemDir, 'skills.json'), JSON.stringify(bundle.ecosystem.skills, null, 2) + '\n', 'utf-8');
-          }
-          ctx.print(`Config bundle imported from ${sourcePath}`);
-          return;
-        }
-
-        ctx.print('Usage: /config bundle export <path> | inspect <path> | import <path>');
-        return;
-      }
-
-      if (args[0] === 'reset') {
-        const resetKey = args[1];
-        if (!resetKey) {
-          ctx.print('Usage: /config reset <key>');
-          return;
-        }
-        const schema = CONFIG_SCHEMA.find((entry) => entry.key === resetKey);
-        if (!schema) {
-          ctx.print(`Unknown config key: ${resetKey}`);
-          return;
-        }
-        try {
-          cm.setDynamic(resetKey as ConfigKey, schema.default);
-          if (isSecretConfigKey(resetKey)) {
-            const secretsManager = requireSecretsManager(ctx);
-            await secretsManager.delete(buildGoodVibesSecretKey(resetKey), { scope: 'user' });
-          }
-          if (resetKey === 'provider.model') ctx.session.runtime.model = schema.default as string;
-          if (resetKey === 'provider.provider') ctx.session.runtime.provider = schema.default as string;
-          if (resetKey === 'provider.reasoningEffort') ctx.session.runtime.reasoningEffort = schema.default as string;
-          ctx.print(`Reset ${resetKey} to default: ${String(schema.default)}`);
-        } catch (e) {
-          ctx.print(`Error: ${summarizeError(e)}`);
-        }
+    description: 'Open the fullscreen configuration workspace',
+    usage: '[category|key]',
+    argsHint: '[category|key]',
+    handler(args, ctx) {
+      if (ctx.openSettingsModal) {
+        ctx.openSettingsModal(args[0]);
         return;
       }
-
-      if (args.length === 0) {
-        if (ctx.openSelection) {
-          const items = CONFIG_SCHEMA.map((schema) => {
-            let current = '';
-            try {
-              current = String(cm.get(schema.key));
-            } catch {
-              current = '(unavailable)';
-            }
-            const toggleable = schema.type === 'boolean' || schema.type === 'enum';
-            const adjustable = toggleable || schema.type === 'number';
-            const adjustmentMeta = getConfigSelectionAdjustmentMeta(schema);
-            return {
-              id: schema.key,
-              label: schema.key,
-              detail: `${current} — ${schema.description}`,
-              category: schema.key.split('.')[0],
-              primaryAction: toggleable ? 'toggle' as const : 'select' as const,
-              adjustable,
-              ...adjustmentMeta,
-              actions: schema.type === 'number'
-                ? '[←/→] adjust  [⇧←/⇧→] ±10  [Enter] inspect'
-                : toggleable
-                ? '[Space/Enter] toggle  [←/→] adjust'
-                : '[Enter] inspect',
-            };
-          });
-          ctx.openSelection('Config Settings', items, { allowSearch: true }, (result) => {
-            if (!result) return;
-            const key = result.item.id as ConfigKey;
-            const schema = CONFIG_SCHEMA.find((entry) => entry.key === key);
-            if (!schema) return;
-            if ((result.action === 'toggle' || result.action === 'increment' || result.action === 'decrement')
-              && (schema.type === 'boolean' || schema.type === 'enum' || schema.type === 'number')) {
-              const currentValue = cm.get(key);
-              let nextValue: unknown = currentValue;
-              if (schema.type === 'boolean') {
-                if (result.action === 'increment') nextValue = true;
-                else if (result.action === 'decrement') nextValue = false;
-                else {
-                  nextValue = !Boolean(currentValue);
-                }
-              } else if (schema.type === 'enum' && schema.enumValues && schema.enumValues.length > 0) {
-                const currentIndex = Math.max(0, schema.enumValues.indexOf(String(currentValue)));
-                if (result.action === 'decrement') {
-                  nextValue = schema.enumValues[(currentIndex - 1 + schema.enumValues.length) % schema.enumValues.length]!;
-                } else {
-                  nextValue = schema.enumValues[(currentIndex + 1) % schema.enumValues.length]!;
-                }
-              } else if (schema.type === 'number') {
-                const currentNumber = Number(currentValue);
-                const delta = result.action === 'decrement' ? -(result.step ?? 1) : (result.step ?? 1);
-                const precision = result.item.adjustPrecision ?? 0;
-                const rounded = roundToPrecision(currentNumber + delta, precision);
-                const clamped = Math.min(
-                  result.item.adjustMax ?? rounded,
-                  Math.max(result.item.adjustMin ?? rounded, rounded),
-                );
-                nextValue = clamped;
-              }
-              cm.setDynamic(key, nextValue);
-              if (key === 'provider.model') ctx.session.runtime.model = nextValue as string;
-              if (key === 'provider.provider') ctx.session.runtime.provider = nextValue as string;
-              if (key === 'provider.reasoningEffort') ctx.session.runtime.reasoningEffort = nextValue as string;
-              result.item.detail = `${String(nextValue)} — ${schema.description}`;
-              ctx.renderRequest();
-              return;
-            }
-            const value = cm.get(key);
-            const lines = [
-              `${key}`,
-              `  value:   ${String(value)}`,
-              `  default: ${String(schema.default)}`,
-              `  type:    ${schema.type}${schema.enumValues ? ` (${schema.enumValues.join(', ')})` : ''}`,
-              `  desc:    ${schema.description}`,
-            ];
-            ctx.print(lines.join('\n'));
-          });
-          return;
-        }
-        const lines: string[] = ['Config settings:'];
-        for (const cat of categories) {
-          lines.push(`  [${cat}]`);
-          for (const schema of CONFIG_SCHEMA.filter((entry) => entry.key.startsWith(`${cat}.`))) {
-            lines.push(`  ${formatConfigSchemaEntry(cm, schema)}`);
-          }
-        }
-        ctx.print(lines.join('\n'));
-        return;
-      }
-
-      const firstArg = args[0];
-      if (categories.includes(firstArg as typeof categories[number]) && args.length === 1) {
-        const cat = firstArg as typeof categories[number];
-        const lines: string[] = [`[${cat}]`];
-        for (const schema of CONFIG_SCHEMA.filter((entry) => entry.key.startsWith(`${cat}.`))) {
-          lines.push(formatConfigSchemaEntry(cm, schema));
-        }
-        ctx.print(lines.join('\n'));
-        return;
-      }
-
-      if (args.length === 1 && firstArg.includes('.')) {
-        const key = firstArg as ConfigKey;
-        const schema = CONFIG_SCHEMA.find((entry) => entry.key === key);
-        if (!schema) {
-          ctx.print(`Unknown config key: ${key}\nRun /config to see all keys.`);
-          return;
-        }
-        try {
-          const val = cm.get(key);
-          const lines = [
-            `${key}`,
-            `  value:   ${String(val)}`,
-            `  default: ${String(schema.default)}`,
-            `  type:    ${schema.type}${schema.enumValues ? ` (${schema.enumValues.join(', ')})` : ''}`,
-            `  desc:    ${schema.description}`,
-          ];
-          ctx.print(lines.join('\n'));
-        } catch (e) {
-          ctx.print(`Error: ${summarizeError(e)}`);
-        }
-        return;
-      }
-
-      if (args.length >= 2 && firstArg.includes('.')) {
-        const key = firstArg as ConfigKey;
-        const rawValue = args.slice(1).join(' ');
-        const schema = CONFIG_SCHEMA.find((entry) => entry.key === key);
-        if (!schema) {
-          ctx.print(`Unknown config key: ${key}\nRun /config to see all keys.`);
-          return;
-        }
-
-        let coerced: unknown;
-        try {
-          coerced = coerceValue(rawValue, schema.type, schema.enumValues);
-        } catch (e) {
-          ctx.print(`Invalid value for ${key}: ${summarizeError(e)}`);
-          return;
-        }
-
-        try {
-          if (schema.type === 'string' && isSecretConfigKey(key)) {
-            const configValue = await persistSecretBackedConfigValue(cm, requireSecretsManager(ctx), key, String(coerced), { scope: 'user' });
-            ctx.print(`Set ${key} = ${configValue}`);
-          } else {
-            cm.setDynamic(key, coerced);
-            ctx.print(`Set ${key} = ${String(coerced)}`);
-          }
-          if (key === 'provider.model') ctx.session.runtime.model = coerced as string;
-          if (key === 'provider.provider') ctx.session.runtime.provider = coerced as string;
-          if (key === 'provider.reasoningEffort') ctx.session.runtime.reasoningEffort = coerced as string;
-        } catch (e) {
-          ctx.print(`Error: ${summarizeError(e)}`);
-        }
-        return;
-      }
-
-      if (args.length >= 2) {
-        const [key, ...rest] = args;
-        const value = rest.join(' ');
-        switch (key) {
-          case 'system':
-          case 'systemPrompt':
-            ctx.session.runtime.systemPrompt = value;
-            ctx.print('System prompt updated (runtime only; use provider.systemPromptFile for persistence).');
-            break;
-          case 'model':
-            try {
-              const selected = await requireProviderApi(ctx).selectModel(value);
-              ctx.session.runtime.model = selected.registryKey;
-              ctx.session.runtime.provider = selected.providerId;
-              cm.set('provider.model', selected.registryKey);
-              cm.set('provider.provider', selected.providerId);
-              ctx.print(`Model set to: ${selected.displayName}`);
-            } catch (e) {
-              ctx.print(`Error: ${summarizeError(e)}`);
-            }
-            break;
-          default:
-            ctx.print(`Unknown config key: ${key}\nRun /config to see all keys.`);
-        }
-        return;
-      }
-
-      ctx.print('Usage: /config [category|key] [value]\n/config reset [key]');
+      ctx.print('Fullscreen config workspace is not available in this runtime.');
     },
   });
 }