mixdog 0.9.95 → 0.9.96

package/src/standalone/fair-call-scheduler.mjs

@@ -0,0 +1,264 @@
+function positiveInt(value, fallback) {
+  const parsed = Math.floor(Number(value));
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function activeLimit(value, fallback) {
+  if (value === null || value === Infinity) return Infinity;
+  return positiveInt(value, fallback);
+}
+
+function schedulerError(message, statusCode = 503) {
+  const error = new Error(message);
+  error.statusCode = statusCode;
+  return error;
+}
+
+function abortError(signal, fallback = 'scheduled call canceled') {
+  return signal?.reason instanceof Error
+    ? signal.reason
+    : schedulerError(String(signal?.reason || fallback), 499);
+}
+
+/**
+ * Owner-fair async dispatcher with an optional active limit.
+ *
+ * One owner may borrow the entire queue while it is alone. When another owner
+ * appears, new admissions are divided by weight and a completely full queue
+ * evicts one tail item from the largest borrower so the newcomer always gets a
+ * seat. Running work is never revoked.
+ */
+export function createFairCallScheduler({
+  name = 'daemon call',
+  activeMax = 32,
+  queueMax = 256,
+  minOwnerQueue = 8,
+  dispatchBurst = 8,
+  yieldUnbounded = false,
+  schedule = setImmediate,
+  now = Date.now,
+} = {}) {
+  const maxActive = activeLimit(activeMax, 32);
+  const maxQueued = positiveInt(queueMax, 256);
+  const ownerFloor = Math.max(1, Math.min(maxQueued, positiveInt(minOwnerQueue, 8)));
+  const maxBurst = positiveInt(dispatchBurst, 8);
+  const groups = new Map();
+  let active = 0;
+  let queued = 0;
+  let scheduled = false;
+  let closed = false;
+
+  function ownerId(value) {
+    const clean = String(value || '').trim();
+    return clean ? clean.slice(0, 240) : 'anonymous';
+  }
+
+  function groupFor(owner, weight = 1) {
+    const id = ownerId(owner);
+    let group = groups.get(id);
+    if (!group) {
+      group = {
+        owner: id,
+        weight: positiveInt(weight, 1),
+        current: 0,
+        active: 0,
+        queue: [],
+      };
+      groups.set(id, group);
+    } else if (weight !== undefined) {
+      group.weight = positiveInt(weight, group.weight);
+    }
+    return group;
+  }
+
+  function maybeDeleteGroup(group) {
+    if (group && group.active === 0 && group.queue.length === 0) groups.delete(group.owner);
+  }
+
+  function detach(item) {
+    if (!item?.onAbort || !item.signal) return;
+    try { item.signal.removeEventListener('abort', item.onAbort); } catch {}
+    item.onAbort = null;
+  }
+
+  function queuedGroups(extra = null) {
+    const out = [];
+    for (const group of groups.values()) {
+      if (group.queue.length > 0 || group === extra) out.push(group);
+    }
+    if (extra && !out.includes(extra)) out.push(extra);
+    return out;
+  }
+
+  function rejectBorrowedTail(incoming) {
+    let borrower = null;
+    for (const group of groups.values()) {
+      if (group === incoming || group.queue.length <= ownerFloor) continue;
+      if (!borrower || group.queue.length > borrower.queue.length) borrower = group;
+    }
+    if (!borrower) return false;
+    const displaced = borrower.queue.pop();
+    queued = Math.max(0, queued - 1);
+    detach(displaced);
+    displaced.reject(schedulerError(
+      `${name} queue rebalanced for another client; retry after running work completes`,
+      503,
+    ));
+    maybeDeleteGroup(borrower);
+    return true;
+  }
+
+  function fairQueueLimit(group) {
+    const contenders = queuedGroups(group);
+    if (contenders.length <= 1) return maxQueued;
+    const totalWeight = contenders.reduce((sum, candidate) => sum + candidate.weight, 0);
+    return Math.max(
+      ownerFloor,
+      Math.floor(maxQueued * group.weight / Math.max(1, totalWeight)),
+    );
+  }
+
+  function pickGroup() {
+    const ready = [...groups.values()].filter((group) => group.queue.length > 0);
+    if (ready.length === 0) return null;
+    const totalWeight = ready.reduce((sum, group) => sum + group.weight, 0);
+    let chosen = null;
+    for (const group of ready) {
+      group.current += group.weight;
+      if (!chosen || group.current > chosen.current) chosen = group;
+    }
+    chosen.current -= totalWeight;
+    return chosen;
+  }
+
+  function scheduleDispatch() {
+    if (closed || scheduled || active >= maxActive || queued === 0) return;
+    scheduled = true;
+    schedule(() => {
+      scheduled = false;
+      let started = 0;
+      while (!closed && active < maxActive && queued > 0 && started < maxBurst) {
+        const group = pickGroup();
+        const item = group?.queue.shift();
+        if (!group || !item) break;
+        queued = Math.max(0, queued - 1);
+        detach(item);
+        active += 1;
+        group.active += 1;
+        started += 1;
+        Promise.resolve()
+          .then(item.run)
+          .then(item.resolve, item.reject)
+          .finally(() => {
+            active = Math.max(0, active - 1);
+            group.active = Math.max(0, group.active - 1);
+            maybeDeleteGroup(group);
+            scheduleDispatch();
+          });
+      }
+      // A bounded burst amortizes loopback dispatch without letting synchronous
+      // setup monopolize the supervisor's socket/control-plane turn.
+      scheduleDispatch();
+    });
+  }
+
+  function enqueue(owner, run, { weight = 1, signal = null } = {}) {
+    if (closed) return Promise.reject(schedulerError(`${name} scheduler is closed`));
+    if (typeof run !== 'function') return Promise.reject(new TypeError('scheduled call must be a function'));
+    if (signal?.aborted) return Promise.reject(abortError(signal));
+    const group = groupFor(owner, weight);
+    // Default daemon lanes are unbounded. Do not enqueue them only to bounce
+    // through setImmediate: independent loopback calls start in this microtask,
+    // while finite operator-configured lanes retain the fair queue below.
+    if (maxActive === Infinity && !yieldUnbounded && queued === 0) {
+      active += 1;
+      group.active += 1;
+      return Promise.resolve()
+        .then(run)
+        .finally(() => {
+          active = Math.max(0, active - 1);
+          group.active = Math.max(0, group.active - 1);
+          maybeDeleteGroup(group);
+          scheduleDispatch();
+        });
+    }
+    const hasCompetitor = queuedGroups(group).some((candidate) =>
+      candidate !== group && candidate.queue.length > 0);
+    if (hasCompetitor && group.queue.length >= fairQueueLimit(group)) {
+      return Promise.reject(schedulerError(
+        `${name} client queue is full; retry after this client's running work completes`,
+        429,
+      ));
+    }
+    if (queued >= maxQueued && !rejectBorrowedTail(group)) {
+      return Promise.reject(schedulerError(`${name} queue is full`, 503));
+    }
+    let item;
+    const promise = new Promise((resolve, reject) => {
+      item = {
+        run,
+        resolve,
+        reject,
+        signal,
+        onAbort: null,
+        queuedAt: now(),
+      };
+      if (signal) {
+        item.onAbort = () => {
+          const index = group.queue.indexOf(item);
+          if (index < 0) return;
+          group.queue.splice(index, 1);
+          queued = Math.max(0, queued - 1);
+          detach(item);
+          maybeDeleteGroup(group);
+          reject(abortError(signal));
+        };
+        signal.addEventListener('abort', item.onAbort, { once: true });
+      }
+      group.queue.push(item);
+      queued += 1;
+    });
+    scheduleDispatch();
+    return promise;
+  }
+
+  function close(reason = `${name} scheduler is closed`) {
+    if (closed) return;
+    closed = true;
+    const error = schedulerError(reason);
+    for (const group of groups.values()) {
+      for (const item of group.queue.splice(0)) {
+        detach(item);
+        item.reject(error);
+      }
+    }
+    queued = 0;
+    for (const group of [...groups.values()]) maybeDeleteGroup(group);
+  }
+
+  function snapshot() {
+    let oldestQueuedAt = Infinity;
+    for (const group of groups.values()) {
+      for (const item of group.queue) {
+        oldestQueuedAt = Math.min(oldestQueuedAt, Number(item.queuedAt) || Infinity);
+      }
+    }
+    return {
+      active,
+      queued,
+      owners: [...groups.values()].filter((group) => group.active || group.queue.length).length,
+      activeMax: Number.isFinite(maxActive) ? maxActive : null,
+      dispatchBurst: maxBurst,
+      queueMax: maxQueued,
+      oldestWaitMs: Number.isFinite(oldestQueuedAt) ? Math.max(0, now() - oldestQueuedAt) : 0,
+    };
+  }
+
+  return {
+    enqueue,
+    close,
+    snapshot,
+    get active() { return active; },
+    get queued() { return queued; },
+  };
+}

package/src/standalone/session-protocol.mjs

@@ -0,0 +1,188 @@
+/**
+ * Explicit session protocol shared by every Mixdog client.
+ *
+ * The wire exposes session lifetime operations directly. Engine capabilities
+ * are finite and split into read/configure lanes; clients cannot discover or
+ * invoke arbitrary properties on the daemon-hosted runtime.
+ */
+
+export const SESSION_READ_ACTIONS = Object.freeze([
+  'contextStatus',
+  'getAgentDefinition',
+  'getAutoClear',
+  'getChannelSettings',
+  'getChannelSetup',
+  'getChannelWorkerStatus',
+  'getCompactionSettings',
+  'getDisabledSkills',
+  'getMediaJob',
+  'getOnboardingStatus',
+  'getOutputStyle',
+  'getProfile',
+  'getProviderSetup',
+  'getRecapSettings',
+  'getSearchRoute',
+  'getSettingsSnapshot',
+  'getSystemShell',
+  'getTheme',
+  'getTurnReviewDiff',
+  'getUpdateSettings',
+  'getUpdateStatus',
+  'getUsageDashboard',
+  'getVoiceStatus',
+  'getWorkflowPack',
+  'hooksStatus',
+  'isRemoteEnabled',
+  'listAgents',
+  'listMediaAssets',
+  'listMediaLanes',
+  'listOutputStyles',
+  'listPresets',
+  'listProviderModels',
+  'listProviders',
+  'listSearchModels',
+  'listThemes',
+  'listWorkflows',
+  'mcpStatus',
+  'peekSessionTranscript',
+  'pluginsStatus',
+  'readMediaAsset',
+  'resolveMediaFile',
+  'skillContent',
+  'skillsStatus',
+  'toolsStatus',
+]);
+
+export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
+  'addHookRule',
+  'addMcpServer',
+  'addPlugin',
+  'addSkill',
+  'agentControl',
+  'authenticateProvider',
+  'beginOAuthProviderLogin',
+  'cacheMediaThumbnail',
+  'cancelMediaJob',
+  'checkForUpdate',
+  'claimRemote',
+  'clear',
+  'compact',
+  'completeOnboarding',
+  'createWorkflow',
+  'deleteAgentDefinition',
+  'deleteHookRule',
+  'deleteMediaAsset',
+  'deleteSchedule',
+  'deleteSession',
+  'deleteWebhook',
+  'deleteWorkflow',
+  'enablePluginMcp',
+  'forgetDiscordToken',
+  'forgetProviderAuth',
+  'forgetTelegramToken',
+  'loginOAuthProvider',
+  'loginOpenCodeGoUsage',
+  'memoryControl',
+  'openMediaAsset',
+  'openMediaFolder',
+  'pushNotice',
+  'recall',
+  'reconnectMcp',
+  'releaseRemote',
+  'reloadPlugins',
+  'reloadSkills',
+  'rememberPromptHistory',
+  'removeMcpServer',
+  'removeNotice',
+  'removePlugin',
+  'renameSessionTitle',
+  'restoreNewerTranscript',
+  'restoreOlderTranscript',
+  'restoreQueued',
+  'revertTurnReviewFile',
+  'rewindToItem',
+  'runDoctor',
+  'runScheduleNow',
+  'runUpdateNow',
+  'saveAgentDefinition',
+  'saveDiscordToken',
+  'saveOpenAIUsageSessionKey',
+  'saveOpenCodeGoUsageAuth',
+  'saveProviderApiKey',
+  'saveSchedule',
+  'saveTelegramToken',
+  'saveWebhook',
+  'saveWorkflowPack',
+  'selectTools',
+  'setAgentRoute',
+  'setAutoClear',
+  'setAutoUpdate',
+  'setBackend',
+  'setChannel',
+  'setChannelsEnabled',
+  'setCompactionSettings',
+  'setCwd',
+  'setDisabledSkills',
+  'setEffort',
+  'setFast',
+  'setHookRuleEnabled',
+  'setLocalProvider',
+  'setMcpServerEnabled',
+  'setModel',
+  'setOutputStyle',
+  'setProfile',
+  'setProgressHint',
+  'setRecapEnabled',
+  'setRoute',
+  'setScheduleEnabled',
+  'setSearchRoute',
+  'setSystemShell',
+  'setTheme',
+  'setToolMode',
+  'setWebhookConfig',
+  'setWebhookEnabled',
+  'setWorkflow',
+  'skipOnboarding',
+  'startMediaJob',
+  'switchContext',
+  'toggleFast',
+  'toggleRemote',
+  'toggleVoice',
+  'transcribeAudio',
+  'updatePlugin',
+]);
+
+export const SESSION_READ_ACTION_SET = new Set(SESSION_READ_ACTIONS);
+export const SESSION_CONFIGURE_ACTION_SET = new Set(SESSION_CONFIGURE_ACTIONS);
+
+function requireTransport(transport) {
+  if (!transport || typeof transport.call !== 'function') {
+    throw new TypeError('session transport is invalid');
+  }
+  return transport;
+}
+
+/** Build the one finite client used by TUI, desktop, and in-daemon adapters. */
+export function createSessionProtocolClient(rawTransport) {
+  const transport = requireTransport(rawTransport);
+  const route = (name, params = {}, options = {}) => transport.call(name, params, options);
+  return Object.freeze({
+    list: (params = {}, options = {}) => route('session.list', params, options),
+    create: (params = {}, options = {}) => route('session.create', params, options),
+    read: (params = {}, options = {}) => route('session.read', params, options),
+    subscribe: (params = {}, options = {}) => route('session.subscribe', params, options),
+    unsubscribe: (params = {}, options = {}) => route('session.unsubscribe', params, options),
+    submit: (params = {}, options = {}) => route('session.submit', params, options),
+    abort: (params = {}, options = {}) => route('session.abort', params, options),
+    approve: (params = {}, options = {}) => route('session.approve', params, options),
+    configure: (params = {}, options = {}) => route('session.configure', params, options),
+    projectList: (params = {}, options = {}) => route('project.list', params, options),
+    projectInspect: (params = {}, options = {}) => route('project.inspect', params, options),
+    projectAdd: (params = {}, options = {}) => route('project.add', params, options),
+    projectTouch: (params = {}, options = {}) => route('project.touch', params, options),
+    projectRename: (params = {}, options = {}) => route('project.rename', params, options),
+    projectRemove: (params = {}, options = {}) => route('project.remove', params, options),
+    projectEnsureDirectory: (params = {}, options = {}) => route('project.ensureDirectory', params, options),
+    close: (reason) => Promise.resolve(transport.close?.(reason)),
+  });
+}

