@pellux/goodvibes-tui 0.19.53 → 0.19.55

package/src/input/commands/knowledge.ts

@@ -1,8 +1,12 @@
+import type { KnowledgeService } from '@pellux/goodvibes-sdk/platform/knowledge/index';
 import type { CommandContext, SlashCommand } from '../command-registry.ts';
 
 const KNOWLEDGE_REVIEW_ACTIONS = ['accept', 'reject', 'resolve', 'reopen', 'edit', 'forget'] as const;
 
 type KnowledgeReviewAction = typeof KNOWLEDGE_REVIEW_ACTIONS[number];
+type KnowledgeAskInput = Parameters<KnowledgeService['ask']>[0];
+type KnowledgeAskResult = Awaited<ReturnType<KnowledgeService['ask']>>;
+type KnowledgeAskMode = NonNullable<KnowledgeAskInput['mode']>;
 
 function requireKnowledgeApi(context: CommandContext) {
   const knowledgeApi = context.clients?.knowledgeApi;
@@ -24,6 +28,13 @@ function readStringListFlag(args: string[], name: string): string[] {
   return value.split(',').map((entry) => entry.trim()).filter(Boolean);
 }
 
+function readPositiveIntFlag(args: string[], name: string, fallback: number): number {
+  const raw = readFlag(args, name);
+  if (!raw) return fallback;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
 function readJsonObjectFlag(args: string[], name: string): Record<string, unknown> | null | undefined {
   const value = readFlag(args, name);
   if (!value) return undefined;
@@ -46,12 +57,84 @@ function positionalArgs(args: string[], valuedFlags: readonly string[] = []): st
   });
 }
 
