@itookit/dsht 0.3.8 → 0.5.1

package/dist/ui/chat/header.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /** Fixed conversation header: session title, workspace, and the agent-preset label. */
 import { Box, Text } from 'ink';
-import { toolLine } from "../../session/transcript.js";
+import { toolLine } from "../../text.js";
 import { Frozen } from "../frozen.js";
 import { useTheme } from "../theme/index.js";
 /** Session title and optional preset label above the divider.

package/dist/ui/chat/history-view.d.ts

@@ -1,4 +1,4 @@
-import type { HistoryRow } from '../../session/history.ts';
+import type { HistoryRow } from '../../contracts.ts';
 /** Render a viewport with role, reasoning, tool and result colors from the selected theme.
  *
  * Rows are sibling text nodes rather than lines inside one text node: Ink measures and caches text per

package/dist/ui/chat/loop-status.d.ts

@@ -0,0 +1,11 @@
+import type { LoopProgress } from '../../contracts.ts';
+/** Progress line shown above the composer.
+ *
+ * It names no command: the protocol supplies `title`, and the remaining fields are the generic
+ * step/attempt score shape, so a new loop protocol renders here without a UI change.
+ * @param props - The application-produced loop snapshot.
+ * @returns One dim line, brightened while the loop is still running.
+ */
+export declare function LoopStatus({ progress }: {
+    progress: LoopProgress;
+}): import("react").JSX.Element;

package/dist/ui/chat/loop-status.js

@@ -0,0 +1,28 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+/** One-line progress of a client-driven agent loop, for whichever protocol is running. */
+import { Text } from 'ink';
+import { useTheme } from "../theme/index.js";
+/** Progress line shown above the composer.
+ *
+ * It names no command: the protocol supplies `title`, and the remaining fields are the generic
+ * step/attempt score shape, so a new loop protocol renders here without a UI change.
+ * @param props - The application-produced loop snapshot.
+ * @returns One dim line, brightened while the loop is still running.
+ */
+export function LoopStatus({ progress }) {
+    const theme = useTheme();
+    const running = progress.phase === 'running';
+    // A paused run is waiting for the operator, not finished: the line says what to do about it.
+    const paused = progress.active && progress.phase === 'needs-human';
+    // A run stopped on a host request shows what the host is waiting for, not just the phase name.
+    const interaction = progress.interaction === undefined ? '' : ` · ${progress.interaction.kind}: ${progress.interaction.text}`;
+    // A run a verifier ended early says why: the reason is the only part of that verdict a reader acts on.
+    const exit = progress.exit === undefined ? '' : ` · ${progress.exit.reason}`;
+    // `passed` only claims the rounds that ran, so the line says which ones it covered.
+    const scope = progress.phase === 'passed' ? ` · ${progress.scope}` : '';
+    // What the live run waits on is controller data, not a note: a work turn is already visible as the
+    // session working, so only the states without a host turn of their own are named here.
+    const activity = running && progress.activity !== undefined && progress.activity !== 'turn'
+        ? ` · ${progress.activity}` : '';
+    return _jsxs(Text, { color: progress.active ? theme.colors.context : theme.colors.muted, children: [progress.title, progress.stepLabel === undefined ? '' : ` · ${progress.stepLabel}`, " \u00B7 step ", progress.step, "/", progress.to, " \u00B7 attempt ", progress.attempt, "/", progress.tries, " \u00B7 best ", progress.best, "/", progress.score, running ? '' : paused ? ' · needs you · /loop answer' : ` · ${progress.phase}`, activity, scope, exit, interaction, progress.note === undefined ? '' : ` · ${progress.note}`] });
+}

package/dist/ui/chat/navigation-model.d.ts

