mixdog 0.9.95 → 0.9.97

package/src/tui/app/message-selector.mjs

@@ -0,0 +1,103 @@
+/**
+ * app/message-selector.mjs — Claude Code's "jump back to a previous message"
+ * list, opened by a double Escape from an EMPTY prompt while idle.
+ *
+ * Selecting a row rewinds the conversation to just before that prompt and
+ * drops its text back into the input box for editing: the transcript rows and
+ * the model-side history after it are undone, so the resubmit continues from
+ * exactly that point (engine side: store.rewindToItem).
+ */
+import { useCallback, useMemo } from 'react';
+
+export const MAX_SELECTABLE_MESSAGES = 20;
+
+/** Newest-last list of rewindable user prompts, capped for the picker. */
+export function selectableUserItems(items, limit = MAX_SELECTABLE_MESSAGES) {
+  const source = Array.isArray(items) ? items : [];
+  const rows = [];
+  for (let index = source.length - 1; index >= 0 && rows.length < limit; index -= 1) {
+    const item = source[index];
+    if (item?.kind !== 'user') continue;
+    if (item?.id == null) continue;
+    const text = String(item.text || '').trim();
+    if (!text) continue;
+    rows.push({ id: String(item.id), text });
+  }
+  return rows.reverse();
+}
+
+export function messageSelectorLabel(text, width = 56) {
+  const firstLine = String(text || '').split('\n').map((line) => line.trim()).find(Boolean) || '';
+  if (firstLine.length <= width) return firstLine;
+  return `${firstLine.slice(0, Math.max(1, width - 1))}…`;
+}
+
+export function useMessageSelector({
+  store,
+  state,
+  setPicker,
+  setPromptDraftOverride,
+  syncPromptLayoutRows,
+  showPromptHint,
+  clearPromptHint,
+}) {
+  // Cheap enough to recompute only when the transcript array identity changes;
+  // the prompt asks for this on every Escape, never per keystroke.
+  const hasUserMessages = useMemo(
+    () => (Array.isArray(state.items) ? state.items : []).some(
+      (item) => item?.kind === 'user' && String(item?.text || '').trim(),
+    ),
+    [state.items],
+  );
+
+  const applyRewind = useCallback((restored) => {
+    const text = String(restored?.text || '');
+    if (!text) {
+      showPromptHint('Could not restore that message.', 'error');
+      return false;
+    }
+    clearPromptHint();
+    syncPromptLayoutRows(text);
+    setPromptDraftOverride({ id: Date.now(), value: text });
+    return true;
+  }, [clearPromptHint, syncPromptLayoutRows, setPromptDraftOverride, showPromptHint]);
+
+  const openMessageSelector = useCallback(() => {
+    const items = store.getState?.().items ?? state.items;
+    const rows = selectableUserItems(items);
+    if (rows.length === 0) {
+      showPromptHint('No message to jump back to.', 'info');
+      return false;
+    }
+    setPicker({
+      _kind: 'message-selector',
+      title: 'Jump back to a message',
+      description: 'Rewind the conversation to a previous prompt and edit it.',
+      initialIndex: rows.length - 1,
+      items: rows.map((row) => ({ value: row.id, label: messageSelectorLabel(row.text) })),
+      onSelect: (value) => {
+        setPicker(null);
+        let restored;
+        try {
+          restored = store.rewindToItem?.(value);
+        } catch (error) {
+          showPromptHint(`rewind failed: ${error?.message || error}`, 'error');
+          return;
+        }
+        // Daemon-backed stores answer asynchronously; a local store returns the
+        // payload directly. Both land in the same apply path.
+        if (restored && typeof restored.then === 'function') {
+          void Promise.resolve(restored)
+            .then(applyRewind)
+            .catch((error) => showPromptHint(`rewind failed: ${error?.message || error}`, 'error'));
+          return;
+        }
+        applyRewind(restored);
+      },
+      onCancel: () => setPicker(null),
+    });
+    return true;
+  }, [store, state.items, setPicker, applyRewind, showPromptHint]);
+
+  return { hasUserMessages, openMessageSelector };
+}

