mixdog 1.2.1 → 1.2.3

package/src/standalone/session-service/agent-tree/agent-cancel.mjs

@@ -1,9 +1,29 @@
 // agent-tree/agent-cancel.mjs
 // Cancelling an agent subtree: descendants first, then a durable canonical
 // close of the session itself. Concurrent cancels of one id share a run.
-import { cancelBackgroundTasks } from '../../../runtime/shared/background-tasks.mjs';
+import {
+  cancelBackgroundTask,
+  cancelBackgroundTasks,
+  listBackgroundTasks,
+} from '../../../runtime/shared/background-tasks.mjs';
 
-export function createAgentCancellation({ registry, rehydrateAgentSessions, sessionOwner, entryForSession, log }) {
+// Cancel the running Agent task(s) bound to this session itself (owned by its
+// parent) BEFORE the session closes, so the owner hears `cancelled` with the
+// turn's partial output instead of the closed turn failing the task.
+function cancelOwnAgentTasks(sessionId, reason) {
+  for (const row of listBackgroundTasks({ surface: 'agent' })) {
+    if (row.status === 'running' && row.sessionId === sessionId) cancelBackgroundTask(row.task_id, reason);
+  }
+}
+
+export function createAgentCancellation({
+  registry,
+  rehydrateAgentSessions,
+  sessionOwner,
+  entryForSession,
+  log,
+  rememberCancelTranscript,
+}) {
   const agentCancelRuns = new Map();
 
   /** The runtime entry that can close this descriptor: the live owner, else a
@@ -39,6 +59,7 @@ export function createAgentCancellation({ registry, rehydrateAgentSessions, sess
       });
       const children = registry.childrenOf(id);
       await Promise.all(children.map((childId) => cancelAgentTree(childId, reason)));
+      cancelOwnAgentTasks(id, reason);
       const descriptor = registry.get(id);
       if (!descriptor) return children.length > 0;
       if (descriptor.closed) return true;
@@ -47,6 +68,16 @@ export function createAgentCancellation({ registry, rehydrateAgentSessions, sess
       if (typeof closeCanonical !== 'function') {
         throw new TypeError('session runtime must implement closeCanonicalSession');
       }
+      // The close clears the transcript: capture a running turn's transcript
+      // first so the cancelled turn still hands off its partial output.
+      if (descriptor.status === 'running') {
+        try {
+          const { messages } = await entry.runtime.readModelMessages(0);
+          rememberCancelTranscript(id, messages);
+        } catch (error) {
+          log(`agent cancel transcript read failed session=${id}: ${error?.message || error}`);
+        }
+      }
       const closed = await closeCanonical.call(entry.runtime, reason);
       if (closed !== true) throw new Error(`agent session ${id} could not be durably closed`);
       descriptor.closed = true;

package/src/standalone/session-service/agent-tree/agent-turns.mjs

@@ -12,16 +12,23 @@ export function createAgentTurns({
   retainUnwatched,
   createSession,
   takeWatchdogStop,
+  takeCancelTranscript,
 }) {
   const createAgentChild = createAgentChildFactory({ registry, rehydrateAgentSessions, createSession });
 
-  // The progress watchdog stopped the turn: rethrow its stall error carrying
-  // the assistant text the turn produced, so the owner still gets a partial
-  // result.
-  async function watchdogStopError(runtime, error, messageStart) {
-    const { messages } = await runtime.readModelMessages(messageStart);
-    const partial = partialHandoffTextFromSession({ messages });
-    if (partial) error.partialHandoff = partial;
+  // The turn was stopped (progress watchdog or cancellation): rethrow its error
+  // carrying the assistant text the turn produced, so the owner still gets a
+  // partial result. A cancel that closed the session captured the transcript
+  // before the close cleared it.
+  async function withPartialHandoff(runtime, sessionId, error, messageStart) {
+    try {
+      const captured = takeCancelTranscript(sessionId);
+      const messages = captured
+        ? captured.slice(messageStart)
+        : (await runtime.readModelMessages(messageStart)).messages;
+      const partial = partialHandoffTextFromSession({ messages });
+      if (partial) error.partialHandoff = partial;
+    } catch {}
     return error;
   }
 
@@ -44,6 +51,7 @@ export function createAgentTurns({
     }
     // A stop left over from an earlier turn must not relabel this one.
     takeWatchdogStop(sessionId);
+    takeCancelTranscript(sessionId);
     // Transcript length before this turn: where a watchdog stop's partial
     // output starts.
     const { messageCount: messageStart } = await entry.runtime.readModelMessages(Number.MAX_SAFE_INTEGER);
@@ -64,9 +72,16 @@ export function createAgentTurns({
         throw new Error(String(detail.error || 'agent session turn failed'));
       }
       if (detail?.status === 'cancelled') {
-        const watchdogStop = takeWatchdogStop(sessionId);
-        if (watchdogStop) throw await watchdogStopError(entry.runtime, watchdogStop, messageStart);
-        throw new Error('agent session turn cancelled');
+        const stop = takeWatchdogStop(sessionId) || new Error('agent session turn cancelled');
+        throw await withPartialHandoff(entry.runtime, sessionId, stop, messageStart);
+      }
+      // Only a completed turn has a result; a rejected submission (session
+      // closing/terminal, steering persist failure) or any unknown status is a
+      // failure, never an empty completion.
+      if (detail?.status !== 'done' && detail?.status !== 'completed') {
+        const status = String(detail?.status || 'unknown');
+        const reason = String(detail?.reason || detail?.error || '').trim();
+        throw new Error(`agent turn ${status}${reason ? `: ${reason}` : ''}`);
       }
       const result = detail?.result || { content: '' };
       descriptor.status = 'idle';
@@ -81,6 +96,7 @@ export function createAgentTurns({
       descriptor.stage = descriptor.status;
       throw error;
     } finally {
+      takeCancelTranscript(sessionId);
       descriptor.updatedAt = Date.now();
       retainUnwatched(entry, 'agent child idle');
     }

package/src/standalone/session-service/agent-tree.mjs

@@ -37,6 +37,16 @@ export function createAgentTree({
     watchdogStops.delete(sessionId);
     return error;
   };
+  // Transcripts of running turns captured by a cancel just before it closes
+  // (and clears) the session, so the cancelled turn still reports the output
+  // it produced.
+  const cancelTranscripts = new Map();
+  const rememberCancelTranscript = (sessionId, messages) => cancelTranscripts.set(sessionId, messages);
+  const takeCancelTranscript = (sessionId) => {
+    const messages = cancelTranscripts.get(sessionId) || null;
+    cancelTranscripts.delete(sessionId);
+    return messages;
+  };
   function getSessionProgressSnapshot(sessionId) {
     const runtime = sessionOwner(sessionId)?.runtime;
     if (typeof runtime?.getTurnLiveness !== 'function') return null;
@@ -58,6 +68,7 @@ export function createAgentTree({
     retainUnwatched,
     createSession,
     takeWatchdogStop,
+    takeCancelTranscript,
   });
   const { cancelAgentTree, cancelAgentDescendants } = createAgentCancellation({
     registry,
@@ -65,6 +76,7 @@ export function createAgentTree({
     sessionOwner,
     entryForSession,
     log,
+    rememberCancelTranscript,
   });
 
   /** The descriptor as callers see it: status from the live runtime when one

package/src/standalone/session-service/quota-resume.mjs

@@ -8,6 +8,8 @@
 // again, and the session's own lane runs the retry under the entry's
 // generation. Overdue entries run as soon as the scheduler starts.
 
+import { isAgentOnlySession } from '../../runtime/shared/quota-resume-store.mjs';
+
 /** A still-exhausted reading is re-taken once, this much later. */
 export const QUOTA_RESUME_RETRY_MS = 5 * 60_000;
 /** A busy session is re-checked this much later, without spending an attempt. */
@@ -30,6 +32,12 @@ async function resumeDueEntry(entry, { store, materializeSession, readQuotaUsabl
     return 'unavailable';
   }
   if (!isCurrent(store, entry)) return 'cancelled';
+  // A delegated agent child never owns a resume (the Lead decides retries), so
+  // an entry persisted for one never fires, whatever wrote it.
+  if (isAgentOnlySession({ id: sessionId, ...runtime?.session })) {
+    store.cancelQuotaResumeEntry(sessionId, { generation });
+    return 'agent-session';
+  }
   let usable = false;
   try {
     usable = await readQuotaUsable(entry.provider, entry.model);

package/src/standalone/session-service/retention/busy.mjs

@@ -28,6 +28,12 @@ export function createBusyTracker({ sessions, currentSessionId }) {
     // reaches a terminal state and its completion can be delivered back into
     // this session.
     if (sessionId && hasActiveBackgroundTasks({ callerSessionId: sessionId })) return true;
+    return sessionTurnBusy(entry);
+  }
+
+  // A turn is running (provider stream / tool call / queued input). Background
+  // tasks are deliberately not counted: they run outside the heap-churning turn.
+  function sessionTurnBusy(entry) {
     if (typeof entry?.busy === 'boolean') return entry.busy;
     try {
       return updateEntryBusy(entry, entry.runtime.getState?.() || {});
@@ -46,5 +52,13 @@ export function createBusyTracker({ sessions, currentSessionId }) {
     return count;
   }
 
-  return { stateBusy, updateEntryBusy, sessionBusy, liveBusyCount };
+  function liveTurnBusyCount() {
+    let count = 0;
+    for (const entry of sessions) {
+      if (sessionTurnBusy(entry)) count += 1;
+    }
+    return count;
+  }
+
+  return { stateBusy, updateEntryBusy, sessionBusy, liveBusyCount, liveTurnBusyCount };
 }

package/src/standalone/session-service/session-calls/session-action.mjs

@@ -2,10 +2,17 @@
 // The generic runtime-action lane (read / configure allowlists) and the
 // session catalog listing.
 import { SESSION_CONFIGURE_ACTION_SET, SESSION_READ_ACTION_SET } from '../../session-protocol.mjs';
+import { annotateSpan, markPhase } from '../../../runtime/shared/slow-span.mjs';
 import { sanitizeForWire } from '../../session-wire-values.mjs';
 
 /** Reads a session without a live runtime answers from disk (readStoredReview). */
-const STORED_REVIEW_ACTIONS = new Set(['getTurnReviewDiff', 'getSessionReviewDiff', 'getTurnChanges']);
+const STORED_REVIEW_ACTIONS = new Set([
+  'getTurnReviewDiff',
+  'getSessionReviewDiff',
+  'getTurnChanges',
+  'getSessionReviewFilePatch',
+  'getTurnReviewFilePatch',
+]);
 
 /** One compact description of an action result for the daemon log, never the payload itself. */
 function resultSummary(value) {
@@ -44,7 +51,8 @@ export function createSessionActionCalls(ctx) {
     assertAvailable();
     if (value === null) throw new Error(`session ${id} is not available`);
     log(`session action ${name} session=${id} result=${resultSummary(value)} (stored)`);
-    return {
+    markPhase('load');
+    const result = {
       value: sanitizeForWire(value) ?? null,
       sessionId: id,
       reservedOnly: false,
@@ -52,6 +60,8 @@ export function createSessionActionCalls(ctx) {
       unchanged: true,
       ...(Number.isInteger(baseRevision) ? { revision: baseRevision } : {}),
     };
+    markPhase('project');
+    return result;
   }
 
   async function runSessionAction(
@@ -62,6 +72,7 @@ export function createSessionActionCalls(ctx) {
     const id = String(sessionId || '');
     if (!id) throw new TypeError('sessionId is required');
     const name = requireSessionAction(action, allowedActions);
+    annotateSpan(name);
     // Opening an earlier session asks for its review right away; loading the
     // whole runtime for that held the review bar (and the pane's reveal) for
     // seconds.
@@ -72,7 +83,9 @@ export function createSessionActionCalls(ctx) {
     assertAvailable(entry);
     const target = entry.runtime[name];
     if (typeof target !== 'function') throw new TypeError(`session action ${name} is unavailable`);
+    markPhase('load');
     const value = await target.apply(entry.runtime, Array.isArray(args) ? args : []);
+    markPhase('action');
     if (name === 'setCwd' && value) {
       try {
         const projects = await loadProjectStore();
@@ -89,11 +102,13 @@ export function createSessionActionCalls(ctx) {
     // Still unwatched: keep it on the retention clock exactly like a runtime
     // released by its view, so an untouched load cannot leak past the idle window.
     retainUnwatched(entry);
-    return {
+    const result = {
       value: sanitizeForWire(value) ?? null,
       sessionId: responseSessionId(entry, id),
       ...bodyForClient(step, Number.isInteger(baseRevision) ? baseRevision : null),
     };
+    markPhase('project');
+    return result;
   }
 
   async function listSessionCatalog(options = {}) {

package/src/standalone/session-service-api.mjs

@@ -1,3 +1,5 @@
+import { shortId, slowSpans } from '../runtime/shared/slow-span.mjs';
+
 const sessionServiceRoutes = ({ desktop, project, session }) => ({
   'desktop.init': (params, ctx) => desktop.init(params, ctx),
   'desktop.invoke': (params, ctx) => desktop.invoke(params, ctx),
@@ -29,15 +31,19 @@ export function createSessionServiceApi({
   methods,
   getSize,
   getBusyCount,
+  getTurnBusyCount,
   getStatus,
   getExternalClientCount,
+  spans = slowSpans,
 }) {
   const routes = sessionServiceRoutes({ desktop, project, session });
   return {
     async handleCall(name, args = {}, ctx = null) {
       const route = routes[String(name || '')];
       if (!route) throw new Error(`unknown session service call ${name}`);
-      return route(args || {}, ctx);
+      const params = args || {};
+      const sid = shortId(params.sessionId);
+      return spans.trace(sid ? `${name}#${sid}` : String(name), () => route(params, ctx));
     },
     ...methods,
     get size() {
@@ -46,6 +52,10 @@ export function createSessionServiceApi({
     get busyCount() {
       return getBusyCount();
     },
+    /** Sessions with a running turn; background-task-only sessions excluded. */
+    get turnBusyCount() {
+      return getTurnBusyCount();
+    },
     get status() {
       return getStatus();
     },

package/src/standalone/session-service.mjs

@@ -296,6 +296,7 @@ export function createSessionService({
     },
     getSize: () => sessions.size,
     getBusyCount: retention.liveBusyCount,
+    getTurnBusyCount: retention.liveTurnBusyCount,
     getStatus,
     getExternalClientCount: () => desktopServices.externalClientCount,
   });

package/src/standalone/session-state-patch.d.mts

@@ -3,5 +3,6 @@ export function diffSessionState(
   next: unknown,
   options?: { prepend?: boolean }
 ): Record<string, unknown> | null;
-export function applySessionStatePatch(previous: unknown, patch: unknown): Record<string, unknown>;
+export function streamingPartialSuffix(before: unknown, after: unknown): string | null;
+export function applySessionStatePatch(previous: unknown, patch: unknown): Record<string, unknown> | null;
 export function transcriptItemsDigest(items: readonly unknown[]): string;

package/src/standalone/session-state-patch.mjs

@@ -7,16 +7,51 @@
 // `transcriptPrepend`) carries rows revealed ABOVE the previous list, an
 // older-history page: the previous rows then start `values.length` rows in,
 // and `itemsAppend.from` indexes the PREVIOUS list.
+//
+// `partialAppend` carries growth of the desktop-only `streamingPartial` (the
+// unfinished streamed line) as just its new text: re-sending the whole line on
+// every tick made a long unfinished line cost O(length²) on the wire. A
+// decoder that predates it keeps its last partial, which the desktop join
+// then ignores or shows behind — never wrong text.
 import { createHash } from 'node:crypto';
 
+/** The text `after` appends to `before` when both are the same unfinished
+ *  line (same row, same offset, same row identity), else null: a retraction,
+ *  another row or a new line travels as a full replacement. */
+export function streamingPartialSuffix(before, after) {
+  if (!before || !after || typeof before !== 'object' || typeof after !== 'object') return null;
+  const { text: beforeText, ...beforeRest } = before;
+  const { text: afterText, ...afterRest } = after;
+  if (typeof beforeText !== 'string' || typeof afterText !== 'string') return null;
+  if (afterText.length <= beforeText.length || !afterText.startsWith(beforeText)) return null;
+  // id, from and the row identity: everything but the text stays put.
+  if (JSON.stringify(beforeRest) !== JSON.stringify(afterRest)) return null;
+  return afterText.slice(beforeText.length);
+}
+
+function appendStreamingPartial(state, suffix) {
+  const held = state.streamingPartial;
+  if (!held || typeof held !== 'object' || typeof held.text !== 'string' || typeof suffix !== 'string') return false;
+  state.streamingPartial = { ...held, text: held.text + suffix };
+  return true;
+}
+
 export function diffSessionState(previous, next, { prepend = false } = {}) {
   if (!previous || !next || typeof previous !== 'object' || typeof next !== 'object') return null;
   const set = {};
   const remove = [];
   let itemsAppend = null;
   let itemsPrepend = null;
+  let partialAppend = null;
   for (const [key, value] of Object.entries(next)) {
     if (previous[key] === value) continue;
+    if (key === 'streamingPartial') {
+      const suffix = streamingPartialSuffix(previous[key], value);
+      if (suffix !== null) {
+        partialAppend = { text: suffix };
+        continue;
+      }
+    }
     if (key === 'items' && Array.isArray(value) && Array.isArray(previous.items)) {
       let head = 0;
       if (prepend && previous.items.length > 0 && value[0] !== previous.items[0]) {
@@ -36,13 +71,18 @@ export function diffSessionState(previous, next, { prepend = false } = {}) {
   for (const key of Object.keys(previous)) {
     if (!(key in next)) remove.push(key);
   }
-  return itemsPrepend ? { set, remove, itemsAppend, itemsPrepend } : { set, remove, itemsAppend };
+  const patch = itemsPrepend ? { set, remove, itemsAppend, itemsPrepend } : { set, remove, itemsAppend };
+  if (partialAppend) patch.partialAppend = partialAppend;
+  return patch;
 }
 
+/** The patched state, or null when a `partialAppend` has no held line to grow
+ *  (a broken chain the caller answers with a full resync, never lost text). */
 export function applySessionStatePatch(previous, patch) {
   const base = previous && typeof previous === 'object' ? previous : {};
   if (!patch || typeof patch !== 'object') return base;
   const next = { ...base, ...(patch.set || {}) };
+  if (Object.hasOwn(patch, 'partialAppend') && !appendStreamingPartial(next, patch.partialAppend?.text)) return null;
   if (patch.itemsAppend || patch.itemsPrepend) {
     const items = Array.isArray(base.items) ? base.items : [];
     const head = Array.isArray(patch.itemsPrepend?.values) ? patch.itemsPrepend.values : [];

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

@@ -235,6 +235,7 @@ export function renderAppView(ctx) {
           model={state.model}
           effort={state.effort}
           fast={state.fast}
+          ultra={state.fast === true && state.modelParameters?.serviceTier === 'ultrafast'}
           cwd={state.cwd}
           stats={statuslineStats}
           contextWindow={state.contextWindow}

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 };
+}