@@ -0,0 +1,86 @@
+/** Presentation model for the workspace and session lists.
+ *
+ * Marker, label and rollup text are the list screens' vocabulary, so they live next to the screens
+ * that render them. `session/navigation.ts` keeps only target resolution, which the domain needs.
+ */
+import { type ObjectValue } from '../../json.ts';
+/** User-visible activity of one session, most actionable first.
+ *
+ * `needs` is the only state that asks the user to do something, and it outranks the host's running
+ * flag because a turn waiting on an answer is running only in the mechanical sense. `blank` stays a
+ * marker for a session that never sent a turn, but it is not a status and never enters a rollup.
+ */
+export type SessionState = 'needs' | 'running' | 'idle' | 'blank';
+/** Classify one session from the host's list summary; nothing is inferred from silence.
+ * @param session - Session summary from `session/list`.
+ * @param pending - Whether this client holds an unanswered interaction for that session.
+ * @returns Needs-you while an answer is owed, running while its agent works, otherwise idle or blank.
+ */
+export declare function sessionState(session: ObjectValue, pending?: boolean): SessionState;
+/** Leading marker per state: a question mark, a working clock, a filled dot, and an unused circle. */
+export declare const SESSION_MARKERS: Record<SessionState, string>;
+/** One word per state, so every screen names the same state the same way. */
+export declare const STATE_LABELS: Record<SessionState, string>;
+/** Coarse age of a session's last activity, so the column stays steady between list refreshes.
+ * @param time - Epoch milliseconds of the last activity, when the summary reported one.
+ * @param now - Current epoch milliseconds.
+ * @returns `now`, minutes, hours or days.
+ */
+export declare function activityAge(time: number | undefined, now: number): string;
+/** Status cell for one session row: its state marker and the age of its last activity.
+ * @param session - Session summary from `session/list`.
+ * @param now - Current epoch milliseconds.
+ * @param pending - Whether this client holds an unanswered interaction for that session.
+ * @returns Marker with an optional age, without a trailing space when unknown.
+ */
+export declare function sessionStatus(session: ObjectValue, now: number, pending?: boolean): string;
+/** States a workspace rollup reports, most actionable first. */
+export declare const ROLLUP_STATES: readonly ["needs", "running", "idle"];
+/** One state a workspace rollup reports. */
+export type RollupState = (typeof ROLLUP_STATES)[number];
+/** One counted state of a workspace rollup. */
+export interface RollupCount {
+    state: RollupState;
+    count: number;
+}
+/** How much room a rollup has for words. */
+export type RollupStyle = 'words' | 'badges';
+/** Count the sessions of one workspace by the state each reports.
+ *
+ * Blank sessions are counted by neither a badge nor a word: a session that never sent a turn is the
+ * absence of activity, and listing it beside real work only makes the rollup harder to read.
+ * @param sessions - Sessions whose `sessionIds` belong to the workspace.
+ * @param pending - Session IDs this client holds an unanswered interaction for.
+ * @returns One count per state that occurs, most actionable first, or an empty list.
+ */
+export declare function workspaceCounts(sessions: readonly ObjectValue[], pending?: ReadonlySet<string>): RollupCount[];
+/** Render one rollup as separately coloured cells.
+ *
+ * Each cell after the first carries the separator that joins it to the previous one, so a caller can
+ * colour the cells independently without losing the text {@link workspaceStatus} would produce.
+ * @param counts - Counts from {@link workspaceCounts}.
+ * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
+ * @returns The cells in the order given, with their separators.
+ */
+export declare function workspaceSegments(counts: readonly RollupCount[], style?: RollupStyle): {
+    state: RollupState;
+    text: string;
+}[];
+/** Render one rollup as plain text, the same way every screen and test reads it.
+ * @param counts - Counts from {@link workspaceCounts}.
+ * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
+ * @returns The joined cell text, empty when nothing was counted.
+ */
+export declare function workspaceStatus(counts: readonly RollupCount[], style?: RollupStyle): string;
+/** Marker key for the compact rollup, which has no room for the words. */
+export declare const ROLLUP_LEGEND: string;
+/** Secondary path text for one workspace row.
+ *
+ * The title is usually the last path segment, so repeating it wastes the row; the parent directory
+ * is what distinguishes two checkouts. A title that does not name the last segment keeps the full
+ * path, because dropping it would hide where the workspace actually lives.
+ * @param path - Registered host directory.
+ * @param title - Workspace title as the row already shows it.
+ * @returns The path to show beside the row, or an empty string when nothing is left.
+ */
+export declare function workspaceDetail(path: string, title: string): string;

package/dist/ui/chat/navigation-model.js

