@mseep/claudian 2.0.25

package/src/app/settings/ClaudianSettingsStorage.ts

@@ -0,0 +1,435 @@
+import {
+  CLAUDIAN_SETTINGS_PATH,
+  LEGACY_CLAUDIAN_SETTINGS_PATH,
+} from '../../core/bootstrap/StoragePaths';
+import {
+  normalizeHiddenCommandList,
+  normalizeHiddenProviderCommands,
+} from '../../core/providers/commands/hiddenCommands';
+import {
+  getSharedEnvironmentVariables,
+  inferEnvironmentSnippetScope,
+  resolveEnvironmentSnippetScope,
+} from '../../core/providers/providerEnvironment';
+import type { VaultFileAdapter } from '../../core/storage/VaultFileAdapter';
+import {
+  CHAT_VIEW_PLACEMENTS,
+  type ChatViewPlacement,
+  type ClaudianSettings,
+  type EnvironmentScope,
+  type EnvSnippet,
+  type HiddenProviderCommands,
+  type ProviderConfigMap,
+} from '../../core/types/settings';
+import {
+  getClaudeProviderSettings,
+  updateClaudeProviderSettings,
+} from '../../providers/claude/settings';
+import {
+  getCodexProviderSettings,
+  updateCodexProviderSettings,
+} from '../../providers/codex/settings';
+import {
+  getOpencodeProviderSettings,
+  updateOpencodeProviderSettings,
+} from '../../providers/opencode/settings';
+import {
+  getPiProviderSettings,
+  updatePiProviderSettings,
+} from '../../providers/pi/settings';
+import { DEFAULT_CLAUDIAN_SETTINGS } from './defaultSettings';
+
+export {
+  CLAUDIAN_SETTINGS_PATH,
+  LEGACY_CLAUDIAN_SETTINGS_PATH,
+};
+
+export type StoredClaudianSettings = ClaudianSettings;
+
+const LEGACY_TOP_LEVEL_PROVIDER_FIELDS = [
+  'claudeSafeMode',
+  'codexSafeMode',
+  'claudeCliPath',
+  'claudeCliPathsByHost',
+  'codexCliPath',
+  'codexCliPathsByHost',
+  'codexReasoningSummary',
+  'loadUserClaudeSettings',
+  'codexEnabled',
+  'lastClaudeModel',
+  'enableChrome',
+  'enableBangBash',
+  'enableOpus1M',
+  'enableSonnet1M',
+  'environmentVariables',
+  'lastEnvHash',
+  'lastCodexEnvHash',
+] as const;
+
+const LEGACY_STRIPPED_SETTING_FIELDS = [
+  'activeConversationId',
+  'show1MModel',
+  'hiddenSlashCommands',
+  'slashCommands',
+  'allowExternalAccess',
+  'allowedExportPaths',
+  'enableBlocklist',
+  'blockedCommands',
+  ...LEGACY_TOP_LEVEL_PROVIDER_FIELDS,
+  'openInMainTab',
+] as const;
+
+function stripLegacyFields(settings: Record<string, unknown>): Record<string, unknown> {
+  const cleaned = { ...settings };
+  for (const key of LEGACY_STRIPPED_SETTING_FIELDS) {
+    delete cleaned[key];
+  }
+  return cleaned;
+}
+
+function isChatViewPlacement(value: unknown): value is ChatViewPlacement {
+  return typeof value === 'string'
+    && (CHAT_VIEW_PLACEMENTS as readonly string[]).includes(value);
+}
+
+function normalizeChatViewPlacement(
+  value: unknown,
+  legacyOpenInMainTab: unknown,
+): ChatViewPlacement {
+  if (isChatViewPlacement(value)) {
+    return value;
+  }
+
+  if (typeof legacyOpenInMainTab === 'boolean') {
+    return legacyOpenInMainTab ? 'main-tab' : 'right-sidebar';
+  }
+
+  return DEFAULT_CLAUDIAN_SETTINGS.chatViewPlacement;
+}
+
+function shouldPersistChatViewPlacementMigration(
+  stored: Record<string, unknown>,
+  normalized: ChatViewPlacement,
+): boolean {
+  return 'openInMainTab' in stored
+    || (
+      'chatViewPlacement' in stored
+      && stored.chatViewPlacement !== normalized
+    );
+}
+
+function normalizeProviderConfigs(value: unknown): ProviderConfigMap {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+
+  const result: ProviderConfigMap = {};
+  for (const [providerId, config] of Object.entries(value as Record<string, unknown>)) {
+    if (config && typeof config === 'object' && !Array.isArray(config)) {
+      result[providerId] = { ...(config as Record<string, unknown>) };
+    }
+  }
+  return result;
+}
+
+const HOST_SCOPED_PROVIDER_CONFIG_FIELDS: Record<string, string[]> = {
+  claude: ['cliPathsByHost'],
+  codex: ['cliPathsByHost', 'installationMethodsByHost', 'wslDistroOverridesByHost'],
+  opencode: ['cliPathsByHost'],
+  pi: ['cliPathsByHost'],
+};
+
+function hasHostScopedProviderConfigNormalization(
+  original: ProviderConfigMap,
+  normalized: unknown,
+): boolean {
+  if (!normalized || typeof normalized !== 'object' || Array.isArray(normalized)) {
+    return false;
+  }
+
+  const normalizedConfigs = normalized as ProviderConfigMap;
+  for (const [providerId, fields] of Object.entries(HOST_SCOPED_PROVIDER_CONFIG_FIELDS)) {
+    const originalConfig = original[providerId];
+    const normalizedConfig = normalizedConfigs[providerId];
+    if (!originalConfig || !normalizedConfig) {
+      continue;
+    }
+
+    for (const field of fields) {
+      if (
+        field in originalConfig
+        && JSON.stringify(originalConfig[field]) !== JSON.stringify(normalizedConfig[field])
+      ) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+function isEnvironmentScope(value: unknown): value is EnvironmentScope {
+  return value === 'shared' || (typeof value === 'string' && value.startsWith('provider:'));
+}
+
+function normalizeContextLimits(value: unknown): Record<string, number> | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+
+  const result: Record<string, number> = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === 'number' && Number.isFinite(entry) && entry > 0) {
+      result[key] = entry;
+    }
+  }
+
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+function normalizeModelAliases(value: unknown): Record<string, string> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+
+  const result: Record<string, string> = {};
+  for (const [key, alias] of Object.entries(value)) {
+    if (typeof alias !== 'string') {
+      continue;
+    }
+
+    const modelId = key.trim();
+    const normalizedAlias = alias.trim();
+    if (modelId && normalizedAlias) {
+      result[modelId] = normalizedAlias;
+    }
+  }
+
+  return result;
+}
+
+function normalizeEnvSnippets(value: unknown): EnvSnippet[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  const snippets: EnvSnippet[] = [];
+  for (const item of value) {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) {
+      continue;
+    }
+
+    const candidate = item as Record<string, unknown>;
+    if (
+      typeof candidate.id !== 'string'
+      || typeof candidate.name !== 'string'
+      || typeof candidate.description !== 'string'
+      || typeof candidate.envVars !== 'string'
+    ) {
+      continue;
+    }
+
+    const modelAliases = 'modelAliases' in candidate
+      ? normalizeModelAliases(candidate.modelAliases)
+      : undefined;
+
+    snippets.push({
+      id: candidate.id,
+      name: candidate.name,
+      description: candidate.description,
+      envVars: candidate.envVars,
+      scope: resolveEnvironmentSnippetScope(
+        candidate.envVars,
+        isEnvironmentScope(candidate.scope)
+          ? candidate.scope
+          : inferEnvironmentSnippetScope(candidate.envVars),
+      ),
+      contextLimits: normalizeContextLimits(candidate.contextLimits),
+      modelAliases,
+    });
+  }
+
+  return snippets;
+}
+
+function hasLegacyTopLevelProviderFields(stored: Record<string, unknown>): boolean {
+  return LEGACY_TOP_LEVEL_PROVIDER_FIELDS.some((key) => key in stored);
+}
+
+function mergeLegacyClaudeHiddenCommands(
+  hiddenProviderCommands: HiddenProviderCommands,
+  legacyHiddenSlashCommands: unknown,
+): HiddenProviderCommands {
+  const legacyCommands = normalizeHiddenCommandList(legacyHiddenSlashCommands);
+  if (legacyCommands.length === 0 || hiddenProviderCommands.claude) {
+    return hiddenProviderCommands;
+  }
+
+  return {
+    ...hiddenProviderCommands,
+    claude: legacyCommands,
+  };
+}
+
+export class ClaudianSettingsStorage {
+  constructor(private adapter: VaultFileAdapter) {}
+
+  async load(): Promise<StoredClaudianSettings> {
+    const settingsPath = await this.getLoadPath();
+    if (!settingsPath) {
+      return this.getDefaults();
+    }
+
+    const content = await this.adapter.read(settingsPath);
+    const stored = JSON.parse(content) as Record<string, unknown>;
+    const hiddenProviderCommands = mergeLegacyClaudeHiddenCommands(
+      normalizeHiddenProviderCommands(stored.hiddenProviderCommands),
+      stored.hiddenSlashCommands,
+    );
+    const envSnippets = normalizeEnvSnippets(stored.envSnippets);
+    const customModelAliases = normalizeModelAliases(stored.customModelAliases);
+    const providerConfigs = normalizeProviderConfigs(stored.providerConfigs);
+    const chatViewPlacement = normalizeChatViewPlacement(
+      stored.chatViewPlacement,
+      stored.openInMainTab,
+    );
+    const legacyProviderSettings = {
+      ...stored,
+      hiddenProviderCommands,
+      providerConfigs,
+    };
+    const storedWithoutLegacy = stripLegacyFields({
+      ...legacyProviderSettings,
+    });
+
+    const legacyNormalized = {
+      ...storedWithoutLegacy,
+      sharedEnvironmentVariables: getSharedEnvironmentVariables(legacyProviderSettings),
+      envSnippets,
+      customModelAliases,
+      hiddenProviderCommands,
+      providerConfigs,
+      chatViewPlacement,
+    };
+
+    const merged = {
+      ...this.getDefaults(),
+      ...legacyNormalized,
+    };
+
+    updateClaudeProviderSettings(
+      merged,
+      getClaudeProviderSettings(legacyProviderSettings),
+    );
+    updateCodexProviderSettings(
+      merged,
+      getCodexProviderSettings(legacyProviderSettings),
+    );
+    updateOpencodeProviderSettings(
+      merged,
+      getOpencodeProviderSettings(legacyProviderSettings),
+    );
+    updatePiProviderSettings(
+      merged,
+      getPiProviderSettings(legacyProviderSettings),
+    );
+    const didNormalizeHostScopedProviderConfigs = hasHostScopedProviderConfigNormalization(
+      providerConfigs,
+      merged.providerConfigs,
+    );
+
+    if (
+      settingsPath !== CLAUDIAN_SETTINGS_PATH
+      || (
+      hasLegacyTopLevelProviderFields(stored)
+      || 'show1MModel' in stored
+      || 'slashCommands' in stored
+      || 'hiddenSlashCommands' in stored
+      || 'activeConversationId' in stored
+      || 'allowExternalAccess' in stored
+      || 'allowedExportPaths' in stored
+      || 'enableBlocklist' in stored
+      || 'blockedCommands' in stored
+      || shouldPersistChatViewPlacementMigration(stored, chatViewPlacement)
+      || JSON.stringify(envSnippets) !== JSON.stringify(stored.envSnippets ?? [])
+      || (
+        'customModelAliases' in stored
+        && JSON.stringify(customModelAliases) !== JSON.stringify(stored.customModelAliases ?? {})
+      )
+      || didNormalizeHostScopedProviderConfigs
+      )
+    ) {
+      await this.save(merged);
+    }
+
+    return merged;
+  }
+
+  async save(settings: StoredClaudianSettings): Promise<void> {
+    const content = JSON.stringify(
+      stripLegacyFields(settings),
+      null,
+      2,
+    );
+    await this.adapter.write(CLAUDIAN_SETTINGS_PATH, content);
+    await this.deleteLegacyFileIfPresent();
+  }
+
+  async exists(): Promise<boolean> {
+    if (await this.adapter.exists(CLAUDIAN_SETTINGS_PATH)) {
+      return true;
+    }
+
+    return this.adapter.exists(LEGACY_CLAUDIAN_SETTINGS_PATH);
+  }
+
+  async update(updates: Partial<StoredClaudianSettings>): Promise<void> {
+    const current = await this.load();
+    await this.save({ ...current, ...updates });
+  }
+
+  async setLastModel(model: string, isCustom: boolean): Promise<void> {
+    if (isCustom) {
+      await this.update({ lastCustomModel: model });
+      return;
+    }
+
+    const current = await this.load();
+    updateClaudeProviderSettings(
+      current,
+      { lastModel: model },
+    );
+    await this.save(current);
+  }
+
+  async setLastEnvHash(hash: string): Promise<void> {
+    const current = await this.load();
+    updateClaudeProviderSettings(
+      current,
+      { environmentHash: hash },
+    );
+    await this.save(current);
+  }
+
+  private getDefaults(): StoredClaudianSettings {
+    return DEFAULT_CLAUDIAN_SETTINGS;
+  }
+
+  private async getLoadPath(): Promise<string | null> {
+    if (await this.adapter.exists(CLAUDIAN_SETTINGS_PATH)) {
+      return CLAUDIAN_SETTINGS_PATH;
+    }
+
+    if (await this.adapter.exists(LEGACY_CLAUDIAN_SETTINGS_PATH)) {
+      return LEGACY_CLAUDIAN_SETTINGS_PATH;
+    }
+
+    return null;
+  }
+
+  private async deleteLegacyFileIfPresent(): Promise<void> {
+    if (await this.adapter.exists(LEGACY_CLAUDIAN_SETTINGS_PATH)) {
+      await this.adapter.delete(LEGACY_CLAUDIAN_SETTINGS_PATH);
+    }
+  }
+}

