@multiclawcli/dashboard 0.12.0 → 0.13.0

package/README.md

@@ -30,12 +30,13 @@ rules are therefore testable without a terminal.
 | Type | Holds |
 |------|-------|
 | `TurnView` | Everything that describes *a turn*: agents, stages, focus, scroll, phase, reply |
-| `TuiState extends TurnView` | The above, for the live turn, plus `name`, `history` and `view` |
+| `TuiState extends TurnView` | The above, for the live turn, plus `name` and `history` |
 
 A finished turn is just a `TurnView` kept in `history`, and every pane takes a `TurnView` — so a past
-turn renders through exactly the same components as the live one. `view` is a *detached* copy of the
-turn being read: `mapShown` routes `tab`, scroll and `/clear` to `view` when one is open, so browsing
-cannot move the focus out from under a run in progress, and cannot rewrite history either.
+turn renders through exactly the same components as the live one. The stream panel reads *past* the
+single turn: `visibleTimeline` concatenates the focused agent's logs from `history` and the live turn,
+with a divider row per turn, and `stream:scroll` / `stream:search` clamp against that whole timeline.
+History is never edited in place — `stream:clear` only empties the live turn's buffer.
 
 ## Source layout
 

package/dist/tui/commands.d.ts

@@ -25,12 +25,20 @@ export interface CommandSpec {
     completes?: "agent";
 }
 export declare const COMMANDS: readonly CommandSpec[];
+export interface CommandContext {
+    history: boolean;
+    retry: boolean;
+    queue: number;
+    paused: boolean;
+    awaitingAnswer: boolean;
+    checkpoint: boolean;
+}
 export interface ParsedCommand {
     name: string;
     args: string[];
 }
 /** Commands that make sense in the current phase. */
-export declare function availableCommands(running: boolean): CommandSpec[];
+export declare function availableCommands(running: boolean, context?: CommandContext): CommandSpec[];
 /**
  * Whether a command may run in the current phase.
  *
@@ -39,26 +47,26 @@ export declare function availableCommands(running: boolean): CommandSpec[];
  * entirely. An unknown name is not "unavailable" — it is let through so the
  * caller's `default:` branch can report it.
  */
-export declare function canRun(name: string, running: boolean): boolean;
+export declare function canRun(name: string, running: boolean, context?: CommandContext): boolean;
 /**
  * Why a command may not run in the current phase, or `undefined` when it may.
  *
  * The mirror of {@link canRun}, and the message names the phase the command
  * *wants* rather than just saying it is unavailable: the two directions mean
  * different things to the user. A mid-run `/replay` has to read as "wait for the
- * turn to finish", while an idle `/cancel` has to read as "this only applies to
+ * turn to finish", while an idle `/steer` has to read as "this only applies to
  * a running turn" — one string for both would leave the user without the fact
  * they need to act on. An unknown name has no reason; it is let through so the
  * caller's `default:` branch can report it.
  */
-export declare function unavailableReason(name: string, running: boolean): string | undefined;
+export declare function unavailableReason(name: string, running: boolean, context?: CommandContext): string | undefined;
 /**
  * Commands matching what has been typed after the slash.
  *
- * Name prefixes outrank description hits: someone typing `/ag` wants `/agents`,
+ * Name prefixes outrank description hits: someone typing `/fo` wants `/focus`,
  * not whichever command happens to mention "agent" in its blurb.
  */
-export declare function matchCommands(query: string, running: boolean): CommandSpec[];
+export declare function matchCommands(query: string, running: boolean, context?: CommandContext): CommandSpec[];
 /** True once the line has committed to command mode. */
 export declare function isCommandLine(text: string): boolean;
 /**

package/dist/tui/components/interaction.d.ts

@@ -12,28 +12,24 @@ import { type FormField, type FormState } from "../interaction";
  * Everything here is one row per fact and clipped by the caller, which is why
  * the row count in `interaction.ts` only has to be an upper bound.
  */