@@ -0,0 +1,107 @@
+/** Classify one session from the host's list summary; nothing is inferred from silence.
+ * @param session - Session summary from `session/list`.
+ * @param pending - Whether this client holds an unanswered interaction for that session.
+ * @returns Needs-you while an answer is owed, running while its agent works, otherwise idle or blank.
+ */
+export function sessionState(session, pending = false) {
+    if (pending)
+        return 'needs';
+    if (session.running === true)
+        return 'running';
+    return session.blank === true ? 'blank' : 'idle';
+}
+/** Leading marker per state: a question mark, a working clock, a filled dot, and an unused circle. */
+export const SESSION_MARKERS = { needs: '?', running: '◐', idle: '●', blank: '○' };
+/** One word per state, so every screen names the same state the same way. */
+export const STATE_LABELS = { needs: 'needs you', running: 'working', idle: 'ready', blank: 'empty' };
+/** Coarse age of a session's last activity, so the column stays steady between list refreshes.
+ * @param time - Epoch milliseconds of the last activity, when the summary reported one.
+ * @param now - Current epoch milliseconds.
+ * @returns `now`, minutes, hours or days.
+ */
+export function activityAge(time, now) {
+    if (time === undefined || !Number.isFinite(time))
+        return '';
+    const seconds = Math.max(0, Math.floor((now - time) / 1000));
+    if (seconds < 60)
+        return 'now';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    return hours < 24 ? `${hours}h` : `${Math.floor(hours / 24)}d`;
+}
+/** Status cell for one session row: its state marker and the age of its last activity.
+ * @param session - Session summary from `session/list`.
+ * @param now - Current epoch milliseconds.
+ * @param pending - Whether this client holds an unanswered interaction for that session.
+ * @returns Marker with an optional age, without a trailing space when unknown.
+ */
+export function sessionStatus(session, now, pending = false) {
+    const age = activityAge(typeof session.updatedAt === 'number' ? session.updatedAt : undefined, now);
+    return `${SESSION_MARKERS[sessionState(session, pending)]}${age === '' ? '' : ` ${age}`}`;
+}
+/** States a workspace rollup reports, most actionable first. */
+export const ROLLUP_STATES = ['needs', 'running', 'idle'];
+/** Count the sessions of one workspace by the state each reports.
+ *
+ * Blank sessions are counted by neither a badge nor a word: a session that never sent a turn is the
+ * absence of activity, and listing it beside real work only makes the rollup harder to read.
+ * @param sessions - Sessions whose `sessionIds` belong to the workspace.
+ * @param pending - Session IDs this client holds an unanswered interaction for.
+ * @returns One count per state that occurs, most actionable first, or an empty list.
+ */
+export function workspaceCounts(sessions, pending = new Set()) {
+    const counts = { needs: 0, running: 0, idle: 0 };
+    for (const session of sessions) {
+        const id = session.sessionId;
+        const state = sessionState(session, typeof id === 'string' && pending.has(id));
+        if (state !== 'blank')
+            counts[state] += 1;
+    }
+    return ROLLUP_STATES.filter(state => counts[state] > 0).map(state => ({ state, count: counts[state] }));
+}
+/** Render one rollup as separately coloured cells.
+ *
+ * Each cell after the first carries the separator that joins it to the previous one, so a caller can
+ * colour the cells independently without losing the text {@link workspaceStatus} would produce.
+ * @param counts - Counts from {@link workspaceCounts}.
+ * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
+ * @returns The cells in the order given, with their separators.
+ */
+export function workspaceSegments(counts, style = 'words') {
+    const separator = style === 'words' ? ' · ' : ' ';
+    return counts.map(({ state, count }, index) => ({ state,
+        text: `${index === 0 ? '' : separator}${style === 'words' ? `${SESSION_MARKERS[state]} ${count} ${STATE_LABELS[state]}` : `${SESSION_MARKERS[state]}${count}`}` }));
+}
+/** Render one rollup as plain text, the same way every screen and test reads it.
+ * @param counts - Counts from {@link workspaceCounts}.
+ * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
+ * @returns The joined cell text, empty when nothing was counted.
+ */
+export function workspaceStatus(counts, style = 'words') {
+    return workspaceSegments(counts, style).map(segment => segment.text).join('');
+}
+/** Marker key for the compact rollup, which has no room for the words. */
+export const ROLLUP_LEGEND = `${SESSION_MARKERS.idle} ${STATE_LABELS.idle} · ${SESSION_MARKERS.running} ${STATE_LABELS.running} · ${SESSION_MARKERS.needs} ${STATE_LABELS.needs}`;
+/** Secondary path text for one workspace row.
+ *
+ * The title is usually the last path segment, so repeating it wastes the row; the parent directory
+ * is what distinguishes two checkouts. A title that does not name the last segment keeps the full
+ * path, because dropping it would hide where the workspace actually lives.
+ * @param path - Registered host directory.
+ * @param title - Workspace title as the row already shows it.
+ * @returns The path to show beside the row, or an empty string when nothing is left.
+ */
+export function workspaceDetail(path, title) {
+    if (!path)
+        return '';
+    const trimmed = path.replace(/\/+$/u, '');
+    const cut = trimmed.lastIndexOf('/');
+    const base = cut < 0 ? trimmed : trimmed.slice(cut + 1);
+    if (base !== title)
+        return path;
+    if (cut > 0)
+        return trimmed.slice(0, cut);
+    return cut === 0 ? '/' : '';
+}

package/dist/ui/chat/shell-view.d.ts

