mixdog 0.9.3 → 0.9.4

package/src/session-runtime/quick-model-rows.mjs

@@ -0,0 +1,170 @@
+// Quick (offline) provider/model picker row builders, extracted from
+// mixdog-session-runtime.mjs. Dependency-injected factory: closes over
+// route/config/search accessors and shared row helpers supplied by the facade.
+import { clean } from './session-text.mjs';
+import { QUICK_SEARCH_MODELS } from './quick-search-models.mjs';
+import { SEARCH_DEFAULT_PROVIDER, SEARCH_DEFAULT_MODEL } from './workflow.mjs';
+
+export function createQuickModelRows({
+  getRoute,
+  getSearchRoute,
+  displayConfig,
+  providerModelCacheRow,
+  providerModelsFromCacheRows,
+  sortProviderModels,
+  modelMetaByRoute,
+  modelMetaKey,
+  normalizeSearchProviderId,
+  normalizeSearchRouteConfig,
+  isSearchCapableProvider,
+  searchCapableFor,
+  currentMainSearchModelMeta,
+}) {
+  function quickProviderModelRows() {
+    const route = getRoute();
+    const pickerConfig = displayConfig();
+    const rows = [];
+    const seen = new Set();
+    const addRoute = (routeLike = {}) => {
+      const provider = clean(routeLike.provider);
+      const model = clean(routeLike.model);
+      if (!provider || !model) return;
+      const key = `${provider}:${model}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      const row = providerModelCacheRow(provider, {
+        id: model,
+        name: routeLike.modelDisplay || routeLike.display || model,
+        display: routeLike.modelDisplay || routeLike.display || model,
+        latest: routeLike.latest === true,
+        supportsReasoning: !!routeLike.effort,
+        mode: 'chat',
+      });
+      rows.push(row);
+      modelMetaByRoute.set(modelMetaKey(provider, model), row);
+    };
+
+    addRoute(route);
+    for (const preset of pickerConfig.presets || []) addRoute(preset);
+    for (const workflowRoute of Object.values(pickerConfig.workflowRoutes || {})) addRoute(workflowRoute);
+    for (const agentRoute of Object.values(pickerConfig.agents || {})) addRoute(agentRoute);
+    return providerModelsFromCacheRows(rows);
+  }
+
+  function addQuickSearchModel(rows, seen, provider, model) {
+    const providerName = normalizeSearchProviderId(provider);
+    const modelId = clean(model?.id || model);
+    if (!providerName || !modelId || !isSearchCapableProvider(providerName)) return;
+    const key = `${providerName}:${modelId}`;
+    if (seen.has(key)) return;
+    const row = providerModelCacheRow(providerName, {
+      id: modelId,
+      name: model?.name || model?.display || modelId,
+      display: model?.display || model?.name || modelId,
+      contextWindow: model?.contextWindow || null,
+      outputTokens: model?.outputTokens || null,
+      latest: model?.latest === true,
+      supportsWebSearch: true,
+      supportsFunctionCalling: model?.supportsFunctionCalling === true,
+      supportsPromptCaching: model?.supportsPromptCaching === true,
+      supportsReasoning: model?.supportsReasoning === true,
+      reasoningLevels: Array.isArray(model?.reasoningLevels) ? model.reasoningLevels : undefined,
+      reasoningOptions: Array.isArray(model?.reasoningOptions) ? model.reasoningOptions : [],
+      mode: 'chat',
+    });
+    if (row.supportsWebSearch !== true) return;
+    seen.add(key);
+    rows.push({
+      ...row,
+      provider: providerName,
+      searchCapable: true,
+      searchToolType: row.searchToolType || 'web_search',
+    });
+  }
+
+  function addDefaultSearchModel(rows, seen = new Set()) {
+    const route = getRoute();
+    const mainModel = currentMainSearchModelMeta();
+    if (!mainModel || !searchCapableFor(route.provider, mainModel)) return;
+    const key = `${SEARCH_DEFAULT_PROVIDER}:${SEARCH_DEFAULT_MODEL}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    rows.push({
+      id: SEARCH_DEFAULT_MODEL,
+      provider: SEARCH_DEFAULT_PROVIDER,
+      display: 'Default',
+      name: 'Default',
+      description: `Use current main model: ${route.provider}/${route.model}`,
+      supportsWebSearch: true,
+      searchCapable: true,
+      searchToolType: 'web_search',
+      mode: 'chat',
+    });
+  }
+
+  function quickSearchProviderModelRows() {
+    const route = getRoute();
+    const pickerConfig = displayConfig();
+    const rows = [];
+    const seen = new Set();
+    addDefaultSearchModel(rows, seen);
+    for (const [name, providerConfig] of Object.entries(pickerConfig.providers || {})) {
+      const providerName = normalizeSearchProviderId(name);
+      if (!providerConfig?.enabled || !isSearchCapableProvider(providerName)) continue;
+      for (const model of QUICK_SEARCH_MODELS[providerName] || []) {
+        addQuickSearchModel(rows, seen, providerName, model);
+      }
+    }
+    const configuredSearch = normalizeSearchRouteConfig(pickerConfig.searchRoute) || normalizeSearchRouteConfig(getSearchRoute());
+    if (configuredSearch?.provider && configuredSearch?.model) {
+      addQuickSearchModel(rows, seen, configuredSearch.provider, {
+        id: configuredSearch.model,
+        display: configuredSearch.model,
+      });
+    }
+    const mainModel = currentMainSearchModelMeta();
+    if (mainModel && searchCapableFor(route.provider, mainModel)) {
+      addQuickSearchModel(rows, seen, route.provider, {
+        id: route.model,
+        display: route.model,
+      });
+    }
+    return searchModelsFromRows(rows);
+  }
+
+  function searchModelsFromRows(rows) {
+    return sortProviderModels((rows || [])
+      .filter((row) => row.supportsWebSearch === true)
+      .map((row) => ({
+        ...row,
+        provider: normalizeSearchProviderId(row.provider),
+        searchCapable: true,
+        searchToolType: row.searchToolType || 'web_search',
+      })));
+  }
+
+  function searchRowsWithDefault(rows = []) {
+    const out = [];
+    const seen = new Set();
+    addDefaultSearchModel(out, seen);
+    for (const row of rows || []) {
+      const providerName = normalizeSearchProviderId(row?.provider);
+      const modelId = clean(row?.id || row?.model);
+      if (providerName === SEARCH_DEFAULT_PROVIDER && modelId.toLowerCase() === SEARCH_DEFAULT_MODEL) continue;
+      const key = `${providerName}:${modelId}`;
+      if (!providerName || !modelId || seen.has(key)) continue;
+      seen.add(key);
+      out.push(row);
+    }
+    return out;
+  }
+
+  return {
+    quickProviderModelRows,
+    addQuickSearchModel,
+    addDefaultSearchModel,
+    quickSearchProviderModelRows,
+    searchModelsFromRows,
+    searchRowsWithDefault,
+  };
+}

package/src/session-runtime/quick-search-models.mjs

@@ -0,0 +1,46 @@
+// Static quick-pick model catalog surfaced during onboarding / search setup.
+// Pure data extracted from mixdog-session-runtime.mjs.
+
+export const ONBOARDING_VERSION = 1;
+
+export const QUICK_SEARCH_MODELS = Object.freeze({
+  'openai-oauth': [
+    { id: 'gpt-5.5', display: 'GPT-5.5', latest: true, contextWindow: 1000000 },
+    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true, contextWindow: 1000000 },
+    { id: 'gpt-5', display: 'GPT-5', contextWindow: 400000 },
+    { id: 'gpt-4.1', display: 'GPT-4.1', contextWindow: 1000000 },
+  ],
+  openai: [
+    { id: 'gpt-5.5', display: 'GPT-5.5', latest: true, contextWindow: 1000000 },
+    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true, contextWindow: 1000000 },
+    { id: 'gpt-5', display: 'GPT-5', contextWindow: 400000 },
+    { id: 'gpt-4.1', display: 'GPT-4.1', contextWindow: 1000000 },
+    { id: 'gpt-4o', display: 'GPT-4o', contextWindow: 128000 },
+  ],
+  'grok-oauth': [
+    { id: 'grok-4.3', display: 'Grok 4.3', latest: true, contextWindow: 1000000 },
+    { id: 'grok-4.20', display: 'Grok 4.20', contextWindow: 1000000 },
+    { id: 'grok-4', display: 'Grok 4', contextWindow: 256000 },
+  ],
+  xai: [
+    { id: 'grok-4.3', display: 'Grok 4.3', latest: true, contextWindow: 1000000 },
+    { id: 'grok-4.20', display: 'Grok 4.20', contextWindow: 1000000 },
+    { id: 'grok-4', display: 'Grok 4', contextWindow: 256000 },
+  ],
+  gemini: [
+    { id: 'gemini-3-pro', display: 'Gemini 3 Pro', latest: true, contextWindow: 1000000 },
+    { id: 'gemini-2.5-pro', display: 'Gemini 2.5 Pro', contextWindow: 1000000 },
+    { id: 'gemini-2.5-flash', display: 'Gemini 2.5 Flash', contextWindow: 1000000 },
+    { id: 'gemini-2.0-flash', display: 'Gemini 2.0 Flash', contextWindow: 1000000 },
+  ],
+  'anthropic-oauth': [
+    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true, contextWindow: 1000000 },
+    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true, contextWindow: 1000000 },
+    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5', contextWindow: 200000 },
+  ],
+  anthropic: [
+    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true, contextWindow: 1000000 },
+    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true, contextWindow: 1000000 },
+    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5', contextWindow: 200000 },
+  ],
+});