package/src/tui/App.jsx

@@ -42,16 +42,6 @@ import {
   splitPastedImagePathCandidates,
 } from './paste-attachments.mjs';
 import { formatDuration } from './time-format.mjs';
-import {
-  listProjects,
-  addProject,
-  touchProjectSelected,
-  renameProject,
-  isDirectory,
-  pathExists,
-  ensureDir,
-  resolveProjectPath,
-} from '../standalone/projects.mjs';
 import { pickFolder } from '../standalone/folder-dialog.mjs';
 import {
   formatHookDenialDetail,
@@ -100,6 +90,7 @@ import { usePromptDraftFlow } from './app/use-prompt-draft-flow.mjs';
 import { useTranscriptActivity } from './app/use-transcript-activity.mjs';
 import { createAppPickers } from './app/create-app-pickers.mjs';
 import { usePromptQueueHistory } from './app/use-prompt-queue-history.mjs';
+import { useMessageSelector } from './app/message-selector.mjs';
 import { useTerminalChrome } from './app/use-terminal-chrome.mjs';
 import { useTranscriptWindow } from './app/use-transcript-window.mjs';
 import {
@@ -120,6 +111,7 @@ import {
   transcriptMeasuredRowsCache,
   buildTranscriptRowIndex,
   transcriptRenderWindow,
+  transcriptSwapReturnsToTail,
 } from './app/transcript-window.mjs';
 import {
   SEARCH_DEFAULT_ROUTE,
@@ -326,6 +318,9 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
   // same glide back to the bottom.
   const followingRef = useRef(false);
   const lastItemsCountRef = useRef(0);
+  // Head item of the last committed transcript: a bulk swap (session load /
+  // clear / compaction trim) changes it, a live append never does.
+  const lastFirstItemIdRef = useRef(null);
   // picker = null | { type, title, items, onSelect }
   // Rendered as an option panel attached directly above the bottom prompt.
   const pickerOpenedFromEnterRef = useRef(false);
@@ -413,10 +408,6 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
     setSettingsPrompt,
     setContextPanel,
     closeUsagePanel,
-    listProjects,
-    addProject,
-    touchProjectSelected,
-    resolveProjectPath,
     projectNameFromPath,
     pickFolder,
   });
@@ -429,9 +420,13 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
     initialPickerBuiltRef.current = true;
     const onboardingOwnsScreen = !resolveOnboardingCompleted(store, onboardingCompleted) || forceOnboarding;
     if (!onboardingOwnsScreen && state.items.length === 0) {
-      setPicker(projectPicker.buildProjectPickerState({ initialEntry: true }));
+      setPicker(projectPicker.buildProjectPickerState({ initialEntry: true, loading: true }));
     }
   }