+function requireKnowledgeAsk(context: CommandContext): ((input: KnowledgeAskInput) => Promise<KnowledgeAskResult>) | null {
+  const serviceAsk = context.extensions.knowledgeService?.ask?.bind(context.extensions.knowledgeService);
+  if (serviceAsk) return serviceAsk;
+
+  const clientAsk = (context.clients?.knowledgeApi as unknown as { ask?: (input: KnowledgeAskInput) => Promise<KnowledgeAskResult> } | undefined)?.ask;
+  if (clientAsk) return clientAsk;
+
+  context.print('[knowledge] Knowledge ask is not available in this runtime.');
+  return null;
+}
+
+function cleanInline(value: unknown): string {
+  return typeof value === 'string' ? value.replace(/\s+/g, ' ').trim() : '';
+}
+
+function nodeLabel(node: { readonly kind?: string; readonly title?: string; readonly summary?: string; readonly confidence?: number }): string {
+  const kind = cleanInline(node.kind) || 'node';
+  const title = cleanInline(node.title) || 'untitled';
+  const summary = cleanInline(node.summary);
+  const confidence = typeof node.confidence === 'number' ? ` confidence=${node.confidence}` : '';
+  return summary ? `[${kind}] ${title}${confidence} - ${summary}` : `[${kind}] ${title}${confidence}`;
+}
+
+function sourceLabel(source: {
+  readonly id?: string;
+  readonly sourceType?: string;
+  readonly title?: string;
+  readonly canonicalUri?: string;
+  readonly sourceUri?: string;
+  readonly summary?: string;
+  readonly status?: string;
+}): string {
+  const title = cleanInline(source.title) || cleanInline(source.canonicalUri) || cleanInline(source.sourceUri) || cleanInline(source.id) || 'untitled';
+  const type = cleanInline(source.sourceType) || 'source';
+  const status = cleanInline(source.status);
+  const summary = cleanInline(source.summary);
+  const suffix = status ? `/${status}` : '';
+  return summary ? `[${type}${suffix}] ${title} - ${summary}` : `[${type}${suffix}] ${title}`;
+}
+
+function renderKnowledgeAskResult(result: KnowledgeAskResult): string {
+  const answer = result.answer;
+  const lines = [
+    `[knowledge] ${result.query}`,
+    answer.text,
+    '',
+    `mode: ${answer.mode}  confidence: ${answer.confidence}  synthesized: ${answer.synthesized ? 'yes' : 'no'}`,
+  ];
+
+  if (answer.sources.length > 0) {
+    lines.push('', 'Sources:');
+    for (const source of answer.sources) lines.push(`  - ${sourceLabel(source)}`);
+  }
+
+  if (answer.facts.length > 0) {
+    lines.push('', 'Facts:');
+    for (const fact of answer.facts) lines.push(`  - ${nodeLabel(fact)}`);
+  }
+
+  if (answer.linkedObjects.length > 0) {
+    lines.push('', 'Linked objects:');
+    for (const object of answer.linkedObjects) lines.push(`  - ${nodeLabel(object)}`);
+  }
+
+  if (answer.gaps.length > 0) {
+    lines.push('', 'Gaps:');
+    for (const gap of answer.gaps) lines.push(`  - ${nodeLabel(gap)}`);
+  }
+
+  return lines.join('\n');
+}
+
 export const knowledgeCommand: SlashCommand = {
   name: 'knowledge',
   aliases: ['know', 'kb'],
   description: 'Structured knowledge graph: ingest URLs/bookmarks, inspect issues, and build compact prompt packets.',
   usage: '<subcommand> [args]',
-  argsHint: 'status|ingest-url|import-bookmarks|import-urls|list|search|get|queue|review-issue|candidates|reports|schedules|lint|packet|explain|reindex|consolidate',
+  argsHint: 'status|ask|ingest-url|import-bookmarks|import-urls|list|search|get|queue|review-issue|candidates|reports|schedules|lint|packet|explain|reindex|consolidate',
   handler: async (args: string[], context: CommandContext): Promise<void> => {
     const knowledge = requireKnowledgeApi(context);
     if (!knowledge) {
@@ -65,6 +148,32 @@ export const knowledgeCommand: SlashCommand = {
     const rest = args.slice(1);
 
     switch (sub) {
+      case 'ask': {
+        const ask = requireKnowledgeAsk(context);
+        if (!ask) return;
+        const valuedFlags = ['--space', '--knowledge-space', '--limit', '--mode'];
+        const query = positionalArgs(rest, valuedFlags).join(' ').trim();
+        if (!query) {
+          context.print('[knowledge] Usage: /knowledge ask <query> [--space <knowledgeSpaceId>] [--limit <n>] [--mode <concise|standard|detailed>]');
+          return;
+        }
+        const requestedMode = readFlag(rest, '--mode') as KnowledgeAskMode | undefined;
+        const mode: KnowledgeAskMode = requestedMode && ['concise', 'standard', 'detailed'].includes(requestedMode)
+          ? requestedMode
+          : 'standard';
+        const result = await ask({
+          query,
+          knowledgeSpaceId: readFlag(rest, '--space') ?? readFlag(rest, '--knowledge-space'),
+          limit: readPositiveIntFlag(rest, '--limit', 10),
+          mode,
+          includeSources: true,
+          includeConfidence: true,
+          includeLinkedObjects: true,
+        });
+        context.print(renderKnowledgeAskResult(result));
+        break;
+      }
+
       case 'status': {
         const status = await knowledge.status.get();
         context.print([
@@ -399,6 +508,7 @@ export const knowledgeCommand: SlashCommand = {
         context.print([
           'Usage: /knowledge <subcommand>',
           '  status',
+          '  ask <query> [--space <knowledgeSpaceId>] [--limit <n>] [--mode <concise|standard|detailed>]',
           '  ingest-url <url> [--title <title>] [--tags <a,b>] [--folder <path>]',
           '  import-bookmarks <path>',
           '  import-urls <path>',

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

@@ -4,8 +4,6 @@ import { readFile } from 'node:fs/promises';
 import type { CommandRegistry, CommandContext } from '../command-registry.ts';
 import type { SelectionItem } from '../selection-modal.ts';
 import type { ContentPart } from '@pellux/goodvibes-sdk/platform/providers/interface';
-import type { ConfigKey } from '../../config/index.ts';
-import { CONFIG_SCHEMA } from '../../config/index.ts';
 import { resolveAndValidatePath } from '@pellux/goodvibes-sdk/platform/utils/path-safety';
 import { BUILTIN_SECRET_PROVIDER_SOURCES, describeSecretRef, isSecretRefInput, resolveSecretRef } from '@pellux/goodvibes-sdk/platform/config/secret-refs';
 import { openCommandPanel, requireBookmarkManager, requireProviderApi, requireSecretsManager } from './runtime-services.ts';
@@ -246,84 +244,6 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
     },
   });
 
-  registry.register({
-    name: 'danger',
-    argsHint: '[key] [value]',
-    description: '⚠ Danger zone settings (agent recursion, daemon, HTTP listener)',
-    usage: '[key] [value]',
-    handler(args, ctx) {
-      if (args.length === 0) {
-        if (ctx.openSelection) {
-          const cm = ctx.platform.configManager;
-          const dangerObj = cm.getAll().danger as Record<string, unknown>;
-          const items: SelectionItem[] = Object.entries(dangerObj).map(([field, val]) => {
-            const key = `danger.${field}`;
-            const schema = CONFIG_SCHEMA.find(s => s.key === key);
-            const toggleable = schema?.type === 'boolean';
-            return {
-              id: key,
-              label: key,
-              detail: String(val),
-              fg: '#ef4444',
-              adjustable: toggleable,
-              primaryAction: toggleable ? 'toggle' : 'select',
-              actions: schema ? `${toggleable ? '[Space/Enter] toggle  [←/→] set' : '[Enter] inspect'}  ${schema.description}` : undefined,
-            };
-          });
-          ctx.openSelection('⚠ Danger Zone', items, { allowSearch: false }, (result) => {
-            if (!result) return;
-            const key = result.item.id as ConfigKey;
-            const schema = CONFIG_SCHEMA.find(s => s.key === key);
-            if (result.action === 'toggle' && schema) {
-              const currentVal = cm.get(key);
-              let newVal: unknown = currentVal;
-              if (schema.type === 'boolean') {
-                newVal = !currentVal;
-                cm.setDynamic(key, newVal);
-              } else if (schema.type === 'number') {
-                ctx.print(`Current: ${key} = ${String(currentVal)}. Use /danger ${key.replace('danger.', '')} <value> to set.`);
-                return;
-              }
-              result.item.detail = String(newVal);
-              ctx.renderRequest();
-            } else if ((result.action === 'increment' || result.action === 'decrement') && schema?.type === 'boolean') {
-              const newVal = result.action === 'increment';
-              cm.setDynamic(key, newVal);
-              result.item.detail = String(newVal);
-              ctx.renderRequest();
-            }
-          });
-        } else {
-          const dangerObj = ctx.platform.configManager.getAll().danger as Record<string, unknown>;
-          ctx.print(['⚠ Danger Zone Settings:', '', ...Object.entries(dangerObj).map(([field, val]) => `  ${`danger.${field}`.padEnd(36)} ${String(val)}`)].join('\n'));
-        }
-        return;
-      }
-      const key = args[0].startsWith('danger.') ? args[0] : `danger.${args[0]}`;
-      if (args.length === 1) {
-        try {
-          ctx.print(`${key} = ${String(ctx.platform.configManager.get(key as Parameters<typeof ctx.platform.configManager.get>[0]))}`);
-        } catch (e) {
-          ctx.print(`Error: ${summarizeError(e)}`);
-        }
-        return;
-      }
-      try {
-        const schema = CONFIG_SCHEMA.find(s => s.key === key);
-        if (!schema) {
-          ctx.print(`Unknown danger key: ${key}`);
-          return;
-        }
-        const rawValue = args.slice(1).join(' ');
-        const coerced: unknown = schema.type === 'boolean' ? (rawValue === 'true' || rawValue === '1' || rawValue === 'yes') : schema.type === 'number' ? Number(rawValue) : rawValue;
-        ctx.platform.configManager.setDynamic(key as Parameters<typeof ctx.platform.configManager.get>[0], coerced);
-        ctx.print(`⚠ Set ${key} = ${String(coerced)}`);
-      } catch (e) {
-        ctx.print(`Error: ${summarizeError(e)}`);
-      }
-    },
-  });
-
   registry.register({
     name: 'image',
     aliases: ['img'],

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

@@ -12,10 +12,10 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
   registry.register({
     name: 'settings',
     aliases: ['cfg-ui'],
-    description: 'Open the config/settings browser modal',
+    description: 'Open the fullscreen configuration workspace',
     handler(_args, ctx) {
       if (ctx.openSettingsModal) ctx.openSettingsModal();
-      else ctx.print('Settings modal not available. Use /config to view or set values.');
+      else ctx.print('Configuration workspace is not available in this runtime.');
     },
   });
 
@@ -72,7 +72,7 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
         ctx.openProfilePicker();
       } else {
         const profiles = requireProfileManager(ctx).list();
-        if (profiles.length === 0) ctx.print('No profiles saved. Use /config profile save <name> to create one.');
+        if (profiles.length === 0) ctx.print('No profiles saved. Open /profiles and press s to save the current settings as a profile.');
         else ctx.print(['Saved profiles:', ...profiles.map(p => `  ${p.name}`)].join('\n'));
       }
     },

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

@@ -1,16 +1,14 @@
 import type { CommandRegistry } from '../command-registry.ts';
-import { classifyIntent } from '@pellux/goodvibes-sdk/platform/core/intent-classifier';
-import { requireAdaptivePlanner, requirePlanManager, requireSessionLineageTracker } from './runtime-services.ts';
+import { requirePlanManager, requireSessionLineageTracker } from './runtime-services.ts';
 
 export function registerPlanningRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'plan',
-    description: 'Manage execution plans and adaptive execution strategy',
-    usage: '[list | show <id> | mode | explain | override <strategy> | status | clear | <task description>]',
-    argsHint: '[list|show|mode|explain|override|status|clear|<task>]',
-    handler(args, ctx) {
+    description: 'Inspect or seed TUI-owned project planning state',
+    usage: '[panel | approve | list | show <id> | mode | explain | override <strategy> | status | clear | <planning goal>]',
+    argsHint: '[panel|approve|status|<goal>]',
+    async handler(args, ctx) {
       const planManager = requirePlanManager(ctx);
-      const adaptivePlanner = requireAdaptivePlanner(ctx);
       const sessionLineageTracker = requireSessionLineageTracker(ctx);
       const plannerSubs = ['mode', 'explain', 'override', 'status', 'clear'];
       if (args.length > 0 && plannerSubs.includes(args[0].toLowerCase())) {
@@ -21,10 +19,29 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
+      const projectPlanningService = ctx.workspace.projectPlanningService;
+      const projectId = ctx.workspace.projectPlanningProjectId;
+      const openProjectPlanningPanel = () => ctx.showPanel?.('project-planning');
+
       if (args.length === 0) {
+        if (projectPlanningService && projectId) {
+          const [status, evaluation] = await Promise.all([
+            projectPlanningService.status({ projectId }),
+            projectPlanningService.evaluate({ projectId }),
+          ]);
+          openProjectPlanningPanel();
+          ctx.print(
+            `Project planning: ${evaluation.readiness}\n` +
+            `Project: ${status.projectId}\n` +
+            `Knowledge space: ${status.knowledgeSpaceId}\n` +
+            `Artifacts: ${status.counts.states} state, ${status.counts.decisions} decisions, ${status.counts.languageArtifacts} language\n` +
+            (evaluation.nextQuestion ? `Next question: ${evaluation.nextQuestion.prompt}` : 'No next question recorded.'),
+          );
+          return;
+        }
         const active = planManager.getActive(ctx.session.runtime.sessionId);
         if (!active) {
-          ctx.print('No active plan. Use /plan <task description> to create one.');
+          ctx.print('No active execution plan.');
           return;
         }
         const summary = planManager.getSummary(active);
@@ -32,6 +49,40 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
+      if (args[0] === 'panel') {
+        openProjectPlanningPanel();
+        ctx.print('Opened project planning panel.');
+        return;
+      }
+
+      if (args[0] === 'approve') {
+        if (!projectPlanningService || !projectId) {
+          ctx.print('Project planning service is not available in this runtime.');
+          return;
+        }
+        const current = await projectPlanningService.getState({ projectId });
+        if (!current.state) {
+          ctx.print('No project planning state exists to approve.');
+          return;
+        }
+        const result = await projectPlanningService.upsertState({
+          projectId,
+          state: {
+            ...current.state,
+            executionApproved: true,
+            metadata: {
+              ...(current.state.metadata ?? {}),
+              approvedFrom: 'plan-command',
+              approvedAt: Date.now(),
+            },
+          },
+        });
+        const evaluation = await projectPlanningService.evaluate({ projectId });
+        openProjectPlanningPanel();
+        ctx.print(`Project planning approved. Readiness: ${evaluation.readiness}. State: ${result.state?.id ?? 'current'}.`);
+        return;
+      }
+
       if (args[0] === 'list') {
         const plans = planManager.list();
         if (plans.length === 0) {
@@ -62,36 +113,34 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
       }
 
       const taskDescription = args.join(' ');
-      const classification = classifyIntent(taskDescription);
-      const plan = planManager.create(taskDescription, [], ctx.session.runtime.sessionId);
-      plan.awaitingPlan = true;
-      planManager.save(plan);
+      if (!projectPlanningService || !projectId) {
+        ctx.print('Project planning service is not available in this runtime.');
+        return;
+      }
+      const result = await projectPlanningService.upsertState({
+        projectId,
+        state: {
+          goal: taskDescription,
+          knownContext: [
+            `Workspace planning was seeded from the TUI /plan command.`,
+          ],
+          metadata: {
+            active: true,
+            owner: 'tui',
+            source: 'plan-command',
+            lastPromptAt: Date.now(),
+          },
+        },
+      });
+      const evaluation = await projectPlanningService.evaluate({ projectId });
       sessionLineageTracker.setOriginalTask(taskDescription.slice(0, 200));
+      openProjectPlanningPanel();
 
       ctx.print(
-        `Plan created: "${plan.title}" (${plan.id.slice(0, 8)})\n` +
-        `Intent: ${classification.intent} (confidence: ${(classification.confidence * 100).toFixed(0)}%)\n` +
-        `Signals: ${classification.signals.join(', ') || 'none'}\n` +
-        'The model will write the execution plan — agents will be spawned automatically.',
-      );
-
-      ctx.session.conversationManager.addSystemMessage(
-        `You are creating an execution plan for the following task: "${taskDescription}"\n\n` +
-        'Output the plan in EXACTLY this markdown format and nothing else:\n\n' +
-        '## Phase 1: [Phase Name] [PENDING]\n' +
-        '- [ ] [Task description] — PENDING\n' +
-        '- [ ] [Task description] — PENDING (depends: [other task description])\n\n' +
-        '## Phase 2: [Phase Name] [PENDING]\n' +
-        '- [ ] [Task description] — PENDING (depends: [Phase 1 task description])\n\n' +
-        'Rules:\n' +
-        '- Each item must be a concrete, independently executable task\n' +
-        '- Use (depends: ...) only where execution order truly matters\n' +
-        '- Items without dependencies in the same phase can run in parallel\n' +
-        '- Keep phases to 2-4 items each, aim for maximum parallelism\n' +
-        '- Output ONLY the plan markdown — the system will parse it and spawn agents automatically',
+        `Project planning seeded: "${result.state?.goal ?? taskDescription}"\n` +
+        `Readiness: ${evaluation.readiness}\n` +
+        (evaluation.nextQuestion ? `Next question: ${evaluation.nextQuestion.prompt}` : 'No next question recorded.'),
       );
-
-      ctx.activatePlan?.(plan.id, taskDescription);
     },
   });
 }

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

@@ -103,12 +103,8 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
           { id: '/model', label: '/model [id]', detail: 'Select LLM model', category: 'Model & Provider' },
           { id: '/provider', label: '/provider [name]', detail: 'Switch provider', category: 'Model & Provider' },
           { id: '/effort', label: '/effort [level]', detail: 'Reasoning effort (instant/low/medium/high)', category: 'Model & Provider' },
-          { id: '/config', label: '/config [key] [value]', detail: 'Show or set config values', category: 'Config & Display' },
-          { id: '/config diff', label: '/config diff', detail: 'Show changed settings', category: 'Config & Display' },
-          { id: '/config reset', label: '/config reset [key]', detail: 'Reset to defaults', category: 'Config & Display' },
-          { id: '/config profile', label: '/config profile ...', detail: 'Save/load/list/delete profiles', category: 'Config & Display' },
+          { id: '/config', label: '/config [category|key]', detail: 'Open fullscreen configuration workspace', category: 'Config & Display' },
           { id: '/debug', label: '/debug', detail: 'Toggle debug mode', category: 'Config & Display' },
-          { id: '/lines', label: '/lines', detail: 'Set line numbers: all, code, or off', category: 'Config & Display' },
           { id: '/expand', label: '/expand [type]', detail: 'Expand blocks (all|thinking|tool|code)', category: 'Config & Display' },
           { id: '/collapse', label: '/collapse [type]', detail: 'Collapse blocks', category: 'Config & Display' },
           { id: '/bookmarks', label: '/bookmarks', detail: 'List bookmarked blocks', category: 'Config & Display' },
@@ -140,11 +136,9 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
           { id: '/template save', label: '/template save <name>', detail: 'Save prompt as template', category: 'Templates' },
           { id: '/template use', label: '/template use <name>', detail: 'Execute template', category: 'Templates' },
           { id: '/tools', label: '/tools', detail: 'List available tools', category: 'Tools & System' },
-          { id: '/permissions', label: '/permissions', detail: 'Permission settings', category: 'Tools & System' },
           { id: '/shortcuts', label: '/shortcuts', detail: 'View keyboard shortcuts reference', category: 'Tools & System' },
           { id: '/commands', label: '/commands', detail: 'Browse all commands in a scrollable list', category: 'Tools & System' },
           { id: '/secrets', label: '/secrets set|link|get|test|list|delete', detail: 'Manage encrypted and provider-backed secrets', category: 'Tools & System' },
-          { id: '/danger', label: '/danger [key] [value]', detail: 'DANGEROUS SETTINGS', category: 'Tools & System', fg: '#ef4444' },
           { id: '/help', label: '/help', detail: 'This help', category: 'Tools & System' },
           { id: '/quit', label: '/quit', detail: 'Exit', category: 'Tools & System' },
           { id: '/wq', label: '/wq', detail: 'Commit all git changes and then exit', category: 'Tools & System' },
@@ -161,7 +155,7 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
         });
         return;
       }
-      ctx.print('Use /help to open the help modal. Commands: /model, /provider, /config, /template, /tools, /permissions, /sessions, /bookmarks, /save, /load, /undo, /redo, /retry, /clear, /reset, /compact, /export, /title, /effort, /lines, /expand, /collapse, /debug, /quit, /wq');
+      ctx.print('Use /help to open the help modal. Commands: /model, /provider, /config, /template, /tools, /sessions, /bookmarks, /save, /load, /undo, /redo, /retry, /clear, /reset, /compact, /export, /title, /effort, /expand, /collapse, /debug, /quit, /wq');
     },
   });
 
@@ -292,30 +286,4 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
     },
   });
 
-  registry.register({
-    name: 'lines',
-    aliases: [],
-    description: 'Set line-number display: all, code, or off',
-    handler(args, ctx) {
-      const current = ctx.platform.configManager.get('display.lineNumbers');
-      const aliases: Record<string, 'all' | 'code' | 'off'> = {
-        on: 'all',
-        all: 'all',
-        code: 'code',
-        blocks: 'code',
-        off: 'off',
-      };
-      const cycle: Array<'all' | 'code' | 'off'> = ['all', 'code', 'off'];
-      const requested = args[0]?.toLowerCase();
-      const next = requested ? aliases[requested] : cycle[(cycle.indexOf(current) + 1) % cycle.length]!;
-      if (requested && !next) {
-        ctx.print('Usage: /lines [all|code|off]');
-        return;
-      }
-      ctx.platform.configManager.set('display.lineNumbers', next);
-      const label = next === 'all' ? 'ON (all lines)' : next === 'code' ? 'CODE BLOCKS ONLY' : 'OFF';
-      ctx.print(`Line numbers: ${label}`);
-      ctx.renderRequest();
-    },
-  });
 }