mixdog 1.2.2 → 1.2.4

package/src/standalone/session-tool-output.mjs

@@ -0,0 +1,82 @@
+import { encodeCatalogCursor } from '../runtime/agent/orchestrator/session/catalog-db/schema.mjs';
+import { truncateToolText } from '../runtime/shared/tool-primitives.mjs';
+import { summarizeToolResult } from '../runtime/shared/tool-result-summary.mjs';
+
+import { TOOL_OUTPUT_PAGE_BYTES, TOOL_OUTPUT_TAIL_BYTES } from '../runtime/shared/tool-output-budget.mjs';
+
+export const SESSION_TOOL_OUTPUT_BYTES = TOOL_OUTPUT_TAIL_BYTES;
+const MESSAGE_TEXT_LIMIT = 2000;
+const outputBytes = (value) => Buffer.byteLength(JSON.stringify(value), 'utf8');
+
+/** Keep catalog paging authoritative even when the output budget shortens a page. */
+export function sessionListOutput(page, limit) {
+  const raw = page.sessions;
+  const sessions = raw.slice(0, limit).map((row) => ({
+    id: row.id,
+    ...(row.title || row.preview ? { title: truncateToolText(row.title || row.preview, 160) } : {}),
+    ...(row.status ? { status: row.status } : {}),
+    ...(row.cwd ? { cwd: row.cwd } : {}),
+  }));
+  const result = { sessions, nextCursor: page.nextCursor ?? null };
+  for (;;) {
+    if (sessions.length < raw.length && sessions.length) {
+      result.nextCursor = encodeCatalogCursor(raw[sessions.length - 1]);
+    }
+    if (outputBytes(result) <= TOOL_OUTPUT_PAGE_BYTES) return result;
+    if (sessions.length <= 1) throw new Error('session: one catalog row exceeds the output budget');
+    sessions.pop();
+  }
+}
+
+function conversationItem(item, offset, textOffset) {
+  const row = { kind: item.kind, offset, ...(item.id != null ? { id: item.id } : {}) };
+  if (item.name) row.name = item.name;
+  if (item.status) row.status = item.status;
+  if (item.isError === true) row.isError = true;
+  let text = item.text || item.detail || item.label || '';
+  if (item.kind === 'tool') {
+    const value = item.rawResult ?? item.result ?? '';
+    const raw = typeof value === 'string' ? value : JSON.stringify(value);
+    text = raw || summarizeToolResult(item.name, item.args, raw, item.isError === true) || text;
+  }
+  if (text) {
+    // Conversation indentation is significant; do not trim code/prose like a title.
+    if (
+      textOffset > 0 &&
+      /[\uDC00-\uDFFF]/.test(text[textOffset] || '') &&
+      /[\uD800-\uDBFF]/.test(text[textOffset - 1])
+    )
+      throw new Error('session: text_offset splits a surrogate pair');
+    let end = Math.min(text.length, textOffset + MESSAGE_TEXT_LIMIT);
+    if (end < text.length && /[\uD800-\uDBFF]/.test(text[end - 1])) end--;
+    row.text = text.slice(textOffset, end);
+    if (end < text.length) row.nextTextOffset = end;
+  }
+  const attachments = item.attachments ?? item.imageRefs ?? item.images;
+  if (attachments?.length) row.attachments = attachments.length;
+  return row;
+}
+
+/** Service windows can be sticky/shared; enforce this tool call's limits locally. */
+export function sessionReadOutput(sessionId, range, { textOffset = 0, itemId } = {}) {
+  const byteLimit = range.offset === 0 && textOffset === 0 ? TOOL_OUTPUT_TAIL_BYTES : TOOL_OUTPUT_PAGE_BYTES;
+  const source = range.items;
+  if (itemId !== undefined && (source.length !== 1 || source[0].id !== itemId)) {
+    throw new Error('session: stale item position; read the tail again');
+  }
+  const items = source.map((item, index) =>
+    conversationItem(item, range.offset + source.length - index - 1, textOffset)
+  );
+  const result = {
+    sessionId,
+    offset: range.offset,
+    items,
+    nextOffset: null,
+  };
+  for (;;) {
+    result.nextOffset = range.hasOlder || items.length < source.length ? range.offset + items.length : null;
+    if (outputBytes(result) <= byteLimit) return result;
+    if (items.length <= 1) throw new Error('session: one transcript item exceeds the output budget');
+    items.shift();
+  }
+}