+  useEffect(() => {
+    if (livePickerRef.current?._projectInitialPending !== true) return;
+    void projectPickerRef.current?.openProjectPicker({ initialEntry: true });
+  }, [store]);
   const {
     beginNewProject,
     registerProject,
@@ -793,12 +788,17 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
     const count = state.items.length;
     const previousCount = lastItemsCountRef.current;
     lastItemsCountRef.current = count;
-    if (count < previousCount || previousCount === 0) {
+    const firstId = count > 0 ? (state.items[0]?.id ?? null) : null;
+    const previousFirstId = lastFirstItemIdRef.current;
+    lastFirstItemIdRef.current = firstId;
+    // A bulk swap (compaction included) is an explicit return to the tail: the
+    // rows the reader was anchored to no longer exist.
+    if (transcriptSwapReturnsToTail({ count, previousCount, firstId, previousFirstId })) {
       resetTranscriptScroll();
       return;
     }
     if (count === previousCount || dragRef.current.active) return;
-  }, [state.items.length, resetTranscriptScroll]);
+  }, [state.items, resetTranscriptScroll]);
 
   // Exit + queued-restore + prompt history: app/use-prompt-queue-history.mjs.
   const {
@@ -823,6 +823,17 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
     promptHistoryNavRef,
   });
 