package/src/tui/app/onboarding-steps.mjs

@@ -138,20 +138,19 @@ export function createOnboardingSteps({
     const done = () => store.pushNotice('First-run setup complete.', 'info');
     const failed = (e) => store.pushNotice(`Couldn’t save setup: ${e?.message || e}`, 'error');
     // Branch 1 — Main Model set: full persist. Agents without an explicit
-    // override are sent; untouched agents are left out so the backend never
+    // override are sent; untouched agents are left out so the session never
     // overwrites them (they follow the Main Model dynamically at runtime).
     if (defaultRoute) {
       void store.completeOnboarding?.({
         defaultRoute,
-        defaultProvider: defaultRoute.provider,
         ...(hasOverrides ? { agentRoutes: { ...overrides } } : {}),
         ...(searchRoute ? { searchRoute } : {}),
       }).then(done).catch(failed);
       return;
     }
     // Branch 2 — Main unset but some Search/agent picks exist: partial persist.
-    // Only the explicit overrides are sent (no defaultRoute/defaultProvider); the
-    // backend skips agents lacking a route and marks onboarding complete.
+    // Only the explicit overrides are sent (no defaultRoute); the
+    // session skips agents lacking a route and marks onboarding complete.
     if (hasOverrides || searchRoute) {
       void store.completeOnboarding?.({
         ...(hasOverrides ? { agentRoutes: { ...overrides } } : {}),

package/src/tui/app/project-picker.mjs

@@ -3,11 +3,9 @@
  *
  * Extracted from App.jsx behavior-preservingly. This cluster is ref/state
  * coupled (it drives setPicker + a fan of prompt setters), so it's delivered as
- * a dependency-injection factory rather than pure functions: App calls
- * createProjectPicker({...}) once and destructures the returned builders. Every
- * function body is the original App logic, verbatim, with closure identifiers
- * (state, store, setPicker, the prompt setters, and the projects.mjs helpers)
- * threaded in through the factory argument.
+ * a dependency-injection factory rather than pure functions. Project registry
+ * and path operations are daemon calls on `store`; the TUI retains only the
+ * OS-native folder chooser.
  */
 export function createProjectPicker({
   state,
@@ -19,44 +17,53 @@ export function createProjectPicker({
   setSettingsPrompt,
   setContextPanel,
   closeUsagePanel,
-  listProjects,
-  addProject,
-  touchProjectSelected,
-  resolveProjectPath,
   projectNameFromPath,
   pickFolder,
 }) {
-  const buildProjectPickerState = ({ initialEntry = false } = {}) => {
-    let projects = [];
-    try {
-      projects = listProjects() || [];
-    } catch {
-      projects = [];
+  const serviceCall = (name, ...args) => {
+    const target = store?.[name];
+    if (typeof target !== 'function') {
+      return Promise.reject(new TypeError(`project service method ${name} is unavailable`));
     }
+    return Promise.resolve(target.apply(store, args));
+  };
+
+  const buildProjectPickerState = ({
+    initialEntry = false,
+    projects = [],
+    loading = false,
+    requestId = null,
+  } = {}) => {
     const currentPath = String(state.cwd || process.cwd() || '');
     const items = [];
-    // Registered projects (store order via listProjects).
-    for (const project of projects) {
-      if (!project?.path) continue;
+    if (!loading) {
+      for (const project of projects) {
+        if (!project?.path) continue;
+        items.push({
+          value: project.path,
+          label: project.name || project.path,
+          meta: project.path,
+          _project: project,
+        });
+      }
+      // Last row: implicit current-directory shortcut (not persisted).
       items.push({
-        value: project.path,
-        label: project.name || project.path,
-        meta: project.path,
-        _project: project,
+        value: '__use_current__',
+        label: 'Current Path',
+        meta: currentPath,
+        _action: 'current',
       });
     }
-    // Last row: implicit current-directory shortcut (not persisted).
-    items.push({
-      value: '__use_current__',
-      label: 'Current Path',
-      meta: currentPath,
-      _action: 'current',
-    });
     return {
       kind: 'project',
+      _kind: 'project',
+      _projectRequestId: requestId,
+      _projectInitialPending: loading && initialEntry,
       title: 'Project',
-      description: 'Choose a project.',
-      help: initialEntry
+      description: loading ? 'Loading projects from the session…' : 'Choose a project.',
+      help: loading
+        ? 'Waiting for the project service…'
+        : initialEntry
         ? '↑/↓ Select · Enter Open · c Create · r Rename'
         : '↑/↓ Select · Enter Open · c Create · r Rename · Esc Back',
       indexMode: 'always',
@@ -69,20 +76,11 @@ export function createProjectPicker({
           return;
         }
         if (item?._action === 'current') {
-          setPicker(null);
-          try {
-            store.setCwd?.(currentPath, {
-              notice: !initialEntry,
-              message: `Project set: ${projectNameFromPath(currentPath)}`,
-            });
-          } catch (e) {
-            store.pushNotice(`project switch failed: ${e?.message || e}`, 'error');
-          }
+          void enterProject(currentPath, { notice: !initialEntry, register: false });
           return;
         }
-        setPicker(null);
         const project = item?._project;
-        if (project?.path) enterProject(project.path, { notice: !initialEntry });
+        if (project?.path) void enterProject(project.path, { notice: !initialEntry });
       },
       onKey: (input, _key, item) => {
         if (input === 'c' || input === 'C') {
@@ -157,7 +155,7 @@ export function createProjectPicker({
           openProjectPicker();
           return;
         }
-        registerProject(result.path);
+        void registerProject(result.path);
       })
       .catch(() => {
         beginNewProjectManual();
@@ -165,39 +163,43 @@ export function createProjectPicker({
   };
 
   // Register a project in the picker list without switching this session's cwd.
-  const registerProject = (rawPath) => {
-    const path = resolveProjectPath(rawPath);
+  const registerProject = async (rawPath) => {
+    const path = String(rawPath || '').trim();
     if (!path) {
       store.pushNotice('project path is required', 'warn');
-      return;
+      return false;
     }
     try {
-      const project = addProject(path);
+      const project = await serviceCall('addProject', path);
       if (project?.name) store.pushNotice(`project added: ${project.name}`, 'info');
-      openProjectPicker();
+      await openProjectPicker();
+      return true;
     } catch (e) {
       store.pushNotice(`project add failed: ${e?.message || e}`, 'error');
+      return false;
     }
   };
 
   // Switch the active working directory to a registered/created project path.
-  const enterProject = (rawPath, options = {}) => {
-    const path = resolveProjectPath(rawPath);
+  const enterProject = async (rawPath, options = {}) => {
+    const path = String(rawPath || '').trim();
     if (!path) {
       store.pushNotice('project path is required', 'warn');
-      return;
+      return false;
     }
+    setPicker(null);
     try {
       // Switch cwd first; only persist the project once the runtime accepts it,
       // so an invalid/missing path can never be written to projects.json.
-      store.setCwd?.(path, {
+      const resolved = await serviceCall('setCwd', path, {
         notice: options?.notice !== false,
         message: `Project set: ${projectNameFromPath(path)}`,
       });
-      addProject(path);
-      touchProjectSelected(path);
+      if (options?.register !== false) await serviceCall('addProject', resolved || path);
+      return true;
     } catch (e) {
       store.pushNotice(`project switch failed: ${e?.message || e}`, 'error');
+      return false;
     }
   };
 
@@ -225,14 +227,36 @@ export function createProjectPicker({
   // a Name column + Path column. The list always opens (even when empty) and
   // lists registered projects first, then a trailing "Current Path" shortcut.
   // Creating a new project is available via the picker-level c shortcut.
-  const openProjectPicker = () => {
+  const openProjectPicker = async ({ initialEntry = false } = {}) => {
     setProviderPrompt(null);
     setChannelPrompt(null);
     setHookPrompt(null);
     setSettingsPrompt(null);
     setContextPanel(null);
     closeUsagePanel();
-    setPicker(buildProjectPickerState());
+    const requestId = Symbol('project-picker-request');
+    setPicker(buildProjectPickerState({
+      initialEntry,
+      loading: true,
+      requestId,
+    }));
+    try {
+      const projects = await serviceCall('listProjects');
+      setPicker((current) => current?._projectRequestId === requestId
+        ? buildProjectPickerState({
+          initialEntry,
+          projects: Array.isArray(projects) ? projects : [],
+          requestId,
+        })
+        : current);
+      return projects;
+    } catch (error) {
+      setPicker((current) => current?._projectRequestId === requestId
+        ? buildProjectPickerState({ initialEntry, projects: [], requestId })
+        : current);
+      store.pushNotice(`project list failed: ${error?.message || error}`, 'error');
+      return [];
+    }
   };
 
   return {

package/src/tui/app/prompt-submit.mjs

@@ -16,13 +16,6 @@ import {
   imageReferenceIds,
   pastedTextReferenceIds,
 } from '../paste-attachments.mjs';
-import {
-  ensureDir,
-  isDirectory,
-  pathExists,
-  renameProject,
-  resolveProjectPath,
-} from '../../standalone/projects.mjs';
 
 export function createPromptSubmit({
   store,
@@ -56,10 +49,17 @@ export function createPromptSubmit({
   pastedImagesRef,
   pastedTextsRef,
 }) {
+  const serviceCall = (name, ...args) => {
+    const target = store?.[name];
+    if (typeof target !== 'function') {
+      return Promise.reject(new TypeError(`project service method ${name} is unavailable`));
+    }
+    return Promise.resolve(target.apply(store, args));
+  };
   const submitPrompt = (prompt, options) => {
     if (typeof store.submitAsync !== 'function') return store.submit(prompt, options);
     void Promise.resolve(store.submitAsync(prompt, options)).then((accepted) => {
-      if (accepted === false) store.pushNotice('prompt was not accepted by the session backend', 'error');
+      if (accepted === false) store.pushNotice('prompt was not accepted by the session service', 'error');
     }).catch((error) => {
       store.pushNotice(`prompt submit failed: ${error?.message || error}`, 'error');
     });
@@ -192,7 +192,7 @@ export function createPromptSubmit({
           const channelId = isPipe ? parts[1] : parts[0];
           Promise.resolve(store.setChannel({
             channelId,
-            backend: channelPrompt.backend,
+            provider: channelPrompt.provider,
           }))
             .then(() => resumeAfterChannelPrompt(channelPrompt))
             .catch((e) => {
@@ -240,9 +240,14 @@ export function createPromptSubmit({
             store.pushNotice('working directory path is required', 'warn');
             return false;
           }
-          store.setCwd?.(commandText, { message: `Project set: ${projectNameFromPath(commandText)}` });
-          setSettingsPrompt(null);
-          void openSettingsPicker();
+          void serviceCall('setCwd', commandText, {
+            message: `Project set: ${projectNameFromPath(commandText)}`,
+          }).then(() => {
+            setSettingsPrompt(null);
+            void openSettingsPicker();
+          }).catch((error) => {
+            store.pushNotice(`project switch failed: ${error?.message || error}`, 'error');
+          });
           return true;
         }
         if (settingsPrompt.kind === 'project-new') {
@@ -250,23 +255,25 @@ export function createPromptSubmit({
             store.pushNotice('project path is required', 'warn');
             return false;
           }
-          const path = resolveProjectPath(commandText);
-          if (isDirectory(path)) {
-            setSettingsPrompt(null);
-            registerProject(path);
-            return true;
-          }
-          // A path that exists but is a regular file is not a valid project dir.
-          if (pathExists(path)) {
-            store.pushNotice(`${path} is not a directory`, 'warn');
-            return false;
-          }
-          // Missing folder: confirm creation before registering.
-          setSettingsPrompt({
-            kind: 'project-create-confirm',
-            label: 'New project · Create folder?',
-            hint: `${path} does not exist. Type "y" to create it, or anything else to cancel.`,
-            pendingPath: path,
+          void serviceCall('inspectProjectPath', commandText).then((result) => {
+            const path = String(result?.path || commandText);
+            if (result?.directory === true) {
+              setSettingsPrompt(null);
+              void registerProject(path);
+              return;
+            }
+            if (result?.exists === true) {
+              store.pushNotice(`${path} is not a directory`, 'warn');
+              return;
+            }
+            setSettingsPrompt({
+              kind: 'project-create-confirm',
+              label: 'New project · Create folder?',
+              hint: `${path} does not exist. Type "y" to create it, or anything else to cancel.`,
+              pendingPath: path,
+            });
+          }).catch((error) => {
+            store.pushNotice(`project path check failed: ${error?.message || error}`, 'error');
           });
           return true;
         }
@@ -274,14 +281,13 @@ export function createPromptSubmit({
           const pendingPath = String(settingsPrompt.pendingPath || '');
           const answer = String(commandText || '').trim().toLowerCase();
           if (answer === 'y' || answer === 'yes') {
-            const created = ensureDir(pendingPath);
-            if (!created) {
-              store.pushNotice(`could not create folder: ${pendingPath}`, 'error');
+            void serviceCall('ensureProjectDirectory', pendingPath).then((created) => {
               setSettingsPrompt(null);
-              return true;
-            }
-            setSettingsPrompt(null);
-            registerProject(pendingPath);
+              void registerProject(created || pendingPath);
+            }).catch((error) => {
+              store.pushNotice(`could not create folder: ${error?.message || error}`, 'error');
+              setSettingsPrompt(null);
+            });
             return true;
           }
           setSettingsPrompt(null);
@@ -290,16 +296,15 @@ export function createPromptSubmit({
         }
         if (settingsPrompt.kind === 'project-rename') {
           const targetPath = String(settingsPrompt.projectPath || '');
-          try {
-            const updated = renameProject(targetPath, commandText);
+          void serviceCall('renameProject', targetPath, commandText).then((updated) => {
             if (updated) {
               store.pushNotice(`project renamed to "${updated.name}"`, 'info');
             }
-          } catch (e) {
-            store.pushNotice(`rename failed: ${e?.message || e}`, 'error');
-          }
-          setSettingsPrompt(null);
-          openProjectPicker();
+            setSettingsPrompt(null);
+            void openProjectPicker();
+          }).catch((error) => {
+            store.pushNotice(`rename failed: ${error?.message || error}`, 'error');
+          });
           return true;
         }
         if (settingsPrompt.kind === 'system-shell') {

package/src/tui/app/resume-picker.mjs

@@ -13,14 +13,14 @@ export function createResumePicker({
   formatSessionUpdatedAt,
   formatSessionMessageCount,
 }) {
-  const openResumePicker = () => {
+  const openResumePicker = async () => {
     let sessions;
     try {
       // Terminal ↔ desktop interop: the summary cache is per-process, so a
       // session created/updated by the desktop app (or another CLI) after this
       // process's first listing would be invisible without an authoritative
       // storage rescan on picker open.
-      sessions = store.listSessions({ refreshFromStorage: true });
+      sessions = await store.listSessions({ refreshFromStorage: true });
     } catch (e) {
       store.pushNotice(`could not list saved chats: ${e?.message || e}`, 'error');
       return;

package/src/tui/app/route-pickers.mjs

@@ -86,7 +86,9 @@ export function createRoutePickers({
     const items = agents.map((agent) => ({
       value: agent.id,
       label: agent.label,
-      metaParts: agentModelParts(routeOverrides[agent.id] || agent.route),
+      metaParts: routeOverrides[agent.id] || agent.route
+        ? agentModelParts(routeOverrides[agent.id] || agent.route)
+        : [{ text: '(follows main)', width: 17 }, { text: '', width: 6 }, { text: '', width: 4 }],
       description: agent.description || agent.definition?.description || '',
       _agent: agent,
     }));

package/src/tui/app/settings-picker.mjs

@@ -53,7 +53,7 @@ export function createSettingsPicker({
     const snapshot = (await store.getSettingsSnapshot?.({ heavy: !heavyCache })) || {};
     const autoClear = snapshot.autoClear || {};
     const compaction = snapshot.compaction || {};
-    const memory = snapshot.memory || { enabled: true };
+    const recap = snapshot.recap || { enabled: true };
     const channels = snapshot.channels || { enabled: true };
     const systemShell = snapshot.systemShell || { source: 'auto', command: '', effective: '' };
     const outputStyle = snapshot.outputStyle || {};
@@ -63,19 +63,19 @@ export function createSettingsPicker({
     const plugins = heavyCache ? heavyCache.plugins : (snapshot.plugins || { count: 0 });
     const skills = heavyCache ? heavyCache.skills : (snapshot.skills || { count: 0 });
     const channelWorker = snapshot.channelWorker || null;
-    const channelBackend = heavyCache
-      ? (heavyCache.channelBackend || 'discord')
-      : (snapshot.channelBackend || 'discord');
-    const effectiveChannelBackend = overrides
-      && Object.prototype.hasOwnProperty.call(overrides, 'channelBackend')
-      ? overrides.channelBackend
-      : channelBackend;
+    const channelProvider = heavyCache
+      ? (heavyCache.channelProvider || 'discord')
+      : (snapshot.channelProvider || 'discord');
+    const effectiveChannelProvider = overrides
+      && Object.prototype.hasOwnProperty.call(overrides, 'channelProvider')
+      ? overrides.channelProvider
+      : channelProvider;
     // Refresh the cache every build (light or full) so the next light
     // refresh reuses whatever was most recently known, and so an
-    // optimistic override (e.g. channel backend cycle) sticks without
+    // optimistic override (e.g. channel provider cycle) sticks without
     // re-running the heavy getter it came from.
-    settingsHeavyCacheRef.current = { mcp, hooks, plugins, skills, channelBackend: effectiveChannelBackend };
-    const channelBackendLabel = effectiveChannelBackend === 'telegram' ? 'Telegram' : 'Discord';
+    settingsHeavyCacheRef.current = { mcp, hooks, plugins, skills, channelProvider: effectiveChannelProvider };
+    const channelProviderLabel = effectiveChannelProvider === 'telegram' ? 'Telegram' : 'Discord';
     const remoteEnabled = snapshot.remoteEnabled === true;
     const remoteRuntimeDescription = channelWorker?.running
       ? `runtime running · pid ${channelWorker.pid}`
@@ -84,9 +84,7 @@ export function createSettingsPicker({
     const outputStyleLabel = outputStyle?.current?.label || outputStyle?.current?.id || outputStyle?.configured || 'Default';
     const workflowLabel = workflowDisplayName(workflow);
     const boolLabel = (enabled) => enabled ? 'On' : 'Off';
-    const compactTypeDescription = memory.enabled === false
-      ? 'Injects raw transcript lines (memory off: no LLM chunking).'
-      : 'Uses Memory recall to rebuild context faster on large histories.';
+    const compactTypeDescription = 'Uses Memory recall to rebuild context faster on large histories.';
     const applyAutoClear = (patch = {}) => {
       void Promise.resolve(store.setAutoClear?.(patch))
         .then((next) => {
@@ -200,25 +198,25 @@ export function createSettingsPicker({
         .catch((e) => store.pushNotice(`Remote toggle failed: ${e?.message || e}`, 'error'))
         .finally(() => { void openSettingsPicker({ light: true }); });
     };
-    const cycleChannelBackend = (direction = 1) => {
-      const backends = ['discord', 'telegram'];
-      const currentIndex = Math.max(0, backends.indexOf(effectiveChannelBackend));
-      const chosen = backends[(currentIndex + direction + backends.length) % backends.length];
-      if (chosen === effectiveChannelBackend) {
-        openSettingsPicker({ light: true, overrides: { channelBackend: effectiveChannelBackend } });
+    const cycleChannelProvider = (direction = 1) => {
+      const providers = ['discord', 'telegram'];
+      const currentIndex = Math.max(0, providers.indexOf(effectiveChannelProvider));
+      const chosen = providers[(currentIndex + direction + providers.length) % providers.length];
+      if (chosen === effectiveChannelProvider) {
+        openSettingsPicker({ light: true, overrides: { channelProvider: effectiveChannelProvider } });
         return;
       }
       try {
-        store.setBackend(chosen);
+        store.setChannelProvider(chosen);
         const label = chosen === 'telegram' ? 'Telegram' : 'Discord';
         const restartHint = (remoteEnabled || channelWorker?.running)
           ? `Channel set to ${label}. Restart remote to apply.`
           : `Channel set to ${label}.`;
         store.pushNotice(restartHint, 'info');
       } catch (e) {
-        store.pushNotice(`channel backend failed: ${e?.message || e}`, 'error');
+        store.pushNotice(`channel provider failed: ${e?.message || e}`, 'error');
       }
-      openSettingsPicker({ light: true, overrides: { channelBackend: chosen } });
+      openSettingsPicker({ light: true, overrides: { channelProvider: chosen } });
     };
     // Row order groups by concern — routing/model first, then session
     // behavior, integrations, channels/remote, system — and must stay in
@@ -304,10 +302,10 @@ export function createSettingsPicker({
       {
         value: 'memory',
         label: 'Memory',
-        meta: boolLabel(memory.enabled !== false),
-        description: memory.enabled === false
-          ? 'Memory off. Core memories stay editable.'
-          : 'Session memory and core memories.',
+        meta: `Recap ${boolLabel(recap.enabled !== false)}`,
+        description: recap.enabled === false
+          ? 'Background recap off. Core memories and on-demand recall stay available.'
+          : 'Background recap and core memories.',
         _action: 'memory',
       },
       {
@@ -352,11 +350,11 @@ export function createSettingsPicker({
         _action: 'channels',
       },
       {
-        value: 'channel-backend',
+        value: 'channel-provider',
         label: 'Channel',
-        meta: channelBackendLabel,
+        meta: channelProviderLabel,
         description: 'Left/Right or Enter changes channel type (Discord or Telegram).',
-        _action: 'channel-backend',
+        _action: 'channel-provider',
       },
       {
         value: 'channel-setting',
@@ -412,7 +410,7 @@ export function createSettingsPicker({
         else if (item?._action === 'autocompact') applyCompaction({ auto: !(compaction.auto !== false) });
         else if (item?._action === 'channels') applyChannels(!(channels.enabled !== false));
         else if (item?._action === 'remote-runtime') applyRemoteRuntime();
-        else if (item?._action === 'channel-backend') cycleChannelBackend(-1);
+        else if (item?._action === 'channel-provider') cycleChannelProvider(-1);
         else if (item?._action === 'output-style') cycleOutputStyle(-1);
         else if (item?._action === 'theme') cycleTheme(-1);
         else if (item?._action === 'workflow') cycleWorkflow(-1);
@@ -422,7 +420,7 @@ export function createSettingsPicker({
         else if (item?._action === 'autocompact') applyCompaction({ auto: !(compaction.auto !== false) });
         else if (item?._action === 'channels') applyChannels(!(channels.enabled !== false));
         else if (item?._action === 'remote-runtime') applyRemoteRuntime();
-        else if (item?._action === 'channel-backend') cycleChannelBackend(1);
+        else if (item?._action === 'channel-provider') cycleChannelProvider(1);
         else if (item?._action === 'output-style') cycleOutputStyle(1);
         else if (item?._action === 'theme') cycleTheme(1);
         else if (item?._action === 'workflow') cycleWorkflow(1);
@@ -433,7 +431,7 @@ export function createSettingsPicker({
         else if (item._action === 'autocompact') applyCompaction({ auto: !(compaction.auto !== false) });
         else if (item._action === 'channels') applyChannels(!(channels.enabled !== false));
         else if (item._action === 'remote-runtime') applyRemoteRuntime();
-        else if (item._action === 'channel-backend') cycleChannelBackend(1);
+        else if (item._action === 'channel-provider') cycleChannelProvider(1);
         else if (item._action === 'channel-setting') openChannelSettingTypePicker({ returnTo: openSettingsPicker });
         else if (item._action === 'output-style') openOutputStylePicker({ returnTo: openSettingsPicker });
         else if (item._action === 'theme') openThemePicker({ returnTo: openSettingsPicker });