package/src/app/settings/defaultSettings.ts

@@ -0,0 +1,54 @@
+import { getDefaultHiddenProviderCommands } from '../../core/providers/commands/hiddenCommands';
+import { type ClaudianSettings } from '../../core/types/settings';
+import { getBuiltInProviderDefaultConfigs } from '../../providers/defaultProviderConfigs';
+
+export const DEFAULT_CLAUDIAN_SETTINGS: ClaudianSettings = {
+  userName: '',
+
+  permissionMode: 'yolo',
+
+  model: 'haiku',
+  thinkingBudget: 'off',
+  effortLevel: 'high',
+  serviceTier: 'default',
+  enableAutoTitleGeneration: true,
+  titleGenerationModel: '',
+
+  excludedTags: [],
+  mediaFolder: '',
+  systemPrompt: '',
+  persistentExternalContextPaths: [],
+
+  sharedEnvironmentVariables: '',
+  envSnippets: [],
+  customContextLimits: {},
+  customModelAliases: {},
+
+  keyboardNavigation: {
+    scrollUpKey: 'w',
+    scrollDownKey: 's',
+    focusInputKey: 'i',
+  },
+  requireCommandOrControlEnterToSend: false,
+
+  locale: 'en',
+
+  providerConfigs: getBuiltInProviderDefaultConfigs(),
+
+  settingsProvider: 'claude',
+  savedProviderModel: {},
+  savedProviderEffort: {},
+  savedProviderServiceTier: {},
+  savedProviderThinkingBudget: {},
+  savedProviderPermissionMode: {},
+
+  lastCustomModel: '',
+
+  maxTabs: 3,
+  enableAutoScroll: true,
+  deferMathRenderingDuringStreaming: true,
+  expandFileEditsByDefault: false,
+  chatViewPlacement: 'right-sidebar',
+
+  hiddenProviderCommands: getDefaultHiddenProviderCommands(),
+};