package/src/tui/App.jsx

@@ -21,6 +21,7 @@ import { useApp, useStdin, useStdout } from 'ink';
 import { useSession } from './hooks/useSession.mjs';
 import { pickFolder } from '../standalone/folder-dialog.mjs';
 import { deriveSlashPalette } from './app/slash-palette.mjs';
+import { createBtwController } from './app/btw-controller.mjs';
 import { skillMentionQuery, useSkillMentionSkills } from './app/skill-mention-palette.mjs';
 import { shouldSupersedePanelEpoch, supersedePanelEpoch } from './app/panel-epoch.mjs';
 import { createPanelSurface } from './app/panel-surface.mjs';
@@ -152,6 +153,24 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
   livePickerRef.current = picker;
   const [contextPanel, setContextPanel] = useState(null);
   const [usagePanel, setUsagePanel] = useState(null);
+  const [btwPanel, setBtwPanel] = useState(null);
+  const btwRef = useRef(null);
+  const sessionIdRef = useRef('');
+  sessionIdRef.current = state.sessionId || '';
+  if (!btwRef.current) {
+    btwRef.current = createBtwController({
+      getStore: () => store,
+      setPanel: setBtwPanel,
+      getSessionId: () => sessionIdRef.current,
+    });
+  }
+  const btw = btwRef.current;
+  // A side answer belongs to the conversation it was asked in: drop it on a
+  // session change (new/resume/clear/switch) and cancel it on unmount.
+  useEffect(() => {
+    btw.sync();
+  }, [btw, state.sessionId]);
+  useEffect(() => () => btw.dispose(), [btw]);
   // OWNING LAYER (app/panel-surface.mjs): the three sinks above are handed over
   // exactly once and never leave that module. Every panel factory below gets
   // `surface` instead, so painting or delegating without a claim that proves
@@ -310,6 +329,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
     setSettingsPrompt,
     setOnboardingActive,
     closeUsagePanel,
+    btw,
     oauthSubmitRef,
     clearModelCaches,
     onboardingRef,
@@ -518,6 +538,8 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
       usagePanel,
       closeUsagePanel,
       contextPanel,
+      btwPanel,
+      closeBtwPanel: btw.close,
       installPastedImages,
       clearPastedImagesSnapshot,
       registerPastedImage,
@@ -650,6 +672,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
     toolApproval: !!toolApproval,
     contextPanel: !!contextPanel,
     usagePanel: !!usagePanel,
+    btwPanel: !!btwPanel,
     providerPrompt: !!providerPrompt,
     settingsPrompt: !!settingsPrompt,
   };
@@ -711,6 +734,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
     picker,
     contextPanel,
     usagePanel,
+    btwPanel,
     slashPaletteOpen,
     tuiReady,
     state,
@@ -822,6 +846,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
     activeSlashQuery,
     activeTools,
     agentRevision,
+    btwPanel,
     cancelProviderPrompt,
     cancelSettingsPrompt,
     cancelSlashPalette,

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

@@ -10,9 +10,12 @@
 import { theme } from '../../theme.mjs';
 import { toolApprovalDescription } from '../app-format.mjs';
 import { Picker } from '../../components/Picker.jsx';
+import { QuestionPanel } from '../../components/QuestionPanel.jsx';
+import { questionsOf } from '../../components/question-panel-model.mjs';
 import { SlashCommandPalette } from '../../components/SlashCommandPalette.jsx';
 import { ContextPanel } from '../../components/ContextPanel.jsx';
 import { UsagePanel } from '../../components/UsagePanel.jsx';
+import { BtwPanel } from '../../components/BtwPanel.jsx';
 import { TextEntryPanel } from '../../components/TextEntryPanel.jsx';
 import { textEntryClearsByEmpty } from '../text-entry-policy.mjs';
 import { withPickerEnterLatch } from '../picker-enter-latch.mjs';
@@ -24,7 +27,23 @@ const SKILL_PALETTE_TEXT = {
   help: '↑/↓ select · Enter insert · Esc cancel',
 };
 
