@toddzheng024/dscode-bundle 0.7.19 → 0.7.21

package/cordis.patch.yml

@@ -844,6 +844,8 @@
       name: "@toddzheng024/dscode-bundle/session-bridge"
     - id: dscode-memory
       name: "@toddzheng024/dscode-bundle/memory"
+    - id: dscode-time-marks
+      name: "@toddzheng024/dscode-bundle/time-marks"
     - id: dscode-tui-tools
       name: "@toddzheng024/dscode-bundle/tui-tools"
     - id: dscode-email-tools

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.7.19",
+  "version": "0.7.21",
   "type": "module",
   "license": "MIT",
   "author": "Todd Zheng",
@@ -35,6 +35,7 @@
     "./memory": "./plugins/memory/index.mjs",
     "./session-bridge": "./plugins/session-bridge/index.mjs",
     "./session-cards": "./plugins/session-cards/index.mjs",
+    "./time-marks": "./plugins/time-marks/index.mjs",
     "./subagent": "./vendor/subagent/index.js",
     "./subagent-core": "./vendor/subagent-core/index.js",
     "./subagent-driver": "./vendor/subagent-driver/index.js",

package/plugins/jev/approval.mjs

@@ -38,12 +38,18 @@ export function approvalQuestions() {
       criteria: {
         allow: 'Read-only, or a change the retained user instruction already asked for.',
         ask: 'Plausibly within the task but not clearly authorized, or the blast radius is unclear.',
-        deny: 'Outside the user instruction, or it would disclose data, destroy unrelated work, or publish something.',
+        deny: 'Outside the user instruction, or it would disclose data, destroy unrelated work, or publish something the instruction did not ask for.',
       },
     },
     authorized: {
       type: 'noul',
-      instructions: 'Does the retained user instruction explicitly authorize this exact action, including its target and effect?',
+      // Scored on its own, never as a function of how risky the action is: the
+      // deployment uses this number to decide whether a risk guard may defer to
+      // the model reviewer, and collapsing authorization into apparent safety
+      // made user-requested work (a release that must leave the sandbox) read as
+      // unauthorized. An instruction almost never names the exact command, so the
+      // question is about the task it asks for, not about a literal match.
+      instructions: 'Judge the authorization alone, separately from how risky the action is: an action the instruction asks for scores high even when it is dangerous, and a risky action nobody asked for scores low. The instruction rarely names a command, so read it as the task it asks for and decide whether this call is a required or ordinary step of that task, including its target and effect. Score 0.9 or more when the instruction directly asks for this step; 0.6 up to but not including 0.9 when the step is necessary to carry out a stated task, or the instruction names the target but not the means; 0.2 up to but not including 0.6 when the call is plausibly part of the task but optional or unclear; below 0.2 when the instruction does not cover it or it serves a different goal.',
     },
     destructive: {
       type: 'score',
@@ -67,8 +73,16 @@ const clip = (value, limit) => {
 // call, and the retained direct user instruction. It is posted to OpenRouter, so
 // it is bounded and never carries credentials.
 export function approvalState({ action, context } = {}) {
+  // `contextFor` hands these over as `{ seq, text }`; a caller may also pass raw
+  // message objects. Reading only `content` left `userInstructions` empty, so Jev
+  // judged every escalation without ever seeing what the user had asked for.
   const instructions = (context?.userMessages ?? [])
-    .map(message => (message?.content ?? []).map(block => block?.text ?? '').join(' ').trim())
+    .map(message => {
+      if (typeof message?.text === 'string') return message.text.trim();
+      const content = message?.content;
+      if (typeof content === 'string') return content.trim();
+      return Array.isArray(content) ? content.map(block => block?.text ?? '').join(' ').trim() : '';
+    })
     .filter(Boolean)
     .join('\n---\n');
   return {

package/plugins/session-bridge/communication.mjs

@@ -102,7 +102,8 @@ export class CommunicationService {
     // Identity must survive retries even when the prior native inbox insertion did not persist.
     return freezeMessage({ ...createUserMessage({ content: [{ type: 'text', text:
       `[External source: ${e.from.kind === 'session' ? `session:${e.from.sessionId}` : e.from.source}] [${e.kind}/${e.mode}]\nMessage ID: ${e.messageId}${e.inReplyTo ? `; reply to: ${e.inReplyTo}` : ''}\n${e.text}` }],
-      source: { kind: 'plugin', plugin, form: 'relay', communicationId: e.messageId, requestId: e.idempotencyKey } }), id: e.messageId });
+      source: { kind: 'plugin', plugin, form: 'relay', communicationId: e.messageId, requestId: e.idempotencyKey,
+        label: e.from.kind === 'session' ? `session:${e.from.sessionId}` : e.from.source, mode: e.mode, composedAt: e.createdAt } }), id: e.messageId });
   }
   async confirm(state) {
     const receipts = [...state.receipts];

package/plugins/session-bridge/server.mjs

@@ -82,7 +82,7 @@ export class SessionBridge {
     let messageId = previous?.messageId;
     if (!previous) {
       const message = createUserMessage({ content: [{ type: 'text', text: `[External source: ${source}]\n${text}` }],
-        source: { kind: 'plugin', plugin: BRIDGE_SOURCE, form: 'relay', requestId, digest, label: source } });
+        source: { kind: 'plugin', plugin: BRIDGE_SOURCE, form: 'relay', requestId, digest, label: source, mode } });
       // Explicit naming uses the native title service, including sanitization,
       // persistence, UI events and cancellation of stale automatic title work.
       // A duplicate request must never undo a newer title.

package/plugins/session-metrics/view.mjs

@@ -81,17 +81,53 @@ function resetStamp(iso, now) {
   const date = new Date(at);
   return pad(date.getMonth() + 1) + '-' + pad(date.getDate()) + ' ' + pad(date.getHours()) + ':' + pad(date.getMinutes());
 }
+
+/**
+ * Fixed figure columns for the live footer. The status line re-reads these
+ * figures every second, so a growing digit count must never move the segments
+ * after it: each figure is right-aligned inside its own columns, and only the
+ * terminal width decides which segments the drop ladder keeps.
+ */
+const FIGURE = {
+  /** `~999.9` decode rates; the average reads the same scale without the tilde. */
+  rate: 6,
+  /** `100%` context occupancy. */
+  percent: 4,
+  /** `100.0%` cache share. */
+  share: 6,
+};
+
+/**
+ * Columns {@link formatFooter} needs on top of the budget it is handed. The
+ * fixed figures above only stop moving once their columns are really reserved,
+ * so a caller that budgets the footer's width adds these columns first —
+ * otherwise the padding evicts a figure the width would have seated. Six
+ * measures the padding a live reading adds across the rate, context and cache
+ * figures at the widths the drop ladder actually decides on.
+ */
+export const FOOTER_FIGURE_RESERVE = 6;
+
+/** Right-align one figure inside its columns; a wider reading keeps its own width. */
+function figure(text, width) {
+  const padding = width - displayWidth(text);
+  return padding > 0 ? ' '.repeat(padding) + text : text;
+}
+
 export function formatFooter(metrics, context, columns = 80, rates, locale = 'en', header = '', provider = providerOfHeader(header) ?? 'deepseek-official') {
   const label = key => t(locale, key);
-  const ctx = Number.isFinite(context) ? `${Math.round(context)}%` : '--';
-  const cache = metrics.cache === null ? '--' : `${metrics.cache.toFixed(1)}%`;
+  const ctx = figure(Number.isFinite(context) ? `${Math.round(context)}%` : '--', FIGURE.percent);
+  const cache = figure(metrics.cache === null ? '--' : `${metrics.cache.toFixed(1)}%`, FIGURE.share);
   // The balance belongs to the provider the header names; only DeepSeek's official route bills by a peak window.
   const balance = balanceNow(provider);
   const spend = metrics.unknown && metrics.cost === 0 ? '--' : `$${metrics.cost.toFixed(2)}${metrics.unknown ? '+' : ''}${metrics.pending ? '…' : ''}`;
-  const dollars = provider === 'grok' ? grokFooterFact(grokSubscriptionNow(), locale) : `${spend} / ${balance === null ? '$--' : '$' + balance.toFixed(2)}${provider === 'deepseek-official' ? ' ' + peakEmoji(trustedNow()) : ''}`;
+  // The money pair is the one live figure left unpadded: its digits cross a
+  // column a handful of times per session, and reserving those columns would
+  // evict a per-second figure at the widths the footer actually runs at.
+  const dollars = provider === 'grok' ? grokFooterFact(grokSubscriptionNow(), locale)
+    : `${spend} / ${balance === null ? '$--' : '$' + balance.toFixed(2)}${provider === 'deepseek-official' ? ' ' + peakEmoji(trustedNow()) : ''}`;
   const base = rates ? [
-    `${label('footer.current')}: ${Number.isFinite(rates.current) ? '~' + rates.current.toFixed(1) : '--'} tps`,
-    `${label('footer.average')}: ${Number.isFinite(rates.average) ? rates.average.toFixed(1) : '--'} tps`,
+    `${label('footer.current')}: ${figure(Number.isFinite(rates.current) ? '~' + rates.current.toFixed(1) : '--', FIGURE.rate)} tps`,
+    `${label('footer.average')}: ${figure(Number.isFinite(rates.average) ? rates.average.toFixed(1) : '--', FIGURE.rate)} tps`,
     `${label('footer.context')}: ${ctx}`, dollars, `${label('footer.cache')}: ${cache}`,
   ] : [`${label('footer.context')}: ${ctx}`, dollars, `${label('footer.cache')}: ${cache}`];
   // Narrow terminals shed the quietest figures first: average, current, context. The

package/plugins/time-marks/index.mjs

@@ -0,0 +1,73 @@
+/**
+ * Clock marks in the model's own context: every message a step admits, and
+ * every turn that closed before it, carries one reading of the host clock. A
+ * mark is its own plugin-sourced message rather than an edit of the prompt, so
+ * message bodies, session cards and title selection read exactly what they
+ * read before. Like the time-context reading it is durable: it spends model
+ * context from then on, replays on resume, and the terminal hides it by
+ * producer.
+ *
+ * @module dscode-time-marks
+ */
+import z from '@deepseek-ai/schemastery';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { arrivalMark, resolveTimeZone, turnEndMark } from './marks.mjs';
+export const name = 'dscode-time-marks';
+export const Config = z.object({
+  /** Fallback display zone; empty uses the host zone. */
+  timeZone: z.string().default(''),
+});
+/** Marks carried by one request at most, so a delivery burst cannot flood a step. */
+const MARK_LIMIT = 8;
+/**
+ * Per-agent mark state: closed turns still waiting for a step to carry them,
+ * and the opening time of the turn each one closed.
+ */
+const marks = new WeakMap();
+const stateFor = agent => {
+  let state = marks.get(agent);
+  if (state === undefined) marks.set(agent, state = { turns: [], starts: new Map() });
+  return state;
+};
+export function apply(ctx, config = {}) {
+  const timeZone = resolveTimeZone(config.timeZone);
+  ctx.on('agent/pre-step', async (payload, next) => {
+    const state = stateFor(payload.agent);
+    // The first step of a turn is the only moment its opening is observable.
+    if (payload.step === 1) state.starts.set(payload.turn, Date.now());
+    const decision = await next();
+    if (decision.kind !== 'enter') return decision;
+    const at = Date.now();
+    const lines = [];
+    for (const message of payload.messages) {
+      // Marks are injected context, never an inbox arrival; skipping our own
+      // producer keeps a future delivery path from marking itself.
+      if (message.source?.plugin === name) continue;
+      const line = arrivalMark(message, at, timeZone);
+      if (line !== null && lines.length < MARK_LIMIT) lines.push(line);
+    }
+    // An arrival burst that fills the limit leaves the remaining turn marks
+    // queued: the next step carries them instead of losing them here.
+    while (lines.length < MARK_LIMIT && state.turns.length > 0) {
+      const ended = state.turns.shift();
+      lines.push(turnEndMark(ended.turn, ended.endedAt, ended.startedAt, timeZone));
+    }
+    if (lines.length === 0) return decision;
+    return {
+      ...decision,
+      // Ahead of the batch, never behind it: whatever reads the request's last
+      // user message (an echo fixture, a title or topic pass) must still find
+      // the prompt there, not this mark.
+      messages: [createUserMessage({
+        content: [{ type: 'text', text: lines.join('\n') }],
+        source: { kind: 'plugin', plugin: name, form: 'snapshot' },
+      }), ...decision.messages],
+    };
+  }, { prepend: true });
+  ctx.on('agent/turn-stopping', payload => {
+    const state = stateFor(payload.agent);
+    state.turns.push({ turn: payload.turn, endedAt: Date.now(), startedAt: state.starts.get(payload.turn) });
+    state.starts.delete(payload.turn);
+    if (state.turns.length > MARK_LIMIT) state.turns.length = MARK_LIMIT;
+  });
+}

package/plugins/time-marks/marks.mjs

@@ -0,0 +1,151 @@
+/**
+ * Host-clock readings for the model's own context: one mark for a message the
+ * step just admitted, one for a turn that closed before it. Pure formatting
+ * over one clock, so the plugin's glue stays thin and the marks stay testable
+ * without a live agent.
+ *
+ * @module dscode-time-marks/marks
+ */
+
+/** Shortest queue wait worth naming; below it the message simply arrived. */
+const WAIT_FLOOR_MS = 1_000
+
+/** One cached `Intl.DateTimeFormat` per zone: construction dominates formatting. */
+const formatters = new Map()
+
+/**
+ * Zone the host process runs in, used when no zone is configured.
+ * @returns an IANA zone name; UTC when the runtime cannot name one.
+ */
+export function hostTimeZone() {
+  try {
+    return new Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC'
+  } catch {
+    return 'UTC'
+  }
+}
+
+/**
+ * Resolve the display zone, failing load on a zone this runtime cannot use.
+ * @param configured - configured zone; empty means the host zone.
+ * @returns the IANA zone name to format marks in.
+ * @throws when the configured zone is not a zone `Intl` accepts.
+ */
+export function resolveTimeZone(configured) {
+  if (typeof configured !== 'string' || configured === '') return hostTimeZone()
+  try {
+    new Intl.DateTimeFormat('en-US', { timeZone: configured })
+  } catch {
+    throw Error(`Unknown time zone: ${configured}`)
+  }
+  return configured
+}
+
+/**
+ * One field read off a message source, flattened to a single bounded line: a
+ * mark is joined line by line, so a newline inside a label would forge the
+ * next mark rather than describe this message.
+ * @param value - the raw field, when it is a string at all.
+ * @param limit - longest run kept.
+ * @returns the flattened field.
+ */
+export function plain(value, limit = 64) {
+  if (typeof value !== 'string') return ''
+  return value.replace(/[\p{Cc}\p{Cf}\u2028\u2029]+/gu, ' ').replace(/\s+/g, ' ').trim().slice(0, limit)
+}
+
+/** Cached formatter for one zone. */
+function formatter(timeZone) {
+  let cached = formatters.get(timeZone)
+  if (cached === undefined) {
+    cached = new Intl.DateTimeFormat('en-CA', {
+      timeZone, year: 'numeric', month: '2-digit', day: '2-digit',
+      hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false, timeZoneName: 'longOffset',
+    })
+    formatters.set(timeZone, cached)
+  }
+  return cached
+}
+
+/**
+ * One clock reading in the shape the system prompt already uses:
+ * `2026-09-19T01:58:34-07:00[America/Los_Angeles]`. The numeric offset keeps
+ * the reading unambiguous and the bracketed zone keeps it interpretable.
+ * @param at - Unix epoch milliseconds.
+ * @param timeZone - IANA zone to render in.
+ * @returns the formatted reading.
+ */
+export function clockText(at, timeZone) {
+  const parts = formatter(timeZone).formatToParts(new Date(at))
+  const field = type => parts.find(part => part.type === type)?.value ?? ''
+  const match = /^GMT([+-])(\d{1,2})(?::(\d{2}))?$/.exec(field('timeZoneName'))
+  const offset = match === null ? '+00:00' : `${match[1]}${match[2].padStart(2, '0')}:${match[3] ?? '00'}`
+  // `hour12: false` renders midnight as 24 in some ICU builds.
+  const hour = field('hour') === '24' ? '00' : field('hour')
+  return `${field('year')}-${field('month')}-${field('day')}T${hour}:${field('minute')}:${field('second')}${offset}[${timeZone}]`
+}
+
+/**
+ * Compact elapsed time: tenths of a second under a minute, `6m24s` from there
+ * on, hours once minutes stop being readable.
+ * @param ms - elapsed milliseconds.
+ * @returns the display string; `--` when the value is unusable.
+ */
+export function elapsedText(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return '--'
+  const seconds = ms / 1_000
+  if (seconds < 60) return `${Math.round(seconds * 10) / 10}s`
+  const whole = Math.round(seconds)
+  if (whole < 3_600) return `${Math.floor(whole / 60)}m${whole % 60}s`
+  return `${Math.floor(whole / 3_600)}h${Math.floor(whole % 3_600 / 60)}m`
+}
+
+/**
+ * Attribution for one arriving message, read off its durable source rather
+ * than its body: a relay names its mode and origin, anything else names its
+ * producer.
+ * @param source - the message's source record.
+ * @returns the attribution clause.
+ */
+export function describeSource(source) {
+  const kind = plain(source?.kind)
+  if (kind === 'user') return 'user message'
+  if (kind !== 'plugin') return kind === '' ? 'message' : `message via ${kind}`
+  if (source.form === 'relay') {
+    const mode = plain(source.mode) || 'queue'
+    const label = plain(source.label) || 'another session'
+    return `${mode} relay from ${label}`
+  }
+  return `message from ${plain(source.plugin) || 'a plugin'}`
+}
+
+/**
+ * One mark for a message the step just admitted. Injected context carries the
+ * `snapshot` form and is never a prompt, so it earns no mark.
+ * @param message - the admitted user message.
+ * @param at - Unix epoch milliseconds the mark is written.
+ * @param timeZone - IANA zone to render in.
+ * @returns the mark line, or null when the message is context rather than input.
+ */
+export function arrivalMark(message, at, timeZone) {
+  const source = message?.source
+  if (source?.form === 'snapshot') return null
+  const waited = Number(source?.composedAt)
+  const queue = Number.isFinite(waited) && at - waited >= WAIT_FLOOR_MS
+    ? `, waited ${elapsedText(at - waited)} (composed ${clockText(waited, timeZone)})`
+    : ''
+  return `Time mark: ${clockText(at, timeZone)} — ${describeSource(source)} arrived${queue}.`
+}
+
+/**
+ * One mark for a turn that closed before this step opened.
+ * @param turn - the closed turn's number.
+ * @param endedAt - Unix epoch milliseconds the turn stopped.
+ * @param startedAt - when that turn opened, when the plugin saw it open.
+ * @param timeZone - IANA zone to render in.
+ * @returns the mark line.
+ */
+export function turnEndMark(turn, endedAt, startedAt, timeZone) {
+  const ran = Number.isFinite(startedAt) && startedAt <= endedAt ? `, ran ${elapsedText(endedAt - startedAt)}` : ''
+  return `Time mark: ${clockText(endedAt, timeZone)} — turn ${turn} ended${ran}.`
+}

package/vendor/tui/lib/app.mjs

@@ -30,7 +30,7 @@ import { imeCursorRowsUp, useImeCursorAnchor } from './render/ime-cursor.mjs';
 import { readClipboardImage } from './dscode/clipboard-image/index.mjs';
 import { dscodeChatLines } from './dscode/chat.mjs';
 import { readFileSync } from 'node:fs';
-import { footerFor as dscodeFooterFor } from '../../../plugins/session-metrics/view.mjs';
+import { FOOTER_FIGURE_RESERVE, footerFor as dscodeFooterFor } from '../../../plugins/session-metrics/view.mjs';
 import { newerVersion as dscodeNewerVersion } from '../../../plugins/tui-tools/update.mjs';
 import { languageName as dscodeLanguageName, normalizeLanguage as dscodeNormalizeLanguage, t as dscodeMessage } from '../../../plugins/i18n/messages.mjs';
 import { dscodeTelemetryNodes } from './dscode/telemetry.mjs';
@@ -92,6 +92,7 @@ import { isSlashLine, submissionPayload } from './commands.mjs';
 import { rankByName } from './render/fuzzy.mjs';
 import { isDeclaredReasoningEfforts, parseReasoningEffortsDraft, serializeReasoningEfforts, } from './provider-settings.mjs';
 import { isPathLikeMentionQuery } from './mentions.mjs';
+import { createTranscriptStore } from './store.mjs';
 import { AgentsPanel, editQuery, EffortPanel as NativeEffortPanel, HistoryPanel, JobsPanel, ModePanel, PermissionPanel, PluginPanel, ResumePanel, ReviewPickerPanel, SchedulePanel, SearchPanel, StatuslinePanel, runClock, SubagentPanel, UsagePanel } from './kernel-panels.mjs';
 import { beginRecall, recallEntries, recallNewer, recallOlder, recordLocalEntry, } from './history.mjs';
 import { authorizationForProvider, providerAuthorizationStatus, } from './authorization.mjs';
@@ -127,7 +128,7 @@ const RESIZE_REFLOW_CLEAR = '\x1b[r\x1b[0m\x1b[H\x1b[2J\x1b[3J\x1b[H';
 const SYNCHRONIZED_UPDATE_BEGIN = '\x1b[?2026h';
 /** Release the held frame after Ink has replayed the source-backed Static rows. */
 const SYNCHRONIZED_UPDATE_END = '\x1b[?2026l';
-import { layoutStatusBar, parseStatuslineItems, statusCycleHint, STATUS_GROUP_SEPARATOR, STATUS_ITEM_SEPARATOR, STATUS_ROW2_INDENT, } from './render/status.mjs';
+import { layoutStatusBar, padValue, parseStatuslineItems, statusCycleHint, STATUS_GROUP_SEPARATOR, STATUS_ITEM_SEPARATOR, STATUS_ROW2_INDENT, } from './render/status.mjs';
 import { displayTail, displayText, singleLineText, truncateColumns } from './render/text.mjs';
 import { isVsCodeTerminalEnv, normalizeKeyboardChunk, PASTE_BRACKET_TIMEOUT_MS, PASTE_END_MARKER, PASTE_START_MARKER, stripPasteMarkers, stripTerminalFocusEvents, tokenizeRawEditorChunk, } from './keyboard.mjs';
 import { clampScroll, followInspectorCursor, inspectorViewport, layoutGutterRows, liveRegionBudget, moveScroll, panelViewport, revealRow, selectionWindow, } from './render/inspector.mjs';
@@ -154,6 +155,7 @@ const LOCAL_COMMANDS = [
     { label: '/animation', descriptionKey: 'cmd.animation' },
     { label: '/history', descriptionKey: 'cmd.history' },
     { label: '/queue', descriptionKey: 'cmd.queue' },
+    { label: '/btw', descriptionKey: 'cmd.btw' },
     { label: '/usage', descriptionKey: 'cmd.usage' },
     { label: '/agents', descriptionKey: 'cmd.agents' },
     { label: '/todos', descriptionKey: 'cmd.todos' },
@@ -725,6 +727,63 @@ export function queuedInboxRows(entries, ids) {
     });
 }
 /** A bounded, keyboard-owned management surface for the durable next-turn inbox. */
+/** Fallback transcript for a panel with no run yet: the store hook must always run. */
+const EMPTY_BTW_STORE = createTranscriptStore();
+/** One localized word per run status. */
+const BTW_STATUS_KEYS = {
+    running: 'panel.btw.running',
+    done: 'panel.btw.done',
+    failed: 'panel.btw.failed',
+    cancelled: 'panel.btw.cancelled',
+};
+/**
+ * The /btw panel: side questions answered beside the main conversation. Each
+ * run renders its own transcript, so a full answer is readable while the
+ * exchange stays out of the main transcript and out of its model context.
+ */
+export function BtwPanel({ feed, runs, selected, onSelect, onClose }) {
+    const stdout = useStdout().stdout;
+    const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
+    const run = runs.find(entry => entry.id === selected) ?? runs[0];
+    const store = (run === undefined ? undefined : feed.store(run.id)) ?? EMPTY_BTW_STORE;
+    const subscribe = useCallback((listener) => store.subscribe(listener), [store]);
+    const read = useCallback(() => store.getView(), [store]);
+    const view = useSyncExternalStore(subscribe, read);
+    // The panel follows the newest rows: an answer longer than the pane stays
+    // readable as it streams, and the composer below is never covered.
+    const lines = useMemo(() => view.entries.flatMap(entry => transcriptEntryLines(entry, viewport.contentColumns)), [view.entries, viewport.contentColumns]);
+    const step = (delta) => {
+        if (runs.length < 2)
+            return;
+        const at = runs.findIndex(entry => entry.id === run?.id);
+        onSelect(runs[(at + delta + runs.length) % runs.length].id);
+    };
+    useStableInput((input, key) => {
+        if (key.escape || input === 'q') {
+            onClose();
+            return;
+        }
+        if (key.leftArrow)
+            step(1);
+        if (key.rightArrow)
+            step(-1);
+    });
+    const accent = panelAccent('btw', getPalette().brand);
+    const title = run === undefined
+        ? t('panel.btw.title')
+        : `${t('panel.btw.title')} · ${t(BTW_STATUS_KEYS[run.status])} · ${run.title}`;
+    const body = lines.slice(-Math.max(1, viewport.bodyRows));
+    return createElement(Box, { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(accent.border) }, createElement(Text, { color: inkColor(accent.title), bold: true, wrap: 'truncate-end' }, truncateColumns(title, viewport.contentColumns)), createElement(PanelGap, { visible: viewport.gapRows > 0 }), body.length === 0
+        ? createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(run === undefined ? t('panel.btw.empty') : t('panel.btw.waiting'), viewport.contentColumns))
+        : createElement(StyledRows, { lines: body }), view.streaming === ''
+        ? undefined
+        : createElement(StreamTail, {
+            text: view.streaming,
+            dim: false,
+            maxRows: Math.max(3, Math.floor(viewport.bodyRows / 2)),
+            prefix: '  ',
+        }), createElement(PanelGap, { visible: viewport.gapRows > 0 }), createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(runs.length > 1 ? t('panel.btw.footerMany', { count: runs.length }) : t('panel.btw.footer'), viewport.contentColumns)));
+}
 function QueuePanel({ rows, busy, update, onClose }) {
     const stdout = useStdout().stdout;
     const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
@@ -960,8 +1019,14 @@ export function StatusLine({ facts, stats, busy, columns, items, onRows, animate
         return () => clearInterval(timer);
     }, []);
     // dscode: the telemetry segment carries the header and only appears once the
-    // terminal can seat it; below that the identity row keeps the model.
-    facts = { ...facts, telemetry: columns >= 48 ? dscodeFooterFor(facts.fullSessionId, stats, Math.max(1, Math.min(columns - 8, Math.max(40, Math.floor(columns * 0.8) - 4))), dscodeFooterHeader(facts, stats), getLanguage()) : '' };
+    // terminal can seat it; below that the identity row keeps the model. Its
+    // slot is padded to the width it was laid out for, so the live figures
+    // decide the text the row shows without ever changing the row's geometry.
+    const telemetryWidth = Math.max(1, Math.min(columns - 8, Math.max(40, Math.floor(columns * 0.8) - 4) + FOOTER_FIGURE_RESERVE));
+    const telemetry = columns >= 48
+        ? dscodeFooterFor(facts.fullSessionId, stats, telemetryWidth, dscodeFooterHeader(facts, stats), getLanguage())
+        : '';
+    facts = { ...facts, telemetry: telemetry === '' ? '' : padValue(telemetry, telemetryWidth) };
     // Flowing-theme busy flow: the identity cluster's live dot cycles the
     // anchor walk while a turn runs; static themes never start the timer.
     const flow = themeFlow();
@@ -1020,15 +1085,21 @@ export function StatusLine({ facts, stats, busy, columns, items, onRows, animate
         if (key === 's2' && row.left.length > 0 && row.right.length > 0) {
             rightParts.push(createElement(Text, { key: key + 'divider', color: inkColor(getPalette().dim) }, '｜ '));
         }
+        // dscode: the cycle hint rides LEFT of the right cluster, so the
+        // right-anchored badge holds its columns whether or not the hint is
+        // painted; layoutStatusBar reserves the hint's width in both states.
+        if (row.hint) {
+            rightParts.push(createElement(Text, { key: key + 'hint', color: inkColor(getPalette().dim) }, statusCycleHint()));
+            if (row.right.length > 0) {
+                rightParts.push(createElement(Text, { key: key + 'hintSep', color: inkColor(getPalette().dim) }, STATUS_ITEM_SEPARATOR));
+            }
+        }
         row.right.forEach((span, index) => {
             if (index > 0) {
                 rightParts.push(createElement(Text, { key: key + 'rs' + index, color: inkColor(getPalette().dim) }, STATUS_ITEM_SEPARATOR));
             }
             rightParts.push(createElement(Text, { key: key + 'r' + index, wrap: 'truncate-end', ...statusToneProps(span.tone, flowMs) }, key === 's2' && index === 0 ? dscodeTelemetryNodes(span.text, key + 'r' + index) : span.text));
         });
-        if (row.hint) {
-            rightParts.push(createElement(Text, { key: key + 'hint', color: inkColor(getPalette().dim) }, statusCycleHint()));
-        }
         // Each row already fits the column budget; truncate-end stays as the
         // terminal-measurement backstop so a drifting cell count clips instead
         // of wrapping.
@@ -3623,7 +3694,7 @@ export function DscodeEffortPanel(props) {
         barIds.every(id => ids.includes(id)) && ids.every(id => id === 'off' || barIds.includes(id));
     return createElement(barCatalog ? DscodeEffortBar : NativeEffortPanel, props);
 }
-function Input({ effortSurface, ultraPulse, active, frozen, frozenHint, busy, descriptors, skills, dispatch, steer, submitMode, cycleSubmitMode, interrupt, quit, openEmail, openLogin, openProvider, openOpenRouter, openModel, openEffort, openHelp, openMode, openPermission, openResume, openSearch, openPlugin, openUpdate, openSchedule, openJobs, openStatusline, openTheme, openLanguage, saveLanguage, openHistory, openQueue, openAgents, openSubagent, openTodos, openUsage, openDelete, openDiff, openReviewPicker, reviewChanges, deleteConfirm, confirmDelete, cancelDelete, createSession, forkSession, cancelSessionSwitch, notify, applyEditorKeys, hasNotice, dismissNotice, toggleReasoning, openVerbose, clearView, refresh, loadMentions, inspectImages, prepareImages, inspectFiles, prepareFiles, readClipboardImage, cycleMode, exportTranscript, renameTitle, copyLastResponse, recallSpace, recordLocal, recordHistory, queued, updateQueued, historyFill, historyConsumed, animations, applyAnimations, applyRainbow, rainbowBurstId, waveTier, waveStyle, maxRows, anchorRowsBelow, tabTitle, onEditorRows, onMenuRows, sessionKey }) {
+function Input({ effortSurface, ultraPulse, active, frozen, frozenHint, busy, descriptors, skills, dispatch, steer, submitMode, cycleSubmitMode, interrupt, quit, openEmail, openLogin, openProvider, openOpenRouter, openModel, openEffort, openHelp, openMode, openPermission, openResume, openSearch, openPlugin, openUpdate, openSchedule, openJobs, openStatusline, openTheme, openLanguage, saveLanguage, openHistory, openQueue, openBtw, openAgents, openSubagent, openTodos, openUsage, openDelete, openDiff, openReviewPicker, reviewChanges, deleteConfirm, confirmDelete, cancelDelete, createSession, forkSession, cancelSessionSwitch, notify, applyEditorKeys, hasNotice, dismissNotice, toggleReasoning, openVerbose, clearView, refresh, loadMentions, inspectImages, prepareImages, inspectFiles, prepareFiles, readClipboardImage, cycleMode, exportTranscript, renameTitle, copyLastResponse, recallSpace, recordLocal, recordHistory, queued, updateQueued, historyFill, historyConsumed, animations, applyAnimations, applyRainbow, rainbowBurstId, waveTier, waveStyle, maxRows, anchorRowsBelow, tabTitle, onEditorRows, onMenuRows, sessionKey }) {
     const { stdout: inputStdout } = useStdout();
     const columns = inputStdout?.columns ?? 80;
     const inputTerminalRows = inputStdout?.rows ?? 30;
@@ -4640,6 +4711,10 @@ function Input({ effortSurface, ultraPulse, active, frozen, frozenHint, busy, de
                 openQueue();
                 return;
             }
+            if (text === '/btw' || text.startsWith('/btw ')) {
+                openBtw(text.slice('/btw'.length).trim());
+                return;
+            }
             if (text === '/usage') {
                 openUsage();
                 return;
@@ -5210,8 +5285,13 @@ export function App(props) {
             controller.abort();
         };
     }, [gmail, imap]);
-    // A session switch never leaves the previous session's inbox open.
-    useEffect(() => { setEmailOpen(false); }, [props.sessionKey]);
+    // A session switch never leaves the previous session's inbox or side
+    // questions open: the runs belong to the session that asked them.
+    useEffect(() => {
+        setEmailOpen(false);
+        setBtwOpen(false);
+        setBtwSelected(undefined);
+    }, [props.sessionKey]);
     // The stores are closure-backed singletons whose methods never touch `this`,
     // but a bare method reference still detaches it from its receiver. One stable
     // wrapper per store keeps both the receiver and the reference identity the
@@ -5437,6 +5517,8 @@ export function App(props) {
     const budgetWarnRef = useRef(undefined);
     const [verboseOpen, setVerboseOpen] = useState(false);
     const [queueOpen, setQueueOpen] = useState(false);
+    const [btwOpen, setBtwOpen] = useState(false);
+    const [btwSelected, setBtwSelected] = useState(undefined);
     /**
      * How the composer delivers its next submission: `queue` waits for the next
      * turn, `steer` joins the turn already running. Tab on an empty composer
@@ -5523,6 +5605,9 @@ export function App(props) {
     const approvalSnapshot = useSyncExternalStore(subscribeApproval, readApprovalSnapshot);
     const questionSnapshot = useSyncExternalStore(subscribeQuestions, readQuestionSnapshot);
     const agentRows = useSyncExternalStore(subscribeSubagents, readAgentRows);
+    const subscribeBtw = useCallback((listener) => props.btw.subscribe(listener), [props.btw]);
+    const readBtw = useCallback(() => props.btw.list(), [props.btw]);
+    const btwRuns = useSyncExternalStore(subscribeBtw, readBtw);
     const approvalPending = approvalSnapshot.pending !== undefined;
     const questionPending = questionSnapshot.pending !== undefined;
     // While any modal owns the keys, the prompt box passes everything through.
@@ -5532,7 +5617,7 @@ export function App(props) {
     const inputActive = deleteConfirmId !== undefined
         ? !approvalPending && !questionPending
         : !emailOpen && !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !updateOpen && !scheduleOpen && !jobsOpen && !statuslineOpen && !themeOpen && !languageOpen && !historyOpen && !queueOpen && !agentsOpen && !subagentOpen && !todosOpen && !usageOpen && !verboseOpen && diffView === undefined && !reviewPickerOpen && !approvalPending && !questionPending;
-    const transcriptVisible = !emailOpen && !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !updateOpen && !scheduleOpen && !jobsOpen && !statuslineOpen && !themeOpen && !languageOpen && !historyOpen && !queueOpen && !agentsOpen && !subagentOpen && !todosOpen && !usageOpen && !verboseOpen && diffView === undefined && !reviewPickerOpen && !approvalPending && !questionPending;
+    const transcriptVisible = !btwOpen && !emailOpen && !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !updateOpen && !scheduleOpen && !jobsOpen && !statuslineOpen && !themeOpen && !languageOpen && !historyOpen && !queueOpen && !agentsOpen && !subagentOpen && !todosOpen && !usageOpen && !verboseOpen && diffView === undefined && !reviewPickerOpen && !approvalPending && !questionPending;
     // Human questions outrank local inspectors. Close the lower modal instead
     // of leaving an approval/question visible but keyboard-locked behind it.
     useEffect(() => {
@@ -6285,6 +6370,14 @@ export function App(props) {
                 setTodosOpen(false);
             },
         })
+        : undefined, btwOpen && !approvalPending && !questionPending
+        ? createElement(BtwPanel, {
+            feed: props.btw,
+            runs: btwRuns,
+            selected: btwSelected,
+            onSelect: setBtwSelected,
+            onClose: () => setBtwOpen(false),
+        })
         : undefined, queueOpen && !approvalPending && !questionPending
         ? createElement(QueuePanel, {
             rows: queuedRows,
@@ -6612,6 +6705,11 @@ export function App(props) {
         saveLanguage: props.saveLanguage,
         openHistory: () => setHistoryOpen(true),
         openQueue: () => setQueueOpen(true),
+        openBtw: (question) => {
+            if (question !== '')
+                props.startBtw(question);
+            setBtwOpen(true);
+        },
         openAgents: () => setAgentsOpen(true),
         openSubagent: () => setSubagentOpen(true),
         openTodos: () => setTodosOpen(true),

package/vendor/tui/lib/btw.mjs

@@ -0,0 +1,152 @@
+/**
+ * Side-question runs (`/btw`): a child session seeded from the main one answers
+ * one question beside it, folded into its own transcript store so the panel can
+ * render the answer while the main conversation keeps running. The run's text
+ * lives only in the child's session — never the main transcript, never its
+ * model context.
+ *
+ * @module @deepseek-ai/dsh-tui/btw
+ */
+import { selectForkSeed } from './fork.mjs';
+import { createTranscriptStore } from './store.mjs';
+import { singleLineText, truncateColumns } from './render/text.mjs';
+/** Longest prefix `/btw` seeds a child with before it degrades to a brief. */
+export const BTW_SEED_EVENT_LIMIT = 400;
+/** Longest background brief kept when the prefix is too long to seed. */
+export const BTW_BRIEF_LIMIT = 1_200;
+/** Longest question text a run is named by. */
+export const BTW_TITLE_LIMIT = 160;
+/** Settled runs kept for the panel's switcher; the oldest settled run retires. */
+export const BTW_RUN_LIMIT = 12;
+/**
+ * Select the child's inherited history. A complete-turn prefix must stay
+ * contiguous from seq 0, so an over-long conversation cannot be trimmed: it
+ * degrades to an unseeded child carrying {@link btwBrief} instead.
+ * @param events - the main session's events in seq order.
+ * @param limit - longest prefix worth handing a child.
+ * @returns the inherited events and whether any were inherited.
+ */
+export function btwSeed(events, limit = BTW_SEED_EVENT_LIMIT) {
+    let seed;
+    try {
+        seed = selectForkSeed(events);
+    }
+    catch {
+        // No completed turn yet: a side question asked mid-turn still runs, it just
+        // has nothing of the main conversation to inherit.
+        return { events: [], inherited: false };
+    }
+    return seed.events.length <= limit ? { events: seed.events, inherited: true } : { events: [], inherited: false };
+}
+/**
+ * Text blocks of one message event. A `user/message` carries the message
+ * directly; an `assistant/message` carries it under `message` (the projection
+ * reads the same two shapes).
+ */
+function messageText(data) {
+    const record = data;
+    const content = record?.message?.content ?? record?.content;
+    if (!Array.isArray(content))
+        return '';
+    return content.filter(block => block?.type === 'text').map(block => String(block.text ?? '')).join('\n').trim();
+}
+/** Clip one brief line to its share of the budget, marking the cut. */
+function clip(text, limit) {
+    const single = text.replace(/\s+/gu, ' ').trim();
+    return single.length <= limit ? single : single.slice(0, Math.max(0, limit - 1)) + '…';
+}
+/**
+ * Build the background a side question runs with when the main conversation is
+ * too long to seed: the last thing the user asked and the last answer given.
+ * @param events - the main session's events in seq order.
+ * @param limit - longest brief kept, columns approximated as characters.
+ * @returns the brief, empty when the log carries neither message.
+ */
+export function btwBrief(events, limit = BTW_BRIEF_LIMIT) {
+    const last = (type) => {
+        for (let index = events.length - 1; index >= 0; index -= 1) {
+            const event = events[index];
+            if (event?.type !== type)
+                continue;
+            const text = messageText(event.data);
+            if (text !== '')
+                return text;
+        }
+        return '';
+    };
+    const request = last('user/message');
+    const answer = last('assistant/message');
+    const header = 'Background from the main conversation; answer only the question at the end.';
+    const fields = [
+        ...(request === '' ? [] : [{ label: 'User last asked: ', text: request }]),
+        ...(answer === '' ? [] : [{ label: 'The agent last answered: ', text: answer }]),
+    ];
+    if (fields.length === 0)
+        return '';
+    // Wording and line breaks come out of the same budget as the quoted text,
+    // so the brief honors its limit instead of exceeding it by the fixed parts.
+    const fixed = header.length + fields.reduce((total, field) => total + field.label.length + 1, 0);
+    const share = Math.max(40, Math.floor((limit - fixed) / fields.length));
+    return [header, ...fields.map(field => field.label + clip(field.text, share))].join('\n');
+}
+/**
+ * One line naming a run in the panel and the switcher.
+ * @param question - the typed side question.
+ * @param columns - budget for the naming line.
+ * @returns the single-line title.
+ */
+export function btwTitle(question, columns = BTW_TITLE_LIMIT) {
+    return truncateColumns(singleLineText(question).trim(), columns);
+}
+/**
+ * Create the side-question feed the kernel drives and the panel reads.
+ * @param limit - settled runs kept before the oldest retires.
+ * @returns the feed.
+ */
+export function createBtwFeed(limit = BTW_RUN_LIMIT) {
+    const runs = new Map();
+    const listeners = new Set();
+    let snapshot = [];
+    const publish = () => {
+        snapshot = [...runs.values()].map(entry => entry.run).reverse();
+        for (const listener of listeners)
+            listener();
+    };
+    /** Retire the OLDEST settled runs past the limit before announcing, so the list never carries one. */
+    const retire = () => {
+        const settled = [...runs.values()].filter(entry => entry.run.status !== 'running');
+        for (const entry of settled.slice(0, Math.max(0, settled.length - limit)))
+            runs.delete(entry.run.id);
+    };
+    return {
+        list: () => snapshot,
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => { listeners.delete(listener); };
+        },
+        store: id => runs.get(id)?.store,
+        begin: ({ id, question, at }) => {
+            if (runs.has(id))
+                return;
+            runs.set(id, {
+                run: { id, question, title: btwTitle(question), status: 'running', startedAt: at },
+                store: createTranscriptStore(),
+            });
+            publish();
+        },
+        apply: (id, event) => { runs.get(id)?.store.apply(event); },
+        applyStreamFrame: (id, frame) => { runs.get(id)?.store.applyStreamFrame(frame); },
+        settle: (id, status, error) => {
+            const entry = runs.get(id);
+            if (entry === undefined || entry.run.status !== 'running')
+                return;
+            entry.run = { ...entry.run, status, endedAt: Date.now(), ...(error === undefined ? {} : { error }) };
+            retire();
+            publish();
+        },
+        drop: id => {
+            if (runs.delete(id))
+                publish();
+        },
+    };
+}

package/vendor/tui/lib/index.mjs

@@ -29,11 +29,13 @@ import { grokStatusSnapshot } from '../../../plugins/grok/status.mjs';
 import { compactionPreview as dscodeCompactionPreview, effectiveContextWindow as dscodeEffectiveContextWindow, pricedThresholdRatio as dscodePricedThresholdRatio } from '../../../plugins/compaction/threshold.mjs';
 import { dscodeLoadOpenRouterAccountFor, dscodeManagementKeyStatus, dscodeSaveManagementKey } from './app.mjs';
 import { buildModelSelection, applyModelSelectionToConfig, loadModelDirectory, modelSelectionLabel, pendingModelSelection, resolveEffectiveSelection } from './models.mjs';
+import { effortFor as dscodeEffortFor } from '../../../plugins/providers/effort.mjs';
 import { discoverProviderModels, loadProviderSettings, removeProviderSettings, saveProviderCredential, saveProviderConfiguration, subscribeProviderSettings, unsetProviderCredential, } from './provider-settings.mjs';
 import { createMentions } from './mentions.mjs';
 import { mountQuestionProvider } from './questions.mjs';
 import { createTranscriptStore } from './store.mjs';
 import { createSubagentFeed } from './subagents.mjs';
+import { btwBrief, btwSeed, createBtwFeed } from './btw.mjs';
 import { parseStatuslineItems } from './render/status.mjs';
 import { historyLine, HISTORY_MAX_ENTRIES, needsCompaction, parseHistoryFile, serializeHistoryList } from './history.mjs';
 import { watchSkills } from './skills.mjs';
@@ -562,6 +564,19 @@ async function run(ctx, startup, io) {
     // Live subagent activity (child sessions of the current root): one bounded
     // row per child, folded from the same event bus the transcript feeds on.
     const subagents = createSubagentFeed();
+    // Side-question runs (/btw): a seeded read-only child whose answer renders in
+    // its own panel and never in this transcript or its model context.
+    const btw = createBtwFeed();
+    /** Live side-question children, disposed with the session that spawned them. */
+    const btwHandles = new Map();
+    /** Stop every live side question; the panel keeps the answers it already has. */
+    const disposeBtw = () => {
+        for (const [id, handle] of btwHandles) {
+            btw.drop(id);
+            void handle.dispose().catch(() => { });
+        }
+        btwHandles.clear();
+    };
     // Pre-session @file completion runs the official search over the launch
     // cwd (model- and session-independent); the prepare/activate paths replace
     // this with the agent-scoped instance once a session exists.
@@ -684,8 +699,15 @@ async function run(ctx, startup, io) {
         // the only durable transcript truth while a running subagent remains
         // visible. Lineage comes from the child header, same field the session
         // directory uses to tag `↳` rows.
-        if (subject.header.parentSession === session.id && subject.header.origin === 'subagent')
+        if (subject.header.parentSession === session.id && subject.header.origin === 'subagent') {
             subagents.apply(subject.id, event);
+            // A side question folds into its own run store and settles at turn end.
+            if (btw.store(subject.id) !== undefined) {
+                btw.apply(subject.id, event);
+                if (event.type === 'turn/end')
+                    btw.settle(subject.id, 'done');
+            }
+        }
     });
     // Live assistant typing (session-log v2+): durable logs are settlement-only,
     // so the streaming tails ride the process-local `agent/assistant-stream`
@@ -693,9 +715,12 @@ async function run(ctx, startup, io) {
     // they land (always before a committed end frame); an abandoned attempt's
     // partial tail is dropped by the store on its end frame.
     ctx.on('agent/assistant-stream', ({ agent: source, frame }) => {
-        if (agent === undefined || source.id !== agent.id)
+        if (agent !== undefined && source.id === agent.id) {
+            store.applyStreamFrame(frame);
             return;
-        store.applyStreamFrame(frame);
+        }
+        // A side question streams into its own panel transcript, never the main one.
+        btw.applyStreamFrame(source.id, frame);
     });
     const commands = watchCommands(ctx);
     if (agent !== undefined)
@@ -966,6 +991,7 @@ async function run(ctx, startup, io) {
         // exit wait below cannot hang (upstream rolls the creation back).
         abortPendingControllers();
         quitAbort.abort();
+        disposeBtw();
         epoch += 1;
         off();
         for (const dispose of offCapabilitySync)
@@ -1800,6 +1826,7 @@ async function run(ctx, startup, io) {
             catch (error) {
                 cleanupWarning = `previous session flush failed: ${error instanceof Error ? error.message : String(error)}`;
             }
+            disposeBtw();
             try {
                 await previous.handle.dispose();
             }
@@ -1919,6 +1946,66 @@ async function run(ctx, startup, io) {
             bridge.notify(t('notice.reviewFailed', { message: error instanceof Error ? error.message : String(error) }), 'error');
         });
     };
+    /**
+     * Run one side question beside the main conversation: a child session that
+     * inherits this log (or a bounded brief when the log is too long), runs
+     * read-only on the cheapest supported effort, and answers into the /btw
+     * panel. The exchange never enters this transcript or its model context.
+     * @param question - the typed side question.
+     */
+    const startBtw = (question) => {
+        const text = question.trim();
+        if (text === '' || active === undefined || agent === undefined || session === undefined)
+            return;
+        const parent = session;
+        const parentAgent = agent;
+        const mode = active.mode;
+        const selection = resolveEffectiveSelection(active.selection.picked, parent.requestHeader()?.config, currentDefaults());
+        const seed = btwSeed(parent.snapshotEvents());
+        const brief = seed.inherited ? '' : btwBrief(parent.snapshotEvents());
+        const id = SessionId(`session-${randomUUID()}`);
+        btw.begin({ id, question: text, at: Date.now() });
+        void (async () => {
+            try {
+                const effort = await dscodeEffortFor(ctx.get('llm'), { provider: selection.provider, model: selection.model }, 'low', quitAbort.signal);
+                const handle = await agents.create({
+                    sessionId: id,
+                    parentAgent,
+                    meta: {
+                        cwd: parent.header.cwd ?? cwd,
+                        agentPreset: mode,
+                        parentSession: parent.id,
+                        origin: 'subagent',
+                        delegationDepth: (parent.header.delegationDepth ?? 0) + 1,
+                    },
+                    ...(seed.inherited ? { seed: seed.events, inheritedEventCount: SessionLogOffset(seed.events.length) } : {}),
+                    agentOptions: {
+                        provider: selection.provider,
+                        model: selection.model,
+                        ...(effort === undefined ? {} : { reasoningEffort: effort }),
+                    },
+                    signal: quitAbort.signal,
+                    setup: async (childCtx) => {
+                        await presets.mount(childCtx, mode);
+                    },
+                });
+                // Applied after creation, the same order the main session uses: setup
+                // composes the child's world, it never drives it.
+                if (permissionPresets !== undefined && permissionPresets.names.includes('read-only')) {
+                    selectPermission(permissionPresets, handle.agent.session, 'read-only');
+                }
+                btwHandles.set(id, handle);
+                handle.agent.followup(createUserMessage({
+                    content: [{ type: 'text', text: brief === '' ? text : `${brief}\n\nQuestion: ${text}` }],
+                    source: { kind: 'user' },
+                }));
+            }
+            catch (error) {
+                btwHandles.delete(id);
+                btw.settle(id, quitAbort.signal.aborted ? 'cancelled' : 'failed', error instanceof Error ? error.message : String(error));
+            }
+        })();
+    };
     const forkSession = (argument) => {
         if (session === undefined || active === undefined) {
             bridge.notify('no session yet - submit a message to start', 'warning');
@@ -2008,6 +2095,8 @@ async function run(ctx, startup, io) {
             approval,
             questions,
             subagents,
+            btw,
+            startBtw,
             commands,
             skills,
             model,

package/vendor/tui/lib/locales/en.mjs

@@ -116,6 +116,7 @@ export const en = {
     'cmd.rainbow': 'reroll or pin the rainbow palette (/rainbow [seed])',
     'cmd.animation': 'toggle timed animations (/animation [on|off])',
     'cmd.history': 'search and recall past prompts',
+    'cmd.btw': 'ask a side question beside this session (/btw <question>)',
     'cmd.queue': 'manage messages queued for the next turn',
     'cmd.usage': 'show this session token usage',
     'cmd.agents': 'inspect subagent sessions of this conversation',
@@ -143,6 +144,15 @@ export const en = {
     'help.skillsTitle': ' skills',
     'help.footer': '↑↓ scroll · pgup/pgdn page · g/G ends · esc/q close',
     'help.compact': '/help · esc/q close',
+    'panel.btw.title': 'Side questions (btw)',
+    'panel.btw.running': 'asking',
+    'panel.btw.done': 'answered',
+    'panel.btw.failed': 'failed',
+    'panel.btw.cancelled': 'stopped',
+    'panel.btw.waiting': 'Waiting for the answer...',
+    'panel.btw.empty': 'No side question yet. Ask one with /btw <question>.',
+    'panel.btw.footer': 'esc closes - the main conversation is untouched',
+    'panel.btw.footerMany': '{count} side questions - left/right switches - esc closes',
     'panel.queue.title': '/queue — {count} queued · rows {from}-{to}',
     'panel.queue.empty': '  no messages queued for the next turn',
     'panel.queue.attachments': '[attachments: read-only]',

package/vendor/tui/lib/locales/zh.mjs

@@ -116,6 +116,7 @@ export const zh = {
     'cmd.rainbow': '重掷或指定彩虹配色（/rainbow [seed]）',
     'cmd.animation': '开关计时动画（/animation [on|off]）',
     'cmd.history': '搜索并复用历史提示词',
+    'cmd.btw': '在本会话旁边问一个旁支问题（/btw <问题>）',
     'cmd.queue': '管理等待下一轮的消息',
     'cmd.usage': '查看本会话的 token 用量',
     'cmd.agents': '查看本会话的子代理',
@@ -143,6 +144,15 @@ export const zh = {
     'help.skillsTitle': ' 技能',
     'help.footer': '↑↓ 滚动 · pgup/pgdn 翻页 · g/G 首尾 · esc/q 关闭',
     'help.compact': '/help · esc/q 关闭',
+    'panel.btw.title': '旁注提问（btw）',
+    'panel.btw.running': '回答中',
+    'panel.btw.done': '已回答',
+    'panel.btw.failed': '失败',
+    'panel.btw.cancelled': '已停止',
+    'panel.btw.waiting': '等待回答…',
+    'panel.btw.empty': '还没有旁注提问。用 /btw <问题> 问一个。',
+    'panel.btw.footer': 'esc 关闭 - 主线对话不受影响',
+    'panel.btw.footerMany': '{count} 条旁注 - 左右方向键切换 - esc 关闭',
     'panel.queue.title': '/queue — {count} 条排队消息 · 行 {from}-{to}',
     'panel.queue.empty': '  下一轮没有排队消息',
     'panel.queue.attachments': '[含附件：只读]',

package/vendor/tui/lib/render/projection.mjs

@@ -124,7 +124,7 @@ export function nextEveryTarget(previousTarget, acceptedAt, everySeconds) {
     return previousTarget + missed * interval;
 }
 /** Plugin snapshot sources folded into token stats but never rendered as rows. */
-const HIDDEN_SNAPSHOT_PLUGINS = new Set(['time-context', 'tmux-context']);
+const HIDDEN_SNAPSHOT_PLUGINS = new Set(['time-context', 'tmux-context', 'dscode-time-marks']);
 /** Plugin prompt sources rendered as full user rows (they ARE the conversation). */
 const REMINDER_PLUGINS = new Set(['schedule']);
 /** Assemble the effective system prompt from surface nodes: head text plus every later non-empty node. */

package/vendor/tui/lib/render/status.mjs

@@ -40,6 +40,38 @@ function formatRate(n) {
         return String(Math.round(n));
     return String(Math.round(n / 100) / 10) + 'K';
 }
+/**
+ * Fixed value columns for the footer's live figures. A running turn changes
+ * these numbers every second, so each one renders right-aligned inside its
+ * own columns: a growing value then reshapes its digits without reflowing the
+ * groups after it, and the row's geometry follows terminal width alone. The
+ * widths cover the figures a session reaches in practice (999 turns, 999K
+ * tokens, 120m0s of wall time); a value past its columns simply grows the
+ * group rather than being clipped into a wrong reading.
+ */
+const VALUE_WIDTH = {
+    /** Turn and step counters. */
+    count: 3,
+    /** `12.3K` token totals. */
+    tokens: 5,
+    /** `45.2s` / `2m42s` wall times. */
+    duration: 6,
+    /** `15.3` / `124` / `1.2K` decode rates. */
+    rate: 4,
+    /** `100%` context occupancy. */
+    percentContext: 4,
+    /** `100.0%` cache shares. */
+    percentShare: 6,
+};
+/** Right-align a figure inside its fixed value columns (wider text is left alone). */
+export function padValue(text, width) {
+    const padding = width - visibleColumns(text);
+    return padding > 0 ? ' '.repeat(padding) + text : text;
+}
+/** The `--` placeholder for a figure with no reading yet, in the same columns. */
+function pendingValue(width) {
+    return padValue('--', width);
+}
 /**
  * Cache-hit share of billed prompt-side input. The denominator is the same
  * billed total the /usage panel shows (uncached input plus both cache
@@ -109,18 +141,27 @@ export function contextBar(usedTokens, contextWindow, width) {
  * OUTSIDE the bar, so the dotted track keeps its proportional meaning no
  * matter how wide the readout is. `full` reads `12.3K/1.0M 25%`; `percent`
  * drops the absolute pair; `none` is the bare bar. The readout turns amber
- * once occupancy reaches the warning threshold.
+ * once occupancy reaches the warning threshold. Before a route advertises a
+ * window the empty track still draws and the readout is the `--` placeholder,
+ * so the group keeps its columns from the first frame on.
  */
 export function contextGroupSpans(usedTokens, contextWindow, barWidth, readout) {
     const spans = [{ text: t('status.label.context') + ' ', tone: 'label' }];
-    spans.push(...contextBar(usedTokens, contextWindow, barWidth));
-    if (readout === 'none' || barWidth <= 0 || contextWindow <= 0)
+    const track = contextWindow > 0
+        ? contextBar(usedTokens, contextWindow, barWidth)
+        : barWidth > 0 ? [{ text: '░'.repeat(barWidth), tone: 'label' }] : [];
+    spans.push(...track);
+    if (readout === 'none' || barWidth <= 0)
+        return spans;
+    if (contextWindow <= 0) {
+        spans.push({ text: ' ', tone: 'label' }, { text: pendingValue(VALUE_WIDTH.tokens), tone: 'value' });
         return spans;
+    }
     const used = Math.max(0, usedTokens);
     const percent = Math.round(used / contextWindow * 100);
     const text = readout === 'full'
-        ? `${formatTokens(used)}/${formatTokens(contextWindow)} ${percent}%`
-        : `${percent}%`;
+        ? `${padValue(formatTokens(used), VALUE_WIDTH.tokens)}/${formatTokens(contextWindow)} ${padValue(percent + '%', VALUE_WIDTH.percentContext)}`
+        : padValue(percent + '%', VALUE_WIDTH.percentContext);
     spans.push({ text: ' ', tone: 'label' }, { text, tone: percent >= CONTEXT_WARN_PERCENT ? 'warn' : 'value' });
     return spans;
 }
@@ -289,62 +330,69 @@ function buildCandidates(facts, stats, busy, enabled, contextWidth) {
     ];
     const right = [];
     const row2 = [];
-    if (stats.turns > 0 || stats.steps > 0) {
-        if (enabled.has('turns')) {
-            // Label/value pairs join through explicit dim separators.
-            const counts = [];
-            const pair = (label, value) => {
-                if (counts.length > 0)
-                    counts.push(sep());
-                counts.push({ text: label + ' ', tone: 'label' }, { text: value, tone: 'value' });
-            };
-            pair(t('status.label.turns'), String(stats.turns));
-            pair(t('status.label.steps'), String(stats.steps));
-            row2.push({ group: { spans: counts }, rank: RANK_COUNTS, id: 'turns' });
-        }
-        if (enabled.has('durations')) {
-            // Model round-trip, first-token latency, decode rate, and tool wall
-            // time; the label keeps its one trailing space so each reads as one
-            // figure ('model 45.2s'). Named in full — no single-letter codes.
-            const durations = [];
-            const pair = (label, value) => {
-                if (durations.length > 0)
-                    durations.push(sep());
-                durations.push({ text: label + ' ', tone: 'label' }, { text: value, tone: 'value' });
-            };
-            if (stats.llmMs > 0)
-                pair(t('status.label.modelTime'), formatDuration(stats.llmMs));
-            if (stats.ttftSteps > 0)
-                pair(t('status.label.latency'), formatDuration(stats.ttftMs / stats.ttftSteps));
-            if (stats.decodeMs > 0 && stats.decodeTokens > 0) {
-                if (durations.length > 0)
-                    durations.push(sep());
-                durations.push({ text: formatRate(stats.decodeTokens / (stats.decodeMs / 1_000)), tone: 'value' }, { text: t('status.label.tokensPerSec'), tone: 'label' });
-            }
-            if (stats.toolMs > 0)
-                pair(t('status.label.tool'), formatDuration(stats.toolMs));
-            if (durations.length > 0) {
-                row2.push({ group: { spans: durations }, rank: RANK2_DURATIONS, id: 'durations' });
-            }
-        }
+    if (enabled.has('turns')) {
+        // Label/value pairs join through explicit dim separators. The counters ride
+        // the footer from the first frame on, so a turn opening one never moves the
+        // row.
+        const counts = [];
+        const pair = (label, value) => {
+            if (counts.length > 0)
+                counts.push(sep());
+            counts.push({ text: label + ' ', tone: 'label' }, { text: value, tone: 'value' });
+        };
+        pair(t('status.label.turns'), padValue(String(stats.turns), VALUE_WIDTH.count));
+        pair(t('status.label.steps'), padValue(String(stats.steps), VALUE_WIDTH.count));
+        row2.push({ group: { spans: counts }, rank: RANK_COUNTS, id: 'turns' });
+    }
+    if (enabled.has('durations')) {
+        // Model round-trip, first-token latency, decode rate, and tool wall
+        // time; the label keeps its one trailing space so each reads as one
+        // figure ('model 45.2s'). Named in full — no single-letter codes. A figure
+        // without a reading yet keeps its columns as `--`.
+        const durations = [];
+        const pair = (label, value) => {
+            if (durations.length > 0)
+                durations.push(sep());
+            durations.push({ text: label + ' ', tone: 'label' }, { text: value, tone: 'value' });
+        };
+        const wall = (ms) => ms > 0
+            ? padValue(formatDuration(ms), VALUE_WIDTH.duration)
+            : pendingValue(VALUE_WIDTH.duration);
+        pair(t('status.label.modelTime'), wall(stats.llmMs));
+        pair(t('status.label.latency'), stats.ttftSteps > 0 ? wall(stats.ttftMs / stats.ttftSteps) : pendingValue(VALUE_WIDTH.duration));
+        if (durations.length > 0)
+            durations.push(sep());
+        durations.push({
+            text: stats.decodeMs > 0 && stats.decodeTokens > 0
+                ? padValue(formatRate(stats.decodeTokens / (stats.decodeMs / 1_000)), VALUE_WIDTH.rate)
+                : pendingValue(VALUE_WIDTH.rate),
+            tone: 'value',
+        }, { text: t('status.label.tokensPerSec'), tone: 'label' });
+        pair(t('status.label.tool'), wall(stats.toolMs));
+        row2.push({ group: { spans: durations }, rank: RANK2_DURATIONS, id: 'durations' });
     }
     // The cache group carries both facts about cached prompt tokens: how many
     // were read and what share of the billed prompt that was. The read count
     // lives here rather than in the tokens group so the tokens group keeps
     // meaning "what the provider billed outside the cache".
+    // An unread cache keeps its columns as the `--` placeholder.
     const cacheHit = cacheHitPercent(stats.usage);
-    if (cacheHit !== null && enabled.has('cache')) {
+    if (enabled.has('cache')) {
         const spans = [{ text: t('status.label.cache') + ' ', tone: 'label' }];
-        if (stats.usage.cacheReadTokens > 0) {
-            spans.push({ text: formatTokens(stats.usage.cacheReadTokens), tone: 'value' }, sep());
-        }
-        spans.push({ text: cacheHit + '%', tone: 'value' });
+        spans.push({
+            text: stats.usage.cacheReadTokens > 0
+                ? padValue(formatTokens(stats.usage.cacheReadTokens), VALUE_WIDTH.tokens)
+                : pendingValue(VALUE_WIDTH.tokens),
+            tone: 'value',
+        });
+        spans.push(sep());
+        spans.push({ text: cacheHit === null ? pendingValue(VALUE_WIDTH.percentShare) : padValue(cacheHit + '%', VALUE_WIDTH.percentShare), tone: 'value' });
         row2.push({ group: { spans }, rank: RANK2_CACHE, id: 'cache' });
     }
     // Context occupancy as a purely proportional bar with the usage readout
     // riding outside it: the used total is the most recent reported prompt
     // size against the advertised route capacity.
-    if (stats.contextWindow > 0 && stats.lastPromptTokens > 0 && enabled.has('context')) {
+    if (enabled.has('context')) {
         left.push({
             group: {
                 spans: contextGroupSpans(stats.lastPromptTokens, stats.contextWindow, contextWidth, 'full'),
@@ -353,15 +401,17 @@ function buildCandidates(facts, stats, busy, enabled, contextWidth) {
             id: 'context',
         });
     }
-    if ((stats.usage.uncachedInputTokens > 0 || stats.usage.outputTokens > 0) && enabled.has('tokens')) {
+    // The token totals keep their columns from the first frame on: an unread
+    // total shows its zero in the same width instead of taking the group out.
+    if (enabled.has('tokens')) {
         const tokens = [];
         const pair = (label, value) => {
             if (tokens.length > 0)
                 tokens.push(sep());
             tokens.push({ text: label + ' ', tone: 'label' }, { text: value, tone: 'value' });
         };
-        pair(t('status.label.in'), formatTokens(stats.usage.uncachedInputTokens));
-        pair(t('status.label.out'), formatTokens(stats.usage.outputTokens));
+        pair(t('status.label.in'), padValue(formatTokens(stats.usage.uncachedInputTokens), VALUE_WIDTH.tokens));
+        pair(t('status.label.out'), padValue(formatTokens(stats.usage.outputTokens), VALUE_WIDTH.tokens));
         row2.push({ group: { spans: tokens }, rank: RANK_TOKENS, id: 'tokens' });
     }
     // dscode: the session title moved to row 1's identity lead (dscodeStatusLead),
@@ -394,19 +444,18 @@ function buildCandidates(facts, stats, busy, enabled, contextWidth) {
     // any other preset (a typed /plan mid-session) stays orthogonal: the badge
     // keeps naming the preset and row 2 carries the green plan marker.
     const planStation = facts.plan && permissionTone(permission) === 'success';
-    // dscode: the permission badge rides row 1 beside the title rather than
-    // right-pinning itself on the identity row.
+    // dscode: the permission badge anchors row 1's right edge, so the left
+    // clusters (title, cwd, mode, branch, context) grow and shrink under it
+    // without ever moving it.
     if (permission !== '' && enabled.has('permission')) {
-        left.push({
-            group: {
-                spans: planStation
-                    ? [{ text: 'plan on', tone: 'plan' }]
-                    : [{ text: permission, tone: permissionTone(permission) }],
-            },
+        right.push({
+            span: planStation
+                ? { text: 'plan on', tone: 'plan' }
+                : { text: permission, tone: permissionTone(permission) },
             rank: RANK_BADGE,
             id: 'permission',
         });
-        badge = left.length - 1;
+        badge = right.length - 1;
     }
     if (facts.plan && enabled.has('plan')) {
         row2.push({ group: { spans: [{ text: '⧉ plan', tone: 'accent' }] }, rank: RANK2_PLAN, id: 'plan' });
@@ -446,9 +495,17 @@ export function layoutStatusBar(facts, stats, columns, options = {}) {
     const orderedLeft = [left[0], ...left.slice(1).sort(byPosition)];
     const orderedRight = right.slice().sort(byPosition);
     const orderedRow2 = row2.slice().sort(byPosition);
+    // The cycle hint keeps its columns reserved whether or not it is painted:
+    // the badge anchors the right edge, so a turn opening or closing must not
+    // change what the left clusters may occupy.
     let hint = badge >= 0 && !busy;
+    let hintWidth = badge >= 0 ? visibleColumns(statusCycleHint()) : 0;
     const leftKept = [...orderedLeft];
     const rightKept = [...orderedRight];
+    // Columns the hint reserves: its own text plus the item separator that
+    // joins it to a right cluster, so an idle and a running turn measure the
+    // row identically.
+    const hintSlot = () => hintWidth > 0 && rightKept.length > 0 ? hintWidth + itemSeparator : hintWidth;
     // Context degradation state: the readout drops its absolute pair first,
     // then the bar shrinks inside its own budget, and only then is the whole
     // group removed — the proportional meter outlives the auxiliary numbers.
@@ -470,7 +527,7 @@ export function layoutStatusBar(facts, stats, columns, options = {}) {
     const width = () => {
         const leftWidth = joinWidth(leftKept.map(entry => spansWidth(entry.group.spans)), groupSeparator);
         const rightWidth = joinWidth(rightKept.map(entry => visibleColumns(entry.span.text)), itemSeparator)
-            + (hint ? visibleColumns(statusCycleHint()) : 0);
+            + hintSlot();
         return rightWidth > 0 ? leftWidth + LEFT_RIGHT_GAP + rightWidth : leftWidth;
     };
     while (width() > budget) {
@@ -494,11 +551,11 @@ export function layoutStatusBar(facts, stats, columns, options = {}) {
             leftKept.splice(leftKept.findIndex(entry => entry.id === 'context'), 1);
             continue;
         }
-        if (hint && rightKept.length > 0 && leftKept.length > 0) {
+        if (hintWidth > 0 && rightKept.length > 0 && leftKept.length > 0) {
             const identity = leftKept[0];
             const identityText = identity.group.spans.map(span => span.text).join('');
             const rightWidth = joinWidth(rightKept.map(entry => visibleColumns(entry.span.text)), itemSeparator);
-            const identityBudget = budget - rightWidth - LEFT_RIGHT_GAP - visibleColumns(statusCycleHint());
+            const identityBudget = budget - rightWidth - LEFT_RIGHT_GAP - hintSlot();
             if (identityBudget > 0 && visibleColumns(identityText) > identityBudget) {
                 leftKept[0] = {
                     ...identity,
@@ -507,8 +564,9 @@ export function layoutStatusBar(facts, stats, columns, options = {}) {
                 continue;
             }
         }
-        if (hint) {
+        if (hintWidth > 0) {
             hint = false;
+            hintWidth = 0;
             continue;
         }
         let dropLeft = -1;