@pellux/goodvibes-tui 0.19.53 → 0.19.55

package/src/runtime/bootstrap-command-context.ts

@@ -72,6 +72,8 @@ export type CreateBootstrapCommandContextOptions = {
   integrationHelpers?: IntegrationHelperService;
   automationManager?: ShellAutomationManagerRuntimeService;
   knowledgeService?: KnowledgeService;
+  projectPlanningService?: import('@pellux/goodvibes-sdk/platform/knowledge/index').ProjectPlanningService;
+  projectPlanningProjectId?: string;
   providerOptimizer?: import('@pellux/goodvibes-sdk/platform/providers/optimizer').ProviderOptimizer;
   pluginManager?: PluginManager;
   hookWorkbench?: HookWorkbench;
@@ -138,6 +140,8 @@ export function createBootstrapCommandContext(
     integrationHelpers,
     automationManager,
     knowledgeService,
+    projectPlanningService,
+    projectPlanningProjectId,
     providerOptimizer,
     pluginManager,
     hookWorkbench,
@@ -227,6 +231,8 @@ export function createBootstrapCommandContext(
     panelManager,
     profileManager,
     bookmarkManager,
+    projectPlanningService,
+    projectPlanningProjectId,
   }, shellServices);
   const platform = createBootstrapCommandPlatformSection({ configManager, voiceProviderRegistry, voiceService }, shellServices);
   const extensions = createBootstrapCommandExtensionsSection({

package/src/runtime/bootstrap-command-parts.ts

@@ -85,6 +85,8 @@ export interface BootstrapCommandSectionOptions {
   readonly memoryRegistry?: MemoryRegistry;
   readonly integrationHelpers?: IntegrationHelperService;
   readonly knowledgeService?: KnowledgeService;
+  readonly projectPlanningService?: import('@pellux/goodvibes-sdk/platform/knowledge/index').ProjectPlanningService;
+  readonly projectPlanningProjectId?: string;
   readonly pluginManager?: PluginManager;
   readonly hookWorkbench?: HookWorkbench;
   readonly providerOptimizer?: import('@pellux/goodvibes-sdk/platform/providers/optimizer').ProviderOptimizer;
@@ -312,6 +314,7 @@ export function createBootstrapCommandWorkspaceSection(
   options: Pick<
     BootstrapCommandSectionOptions,
     'keybindingsManager' | 'fileUndoManager' | 'panelManager' | 'profileManager' | 'bookmarkManager'
+    | 'projectPlanningService' | 'projectPlanningProjectId'
   >,
   shellServices: BootstrapCommandShellServices,
 ): BootstrapCommandWorkspaceSection {
@@ -321,6 +324,8 @@ export function createBootstrapCommandWorkspaceSection(
     panelManager: options.panelManager,
     profileManager: options.profileManager,
     bookmarkManager: options.bookmarkManager,
+    projectPlanningService: options.projectPlanningService,
+    projectPlanningProjectId: options.projectPlanningProjectId,
     ...shellServices.workspace,
   };
 }

package/src/runtime/bootstrap-shell.ts

@@ -196,6 +196,8 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     integrationHelpers: services.integrationHelpers,
     automationManager: services.automationManager,
     knowledgeService: services.knowledgeService,
+    projectPlanningService: services.projectPlanningService,
+    projectPlanningProjectId: services.projectPlanningProjectId,
     providerOptimizer: services.providerOptimizer,
     pluginManager: services.pluginManager,
     hookWorkbench: services.hookWorkbench,

package/src/runtime/services.ts

@@ -9,7 +9,16 @@ import { ChannelDeliveryRouter } from '@pellux/goodvibes-sdk/platform/channels/d
 import { ApprovalBroker, GatewayMethodCatalog, SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane/index';
 import { WatcherRegistry } from '@pellux/goodvibes-sdk/platform/watchers/index';
 import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts/index';
-import { HomeGraphService, KnowledgeService, KnowledgeStore } from '@pellux/goodvibes-sdk/platform/knowledge/index';
+import {
+  HomeGraphService,
+  KnowledgeService,
+  KnowledgeSemanticService,
+  KnowledgeStore,
+  ProjectPlanningService,
+  createProviderBackedKnowledgeSemanticLlm,
+  createWebKnowledgeGapRepairer,
+  projectPlanningProjectIdFromPath,
+} from '@pellux/goodvibes-sdk/platform/knowledge/index';
 import { MediaProviderRegistry, ensureBuiltinMediaProviders } from '@pellux/goodvibes-sdk/platform/media/index';
 import { MultimodalService } from '@pellux/goodvibes-sdk/platform/multimodal/index';
 import { AgentManager } from '@pellux/goodvibes-sdk/platform/tools/agent/index';
@@ -109,6 +118,8 @@ export interface RuntimeServices {
   readonly artifactStore: ArtifactStore;
   readonly knowledgeService: KnowledgeService;
   readonly homeGraphService: HomeGraphService;
+  readonly projectPlanningService: ProjectPlanningService;
+  readonly projectPlanningProjectId: string;
   readonly memoryStore: MemoryStore;
   readonly memoryRegistry: MemoryRegistry;
   readonly serviceRegistry: ServiceRegistry;
@@ -352,12 +363,26 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     },
   });
   const knowledgeStore = new KnowledgeStore({ configManager });
+  const knowledgeSemanticService = new KnowledgeSemanticService(knowledgeStore, {
+    llm: createProviderBackedKnowledgeSemanticLlm(providerRegistry, {
+      timeoutMs: 20_000,
+      maxConcurrent: 1,
+    }),
+    maxLlmSourcesPerReindex: 3,
+  });
   const knowledgeService = new KnowledgeService(knowledgeStore, artifactStore, undefined, {
     memoryRegistry,
     runtimeBus: options.runtimeBus,
+    semanticService: knowledgeSemanticService,
   });
   knowledgeService.attachRuntimeBus(options.runtimeBus);
-  const homeGraphService = new HomeGraphService(knowledgeStore, artifactStore);
+  const homeGraphService = new HomeGraphService(knowledgeStore, artifactStore, {
+    semanticService: knowledgeSemanticService,
+  });
+  const projectPlanningProjectId = projectPlanningProjectIdFromPath(workingDirectory);
+  const projectPlanningService = new ProjectPlanningService(knowledgeStore, {
+    defaultProjectId: projectPlanningProjectId,
+  });
   const voiceProviders = new VoiceProviderRegistry();
   ensureBuiltinVoiceProviders(voiceProviders);
   const voiceService = new VoiceService(voiceProviders);
@@ -369,6 +394,10 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     serviceRegistry,
     featureFlags,
   });
+  knowledgeSemanticService.setGapRepairer(createWebKnowledgeGapRepairer({
+    searchService: webSearchService,
+    ingestService: knowledgeService,
+  }));
   const mediaProviders = new MediaProviderRegistry();
   ensureBuiltinMediaProviders(mediaProviders, artifactStore, providerRegistry);
   const multimodalService = new MultimodalService(artifactStore, mediaProviders, voiceService, knowledgeService);
@@ -497,6 +526,8 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     artifactStore,
     knowledgeService,
     homeGraphService,
+    projectPlanningService,
+    projectPlanningProjectId,
     memoryStore,
     memoryRegistry,
     serviceRegistry,

package/src/runtime/terminal-output-guard.ts

@@ -0,0 +1,228 @@
+import { format } from 'node:util';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+
+type WritableStreamLike = {
+  write: {
+    (buffer: string | Uint8Array, cb?: (error?: Error | null) => void): boolean;
+    (buffer: string | Uint8Array, encoding?: BufferEncoding, cb?: (error?: Error | null) => void): boolean;
+  };
+};
+
+export type TerminalOutputInterceptSource =
+  | 'stdout'
+  | 'stderr'
+  | 'console.debug'
+  | 'console.error'
+  | 'console.info'
+  | 'console.log'
+  | 'console.warn';
+
+export type TerminalOutputIntercept = {
+  readonly source: TerminalOutputInterceptSource;
+  readonly text: string;
+  readonly preview: string;
+};
+
+export type TerminalOutputGuard = {
+  setActive(active: boolean): void;
+  allowTerminalWrite<T>(fn: () => T): T;
+  dispose(): void;
+};
+
+export type TerminalOutputGuardOptions = {
+  readonly stdout: WritableStreamLike;
+  readonly stderr?: WritableStreamLike;
+  readonly active?: boolean;
+  readonly onIntercept?: (event: TerminalOutputIntercept) => void;
+};
+
+export type TuiTerminalOutputGuardOptions = {
+  readonly stdout: WritableStreamLike;
+  readonly stderr?: WritableStreamLike;
+  readonly active?: boolean;
+  readonly notify: (message: string) => void;
+};
+
+const MAX_LOG_TEXT = 4_000;
+const MAX_PREVIEW_TEXT = 180;
+const ANSI_RE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+
+let currentGuard: TerminalOutputGuard | null = null;
+
+function writeCallback(args: unknown[]): ((error?: Error | null) => void) | undefined {
+  const maybeCallback = args[args.length - 1];
+  return typeof maybeCallback === 'function'
+    ? maybeCallback as (error?: Error | null) => void
+    : undefined;
+}
+
+function chunkToText(chunk: unknown): string {
+  if (typeof chunk === 'string') return chunk;
+  if (chunk instanceof Uint8Array) return Buffer.from(chunk).toString('utf8');
+  return String(chunk);
+}
+
+function normalizeText(text: string): string {
+  return text.replace(ANSI_RE, '').replace(/\r/g, '').trim();
+}
+
+function previewText(text: string): string {
+  const singleLine = normalizeText(text).replace(/\s+/g, ' ');
+  if (singleLine.length <= MAX_PREVIEW_TEXT) return singleLine;
+  return `${singleLine.slice(0, MAX_PREVIEW_TEXT - 1)}...`;
+}
+
+function truncateForLog(text: string): string {
+  if (text.length <= MAX_LOG_TEXT) return text;
+  return `${text.slice(0, MAX_LOG_TEXT)}\n[truncated ${text.length - MAX_LOG_TEXT} byte(s)]`;
+}
+
+function invokeSuppressedCallback(args: unknown[]): void {
+  const callback = writeCallback(args);
+  if (callback) {
+    queueMicrotask(() => callback(null));
+  }
+}
+
+export function allowTerminalWrite<T>(fn: () => T): T {
+  return currentGuard ? currentGuard.allowTerminalWrite(fn) : fn();
+}
+
+export function installTerminalOutputGuard(options: TerminalOutputGuardOptions): TerminalOutputGuard {
+  const stdout = options.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  const originalStdoutWriteMethod = stdout.write;
+  const originalStderrWriteMethod = stderr.write;
+  const originalStdoutWrite = (...args: unknown[]): boolean =>
+    Reflect.apply(originalStdoutWriteMethod, stdout, args) as boolean;
+  const originalStderrWrite = (...args: unknown[]): boolean =>
+    Reflect.apply(originalStderrWriteMethod, stderr, args) as boolean;
+  const originalConsole = {
+    debug: console.debug.bind(console),
+    error: console.error.bind(console),
+    info: console.info.bind(console),
+    log: console.log.bind(console),
+    warn: console.warn.bind(console),
+  };
+
+  let active = options.active ?? true;
+  let disposed = false;
+  let allowDepth = 0;
+  let captureDepth = 0;
+
+  const record = (source: TerminalOutputInterceptSource, text: string): void => {
+    if (disposed || !active) return;
+    const normalized = normalizeText(text);
+    if (!normalized) return;
+    if (normalized.startsWith('[ActivityLogger]')) return;
+    if (captureDepth > 0) return;
+
+    captureDepth++;
+    try {
+      const event: TerminalOutputIntercept = {
+        source,
+        text: truncateForLog(normalized),
+        preview: previewText(normalized),
+      };
+      logger.warn('Intercepted terminal output while TUI renderer was active', {
+        source: event.source,
+        text: event.text,
+      });
+      options.onIntercept?.(event);
+    } finally {
+      captureDepth--;
+    }
+  };
+
+  const shouldPassThrough = (): boolean => !active || allowDepth > 0 || disposed;
+
+  stdout.write = ((...args: unknown[]) => {
+    if (shouldPassThrough()) {
+      return originalStdoutWrite(...args);
+    }
+    record('stdout', chunkToText(args[0]));
+    invokeSuppressedCallback(args);
+    return true;
+  }) as WritableStreamLike['write'];
+
+  stderr.write = ((...args: unknown[]) => {
+    if (shouldPassThrough()) {
+      return originalStderrWrite(...args);
+    }
+    record('stderr', chunkToText(args[0]));
+    invokeSuppressedCallback(args);
+    return true;
+  }) as WritableStreamLike['write'];
+
+  console.debug = (...args: unknown[]) => {
+    if (!active || disposed) return originalConsole.debug(...args);
+    record('console.debug', format(...args));
+  };
+  console.error = (...args: unknown[]) => {
+    if (!active || disposed) return originalConsole.error(...args);
+    record('console.error', format(...args));
+  };
+  console.info = (...args: unknown[]) => {
+    if (!active || disposed) return originalConsole.info(...args);
+    record('console.info', format(...args));
+  };
+  console.log = (...args: unknown[]) => {
+    if (!active || disposed) return originalConsole.log(...args);
+    record('console.log', format(...args));
+  };
+  console.warn = (...args: unknown[]) => {
+    if (!active || disposed) return originalConsole.warn(...args);
+    record('console.warn', format(...args));
+  };
+
+  const guard: TerminalOutputGuard = {
+    setActive(nextActive) {
+      active = nextActive;
+    },
+    allowTerminalWrite<T>(fn: () => T): T {
+      allowDepth++;
+      try {
+        return fn();
+      } finally {
+        allowDepth--;
+      }
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      stdout.write = originalStdoutWriteMethod;
+      stderr.write = originalStderrWriteMethod;
+      console.debug = originalConsole.debug;
+      console.error = originalConsole.error;
+      console.info = originalConsole.info;
+      console.log = originalConsole.log;
+      console.warn = originalConsole.warn;
+      if (currentGuard === guard) {
+        currentGuard = null;
+      }
+    },
+  };
+
+  currentGuard = guard;
+  return guard;
+}
+
+export function installTuiTerminalOutputGuard(options: TuiTerminalOutputGuardOptions): TerminalOutputGuard {
+  let capturedWriteCount = 0;
+  let lastNoticeAt = 0;
+  return installTerminalOutputGuard({
+    stdout: options.stdout,
+    stderr: options.stderr,
+    active: options.active,
+    onIntercept: (event) => {
+      capturedWriteCount++;
+      const now = Date.now();
+      if (now - lastNoticeAt < 5_000) return;
+      const count = capturedWriteCount;
+      capturedWriteCount = 0;
+      lastNoticeAt = now;
+      const plural = count === 1 ? '' : 's';
+      options.notify(`[Terminal] Captured ${count} direct ${event.source} write${plural} that would have corrupted the TUI: ${event.preview}`);
+    },
+  });
+}

package/src/runtime/ui-services.ts

@@ -79,6 +79,8 @@ export interface UiPlatformServices {
 export interface UiPlanningServices {
   readonly planManager: RuntimeServices['planManager'];
   readonly adaptivePlanner: RuntimeServices['adaptivePlanner'];
+  readonly projectPlanningService: RuntimeServices['projectPlanningService'];
+  readonly projectPlanningProjectId: RuntimeServices['projectPlanningProjectId'];
 }
 
 export interface UiCoordinationServices {
@@ -169,6 +171,8 @@ export function createUiRuntimeServices(
     planning: {
       planManager: runtimeServices.planManager,
       adaptivePlanner: runtimeServices.adaptivePlanner,
+      projectPlanningService: runtimeServices.projectPlanningService,
+      projectPlanningProjectId: runtimeServices.projectPlanningProjectId,
     },
     coordination: {
       approvalBroker: runtimeServices.approvalBroker,

package/src/shell/ui-openers.ts

@@ -10,6 +10,7 @@ import type { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp/registry';
 import type { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config/subscriptions';
 import type { SecretsManager } from '@pellux/goodvibes-sdk/platform/config/secrets';
 import type { ServiceInspectionQuery } from '../runtime/ui-service-queries.ts';
+import type { ModelPickerTargetInfo } from '../input/model-picker.ts';
 
 type WireShellUiOpenersOptions = {
   commandContext: CommandContext;
@@ -112,7 +113,8 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
   }
 
   const getCurrentModelForPickerTarget = (): string => {
-    const target = input.modelPicker.target;
+    const selectedTarget = input.modelPicker.getSelectedTargetInfo();
+    const target = selectedTarget?.target ?? input.modelPicker.target;
     if (target === 'helper') return String(configManager.get('helper.globalModel') || runtime.model);
     if (target === 'tool') return String(configManager.get('tools.llmModel') || runtime.model);
     if (target === 'tts') return String(configManager.get('tts.llmModel') || runtime.model);
@@ -120,13 +122,64 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
   };
 
   const getCurrentProviderForPickerTarget = (): string => {
-    const target = input.modelPicker.target;
+    const selectedTarget = input.modelPicker.getSelectedTargetInfo();
+    const target = selectedTarget?.target ?? input.modelPicker.target;
     if (target === 'helper') return String(configManager.get('helper.globalProvider') || runtime.provider);
     if (target === 'tool') return String(configManager.get('tools.llmProvider') || runtime.provider);
     if (target === 'tts') return String(configManager.get('tts.llmProvider') || runtime.provider);
     return runtime.provider;
   };
 
+  const buildModelPickerTargets = (): ModelPickerTargetInfo[] => {
+    const mainProvider = String(configManager.get('provider.provider') || runtime.provider || '').trim();
+    const mainModel = String(configManager.get('provider.model') || runtime.model || '').trim();
+    const helperProvider = String(configManager.get('helper.globalProvider') ?? '').trim();
+    const helperModel = String(configManager.get('helper.globalModel') ?? '').trim();
+    const toolProvider = String(configManager.get('tools.llmProvider') ?? '').trim();
+    const toolModel = String(configManager.get('tools.llmModel') ?? '').trim();
+    const ttsProvider = String(configManager.get('tts.llmProvider') ?? '').trim();
+    const ttsModel = String(configManager.get('tts.llmModel') ?? '').trim();
+
+    return [
+      {
+        target: 'main',
+        label: 'Main Chat',
+        description: 'Default provider and model for normal chat turns in this TUI session.',
+        provider: mainProvider,
+        model: mainModel,
+        enabled: true,
+        inherited: false,
+      },
+      {
+        target: 'helper',
+        label: 'Helper Model',
+        description: 'Optional helper route used for supporting work. Empty provider/model values inherit Main Chat.',
+        provider: helperProvider || mainProvider,
+        model: helperModel || mainModel,
+        enabled: Boolean(configManager.get('helper.enabled')),
+        inherited: helperProvider.length === 0 && helperModel.length === 0,
+      },
+      {
+        target: 'tool',
+        label: 'Tool LLM',
+        description: 'Optional LLM route for tool-specific reasoning. Selecting a model enables the tool LLM route.',
+        provider: toolProvider || mainProvider,
+        model: toolModel || mainModel,
+        enabled: Boolean(configManager.get('tools.llmEnabled')),
+        inherited: toolProvider.length === 0 && toolModel.length === 0,
+      },
+      {
+        target: 'tts',
+        label: 'TTS LLM',
+        description: 'Optional LLM override for /tts response generation. Empty values use the current chat model.',
+        provider: ttsProvider || mainProvider,
+        model: ttsModel || mainModel,
+        enabled: true,
+        inherited: ttsProvider.length === 0 && ttsModel.length === 0,
+      },
+    ];
+  };
+
   commandContext.openModelPicker = () => {
     void (async () => {
       const models = providerRegistry.getSelectableModels();
@@ -140,6 +193,7 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
       });
       void input.modelPicker.loadRecentModels().catch(() => {}); // best-effort: prefetch for UI, failure is non-visible
       input.modalOpened('modelPicker');
+      input.modelPicker.setTargetInfos(buildModelPickerTargets());
       input.modelPicker.openAllModels(models, getCurrentModelForPickerTarget());
       render();
     })().catch((error: unknown) => {
@@ -159,6 +213,7 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
       const secretProviderIds = await resolveSecretProviderIds();
       input.modelPicker.configuredViaMap = buildConfiguredViaMap(providers, configuredIds, subscriptionManager, secretProviderIds);
       input.modalOpened('modelPicker');
+      input.modelPicker.setTargetInfos(buildModelPickerTargets());
       input.modelPicker.openProviders(providers, getCurrentProviderForPickerTarget());
       render();
     })().catch((error: unknown) => {
@@ -206,9 +261,10 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     render();
   };
 
-  commandContext.openSettingsModal = () => {
+  commandContext.openSettingsModal = (target?: string) => {
     input.modalOpened('settings');
     input.settingsModal.open(configManager, featureFlags, subscriptionManager, serviceRegistry, mcpRegistry, secretsManager);
+    input.settingsModal.selectTarget(target);
     render();
   };
 

package/src/utils/clipboard.ts

@@ -1,5 +1,6 @@
 import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+import { allowTerminalWrite } from '../runtime/terminal-output-guard.ts';
 
 /**
  * copyToClipboard - Uses OSC 52 escape sequence to copy text to the terminal clipboard.
@@ -11,7 +12,7 @@ export function copyToClipboard(text: string) {
   try {
     const base64 = Buffer.from(text).toString('base64');
     const sequence = `\x1b]52;c;${base64}\x07`;
-    process.stdout.write(sequence);
+    allowTerminalWrite(() => process.stdout.write(sequence));
     logger.info('Clipboard: OSC 52 sequence written');
   } catch (err: unknown) {
     logger.error('Clipboard: OSC 52 copy failed', { error: summarizeError(err) });

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.19.53';
+let _version = '0.19.55';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;

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

@@ -1,104 +0,0 @@
-import type { CommandRegistry } from '../command-registry.ts';
-import type { SelectionItem } from '../selection-modal.ts';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-const VALID_MODES = ['allow-all', 'prompt', 'custom'] as const;
-const VALID_ACTIONS = ['allow', 'prompt', 'deny'] as const;
-const VALID_TOOLS = ['read', 'write', 'edit', 'exec', 'find', 'fetch', 'analyze', 'inspect', 'agent', 'state', 'workflow', 'registry', 'delegate', 'mcp'] as const;
-type PermTool = typeof VALID_TOOLS[number];
-
-export function registerPermissionsRuntimeCommands(registry: CommandRegistry): void {
-  registry.register({
-    name: 'permissions',
-    aliases: ['perms'],
-    description: 'Show or set permission mode and per-tool settings',
-    usage: '[allow-all|prompt|custom] | [tool <name> allow|prompt|deny]',
-    argsHint: '[allow-all|prompt|custom]',
-    handler(args, ctx) {
-      const cm = ctx.platform.configManager;
-      if (args.length === 0) {
-        if (ctx.openSelection) {
-          const items: SelectionItem[] = VALID_TOOLS.map((tool) => ({
-            id: tool,
-            label: tool,
-            detail: cm.get(`permissions.tools.${tool}` as Parameters<typeof cm.get>[0]) as string,
-            category: 'tools',
-            adjustable: true,
-            primaryAction: 'toggle',
-            actions: '[Space/Enter] cycle  [←/→] adjust',
-          }));
-          items.unshift({
-            id: '__mode__',
-            label: 'permission mode',
-            detail: cm.get('permissions.mode') as string,
-            category: 'global',
-            adjustable: true,
-            primaryAction: 'toggle',
-            actions: '[Space/Enter] cycle  [←/→] adjust',
-          });
-          ctx.openSelection('Permissions', items, { allowSearch: true }, (result) => {
-            if (!result) return;
-            if (result.item.id === '__mode__') {
-              const currentMode = cm.get('permissions.mode') as string;
-              const currentIndex = Math.max(0, VALID_MODES.indexOf(currentMode as typeof VALID_MODES[number]));
-              const nextMode = result.action === 'decrement'
-                ? VALID_MODES[(currentIndex - 1 + VALID_MODES.length) % VALID_MODES.length]
-                : VALID_MODES[(currentIndex + 1) % VALID_MODES.length];
-              cm.setDynamic('permissions.mode', nextMode);
-              result.item.detail = nextMode;
-            } else {
-              const toolKey = `permissions.tools.${result.item.id}` as Parameters<typeof cm.get>[0];
-              const currentAction = cm.get(toolKey) as string;
-              const currentIndex = Math.max(0, VALID_ACTIONS.indexOf(currentAction as typeof VALID_ACTIONS[number]));
-              const nextAction = result.action === 'decrement'
-                ? VALID_ACTIONS[(currentIndex - 1 + VALID_ACTIONS.length) % VALID_ACTIONS.length]
-                : VALID_ACTIONS[(currentIndex + 1) % VALID_ACTIONS.length];
-              cm.setDynamic(toolKey, nextAction);
-              result.item.detail = nextAction;
-            }
-            ctx.renderRequest();
-          });
-          return;
-        }
-        const lines = [`Permission mode: ${cm.get('permissions.mode')}`, '  Tool settings:'];
-        for (const tool of VALID_TOOLS) lines.push(`    ${tool.padEnd(16)} ${cm.get(`permissions.tools.${tool}` as Parameters<typeof cm.get>[0])}`);
-        lines.push('', '  Modes: prompt (default), allow-all, custom', '  Usage: /permissions <mode> | /permissions tool <name> allow|prompt|deny');
-        ctx.print(lines.join('\n'));
-        return;
-      }
-      if (args[0] === 'tool') {
-        const toolName = args[1];
-        const action = args[2];
-        if (!toolName || !action) {
-          ctx.print('Usage: /permissions tool <name> allow|prompt|deny');
-          return;
-        }
-        if (!VALID_TOOLS.includes(toolName as PermTool)) {
-          ctx.print(`Unknown tool: ${toolName}\nValid tools: ${VALID_TOOLS.join(', ')}`);
-          return;
-        }
-        if (!VALID_ACTIONS.includes(action as typeof VALID_ACTIONS[number])) {
-          ctx.print(`Invalid action: ${action}\nValid actions: allow, prompt, deny`);
-          return;
-        }
-        try {
-          cm.setDynamic(`permissions.tools.${toolName}` as Parameters<typeof cm.set>[0], action);
-          ctx.print(`Permission for ${toolName} set to: ${action}`);
-        } catch (e) {
-          ctx.print(`Error: ${summarizeError(e)}`);
-        }
-        return;
-      }
-      if (!VALID_MODES.includes(args[0] as typeof VALID_MODES[number])) {
-        ctx.print(`Invalid mode: ${args[0]}\nValid modes: ${VALID_MODES.join(', ')}`);
-        return;
-      }
-      try {
-        cm.setDynamic('permissions.mode', args[0]);
-        ctx.print(`Permission mode set to: ${args[0]}`);
-      } catch (e) {
-        ctx.print(`Error: ${summarizeError(e)}`);
-      }
-    },
-  });
-}