@@ -1,5 +1,5 @@
-import { type HistoryRow } from '../../session/history.ts';
-import type { ShellBlock } from '../../shell/index.ts';
+import type { HistoryRow, RowKind } from '../../contracts.ts';
+import type { ShellBlock } from '../../contracts.ts';
 /** The part of a transcript layout this module needs to place a block. */
 export interface RowSource {
     /** Number of host rows, live tail included. */
@@ -30,5 +30,18 @@ export declare function blockRows(run: ShellBlock, width: number): HistoryRow[];
  */
 export declare function mergeShellRuns(layout: RowSource, runs: readonly ShellBlock[], width: number): {
     total: number;
+    /** Merged row index of each block bar that opens a readable source, to its source id. */
+    sources: ReadonlyMap<number, string>;
     viewport(start: number, end: number): HistoryRow[];
 };
+/** Wrap plain local text into terminal rows, preserving its own whitespace.
+ *
+ * Command output is aligned by spaces and indented by stack traces, so this never collapses runs of
+ * whitespace the way tool summaries do; only the terminal width decides where a row breaks.
+ * @param text - Raw text, possibly containing newlines.
+ * @param width - Available terminal columns.
+ * @param kind - Row kind used for coloring.
+ * @param highlight - Whether the rows are a local command line drawn on the command bar.
+ * @returns One row per wrapped terminal line; empty text yields one empty row.
+ */
+export declare function plainRows(text: string, width: number, kind: RowKind, highlight?: boolean): HistoryRow[];

package/dist/ui/chat/shell-view.js

@@ -5,7 +5,7 @@
  * the bottom of the screen.
  */
 import stringWidth from 'string-width';
-import { plainRows } from "../../session/history.js";
+import wrapAnsi from 'wrap-ansi';
 /** First output row's marker, so a block reads as the command's result. */
 const MARKER = '  ⎿  ';
 /** Rows after the first, aligned under the marker. */
@@ -17,7 +17,16 @@ const GUTTER = '   ';
  */
 export function blockRows(run, width) {
     const reserve = Math.max(stringWidth(MARKER), stringWidth(GUTTER));
-    const rows = [{ text: `! ${run.command}`, kind: 'shell', bold: true, highlight: true }];
+    const rows = [{ text: run.kind === 'note' ? run.command : `! ${run.command}`,
+            kind: 'shell', bold: true, highlight: true }];
+    // A note produced nothing to show, so its second row is the action itself. The label is the whole
+    // affordance — a sentence saying "click this bar" left the reader clicking a row that was not the
+    // bar — and every row of a note opens the source (see `mergeShellRuns`).
+    if (run.kind === 'note') {
+        rows.push({ text: run.source === undefined ? `${MARKER}no readable session yet` : `${MARKER}view`,
+            kind: 'shell', bold: true });
+        return rows;
+    }
     const body = [
         ...(run.dropped > 0 ? [`… ${run.dropped} earlier lines dropped …`] : []),
         ...run.lines,
@@ -67,10 +76,12 @@ function rowAfter(layout, anchor) {
  */
 export function mergeShellRuns(layout, runs, width) {
     const placements = [];
+    const sources = new Map();
     let cursor = 0;
     for (const run of runs) {
         const at = Math.max(cursor, Math.min(layout.length, rowAfter(layout, run.anchor)));
-        placements.push({ at, rows: blockRows(run, width) });
+        placements.push({ at, rows: blockRows(run, width), ...(run.source === undefined ? {} : { source: run.source }),
+            ...(run.kind === 'note' ? { whole: true } : {}) });
         cursor = at;
     }
     // Segments alternate host rows and block rows in merged index order.
@@ -82,6 +93,13 @@ export function mergeShellRuns(layout, runs, width) {
             merged += placement.at - host;
             host = placement.at;
         }
+        // Only a `!` block's first row is its bar; the rows under it are its output, not its identity.
+        // A note has no output, so all of its rows open what it points at.
+        if (placement.source !== undefined) {
+            const opening = placement.whole === true ? placement.rows.length : 1;
+            for (let offset = 0; offset < opening; offset += 1)
+                sources.set(merged + offset, placement.source);
+        }
         segments.push({ from: merged, count: placement.rows.length, rows: placement.rows });
         merged += placement.rows.length;
     }
@@ -90,6 +108,7 @@ export function mergeShellRuns(layout, runs, width) {
     const total = merged + Math.max(0, layout.length - host);
     return {
         total,
+        sources,
         viewport(start, end) {
             const rows = [];
             for (const segment of segments) {
@@ -109,3 +128,18 @@ export function mergeShellRuns(layout, runs, width) {
         },
     };
 }
+/** Wrap plain local text into terminal rows, preserving its own whitespace.
+ *
+ * Command output is aligned by spaces and indented by stack traces, so this never collapses runs of
+ * whitespace the way tool summaries do; only the terminal width decides where a row breaks.
+ * @param text - Raw text, possibly containing newlines.
+ * @param width - Available terminal columns.
+ * @param kind - Row kind used for coloring.
+ * @param highlight - Whether the rows are a local command line drawn on the command bar.
+ * @returns One row per wrapped terminal line; empty text yields one empty row.
+ */
+export function plainRows(text, width, kind, highlight = false) {
+    const columns = Math.max(1, width);
+    const wrapped = wrapAnsi(text === '' ? ' ' : text, columns, { hard: true, trim: false });
+    return wrapped.split('\n').map(line => ({ text: line, kind, ...(highlight ? { highlight: true } : {}) }));
+}

package/dist/ui/chat/status.d.ts

@@ -1,5 +1,49 @@
-import type { Controller } from '../../controller/controller.ts';
-import { type ObjectValue } from '../../transport/wire.ts';
+import type { ClientActivity, Coverage, LivePhase } from '../../contracts.ts';
+/** One formatted cost scope, with the raw totals the money column needs. */
+export interface StatusCostLine {
+    text: string;
+    amount: number;
+    unknown: number;
+}
+/** Everything the status bar renders, as plain data the composition root assembles. */
+export interface StatusSource {
+    /** Host origin, so a reader can tell which deployment the numbers describe. */
+    host: string;
+    online: boolean;
+    status: string;
+    running: boolean;
+    /** What the client is working on now, merged by the controller: a host turn or a running loop.
+     *
+     * The bar renders this and never merges sources itself, so "busy", its clock and the loop's
+     * sub-state all come from one controller-owned answer.
+     */
+    activity?: ClientActivity;
+    sessionId?: string;
+    sessionMode?: string;
+    workspaceLabel: string;
+    activeTurnStartedAt?: number;
+    pendingCount: number;
+    /** What the live attempt is doing now, straight from the record. */
+    livePhase?: LivePhase;
+    /** Retained host projections for the selected session. */
+    values: ObjectValue;
+    queued?: number;
+    jobs?: number;
+    defaultModel?: ObjectValue;
+    /** Billing summary; absent when this run has no ledger. */
+    cost?: {
+        sessionText: string;
+        /** Read on every render, so a day rollover reaches the bar without an application re-render. */
+        today(): StatusCostLine;
+        session(): StatusCostLine | undefined;
+        coverage: Coverage;
+        error?: string;
+    };
+    controlError?: string;
+    presetError?: string;
+    modelError?: string;
+}
+import type { ObjectValue } from '../../json.ts';
 /** Format elapsed wall time, clamping clock skew instead of displaying negative durations.
  * @param milliseconds - Elapsed duration.
  * @returns Minute/second display, with hours when needed.
@@ -77,7 +121,7 @@ export declare function phaseText(milliseconds: number): string;
 export declare function compactStatusRows(groups: StatusGroups, width: number): StatusSegment[][];
 /** Render a live clock and selected-session metadata; the timer belongs to this mounted bar. */
 export declare const StatusBar: import("react").NamedExoticComponent<{
-    controller: Controller;
+    source: StatusSource;
     expanded?: boolean;
     width?: number;
     revision?: number;

package/dist/ui/chat/status.js

@@ -5,9 +5,8 @@ import { memo, useEffect, useState } from 'react';
 import { Box, Text, useStdout } from 'ink';
 import wrapAnsi from 'wrap-ansi';
 import stringWidth from 'string-width';
-import { costText } from "../../cost/index.js";
-import { toolLine } from "../../session/transcript.js";
-import { safeText } from "../../transport/wire.js";
+import { toolLine } from "../../text.js";
+import { safeText } from "../../text.js";
 /** Format elapsed wall time, clamping clock skew instead of displaying negative durations.
  * @param milliseconds - Elapsed duration.
  * @returns Minute/second display, with hours when needed.
@@ -215,32 +214,33 @@ function measure(row) {
     return row.reduce((sum, segment) => sum + stringWidth(segment.text), 0);
 }
 /** Render a live clock and selected-session metadata; the timer belongs to this mounted bar. */
-export const StatusBar = memo(function StatusBar({ controller, expanded = false, width, scroll = 0, pageSize, onScroll, onOverflow, onRows, pauseReason }) {
+export const StatusBar = memo(function StatusBar({ source, expanded = false, width, scroll = 0, pageSize, onScroll, onOverflow, onRows, pauseReason }) {
     const paused = pauseReason !== undefined;
     const theme = useTheme();
     const { stdout } = useStdout();
     const [now, setNow] = useState(Date.now);
     const [reported, setReported] = useState(1);
-    const running = controller.running;
-    const since = controller.workingSince;
+    const running = source.running;
+    const activity = source.activity;
+    // The controller already merged a turn and a loop into one answer; the bar only draws it.
+    const busy = activity !== undefined;
+    const since = activity?.kind === 'turn' ? activity.since : activity?.kind === 'loop' ? activity.startedAt : undefined;
     useEffect(() => {
         setNow(Date.now());
         if (paused)
             return;
         // An idle bar still re-reads the clock, so a day rollover reaches the cost it reports without
-        // waiting for an unrelated render; a running bar keeps its per-second clock.
-        const timer = setInterval(() => setNow(Date.now()), running ? 1000 : 60_000);
+        // waiting for an unrelated render; a busy bar keeps its per-second clock.
+        const timer = setInterval(() => setNow(Date.now()), busy ? 1000 : 60_000);
         return () => clearInterval(timer);
-    }, [running, since, paused]);
-    const state = controller.state;
-    const workspace = state.workspaces.find(item => item.workspaceId === state.workspaceId);
-    const view = controller.telemetry.view(state.sessionId);
-    const costs = controller.costs;
-    const sessionCost = controller.sessionCostText;
-    const todayCost = costs ? costText(costs.today()) : '?';
+    }, [busy, since, paused]);
+    const state = source;
+    const view = { values: source.values, queued: source.queued, jobs: source.jobs };
+    const costs = source.cost;
+    const sessionCost = source.cost?.sessionText ?? '?';
     // `*` belongs to costText alone; incomplete coverage is a separate degradation, reported by `!`.
-    const coverage = costs?.coverage ?? 'complete';
-    const label = workspace ? `${workspace.title} · ${workspace.path}` : 'none selected';
+    const coverage = source.cost?.coverage ?? 'complete';
+    const label = source.workspaceLabel;
     if (!expanded) {
         const selection = record(view.values.modelSelection);
         const route = record(running ? selection.lastUsed ?? selection.next ?? state.defaultModel : selection.next ?? selection.lastUsed ?? state.defaultModel);
@@ -258,29 +258,38 @@ export const StatusBar = memo(function StatusBar({ controller, expanded = false,
         const billed = buckets[0] === undefined || buckets[2] === undefined ? undefined : buckets[0] + buckets[2] + (buckets[3] ?? 0);
         const hit = cacheHitText(buckets[2], billed);
         const compactCount = (value) => value === undefined ? '?' : compactNumber.format(value);
-        const phase = state.session.record.livePhase;
-        const clock = running && since !== undefined ? ` ${clockText(now - since)}` : '';
+        const phase = source.livePhase;
+        const clock = busy && since !== undefined ? ` ${clockText(now - since)}` : '';
         const phaseLabel = phase === undefined ? undefined
             : phase.kind === 'tool' ? `${phase.name ?? 'tool'} ${phaseText(now - phase.startedAt)}`
                 : `${phase.kind === 'thinking' ? 'think' : 'write'} ${phaseText(now - phase.startedAt)}`;
+        // A host turn's phase wins; without one, the controller's loop activity names what the client is
+        // doing, so the bar never reports an idle session while a review is in flight.
+        const phaseSegment = !busy ? undefined
+            : phaseLabel !== undefined ? { text: phaseLabel }
+                : activity?.kind === 'loop' ? { text: `${activity.activity} ${activity.step}/${activity.total}` }
+                    : activity?.kind === 'paused' ? { text: 'needs you' }
+                        : undefined;
         // The state token reports a fact and never guesses: a paused clock is named, offline and errors
         // take the token over, and an unknown phase simply leaves the phase group empty. An answer this
         // client still owes outranks the paused reason, because that reason is only why the clock stopped.
-        const stateToken = !state.online
+        const stateToken = !source.online
             ? { text: '! Offline', color: theme.status.offline }
-            : state.controlError || state.modelError
+            : source.controlError || source.modelError
                 ? { text: '⚠ Error', color: theme.status.warning }
-                : state.pending.length > 0
+                : source.pendingCount > 0
                     ? { text: '? Needs you', color: theme.status.critical }
                     : pauseReason !== undefined
                         ? { text: `⏸ ${pauseReason}${clock}`, color: theme.colors.muted }
-                        : running ? { text: `◐${clock}`, color: theme.status.working } : { text: '● Ready', color: theme.status.ready };
+                        : activity?.kind === 'paused' ? { text: '⏸ needs you', color: theme.status.critical }
+                            : busy ? { text: `◐${clock}`, color: theme.status.working } : { text: '● Ready', color: theme.status.ready };
         // One marker covers both scopes, because either an unpriceable record or a scan that has not
         // covered every session makes the pair inexact as a reading.
         const inexact = coverage !== 'complete';
         const money = (session, today) => `¥: ${session === undefined ? '?' : session.amount.toFixed(2)}(${today.amount.toFixed(2)})${session?.unknown || today.unknown || inexact ? '*' : ''}`;
+        // Read here rather than from a snapshot, so the bar's own clock drives a day rollover.
         const todayTotal = costs?.today();
-        const sessionTotal = costs !== undefined && costs.hasSession(state.sessionId) ? costs.total(state.sessionId) : undefined;
+        const sessionTotal = costs?.session();
         const contextColor = percent === undefined ? theme.status.usage
             : percent >= 95 ? theme.status.critical : percent >= 80 ? theme.status.warning : theme.status.context;
         // Ten cells resolve context to tenths, the same resolution the percentage beside them reports.
@@ -288,10 +297,11 @@ export const StatusBar = memo(function StatusBar({ controller, expanded = false,
         const groups = {
             state: stateToken,
             // A paused bar keeps the phase: the reason already says why the clock stopped, and dropping the
-            // running tool would leave the one question this bar exists to answer unanswered. A ready bar
-            // has none: the transcript keeps the last event it saw, and only the host knows the turn ended.
-            ...(phaseLabel === undefined || !running ? {} : { phase: { text: phaseLabel } }),
-            ...(running && pauseReason === undefined ? { stop: { text: '^C' } } : {}),
+            // running tool would leave the one question this bar exists to answer unanswered. A bar with no
+            // work of its own has none: the transcript keeps the last event it saw, and only the host knows
+            // the turn ended.
+            ...(phaseSegment === undefined ? {} : { phase: phaseSegment }),
+            ...(busy && pauseReason === undefined ? { stop: { text: '^C' } } : {}),
             ...(todayTotal === undefined ? {} : { cost: { text: money(sessionTotal, todayTotal), color: theme.status.cost } }),
             ...(percent === undefined ? {} : {
                 context: { text: `ctx ${percent}%`, color: contextColor },
@@ -310,26 +320,27 @@ export const StatusBar = memo(function StatusBar({ controller, expanded = false,
         }
         return _jsx(Box, { flexDirection: "column", children: rows.map((row, index) => _jsx(Text, { wrap: "truncate-end", children: row.map((segment, position) => _jsx(Text, { color: segment.color ?? theme.colors.muted, bold: index === 0 && position === 0, children: segment.text }, position)) }, index)) });
     }
-    return _jsx(StatusDetails, { controller: controller, theme: theme, width: width, now: now, scroll: scroll, pageSize: pageSize, onScroll: onScroll, onOverflow: onOverflow });
+    return _jsx(StatusDetails, { source: source, theme: theme, width: width, now: now, scroll: scroll, pageSize: pageSize, onScroll: onScroll, onOverflow: onOverflow });
 });
 /** Expanded detail panel.
  *
  * It is a separate component because it is the only branch that scrolls, and a hook behind the
  * collapsed branch's early return would change the hook order between the two states.
  */
-const StatusDetails = memo(function StatusDetails({ controller, theme, width, now, scroll, pageSize, onScroll, onOverflow }) {
+const StatusDetails = memo(function StatusDetails({ source, theme, width, now, scroll, pageSize, onScroll, onOverflow }) {
     const { stdout } = useStdout();
-    const state = controller.state;
-    const running = controller.running;
-    const since = controller.workingSince;
-    const workspace = state.workspaces.find(item => item.workspaceId === state.workspaceId);
-    const view = controller.telemetry.view(state.sessionId);
-    const costs = controller.costs;
-    const sessionCost = controller.sessionCostText;
-    const todayCost = costs ? costText(costs.today()) : '?';
+    const state = source;
+    const running = source.running;
+    const activity = source.activity;
+    const busy = activity !== undefined;
+    const since = activity?.kind === 'turn' ? activity.since : activity?.kind === 'loop' ? activity.startedAt : undefined;
+    const view = { values: source.values, queued: source.queued, jobs: source.jobs };
+    const costs = source.cost;
+    const sessionCost = source.cost?.sessionText ?? '?';
+    const todayCost = source.cost?.today().text ?? '?';
     // `*` belongs to costText alone; incomplete coverage is a separate degradation, reported by `!`.
-    const coverage = costs?.coverage ?? 'complete';
-    const label = workspace ? `${workspace.title} · ${workspace.path}` : 'none selected';
+    const coverage = source.cost?.coverage ?? 'complete';
+    const label = source.workspaceLabel;
     // Every detail row wraps to the terminal width, so a narrow terminal loses nothing; lines that
     // still do not fit are scrolled rather than dropped, because the panel shares the screen height.
     // Rows are merged and labelled compactly so a normal terminal shows every detail on one screen;
@@ -337,23 +348,27 @@ const StatusDetails = memo(function StatusDetails({ controller, theme, width, no
     const turns = count(numeric(record(view.values.sessionStats).turns));
     const duration = since === undefined ? 'unknown duration' : elapsedTime(now - since);
     const detail = [
-        { key: 'activity', color: state.pending.length > 0 ? theme.status.critical : running ? theme.colors.context : theme.colors.muted, text: state.pending.length > 0
+        { key: 'activity', color: source.pendingCount > 0 ? theme.status.critical : busy ? theme.colors.context : theme.colors.muted, text: source.pendingCount > 0
                 ? '? Needs you · answer the request above to continue'
                 : running
-                    ? `◐ Working · ${duration}${state.session.record.activeTurnStartedAt === undefined ? ' (observed)' : ''} · Ctrl+C Stop`
-                    : '● Ready · Ctrl+C exit' },
-        { key: 'host', text: `${safeText(controller.base)} · ${safeText(state.status)}${!state.online ? ' · offline, last known status' : ''}` },
-        ...state.sessionId
-            ? [{ key: 'session', text: `Session ${safeText(state.sessionId)}${controller.sessionMode ? ` · ${safeText(controller.sessionMode)}` : ''}` }] : [],
+                    ? `◐ Working · ${duration}${source.activeTurnStartedAt === undefined ? ' (observed)' : ''} · Ctrl+C Stop`
+                    : activity?.kind === 'loop'
+                        ? `◐ ${activity.activity} ${activity.step}/${activity.total} · ${duration} · Ctrl+C Stop`
+                        : activity?.kind === 'paused'
+                            ? `⏸ ${activity.title} · needs you · /loop answer <text> or /loop abort`
+                            : '● Ready · Ctrl+C exit' },
+        { key: 'host', text: `${safeText(source.host)} · ${safeText(state.status)}${!source.online ? ' · offline, last known status' : ''}` },
+        ...source.sessionId
+            ? [{ key: 'session', text: `Session ${safeText(source.sessionId)}${source.sessionMode ? ` · ${safeText(source.sessionMode)}` : ''}` }] : [],
         { key: 'workspace', text: `Workspace ${safeText(label)}` },
-        ...metricLines(view.values, state.defaultModel, running).map((line, index) => ({ key: `metric-${index}`, text: safeText(line), dim: true })),
+        ...metricLines(view.values, source.defaultModel, running).map((line, index) => ({ key: `metric-${index}`, text: safeText(line), dim: true })),
         ...costs ? [{ key: 'cost', text: `Cost ${sessionCost} session · ${todayCost} today · ${turns} turns`, dim: true }] : [],
         { key: 'queued', text: `Queued ${count(view.queued)} · Jobs ${count(view.jobs)}${costs ? '' : ` · ${turns} turns`}`, dim: true },
         ...costs && coverage === 'partial'
             ? [{ key: 'coverage', color: theme.colors.context, text: `Cost coverage incomplete: ${costs.error ? safeText(costs.error) : 'no complete scan yet'}` }] : [],
-        ...state.controlError ? [{ key: 'control-error', color: theme.colors.context, text: safeText(state.controlError) }] : [],
-        ...state.presetError ? [{ key: 'preset-error', color: theme.colors.context, text: `Preset names unavailable: ${safeText(state.presetError)}` }] : [],
-        ...state.modelError ? [{ key: 'model-error', color: theme.colors.context, text: `Model catalog unavailable: ${safeText(state.modelError)}` }] : [],
+        ...source.controlError ? [{ key: 'control-error', color: theme.colors.context, text: safeText(source.controlError) }] : [],
+        ...source.presetError ? [{ key: 'preset-error', color: theme.colors.context, text: `Preset names unavailable: ${safeText(source.presetError)}` }] : [],
+        ...source.modelError ? [{ key: 'model-error', color: theme.colors.context, text: `Model catalog unavailable: ${safeText(source.modelError)}` }] : [],
     ];
     // Border and horizontal padding take four columns, so a detail row wraps inside what is left.
     const inner = Math.max(1, (width ?? Math.max(3, (stdout.columns ?? 80) - 2)) - 4);