package/src/app/storage/SharedStorageService.ts

@@ -0,0 +1,106 @@
+import type { Plugin } from 'obsidian';
+import { Notice } from 'obsidian';
+
+import { SESSIONS_PATH, SessionStorage } from '../../core/bootstrap/SessionStorage';
+import type { SharedAppStorage } from '../../core/bootstrap/storage';
+import { CLAUDIAN_STORAGE_PATH } from '../../core/bootstrap/StoragePaths';
+import { VaultFileAdapter } from '../../core/storage/VaultFileAdapter';
+import { ClaudianSettingsStorage, type StoredClaudianSettings } from '../settings/ClaudianSettingsStorage';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+export class SharedStorageService implements SharedAppStorage {
+  readonly claudianSettings: ClaudianSettingsStorage;
+  readonly sessions: SessionStorage;
+
+  private adapter: VaultFileAdapter;
+  private plugin: Plugin;
+
+  constructor(plugin: Plugin) {
+    this.plugin = plugin;
+    this.adapter = new VaultFileAdapter(plugin.app);
+    this.claudianSettings = new ClaudianSettingsStorage(this.adapter);
+    this.sessions = new SessionStorage(this.adapter);
+  }
+
+  async initialize(): Promise<{ claudian: Record<string, unknown> }> {
+    await this.ensureDirectories();
+    const claudian = await this.claudianSettings.load();
+    return { claudian };
+  }
+
+  async saveClaudianSettings(settings: Record<string, unknown>): Promise<void> {
+    await this.claudianSettings.save(settings as StoredClaudianSettings);
+  }
+
+  async setTabManagerState(state: { openTabs: Array<{ tabId: string; conversationId: string | null; draftModel?: string | null }>; activeTabId: string | null }): Promise<void> {
+    try {
+      const loaded: unknown = await this.plugin.loadData();
+      const data = isRecord(loaded) ? loaded : {};
+      data.tabManagerState = state;
+      await this.plugin.saveData(data);
+    } catch {
+      new Notice('Failed to save tab layout');
+    }
+  }
+
+  async getTabManagerState(): Promise<{ openTabs: Array<{ tabId: string; conversationId: string | null; draftModel?: string | null }>; activeTabId: string | null } | null> {
+    try {
+      const data: unknown = await this.plugin.loadData();
+      if (!isRecord(data) || !data.tabManagerState) {
+        return null;
+      }
+
+      return this.validateTabManagerState(data.tabManagerState);
+    } catch {
+      return null;
+    }
+  }
+
+  getAdapter(): VaultFileAdapter {
+    return this.adapter;
+  }
+
+  private async ensureDirectories(): Promise<void> {
+    await this.adapter.ensureFolder(CLAUDIAN_STORAGE_PATH);
+    await this.adapter.ensureFolder(SESSIONS_PATH);
+  }
+
+  private validateTabManagerState(data: unknown): { openTabs: Array<{ tabId: string; conversationId: string | null; draftModel?: string | null }>; activeTabId: string | null } | null {
+    if (!data || typeof data !== 'object') {
+      return null;
+    }
+
+    const state = data as Record<string, unknown>;
+    if (!Array.isArray(state.openTabs)) {
+      return null;
+    }
+
+    const validatedTabs: Array<{ tabId: string; conversationId: string | null; draftModel?: string | null }> = [];
+    for (const tab of state.openTabs) {
+      if (!tab || typeof tab !== 'object') {
+        continue;
+      }
+
+      const tabObj = tab as Record<string, unknown>;
+      if (typeof tabObj.tabId !== 'string') {
+        continue;
+      }
+
+      validatedTabs.push({
+        tabId: tabObj.tabId,
+        conversationId: typeof tabObj.conversationId === 'string' ? tabObj.conversationId : null,
+        ...(typeof tabObj.draftModel === 'string'
+          ? { draftModel: tabObj.draftModel }
+          : {}),
+      });
+    }
+
+    return {
+      openTabs: validatedTabs,
+      activeTabId: typeof state.activeTabId === 'string' ? state.activeTabId : null,
+    };
+  }
+}