package/src/session-runtime/session-hooks.mjs

@@ -0,0 +1,93 @@
+// session-hooks.mjs — attaches the standard hook-bus bridge properties
+// (beforeToolHook / afterToolHook / afterToolFailureHook / afterToolBatchHook /
+// preCompactHook / postCompactHook) onto a freshly created session object.
+// Extracted from mixdog-session-runtime.mjs createCurrentSession(): a
+// self-contained cluster whose only couplings are the hooks bus and the
+// facade's hookCommonPayload / currentCwd accessor + the session itself. All
+// properties are non-enumerable/configurable/writable exactly as before so the
+// loop/manager can read them by name without changing session enumeration.
+
+export function attachSessionHooks(session, { hooks, hookCommonPayload, getCwd }) {
+  const currentCwd = () => getCwd();
+  // PreToolUse bridge.
+  Object.defineProperty(session, 'beforeToolHook', {
+    value: (input) => hooks.beforeTool(hookCommonPayload({
+      ...input,
+      session_id: input?.sessionId || input?.session_id || session?.id,
+      tool_name: input?.name || input?.tool_name,
+      tool_input: input?.args || input?.tool_input,
+      tool_use_id: input?.toolCallId || input?.tool_use_id,
+      cwd: input?.cwd || currentCwd(),
+    })),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+  // PostToolUse: bridge runtime tool completions to the standard hook bus.
+  // dispatch() returns a promise; the loop's afterToolHook caller already
+  // try/catches, so a rejection cannot escape the tool loop.
+  Object.defineProperty(session, 'afterToolHook', {
+    value: (input) => hooks.dispatch('PostToolUse', hookCommonPayload({
+      session_id: input?.sessionId || input?.session_id || session?.id,
+      cwd: input?.cwd || currentCwd(),
+      tool_name: input?.name,
+      tool_input: input?.args,
+      tool_use_id: input?.toolCallId || input?.tool_use_id,
+      tool_response: input?.result,
+    })),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+  // PostToolUseFailure: dispatched by loop.mjs only when a tool execution
+  // resolved to a failure (thrown-error path or an is_error result). Same
+  // shape as afterToolHook; `result` carries the error text. Best-effort.
+  Object.defineProperty(session, 'afterToolFailureHook', {
+    value: (input) => hooks.dispatch('PostToolUseFailure', hookCommonPayload({
+      session_id: input?.sessionId || input?.session_id || session?.id,
+      cwd: input?.cwd || currentCwd(),
+      tool_name: input?.name,
+      tool_input: input?.args,
+      tool_use_id: input?.toolCallId || input?.tool_use_id,
+      tool_response: input?.result,
+    })),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+  // PostToolBatch: dispatched by loop.mjs after a full parallel batch of
+  // tool calls resolves and before the next model call. No matcher event.
+  Object.defineProperty(session, 'afterToolBatchHook', {
+    value: (input) => hooks.dispatch('PostToolBatch', hookCommonPayload({
+      session_id: input?.sessionId || input?.session_id || session?.id,
+      cwd: input?.cwd || currentCwd(),
+    })),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+  // PreCompact / PostCompact: dispatched by manager.mjs/loop.mjs compaction
+  // flow via these session-property hooks (manager has no hooks bus access).
+  // payload { trigger: 'auto' | 'manual' }. Best-effort.
+  Object.defineProperty(session, 'preCompactHook', {
+    value: (input) => hooks.dispatch('PreCompact', hookCommonPayload({
+      session_id: input?.sessionId || input?.session_id || session?.id,
+      cwd: input?.cwd || currentCwd(),
+      trigger: input?.trigger || 'auto',
+    })),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+  Object.defineProperty(session, 'postCompactHook', {
+    value: (input) => hooks.dispatch('PostCompact', hookCommonPayload({
+      session_id: input?.sessionId || input?.session_id || session?.id,
+      cwd: input?.cwd || currentCwd(),
+      trigger: input?.trigger || 'auto',
+    })),
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+  return session;
+}

package/src/session-runtime/settings-api.mjs

@@ -0,0 +1,319 @@
+// settings-api.mjs — pure settings delegate methods extracted from the main
+// runtime API object in mixdog-session-runtime.mjs. These are the small
+// config/settings members with NO heavy closure deps beyond the injected
+// helpers; the returned object is SPREAD into the facade's API object so the
+// external surface stays byte-identical. Methods that reference `this.*`
+// resolve against the spread target, so cross-member calls (e.g.
+// setProfile -> this.getProfile) keep working when spread into the facade.
+
+export function createSettingsApi({
+  // config accessors / mutable state
+  getConfig,
+  getRoute,
+  getSession,
+  getRemoteEnabled,
+  // config-lifecycle
+  saveConfigAndAdopt,
+  scheduleBackendSave,
+  // normalizers / helpers
+  cfgMod,
+  hasOwn,
+  normalizeAutoClearConfig,
+  autoClearIdleMsForProvider,
+  normalizeCompactionConfig,
+  normalizeCompactTypeSetting,
+  normalizeSystemShellConfig,
+  normalizeSystemShellCommand,
+  setConfiguredShell,
+  setRecapEnabledInConfig,
+  setModuleEnabledInConfig,
+  summarizeWorkflowRoutes,
+  parseDurationMs,
+  formatDurationMs,
+  localPackageVersion,
+  // state getters / feature flags
+  memoryEnabled,
+  recapEnabledFn,
+  channelsEnabled,
+  autoUpdateEnabled,
+  getUpdateCheckState,
+  getUpdateProcessState,
+  // side-effect callbacks
+  invalidateContextStatusCache,
+  invalidatePreSessionToolSurface,
+  scheduleChannelStart,
+  channels,
+  clearChannelStartTimer,
+  checkForUpdateInternal,
+  runUpdateNowInternal,
+  reloadChannelsSoon,
+  ONBOARDING_VERSION,
+  // channel-admin token delegates
+  saveDiscordToken,
+  forgetDiscordToken,
+  saveTelegramToken,
+  forgetTelegramToken,
+  saveWebhookAuthtoken,
+  forgetWebhookAuthtoken,
+  setBackend,
+}) {
+  return {
+    getOnboardingStatus() {
+      const nextConfig = getConfig();
+      return {
+        completed: nextConfig?.onboarding?.completed === true,
+        version: nextConfig?.onboarding?.version || 0,
+        default: nextConfig?.default || null,
+        workflowRoutes: summarizeWorkflowRoutes(nextConfig),
+      };
+    },
+    // Mark onboarding as done WITHOUT touching routes/agents/provider. Used by
+    // the TUI "skip" (Esc) path so the wizard doesn't reappear next launch,
+    // while leaving any existing config routes untouched.
+    skipOnboarding() {
+      const config = getConfig();
+      const nextConfig = { ...config };
+      nextConfig.onboarding = {
+        ...(nextConfig.onboarding || {}),
+        completed: true,
+        version: ONBOARDING_VERSION,
+        completedAt: new Date().toISOString(),
+        skipped: true,
+      };
+      saveConfigAndAdopt(nextConfig);
+      return this.getOnboardingStatus();
+    },
+    getAutoClear() {
+      const config = getConfig();
+      const route = getRoute();
+      const normalized = normalizeAutoClearConfig(config.autoClear);
+      const provider = route?.provider || null;
+      const providerDefault = autoClearIdleMsForProvider(provider);
+      const idleMs = normalized.custom ? normalized.idleMs : providerDefault;
+      return {
+        enabled: normalized.enabled,
+        idleMs,
+        custom: normalized.custom,
+        providerDefault,
+        provider,
+      };
+    },
+    // --- User profile (/profile statusline command) ---------------------
+    // getProfile returns the normalized { title, language } plus the resolved
+    // language catalog entry and the full language list for the picker UI.
+    getProfile() {
+      const config = getConfig();
+      const profile = cfgMod.normalizeProfileConfig(config.profile);
+      return {
+        ...profile,
+        languageEntry: cfgMod.profileLanguageEntry(profile.language),
+        languages: cfgMod.PROFILE_LANGUAGES,
+      };
+    },
+    // setProfile patches title and/or language and persists. Unknown language
+    // ids normalize back to 'system'. Prompt-side injection is wired separately
+    // (composeSystemPrompt) — this only owns the stored value.
+    setProfile(input = {}) {
+      const config = getConfig();
+      const current = cfgMod.normalizeProfileConfig(config.profile);
+      const next = { ...current };
+      if (hasOwn(input, 'title') || hasOwn(input, 'name')) {
+        next.title = input.title ?? input.name ?? '';
+      }
+      if (hasOwn(input, 'language') || hasOwn(input, 'lang')) {
+        next.language = input.language ?? input.lang ?? 'system';
+      }
+      const normalized = cfgMod.normalizeProfileConfig(next);
+      saveConfigAndAdopt({ ...config, profile: normalized });
+      return this.getProfile();
+    },
+    getCompactionSettings() {
+      const config = getConfig();
+      return normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() });
+    },
+    setCompactionSettings(input = {}) {
+      const config = getConfig();
+      const current = normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() });
+      const next = { ...current };
+      if (hasOwn(input, 'auto')) next.auto = input.auto !== false;
+      if (hasOwn(input, 'enabled')) next.auto = input.enabled !== false;
+      if (hasOwn(input, 'type') || hasOwn(input, 'compactType') || hasOwn(input, 'compact_type')) {
+        const requestedType = input.type ?? input.compactType ?? input.compact_type;
+        const compactType = normalizeCompactTypeSetting(requestedType, current.compactType || current.type || 'semantic');
+        next.type = compactType;
+        next.compactType = compactType;
+      }
+      const nextConfig = { ...config };
+      nextConfig.compaction = normalizeCompactionConfig(next, { memoryEnabled: memoryEnabled() });
+      saveConfigAndAdopt(nextConfig);
+      const config2 = getConfig();
+      const session = getSession();
+      if (session) {
+        session.compaction = {
+          ...(session.compaction || {}),
+          ...normalizeCompactionConfig(config2.compaction, { memoryEnabled: memoryEnabled() }),
+        };
+      }
+      invalidateContextStatusCache();
+      return normalizeCompactionConfig(config2.compaction, { memoryEnabled: memoryEnabled() });
+    },
+    // Recap toggle: user-facing switch that gates ONLY the background memory
+    // cycles (1/2/3). The memory module (transcript watcher/ingest, on-demand
+    // recall/fasttrack drains) is always-on. Persisted via the same
+    // saveConfigAndAdopt path as compaction/autoClear. The memory daemon
+    // re-reads recap from the agent config section each cycle tick, so toggling
+    // takes effect without a restart (no memory-service stop/start here).
+    getRecapSettings() {
+      return { enabled: recapEnabledFn() };
+    },
+    setRecapEnabled(enabled) {
+      const config = getConfig();
+      const nextConfig = setRecapEnabledInConfig({ ...config }, enabled !== false);
+      saveConfigAndAdopt(nextConfig);
+      invalidatePreSessionToolSurface();
+      invalidateContextStatusCache();
+      return this.getRecapSettings();
+    },
+    // Thin aliases kept for the current TUI callsites (updated separately).
+    // enabled here reflects the recap toggle; memory itself is always-on.
+    getMemorySettings() {
+      return {
+        enabled: recapEnabledFn(),
+        compactFastTrackAvailable: true,
+      };
+    },
+    async setMemoryEnabled(enabled) {
+      return this.setRecapEnabled(enabled);
+    },
+    getChannelSettings(options = {}) {
+      return {
+        enabled: channelsEnabled(),
+        ...(options?.includeStatus === false ? {} : { status: channels.status() }),
+      };
+    },
+    async setChannelsEnabled(enabled) {
+      const config = getConfig();
+      const nextConfig = setModuleEnabledInConfig({ ...config }, 'channels', enabled !== false);
+      saveConfigAndAdopt(nextConfig);
+      if (!channelsEnabled()) {
+        clearChannelStartTimer();
+        await channels.stop('settings-disabled', { waitForExit: false }).catch(() => {});
+      } else {
+        // Enabling channels in settings only boots the worker when this session
+        // is in remote mode; otherwise the toggle just persists config.
+        if (getRemoteEnabled()) scheduleChannelStart(0);
+      }
+      invalidatePreSessionToolSurface();
+      return this.getChannelSettings();
+    },
+    getSystemShell() {
+      const config = getConfig();
+      return normalizeSystemShellConfig(config.shell);
+    },
+    setSystemShell(input = {}) {
+      const config = getConfig();
+      const command = normalizeSystemShellCommand(typeof input === 'string' ? input : input?.command);
+      saveConfigAndAdopt({
+        ...config,
+        shell: command ? { ...(config.shell || {}), command } : {},
+      });
+      setConfiguredShell(command);
+      return normalizeSystemShellConfig(getConfig().shell);
+    },
+    setAutoClear(input = {}) {
+      const config = getConfig();
+      const current = normalizeAutoClearConfig(config.autoClear);
+      const next = { ...current };
+      if (hasOwn(input, 'enabled')) next.enabled = input.enabled !== false;
+      if (input.reset === true || (hasOwn(input, 'idleMs') && input.idleMs == null)) {
+        next.idleMs = null;
+      } else if (hasOwn(input, 'idleMs')) {
+        const idleMs = Number(input.idleMs);
+        if (!Number.isFinite(idleMs) || idleMs <= 0) throw new Error('autoclear idleMs must be a positive number');
+        next.idleMs = Math.max(60_000, Math.round(idleMs));
+      }
+      if (hasOwn(input, 'duration')) {
+        const idleMs = parseDurationMs(input.duration);
+        if (!idleMs) throw new Error('usage: /autoclear [on|off|status|<minutes|1h|90m>]');
+        next.idleMs = idleMs;
+        if (!hasOwn(input, 'enabled')) next.enabled = true;
+      }
+      saveConfigAndAdopt({ ...config, autoClear: next });
+      const resolved = this.getAutoClear();
+      return { ...resolved, label: formatDurationMs(resolved.idleMs) };
+    },
+    getUpdateSettings() {
+      const updateCheckState = getUpdateCheckState();
+      return {
+        autoUpdate: autoUpdateEnabled(),
+        currentVersion: updateCheckState.currentVersion || localPackageVersion(),
+        latestVersion: updateCheckState.latestVersion,
+        updateAvailable: updateCheckState.updateAvailable,
+        lastCheckedAt: updateCheckState.lastCheckedAt,
+      };
+    },
+    setAutoUpdate(enabled) {
+      const config = getConfig();
+      saveConfigAndAdopt({
+        ...config,
+        update: { ...(config.update || {}), auto: enabled === true },
+      });
+      return this.getUpdateSettings();
+    },
+    async checkForUpdate(options = {}) {
+      await checkForUpdateInternal({ force: options?.force === true });
+      return this.getUpdateSettings();
+    },
+    async runUpdateNow() {
+      const state = await runUpdateNowInternal();
+      return { ok: state.phase === 'installed', ...state };
+    },
+    getUpdateStatus() {
+      return { ...getUpdateProcessState() };
+    },
+    saveDiscordToken(token) {
+      const result = saveDiscordToken(token);
+      reloadChannelsSoon();
+      return result;
+    },
+    forgetDiscordToken() {
+      const result = forgetDiscordToken();
+      reloadChannelsSoon();
+      return result;
+    },
+    saveTelegramToken(token) {
+      const result = saveTelegramToken(token);
+      reloadChannelsSoon();
+      return result;
+    },
+    forgetTelegramToken() {
+      const result = forgetTelegramToken();
+      reloadChannelsSoon();
+      return result;
+    },
+    setBackend(name) {
+      // Validate synchronously (same contract as before: bad input throws on
+      // this call so the TUI's try/catch can react immediately). The actual
+      // channels-section file read-modify-write is the hitch source on the
+      // settings-toggle key handler, so defer it through the same debounce
+      // pattern as saveConfigAndAdopt/flushConfigSave instead of writing to
+      // disk synchronously inside the key handler.
+      const value = String(name || '').trim();
+      if (value !== 'discord' && value !== 'telegram') {
+        throw new Error('backend must be discord or telegram');
+      }
+      scheduleBackendSave(value);
+      return { ok: true, backend: value };
+    },
+    saveWebhookAuthtoken(token) {
+      const result = saveWebhookAuthtoken(token);
+      reloadChannelsSoon();
+      return result;
+    },
+    forgetWebhookAuthtoken() {
+      const result = forgetWebhookAuthtoken();
+      reloadChannelsSoon();
+      return result;
+    },
+  };
+}