+  // Double-Esc message selector (Claude Code parity): app/message-selector.mjs.
+  const { hasUserMessages, openMessageSelector } = useMessageSelector({
+    store,
+    state,
+    setPicker,
+    setPromptDraftOverride,
+    syncPromptLayoutRows,
+    showPromptHint,
+    clearPromptHint,
+  });
+
   // PROMPT HANDLER cluster extracted to app/use-prompt-handlers.mjs.
   const {
     handlePromptPaste,
@@ -849,6 +860,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
     recentPromptHistory,
     resetPromptHistoryNav,
     restoreQueuedToPrompt,
+    openMessageSelector,
     usagePanel,
     closeUsagePanel,
     contextPanel,
@@ -1257,6 +1269,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
     handlePromptHistoryNavigate,
     handlePromptInterrupt,
     handlePromptPaste,
+    hasUserMessages,
     hookPrompt,
     initialStatusLine,
     onPromptDraftChange,

package/src/tui/app/app-view.jsx

@@ -20,7 +20,7 @@ import { UsagePanel } from '../components/UsagePanel.jsx';
 import { TextEntryPanel } from '../components/TextEntryPanel.jsx';
 import { Item } from '../components/TranscriptItem.jsx';
 export function renderAppView(ctx) {
-  const { PANEL_MAX_VISIBLE, acceptSlashPalette, activeSlashQuery, activeTools, agentRevision, cancelChannelPrompt, cancelHookPrompt, cancelProviderPrompt, cancelSettingsPrompt, cancelSlashPalette, channelPrompt, clearPromptHint, completeSlashPalette, contextPanel, cycleWorkflowFromPrompt, exiting, expandedOptionPanel, floatingPanelRows, frameColumns, gridSelectionActiveRef, guardHintWidth, handlePromptEscape, handlePromptHistoryNavigate, handlePromptInterrupt, handlePromptPaste, hookPrompt, initialStatusLine, inputBoxHidden, inputHint, inputHintTone, liveSpinner, onPromptDraftChange, onSubmit, overlayHintAttachItemIndex, overlayHintBandRows, overlayHintFallbackRow, overlayHintOnLastItem, panelCloseMaskRows, panelInkMaskEpoch, panelTransitionClearRows, panelTransitionEpoch, picker, pickerOpenedFromEnterRef, pickerOpenedFromEnterTimerRef, pickerVisibleRows, promptBoxRectRef, promptBoxRows, promptDraft, promptDraftOverride, promptMetaVisible, promptMouseSelectionRef, promptSelectionRef, promptSpinnerColumns, promptValueRef, providerPrompt, queuedCompact, queuedVisible, renderedTranscriptItems, resizeEpoch, resizeState, restoreQueuedToPrompt, setPicker, setSlashIndex, setTextEntryLayoutRows, settingsPrompt, showWelcomeBanner, slashCommands, slashIndex, slashPaletteOpen, state, statuslineStats, store, toolApproval, toolOutputExpanded, transcriptContentHeight, transcriptGuardRows, transcriptMeasureRef, transcriptTailPinned, transcriptWindow, transientStatusWidth, tuiReady, usagePanel, viewportHeight, welcomePromptHintRows, welcomePromptHintText } = ctx; /* DESTRUCTURE */
+  const { PANEL_MAX_VISIBLE, acceptSlashPalette, activeSlashQuery, activeTools, agentRevision, cancelChannelPrompt, cancelHookPrompt, cancelProviderPrompt, cancelSettingsPrompt, cancelSlashPalette, channelPrompt, clearPromptHint, completeSlashPalette, contextPanel, cycleWorkflowFromPrompt, exiting, expandedOptionPanel, floatingPanelRows, frameColumns, gridSelectionActiveRef, guardHintWidth, handlePromptEscape, handlePromptHistoryNavigate, handlePromptInterrupt, handlePromptPaste, hasUserMessages, hookPrompt, initialStatusLine, inputBoxHidden, inputHint, inputHintTone, liveSpinner, onPromptDraftChange, onSubmit, overlayHintAttachItemIndex, overlayHintBandRows, overlayHintFallbackRow, overlayHintOnLastItem, panelCloseMaskRows, panelInkMaskEpoch, panelTransitionClearRows, panelTransitionEpoch, picker, pickerOpenedFromEnterRef, pickerOpenedFromEnterTimerRef, pickerVisibleRows, promptBoxRectRef, promptBoxRows, promptDraft, promptDraftOverride, promptMetaVisible, promptMouseSelectionRef, promptSelectionRef, promptSpinnerColumns, promptValueRef, providerPrompt, queuedCompact, queuedVisible, renderedTranscriptItems, resizeEpoch, resizeState, restoreQueuedToPrompt, setPicker, setSlashIndex, setTextEntryLayoutRows, settingsPrompt, showWelcomeBanner, slashCommands, slashIndex, slashPaletteOpen, state, statuslineStats, store, toolApproval, toolOutputExpanded, transcriptContentHeight, transcriptGuardRows, transcriptMeasureRef, transcriptTailPinned, transcriptWindow, transientStatusWidth, tuiReady, usagePanel, viewportHeight, welcomePromptHintRows, welcomePromptHintText } = ctx; /* DESTRUCTURE */
   const promptInputControl = (
     <PromptInput
       onSubmit={onSubmit}
@@ -47,6 +47,7 @@ export function renderAppView(ctx) {
       // actually be accepted — otherwise Enter must submit the raw text as
       // before instead of dead-ending in the palette accept path.
       commandPaletteActive={slashPaletteOpen && slashCommands.length > 0}
+      commandPaletteOpen={slashPaletteOpen}
       onCommandPaletteNavigate={(direction) => {
         setSlashIndex((index) => {
           const total = slashCommands.length;
@@ -65,7 +66,9 @@ export function renderAppView(ctx) {
       onCommandPaletteAccept={acceptSlashPalette}
       onCommandPaletteCancel={cancelSlashPalette}
       onCommandPaletteComplete={completeSlashPalette}
-      onRestoreQueued={(currentText) => restoreQueuedToPrompt({ restoreDraft: true, showHint: false, currentText })}
+      onRestoreQueued={restoreQueuedToPrompt}
+      hasQueuedMessages={Array.isArray(state.queued) && state.queued.length > 0}
+      hasMessages={hasUserMessages}
     />
   );
 

package/src/tui/app/core-memory-picker.mjs

@@ -39,20 +39,20 @@ export function createCoreMemoryPicker({
     });
     void store.memoryControl?.({ action: 'core', op: 'list', project_id: '*' }, { silent: true })
       .then(async (result) => {
-        // Memory on/off lives here too so /memory is a one-stop surface:
+        // The recap toggle lives here too so /memory is a one-stop surface:
         // toggle row + add row + curated entries.
-        const memory = (await store.getMemorySettings?.()) || { enabled: true };
-        const memoryOn = memory.enabled !== false;
+        const recap = (await store.getRecapSettings?.()) || { enabled: true };
+        const recapOn = recap.enabled !== false;
         const coreRows = parseMemoryCoreRows(result);
         const rows = [
           {
-            value: 'memory-toggle',
-            label: 'Memory',
-            meta: memoryOn ? 'On' : 'Off',
-            description: memoryOn
-              ? 'Background memory cycles on'
-              : 'Background memory cycles off',
-            _action: 'toggle-memory',
+            value: 'recap-toggle',
+            label: 'Recap',
+            meta: recapOn ? 'On' : 'Off',
+            description: recapOn
+              ? 'Background session recaps on'
+              : 'Background recaps off; core memory remains available',
+            _action: 'toggle-recap',
           },
           { value: 'core-add', label: 'Add Memory', description: 'store a new curated memory sentence', _action: 'add-core' },
           {
@@ -76,17 +76,17 @@ export function createCoreMemoryPicker({
           labelWidth: 12,
           footer: (item) => (item && item._action === 'core-entry' ? (item._summary || item._element || '') : ''),
           onSelect: (_value, item) => {
-            if (item?._action === 'toggle-memory') toggleMemoryEnabled();
+            if (item?._action === 'toggle-recap') toggleRecapEnabled();
             else if (item?._action === 'add-core') beginAddCoreMemory();
             else if (item?._action === 'core-list') openCoreMemoryListPicker(item._rows);
             else if (item?._line) store.pushNotice(item._line, 'info');
           },
           // Toggle rows also respond to ←/→ (matches settings/channels UX).
           onLeft: (item) => {
-            if (item?._action === 'toggle-memory') toggleMemoryEnabled();
+            if (item?._action === 'toggle-recap') toggleRecapEnabled();
           },
           onRight: (item) => {
-            if (item?._action === 'toggle-memory') toggleMemoryEnabled();
+            if (item?._action === 'toggle-recap') toggleRecapEnabled();
           },
           onCancel: closeMemoryCorePicker,
         });
@@ -137,14 +137,14 @@ export function createCoreMemoryPicker({
       });
   };
 
-  const toggleMemoryEnabled = async () => {
-    const memory = (await store.getMemorySettings?.()) || { enabled: true };
-    void Promise.resolve(store.setMemoryEnabled?.(!(memory.enabled !== false)))
+  const toggleRecapEnabled = async () => {
+    const recap = (await store.getRecapSettings?.()) || { enabled: true };
+    void Promise.resolve(store.setRecapEnabled?.(!(recap.enabled !== false)))
       .then((next) => {
-        if (!next) store.pushNotice('memory setting is busy', 'warn');
-        else store.pushNotice(`Memory ${next.enabled ? 'on' : 'off'}`, 'info');
+        if (!next) store.pushNotice('recap setting is busy', 'warn');
+        else store.pushNotice(`Recap ${next.enabled ? 'on' : 'off'}`, 'info');
       })
-      .catch((e) => store.pushNotice(`memory toggle failed: ${e?.message || e}`, 'error'))
+      .catch((e) => store.pushNotice(`recap toggle failed: ${e?.message || e}`, 'error'))
       .finally(() => openMemoryCorePicker());
   };