package/src/core/CLAUDE.md

@@ -0,0 +1,84 @@
+# Core Infrastructure
+
+Core modules stay provider-neutral. Features depend on `core/`; providers implement the boundary behind it.
+
+## Runtime Status
+
+- `core/runtime/` and `core/providers/` define the chat-facing seam. `ChatRuntime` is the neutral runtime interface. `src/providers/claude/runtime/` and `src/providers/codex/runtime/` provide the concrete implementations.
+- `ProviderRegistry` owns runtime and auxiliary-service factories. `ProviderWorkspaceRegistry` owns provider workspace services such as command catalogs, agent mentions, CLI resolution, MCP managers, and provider settings tabs.
+- Claude-specific agents, plugins, MCP, runtime command discovery, and storage live under `src/providers/claude/`.
+- Codex-specific skills, subagents, JSONL history hydration, session tailing, and workspace services live under `src/providers/codex/`.
+
+## Modules
+
+| Module | Purpose | Key Files |
+|--------|---------|-----------|
+| `bootstrap/` | Provider-neutral session metadata storage and shared app-storage contracts | `SessionStorage`, `storage.ts` |
+| `commands/` | Built-in cross-provider commands | `builtInCommands` |
+| `mcp/` | Provider-neutral MCP coordination and config parsing | `McpConfigParser`, `McpServerManager`, `McpTester`, `McpStorageAdapter` |
+| `prompt/` | Shared prompt templates | `mainAgent`, `inlineEdit`, `titleGeneration`, `instructionRefine` |
+| `providers/` | Registry, capability, environment, and workspace-service contracts | `ProviderRegistry`, `ProviderWorkspaceRegistry`, `ProviderSettingsCoordinator`, `providerEnvironment`, `providerConfig`, `modelRouting`, `types` |
+| `providers/commands/` | Shared command catalog contracts | `ProviderCommandCatalog`, `ProviderCommandEntry`, `hiddenCommands` |
+| `runtime/` | Provider-neutral runtime contracts | `ChatRuntime`, `ChatTurnRequest`, `PreparedChatTurn`, `SessionUpdateResult`, approval/query types |
+| `security/` | Permission and approval helpers | `ApprovalManager` |
+| `storage/` | Generic filesystem adapters | `VaultFileAdapter`, `HomeFileAdapter` |
+| `tools/` | Shared tool constants and formatting helpers | `toolNames`, `toolIcons`, `toolInput`, `todo` |
+| `types/` | Shared type definitions | `settings`, `mcp`, `chat`, `tools`, `diff`, `agent`, `plugins` |
+
+## Dependency Rules
+
+```text
+types/ <- all modules
+storage/ <- bootstrap/, provider workspace services
+runtime/ + providers/ <- provider implementations
+features/ -> core contracts only
+```
+
+## Key Patterns
+
+### ChatRuntime
+
+```typescript
+const runtime = ProviderRegistry.createChatRuntime({ plugin, providerId });
+const preparedTurn = runtime.prepareTurn(request);
+
+for await (const chunk of runtime.query(preparedTurn, history)) {
+  // Feature layer consumes provider-neutral StreamChunk values.
+}
+```
+
+### Provider Factories
+
+```typescript
+const titleService = ProviderRegistry.createTitleGenerationService(plugin);
+const refineService = ProviderRegistry.createInstructionRefineService(plugin, providerId);
+const inlineEditService = ProviderRegistry.createInlineEditService(plugin, providerId);
+```
+
+Title generation is provider-routed by the global `titleGenerationModel` setting.
+It is intentionally independent from the active chat tab provider.
+
+### Workspace Services
+
+```typescript
+const catalog = ProviderWorkspaceRegistry.getCommandCatalog(providerId);
+const agentMentions = ProviderWorkspaceRegistry.getAgentMentionProvider(providerId);
+const cliResolver = ProviderWorkspaceRegistry.getCliResolver(providerId);
+```
+
+### Storage
+
+- `core/storage/` provides generic vault/home adapters only
+- Provider-owned workspace storage lives under `src/providers/claude/storage/` and `src/providers/codex/storage/`
+- Provider-owned transcript hydration and deletion live under provider `history/` services
+
+## Gotchas
+
+- `ChatRuntime.cleanup()` must run when a tab is disposed
+- `Conversation.providerState` is intentionally opaque in feature code; provider-specific fields belong behind typed provider helpers
+- Plan mode is capability-driven
+  - Claude enters and exits plan mode through provider/runtime events
+  - Codex sends `collaborationMode` on `turn/start` and uses post-stream plan approval metadata
+- Command discovery differs by provider
+  - Claude merges runtime-discovered commands with vault commands and skills
+  - Codex skill discovery comes from `CodexSkillCatalog` and does not depend on runtime command discovery

package/src/core/auxiliary/AuxQueryRunner.ts

@@ -0,0 +1,11 @@
+export interface AuxQueryConfig {
+  systemPrompt: string;
+  model?: string;
+  abortController?: AbortController;
+  onTextChunk?: (accumulatedText: string) => void;
+}
+
+export interface AuxQueryRunner {
+  query(config: AuxQueryConfig, prompt: string): Promise<string>;
+  reset(): void;
+}