-function renderToolApproval({ toolApproval, store, frameColumns, expandedOptionPanel }) {
+function renderToolApproval({ toolApproval, store, frameColumns, expandedOptionPanel, floatingPanelRows }) {
+  if (toolApproval.kind === 'question') {
+    return (
+      <QuestionPanel
+        key={toolApproval.id}
+        questions={questionsOf(toolApproval)}
+        columns={frameColumns}
+        rows={floatingPanelRows}
+        onSubmit={(answers) =>
+          store.resolveToolApproval?.(toolApproval.id, { approved: true, reason: 'answered by user', answers })
+        }
+        onDismiss={() =>
+          store.resolveToolApproval?.(toolApproval.id, { approved: false, reason: 'dismissed by user' })
+        }
+      />
+    );
+  }
   const resolve = (approved) => {
     store.resolveToolApproval?.(toolApproval.id, {
       approved,
@@ -144,6 +163,7 @@ export function renderFloatingPanel(ctx) {
     slashPaletteOpen,
     toolApproval,
     usagePanel,
+    btwPanel,
   } = ctx;
   if (toolApproval) return renderToolApproval(ctx);
   if (picker) return renderPicker(ctx);
@@ -227,5 +247,10 @@ export function renderFloatingPanel(ctx) {
       />
     );
   }
+  if (btwPanel) {
+    return (
+      <BtwPanel panel={btwPanel} columns={frameColumns} panelRows={floatingPanelRows} themeEpoch={ctx.state?.themeEpoch || 0} />
+    );
+  }
   return null;
 }

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

@@ -138,6 +138,7 @@ export function renderAppView(ctx) {
       thinkingActiveSince={liveSpinner?.thinkingSegmentStartedAt ?? 0}
       thinkingMs={liveSpinner?.thinkingAccumulatedMs ?? 0}
       effort={state.effort || ''}
+      quiet={liveSpinner?.quiet ?? null}
       hasActiveTools={!!activeTools?.web_search?.count}
       paused={!!toolApproval}
       interruptible={!!(state.busy && state.spinner?.active)}
@@ -230,7 +231,7 @@ export function renderAppView(ctx) {
         ) : null}
         <StatusLine
           sessionId={state.sessionId}
-          clientHostPid={state.ownerClientHostPid || state.clientHostPid}
+          clientHostPid={state.clientHostPid}
           provider={state.provider}
           model={state.model}
           effort={state.effort}

package/src/tui/app/btw-controller.mjs

@@ -0,0 +1,118 @@
+/**
+ * app/btw-controller.mjs — the transient `/btw` side-question panel.
+ *
+ * The answer lives only in this panel (never the transcript). `ask` replaces
+ * any existing panel, `close` (Esc) cancels a pending request, and a result
+ * that arrives after a replace/close is ignored via the request sequence.
+ */
+import { measureMarkdownRenderedRows } from '../markdown/measure-rendered-rows.mjs';
+
+export const BTW_USAGE_HINT = 'usage: /btw <question>';
+// Border (2) + header (1) + footer (1).
+export const BTW_CHROME_ROWS = 4;
+const BTW_MAX_BODY_ROWS = 10;
+
+/** Rendered row count of the answer body (the scrollable content height). */
+export function btwContentRows(panel, columns) {
+  const body =
+    panel.status === 'done'
+      ? measureMarkdownRenderedRows(panel.text, Math.max(1, columns - 4))
+      : String(panel.text || '').split('\n').length;
+  return Math.max(1, body);
+}
+
+export function btwPanelRows(panel, columns) {
+  if (!panel) return 0;
+  return BTW_CHROME_ROWS + Math.min(BTW_MAX_BODY_ROWS, btwContentRows(panel, columns));
+}
+
+/** Largest scroll offset for `total` content rows shown through `visible` rows. */
+export function btwScrollMax(total, visible) {
+  return Math.max(0, total - Math.max(1, visible));
+}
+
+/** Next scroll offset for a PageUp/PageDown key (other keys leave it unchanged). */
+export function btwScrollOffset(key, offset, visible, total) {
+  const max = btwScrollMax(total, visible);
+  const page = Math.max(1, visible - 1);
+  if (key.pageUp) return Math.max(0, Math.min(max, offset) - page);
+  if (key.pageDown) return Math.min(max, offset + page);
+  return Math.min(max, offset);
+}
+
+/**
+ * Each request is bound to the session it was asked in. A settlement whose
+ * session no longer matches is ignored; `sync` (session change) and `dispose`
+ * (unmount) cancel a pending request for its originating session.
+ */
+export function createBtwController({ getStore, setPanel, getSessionId = () => '' }) {
+  let seq = 0;
+  let pending = null; // { sessionId, dispatched } while a request is queued or in flight
+  let origin = null; // session the visible panel was asked in
+
+  const cancelPending = () => {
+    if (!pending) return;
+    const { sessionId, dispatched } = pending;
+    pending = null;
+    // Not dispatched yet: dropping `pending` stops the queued request, so
+    // there is nothing to cancel (a cancel sent first would not hit it).
+    if (!dispatched) return;
+    try {
+      const result = getStore().cancelSide?.(sessionId);
+      if (result?.catch) void result.catch(() => {});
+    } catch {
+      /* best-effort cancel */
+    }
+  };
+
+  const ask = (question) => {
+    cancelPending();
+    const id = ++seq;
+    const sessionId = getSessionId();
+    const request = { sessionId, dispatched: false };
+    pending = request;
+    origin = sessionId;
+    setPanel({ question, status: 'pending', text: '' });
+    const settle = (next) => {
+      if (id !== seq || getSessionId() !== sessionId) return;
+      pending = null;
+      setPanel({ question, ...next });
+    };
+    Promise.resolve()
+      .then(() => {
+        // askSide runs against the store's current session, so only dispatch
+        // while this ask is still live and still in its origin session.
+        if (pending !== request || id !== seq || getSessionId() !== sessionId) {
+          if (pending === request) pending = null;
+          return undefined; // dropped, never sent; `settle` ignores it (stale id/session)
+        }
+        request.dispatched = true;
+        return getStore().askSide(question);
+      })
+      .then(
+        (result) => settle({ status: 'done', text: String(result?.text ?? '') }),
+        (error) => settle({ status: 'error', text: String(error?.message || error || 'side question failed') })
+      );
+  };
+
+  const close = () => {
+    cancelPending();
+    seq += 1;
+    origin = null;
+    setPanel(null);
+  };
+
+  /** Session changed: a panel from another conversation is cancelled and cleared. */
+  const sync = () => {
+    if (origin !== null && getSessionId() !== origin) close();
+  };
+
+  /** Unmount: cancel without touching React state. */
+  const dispose = () => {
+    cancelPending();
+    seq += 1;
+    origin = null;
+  };
+
+  return { ask, close, sync, dispose };
+}

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

@@ -37,6 +37,7 @@ export function createAppPickers({
   setSettingsPrompt,
   setOnboardingActive,
   closeUsagePanel,
+  btw,
   oauthSubmitRef,
   clearModelCaches,
   onboardingRef,
@@ -207,6 +208,7 @@ export function createAppPickers({
     normalizeSlashCommandName,
     surface,
     closeUsagePanel,
+    btw,
     openModelPicker: (...a) => openModelPicker(...a),
     modelSwitchNotice,
     openWebSearchPicker: (...a) => openWebSearchPicker(...a),

package/src/tui/app/provider-setup/provider-items.mjs

@@ -77,6 +77,14 @@ export function buildProviderItems(setup) {
       _authenticated: p.authenticated,
     });
   }
+  if (setup.managedByClient === true) {
+    for (const p of setup.local || []) {
+      providerItems.push({
+        value: `local:${p.id}`, label: p.name, meta: providerStatusLabel(p), description: '',
+        _type: 'local', _providerId: p.id, _providerName: p.name, _provider: p,
+      });
+    }
+  }
   providerItems.sort((a, b) => {
     const rank = providerItemRank(a) - providerItemRank(b);
     if (rank !== 0) return rank;

package/src/tui/app/provider-setup-picker.mjs

@@ -54,7 +54,7 @@ export function createProviderSetupPicker({
     });
     try {
       await new Promise((resolve) => setTimeout(resolve, 0));
-      return await store.getProviderSetup();
+      return await store.getProviderSetup(options.forceRefresh ? { force: true } : undefined);
     } catch (e) {
       store.pushNotice(`providers failed: ${e?.message || e}`, 'error');
       return null;
@@ -98,6 +98,9 @@ export function createProviderSetupPicker({
       });
     }
     items.push(...buildProviderItems(setup));
+    if (setup.managedByClient === true) {
+      items.push({ value: 'refresh-client-providers', label: 'Refresh', _type: 'refresh-client-providers' });
+    }
 
     const flow = {
       store,
@@ -127,10 +130,13 @@ export function createProviderSetupPicker({
 
     flow.paint({
       title: options.title || 'Providers',
-      description: options.description || 'Choose a provider. Enter opens provider actions.',
+      description: setup.managedByClient === true
+        ? 'Manage provider sign-ins and accounts in the local desktop window. Refresh to update availability.'
+        : options.description || 'Choose a provider. Enter opens provider actions.',
       footer: providerFooter,
       footerGapRows: 1,
-      help: options.confirmBar ? undefined : '↑/↓ Select · Enter Open · Esc Back',
+      help: options.confirmBar ? undefined : setup.managedByClient === true
+        ? '↑/↓ Select · Enter Refresh · Esc Back' : '↑/↓ Select · Enter Open · Esc Back',
       indexMode: 'always',
       labelWidth: 18,
       metaWidth: 12,
@@ -142,6 +148,12 @@ export function createProviderSetupPicker({
         if (item?._providerId) flow.rememberProviderSelection(item);
       },
       onSelect: (_value, item) => {
+        if (setup.managedByClient === true && item._type !== 'continue') {
+          if (item._type === 'refresh-client-providers') {
+            void openProviderSetupPicker({ ...options, preloadedSetup: null, forceRefresh: true });
+          }
+          return;
+        }
         // In-flow navigation (Enter on a provider row): the flow keeps the
         // surface, so clear-and-continue — own.close() would supersede this
         // very flow and paintProviders would then reject the action panel the

package/src/tui/app/shell-layout/row-budgets.mjs

@@ -5,7 +5,9 @@
  */
 import { isLiveSpinnerMetaVisible } from '../live-spinner-visibility.mjs';
 import { promptContentRows, wrappedDetailRows, queuedBandRows } from '../text-layout.mjs';
+import { questionPanelRows, questionsOf } from '../../components/question-panel-model.mjs';
 import { CORE_MULTILINE_TEXT_ENTRY_KINDS } from '../panel-signature.mjs';
+import { btwPanelRows } from '../btw-controller.mjs';
 
 const SCROLL_HINT_ROWS = 0;
 const LIVE_STATUS_ROWS = 0;
@@ -114,20 +116,25 @@ function floatingPanelBudget({
   picker,
   contextPanel,
   usagePanel,
+  btwPanel,
   slashPaletteOpen,
   hasTextEntryPrompt,
   TEXT_ENTRY_ROWS,
   OPTION_PANEL_EXTRA_ROWS,
   maxFloatingPanelRows,
+  frameColumns,
 }) {
   let desiredFloatingPanelRows = 0;
-  if (toolApproval) desiredFloatingPanelRows = PANEL_CHROME_ROWS + 2 + OPTION_PANEL_EXTRA_ROWS;
+  if (toolApproval?.kind === 'question' && questionsOf(toolApproval).length > 0) {
+    desiredFloatingPanelRows = questionPanelRows(questionsOf(toolApproval), frameColumns);
+  } else if (toolApproval) desiredFloatingPanelRows = PANEL_CHROME_ROWS + 2 + OPTION_PANEL_EXTRA_ROWS;
   else if (picker?.fillAvailable) desiredFloatingPanelRows = maxFloatingPanelRows;
   else if (picker) desiredFloatingPanelRows = PANEL_BASE_ROWS + OPTION_PANEL_EXTRA_ROWS;
   else if (contextPanel) desiredFloatingPanelRows = PANEL_BASE_ROWS + OPTION_PANEL_EXTRA_ROWS + 3;
   else if (usagePanel) desiredFloatingPanelRows = PANEL_BASE_ROWS + OPTION_PANEL_EXTRA_ROWS;
   else if (slashPaletteOpen) desiredFloatingPanelRows = SLASH_PALETTE_ROWS;
   else if (hasTextEntryPrompt) desiredFloatingPanelRows = TEXT_ENTRY_ROWS;
+  else if (btwPanel) desiredFloatingPanelRows = btwPanelRows(btwPanel, frameColumns);
   const floatingPanelRows = desiredFloatingPanelRows > 0 ? Math.min(desiredFloatingPanelRows, maxFloatingPanelRows) : 0;
   // Give the list every content row the panel exposes. The panel already grew
   // by OPTION_PANEL_EXTRA_ROWS; previously that growth was subtracted back out
@@ -174,6 +181,7 @@ export function computeRowBudgets({
   picker,
   contextPanel,
   usagePanel,
+  btwPanel,
   slashPaletteOpen,
 }) {
   const { textEntryPrompt, hasTextEntryPrompt, hasFloatingPanel, expandedOptionPanel, inputBoxHidden } = surfaces;
@@ -211,11 +219,13 @@ export function computeRowBudgets({
     picker,
     contextPanel,
     usagePanel,
+    btwPanel,
     slashPaletteOpen,
     hasTextEntryPrompt,
     TEXT_ENTRY_ROWS: textEntry.TEXT_ENTRY_ROWS,
     OPTION_PANEL_EXTRA_ROWS,
     maxFloatingPanelRows,
+    frameColumns,
   });
   const rows = {
     floatingPanelRows: panel.floatingPanelRows,

package/src/tui/app/shell-layout/surfaces.mjs

@@ -10,6 +10,7 @@ export function deriveSurfaces({
   picker,
   contextPanel,
   usagePanel,
+  btwPanel,
   slashPaletteOpen,
   tuiReady,
   state,
@@ -24,7 +25,8 @@ export function deriveSurfaces({
     contextPanel ||
     usagePanel ||
     slashPaletteOpen ||
-    hasTextEntryPrompt
+    hasTextEntryPrompt ||
+    btwPanel
   );
   const expandedOptionPanel = !!(toolApproval || picker || contextPanel || usagePanel || hasTextEntryPrompt);
   if (panelTransitionRef.current.signature.includes('picker:project') && !picker) {

package/src/tui/app/slash-commands.mjs

@@ -15,6 +15,12 @@ export const SLASH_COMMANDS = [
     description: 'Switch working directory (project)',
   },
   { name: 'compact', usage: '/compact', description: 'Compact older conversation context' },
+  {
+    name: 'btw',
+    usage: '/btw',
+    params: '<question>',
+    description: 'Ask a quick side question without interrupting the current work',
+  },
   {
     name: 'goal',
     usage: '/goal',
@@ -30,9 +36,18 @@ export const SLASH_COMMANDS = [
   { name: 'resume', usage: '/resume', params: '[id]', description: 'Resume a saved chat' },
   { name: 'context', usage: '/context', description: 'Show current context surface' },
   {
-    name: 'inherit',
-    usage: '/inherit',
-    description: 'Carry this conversation into a new session on the current model',
+    name: 'shells',
+    usage: '/shells',
+    params: '[release <task_id> [--confirm]]',
+    description: 'List shells; release one whose termination is unconfirmed',
+  },
+  {
+    name: 'fork',
+    usage: '/fork',
+    aliases: ['inherit'],
+    aliasUsage: ['inherit'],
+    showAliasUsage: false,
+    description: 'Fork this conversation into a new session on the current model',
   },
   { name: 'usage', usage: '/usage', params: '[refresh]', description: 'Show total provider quota / balance' },
   { name: 'model', usage: '/model', params: '[name|refresh]', description: 'Switch model for subsequent turns' },
@@ -109,6 +124,7 @@ export function overlayBlocksGlobalTranscriptScroll(owner = {}) {
     owner.toolApproval ||
     owner.contextPanel ||
     owner.usagePanel ||
+    owner.btwPanel ||
     owner.providerPrompt ||
     owner.settingsPrompt
   );

package/src/tui/app/slash-dispatch/session-commands.mjs

@@ -1,8 +1,9 @@
 // slash-dispatch/session-commands.mjs
 // Slash commands that act on the session itself: clear/new, compact, goal,
-// resume, inherit, doctor and quit. Busy guards refuse the destructive ones
+// resume, fork (alias inherit), doctor and quit. Busy guards refuse the destructive ones
 // while a turn or session command is running.
 import { presentErrorText } from '../../../runtime/shared/err-text.mjs';
+import { BTW_USAGE_HINT } from '../btw-controller.mjs';
 
 function compactFailureNotice(error) {
   if (error == null || String(error).trim() === '') return 'Compact failed.';
@@ -63,6 +64,18 @@ export const sessionCommands = {
     return true;
   },
 
+  // Side question: allowed mid-turn; never queued, steered, or interrupting.
+  btw(ctx, arg) {
+    const { store, deps } = ctx;
+    const question = String(arg || '').trim();
+    if (!question) {
+      store.pushNotice(BTW_USAGE_HINT, 'warn');
+      return true;
+    }
+    deps.btw.ask(question);
+    return true;
+  },
+
   goal(ctx, arg) {
     const { store } = ctx;
     void Promise.resolve(store.goalControl?.({ command: arg }))
@@ -91,18 +104,67 @@ export const sessionCommands = {
     return true;
   },
 
-  inherit(ctx) {
+  fork(ctx, _arg, rawName) {
     const { state, store } = ctx;
-    if (state.busy) return refuseWhileBusy(store, 'inherit');
+    if (state.busy) return refuseWhileBusy(store, rawName === 'inherit' ? 'inherit' : 'fork');
     void Promise.resolve(store.inheritSession?.())
       .then((result) => {
         if (!result) {
-          store.pushNotice('nothing to inherit', 'warn');
+          store.pushNotice('nothing to fork', 'warn');
           return;
         }
-        store.pushNotice(`inherited ${result.messages} messages into ${result.sessionId}`, 'info');
+        store.pushNotice(`forked ${result.messages} messages into ${result.sessionId}`, 'info');
       })
-      .catch((e) => store.pushNotice(`inherit failed: ${e?.message || e}`, 'error'));
+      .catch((e) => store.pushNotice(`fork failed: ${e?.message || e}`, 'error'));
+    return true;
+  },
+
+  // /shells — this session's shells, each marked running or "termination
+  // unconfirmed". `/shells release <id>` explains what releasing means and
+  // asks for `--confirm`; only then is the workspace hold dropped.
+  shells(ctx, arg) {
+    const { store } = ctx;
+    const [action, taskId, flag] = String(arg || '')
+      .trim()
+      .split(/\s+/)
+      .filter(Boolean);
+    if (!action) {
+      void Promise.resolve(store.listShellJobs?.())
+        .then((result) => {
+          const jobs = Array.isArray(result?.jobs) ? result.jobs : [];
+          if (!jobs.length) {
+            store.pushNotice('No shells are running.', 'info');
+            return;
+          }
+          const lines = jobs.map(
+            (job) =>
+              `${job.taskId}  ${job.terminationUnconfirmed ? 'termination unconfirmed' : 'running'}  ${job.command}`
+          );
+          const held = jobs.some((job) => job.terminationUnconfirmed);
+          if (held) lines.push('Release a held shell with /shells release <task_id>.');
+          store.pushNotice(lines.join('\n'), held ? 'warn' : 'info');
+        })
+        .catch((error) => store.pushNotice(`Couldn’t list shells: ${error?.message || error}`, 'error'));
+      return true;
+    }
+    if (action !== 'release' || !taskId) {
+      store.pushNotice('usage: /shells [release <task_id> [--confirm]]', 'warn');
+      return true;
+    }
+    if (flag !== '--confirm') {
+      store.pushNotice(
+        `Releasing ${taskId} unlocks its folder although its processes may still be running. To proceed, run /shells release ${taskId} --confirm`,
+        'warn'
+      );
+      return true;
+    }
+    void Promise.resolve(store.releaseShellJob?.(taskId))
+      .then((result) =>
+        result?.released
+          ? store.pushNotice(`Released ${taskId}.`, 'info')
+          : store.pushNotice(`Couldn’t release ${taskId}: ${result?.error || 'unavailable'}`, 'warn')
+      )
+      .catch((error) => store.pushNotice(`Couldn’t release ${taskId}: ${error?.message || error}`, 'error'));
     return true;
   },
 

package/src/tui/app/use-global-key-input/approval-shortcut.mjs

@@ -0,0 +1,12 @@
+// Global tool-approval shortcuts: Esc/d/n deny, a/y approve. Returns the
+// decision to resolve with, or null. Question approvals (ask_user) are
+// answered only inside QuestionPanel, so typed letters and Esc never reach here.
+export function approvalShortcutDecision(toolApproval, input, key) {
+  if (!toolApproval || toolApproval.kind === 'question') return null;
+  const value = String(input || '')
+    .trim()
+    .toLowerCase();
+  if (key.escape || value === 'd' || value === 'n') return { approved: false, reason: 'denied by user' };
+  if (value === 'a' || value === 'y') return { approved: true, reason: 'approved by user' };
+  return null;
+}