-export declare function PermissionBar({ request, others, cursor, released, width, }: {
+export declare function PermissionBar({ request, others, cursor, released, width, maxRows, }: {
     request: RuntimePermissionRequest;
     /** Requests behind this one, shown so "2 waiting" is not a bare number. */
     others: readonly RuntimePermissionRequest[];
     /** Highlighted option, or `undefined` when nothing has been picked yet. */
     cursor: number | undefined;
-    /** The user asked for the keyboard back; only the commands still reach it. */
+    /** The user asked for the keyboard back; escape returns to its options. */
     released: boolean;
     width: number;
+    maxRows?: number;
 }): import("react").JSX.Element;
 /**
  * The question, as a form.
  *
- * The old path asked for `/respond q1 {"database":"postgres"}` — a hand-written
- * JSON object matching a schema the user could only read in the same terminal
- * that was now occupied by what they were typing. Here every field is a row, the
- * focused row is the one the keystrokes go to, and choices are picked rather
- * than spelled. The prompt below still does the typing: it already owns the
- * caret, the wrapping and the paste handling, so a text field reuses it instead
- * of growing a second editor.
+ * Fields are edited in the prompt, while choice fields use the arrow keys.
+ * Submit, skip and cancel are explicit actions after the last field.
  */
-export declare function QuestionForm({ request, others, fields, form, draft, width, }: {
+export declare function QuestionForm({ request, others, fields, form, draft, width, maxRows, }: {
     request: RuntimeQuestionRequest;
     others: readonly RuntimeQuestionRequest[];
     fields: FormField[];
@@ -41,4 +37,5 @@ export declare function QuestionForm({ request, others, fields, form, draft, wid
     /** Text in the prompt, which is the focused text field's editor. */
     draft: string;
     width: number;
+    maxRows?: number;
 }): import("react").JSX.Element;

package/dist/tui/components/panels.d.ts

@@ -1,5 +1,5 @@
 import type { LeaderMessage } from "@multiclawcli/core";
-import { type TurnView } from "../state";
+import { type TuiState, type TurnView } from "../state";
 /** The roster: one row per agent, with the focused one called out by a caret. */
 export declare function TeamPanel({ turn, width, now, spinner, }: {
     turn: TurnView;
@@ -23,8 +23,8 @@ export declare function Divider(): import("react").JSX.Element;
  * or parked. Output itself is rendered at normal brightness — the chrome is what
  * should recede, not the agent's work.
  */
-export declare function StreamPanel({ turn, height, width, now, spinner, }: {
-    turn: TurnView;
+export declare function StreamPanel({ state, height, width, now, spinner, }: {
+    state: TuiState;
     height: number;
     width: number;
     now: number;

package/dist/tui/interaction.d.ts

@@ -2,19 +2,8 @@
  * The two things an agent can stop and ask for, modelled as something the user
  * can *point at* instead of something they have to spell out.
  *
- * Both used to be answered by command — `/approve p4 1`, `/respond q1
- * {"database":"postgres"}` — which put three transformations between reading a
- * question and answering it: remember an internal alias, map a number back onto
- * a list rendered somewhere else, and hand-write JSON that happens to match a
- * schema. None of those are the decision. So the rendered question becomes the
- * thing that is operated on: the option you are looking at is the option you
- * commit, and the field you are editing is the field that receives the
- * keystroke.
- *
- * Pure on purpose. The keyboard rules are the part of this easiest to get
- * subtly wrong — a bare key that both selects and types, a required field that
- * silently submits empty — so they live here, where they can be tested without
- * rendering a terminal.
+ * The docked controls keep permission decisions and structured answers tied to
+ * their requesting agent while leaving the execution stream visible.
  */
 import type { RuntimePermissionRequest, RuntimeQuestionRequest } from "@multiclawcli/core";
 export type PermissionOptionKind = RuntimePermissionRequest["options"][number]["kind"];

package/dist/tui/layout.d.ts

@@ -72,8 +72,6 @@ export interface LayoutInput {
     promptRows?: number;
     /** Whether a command result is waiting to be shown. */
     notice: boolean;
-    /** A past turn is open for reading, which costs a banner row. */
-    viewing?: boolean;
     /** Whether there is a leader or any stage to draw. */
     hasRail: boolean;
     /**

package/dist/tui/state.d.ts

@@ -131,14 +131,6 @@ export interface TuiState extends TurnView {
     name: string;
     /** Finished turns, oldest first. The live turn is `state` itself. */
     history: TurnView[];
-    /**
-     * A finished turn opened for reading.
-     *
-     * Kept as a detached copy so scrolling and tabbing through it cannot disturb
-     * the turn that is actually running. While it is set the panes render it, and
-     * `focusId` / `scroll` edits land on it rather than on the live turn.
-     */
-    view?: TurnView;
     /**
      * Whether tool detail is shown in the stream.
      *
@@ -180,6 +172,7 @@ export type TuiAction = {
  | {
     type: "stream:search";
     query: string;
+    match?: number;
     viewport: number;
     width: number;
 }
@@ -203,15 +196,6 @@ export type TuiAction = {
     agentId: string;
     text: string;
 }
-/** Open a finished turn for reading, by its turn number. */
- | {
-    type: "view:open";
-    turn: number;
-}
-/** Go back to the live turn. */
- | {
-    type: "view:close";
-}
 /** Flip whether tool detail is shown in the stream. */
  | {
     type: "verbose:toggle";
@@ -272,6 +256,8 @@ export declare function seedAgents(config: MultiClawConfig): Record<string, Agen
  */
 export declare function createInitialState(config: MultiClawConfig, history?: TurnView[]): TuiState;
 export declare function reduceEvent(state: TuiState, event: MultiClawEvent): TuiState;
+/** Matching wrapped rows in the focused agent's entire session. */
+export declare function streamMatches(state: TuiState, query: string, width: number): number[];
 /**
  * The turns worth keeping: those already in `history`, plus the turn on screen
  * once it has ended.
@@ -343,14 +329,20 @@ export interface LogWindow {
     following: boolean;
 }
 /**
- * The slice of the focused agent's output that fits the pane.
+ * The slice of the focused agent's session that fits the pane.
  *
  * Wrapped first, then windowed, and both steps are needed: the pane is a fixed
  * number of *rows*, while the buffer is a string of *lines*, and one line can
  * spend several rows. Slicing lines would hand the pane more rows than it has
  * and push the newest output out of sight.
  *
+ * Turn-divider rows are interspersed to give the reader an anchor: they show
+ * the turn number and a clipped requirement snippet so a reader scrolled back
+ * knows which request they are looking at.
+ *
  * Clamping here as well as in the reducer keeps the window correct even when
- * the pane is resized between two scroll actions.
+ * the pane is resized between two scroll actions. Scroll semantics: 0 means
+ * pinned to the newest output, positive values mean scrolled back, and
+ * `following` is true when the window is at the tail.
  */
-export declare function visibleLog(turn: TurnView, viewport: number, width: number): LogWindow;
+export declare function visibleTimeline(state: TuiState, agentId: string, viewport: number, width: number, scroll: number): LogWindow;