@qwen-code/web-shell 0.25.1-preview.0 → 0.25.1-preview.1

package/dist/types/components/workspace-agents/agent-events.d.ts

@@ -4,47 +4,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
- * Client for `GET /workspaces/:ws/agent/events`, the collaboration stream.
+ * Client for the session-agents stream under `/workspaces/:ws/agent/`
+ * (`session-events?sessionId=`: a chat session's live agent runs). The roster
+ * has no stream; the Agents page polls it.
  *
  * `fetch` rather than `EventSource`: the daemon wants a bearer header, which
  * `EventSource` cannot send. Frames are plain `event:` + one `data:` line.
  */
-export interface AgentPermissionPromptView {
-    requestId: string;
-    title: string;
-    options: Array<{
-        optionId: string;
-        name: string;
-        kind?: string;
-    }>;
-}
-export interface AgentRunStepView {
-    id: string;
-    title: string;
-    status: 'running' | 'done' | 'failed';
-}
-export interface AgentRunProgressEvent {
-    type: 'progress';
-    threadId: string;
-    runId: string;
-    attempt: number;
-    sessionId: string;
-    stage: string;
-    detail: string;
-    outputText: string;
-    thoughtText: string;
-    activityAt: number;
-    permission?: AgentPermissionPromptView;
-    steps?: AgentRunStepView[];
-}
-export type AgentLiveEvent = {
-    type: 'changed';
-    threadId?: string;
-} | AgentRunProgressEvent;
 export type AgentStreamState = 'open' | 'closed';
 /**
  * Subscribes to a workspace's stream. Subscribers of the same URL share one
  * connection: browsers allow only a handful per origin, and the sidebar plus
  * an open conversation would otherwise hold several for the same workspace.
  */
-export declare function subscribeAgentStream(url: string, token: string | undefined, onEvent: (event: AgentLiveEvent) => void, onState: (state: AgentStreamState) => void): () => void;
+export declare function subscribeAgentStream<T = unknown>(url: string, token: string | undefined, onEvent: (event: T) => void, onState: (state: AgentStreamState) => void): () => void;

package/dist/types/components/workspace-agents/agents-route.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type AgentWorkspaceView } from './ThreadsPage';
+export interface AgentsRouteProps {
+    /** `new-agent` opens straight into the New agent page. */
+    initialView?: AgentWorkspaceView | 'new-agent';
+    workspaceCwd?: string;
+    onOpenDefinitions?: () => void;
+    /** Puts `@name ` into the chat composer; absent hides the card button. */
+    onMentionAgent?: (name: string) => void;
+}
+/**
+ * The Agents page with its data: the workspace's roster and runtimes, kept
+ * fresh by polling.
+ */
+export declare function AgentsRoute({ initialView, workspaceCwd: boundWorkspaceCwd, onOpenDefinitions, onMentionAgent, }: AgentsRouteProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workspace-agents/agents-view-logic.d.ts

@@ -4,177 +4,28 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
- * @fileoverview Presentation logic for the agents-and-threads surface.
+ * @fileoverview Presentation logic for the Agents page (roster and runtimes).
  *
  * Everything here is pure and testable without a browser, following the same
- * split as `agents-manager-logic.ts`. Two rules it exists to enforce:
- *
- * 1. **The server decides a thread's state; this file only renders it.** The
- *    thread resolver already returns a status *and* the sentence explaining it.
- *    Deriving a second, shorter vocabulary here would give the product two
- *    answers to "why is this blocked", and the shorter one would win because it
- *    is the one on screen.
- * 2. **A label never asserts a cause its reason code does not carry.** Copy
- *    that conflates two causes sends people to fix the wrong thing — Multica
- *    learned this when "runtime offline" wording sent users to reconnect a
- *    machine that was already connected. Each refusal below names its own fix.
- */
-import type { AgentPermissionPromptView, AgentRunStepView } from './agent-events';
-/** The programs an agent can be bound to on a joined runtime. */
-export declare const AGENT_PROGRAMS: readonly ["qwen"];
-export type AgentProgramView = (typeof AGENT_PROGRAMS)[number];
-export declare function programLabel(program: string | undefined): string;
-/**
- * Opens a thread body that carries the conversation it was started from. The
- * agents read it as-is; the chat view shows it folded instead of as a message.
- */
-export declare const CONVERSATION_CONTEXT_PREFIX = "Context from the conversation this was sent from:\n\n";
-/** Wire shape of a thread row, as the REST layer returns it. */
-export interface ThreadSummaryView {
-    id: string;
-    title: string;
-    status: 'open' | 'in_progress' | 'blocked' | 'in_review' | 'done' | 'cancelled';
-    /** The resolver's own sentence. Rendered verbatim; never re-derived. */
-    reason: string;
-    updatedAt: number;
-    liveRunCount: number;
-    assigneeName?: string;
-    parentThreadId?: string;
-}
-export interface ThreadGroup {
-    key: 'needs_you' | 'running' | 'idle' | 'done';
-    threads: ThreadSummaryView[];
-    /** Finished work is evidence, not a task, so it starts collapsed. */
-    collapsedByDefault: boolean;
-}
-/**
- * Groups threads by what they need, not by recency.
- *
- * Recency is the default sort and it buries the two threads that need a person
- * under twenty that do not. `blocked` and `in_review` share one group because
- * they are the same query for the reader — this is waiting on me — even though
- * one is a question and the other is finished work. What tells them apart is
- * each thread's own sentence, which is already on the row.
- */
-export declare function groupThreads(threads: readonly ThreadSummaryView[]): ThreadGroup[];
-/** Which threads carry the single attention treatment. */
-export declare function needsAttention(thread: ThreadSummaryView): boolean;
-/** Wire shape of one run, as the REST layer returns it. */
-export interface RunView {
-    progress?: {
-        attempt?: number;
-        receivedAt: number;
-        activityAt: number;
-        /** A code: starting, thinking, responding, tool, awaiting_approval, stream_lost. */
-        stage: string;
-        /** Raw text such as a tool title; never UI copy. */
-        detail: string;
-        outputText?: string;
-        thoughtText?: string;
-        permission?: AgentPermissionPromptView;
-        /** The turn's latest tool calls, oldest first. */
-        steps?: AgentRunStepView[];
-    };
-    id: string;
-    agentId: string;
-    agentName: string;
-    agentColor?: string;
-    status: 'queued' | 'running' | 'finishing' | 'cancelling' | 'completed' | 'failed' | 'cancelled';
-    closeKind?: 'waiting' | 'blocked' | 'review' | 'unclosed' | 'stranded';
-    closeAcknowledged: boolean;
-    failureStage?: string;
-    error?: string;
-    /** Why this run exists, e.g. "assigned by you", "mentioned by alice". */
-    trigger: string;
-    /** Queued runs of the same agent that start before this one. */
-    queueAhead?: number;
-    startedAt?: number;
-    endedAt?: number;
-    /** The agent session this run took its turn in, once one is bound. */
-    sessionId?: string;
-}
-export interface RunRow {
-    run: RunView;
-    /** What this run is doing or left behind, in the reader's words. */
-    state: string;
-    /** Live runs pin to the top; terminal runs collapse behind a count. */
-    live: boolean;
-    /** True when a person still owes this run an answer. */
-    outstanding: boolean;
-}
-/**
- * Describes a run the way the reader asks about it.
- *
- * A failed run reports its failure whatever close it managed to record first,
- * because the failure is the thing a person has to act on. A stranded run is
- * the exception: nothing the agent did ended it.
- */
-export declare function describeRun(run: RunView, t: Translate): string;
-/**
- * Orders runs for the side panel: live first in start order, then terminal
- * runs newest-first behind their count.
- *
- * The row carries no agent-availability indicator. Whether an agent is
- * reachable is not this row's story — the run's own state is, and a second
- * signal beside it competes for the same glance.
- */
-export declare function buildRunRows(runs: readonly RunView[], t: Translate): {
-    live: RunRow[];
-    past: RunRow[];
-};
-/**
- * One line, not a bar. A budget is a limit you want to notice before it trips,
- * not a goal you are filling, and a bar invites the second reading.
+ * split as `agents-manager-logic.ts`.
  */
-export declare function formatBudget(budget: {
-    turnsUsed: number;
-    turnLimit: number;
-    tokensUsed: number;
-    tokenLimit: number;
-}, t: Translate): {
-    turns: string;
-    tokens: string;
-    scope: string;
-};
-/** One target's fate for a draft reply, as the server previews it. */
-export interface RoutingPreviewTarget {
-    agentName: string;
-    willWake: boolean;
-    kind?: 'dispatch' | 'coalesce' | 'skip';
-    into?: 'queued' | 'running';
-    /** Present when `willWake` is false. A skip reason from the rules layer. */
-    reason?: string;
-    /** True when the name matched no agent, so it renders as a warning. */
-    unknown?: boolean;
-}
 /**
- * What a refusal means, and what to do about it.
- *
- * Each entry names its own fix. Two reasons that look alike but need different
- * fixes stay apart: a missing definition is repaired by pointing the agent at
- * one that exists, while a disabled agent is repaired by enabling it, and copy
- * that merged them would send the reader to the wrong screen.
+ * The programs an agent can run as. Mirrors `SessionAgentProgram` in
+ * `@qwen-code/sdk/daemon`; a runtime reports which of them it can run.
  */
-export declare function explainSkip(reason: string, target: string, t: Translate): string;
+export declare const AGENT_PROGRAMS: readonly ["qwen", "claude", "codex"];
+export type AgentProgramView = (typeof AGENT_PROGRAMS)[number];
+export declare function programLabel(program: string | undefined): string;
+/** Narrows a server-sent program id; anything unknown is dropped. */
+export declare function isAgentProgram(value: unknown): value is AgentProgramView;
 /**
- * A one-line summary of a preview, for the composer's collapsed state.
- *
- * Says who *will* run, because that is the consequence of pressing send. When
- * nobody will, that is the headline, since it is the case the system used to
- * swallow silently.
+ * The programs a runtime offers, in display order. An omitted field keeps the
+ * older daemon's Qwen default; an explicit empty list offers no programs.
  */
-export declare function summarizePreview(targets: readonly RoutingPreviewTarget[], t: Translate): string;
+export declare function runtimePrograms(runtime: {
+    programs?: readonly string[];
+}): AgentProgramView[];
 type Translate = (key: string, vars?: Record<string, string | number>) => string;
 /** "45 秒" or "6 分 45 秒": the one duration format the collaboration UI uses. */
 export declare function formatElapsed(ms: number, t: Translate): string;
-/**
- * Why a run exists, in the reader's language. The server words this in
- * English from a fixed set; anything outside it is shown as sent.
- */
-export declare function triggerLabel(trigger: string, t: Translate): string;
-/**
- * A thread's status reason in the reader's language. The server words it in
- * English from a fixed set; anything outside it is shown as sent.
- */
-export declare function statusReasonLabel(reason: string, t: Translate): string;
 export {};

package/dist/types/components/workspace-agents/lazy-agents-route.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AgentsRouteProps } from './agents-route';
+export declare function LazyAgentsRoute(props: AgentsRouteProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workspace-agents/messages.d.ts

@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
- * Agent collaboration strings (the Agent page, collaboration conversations,
- * the @ picker's agent entries). Kept out of the main dictionary like Live
+ * Agent collaboration strings (the Agents page, agents' live runs in a chat
+ * session, the @ picker's agent entries). Kept out of the main dictionary like Live
  * Voice's: an exported transcript never renders these surfaces, so
  * `vite.lib.config.ts` resolves this module to `messages.transcript-stub.ts`
  * in `--mode transcript` and the transcript bundle stays within its budget.

package/dist/types/components/workspace-agents/session-agent-live-runs.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { SessionAgentPermissionPrompt, SessionAgentRunFrame } from '@qwen-code/sdk/daemon';
+import type { PermissionRequest } from '../../adapters/types';
+import { useI18n } from '../../i18n';
+type Translate = ReturnType<typeof useI18n>['t'];
+/** No agent activity for this long: say it may be stuck. */
+export declare const STALL_NOTICE_MS: number;
+/**
+ * One line saying where a live run is. Returns `attention` for the states the
+ * user should notice (stuck, failed, offline).
+ */
+export declare function describeRun(run: SessionAgentRunFrame, now: number, t: Translate): {
+    text?: string;
+    attention: boolean;
+};
+/** Client-side cap on a tool input preview (the daemon bounds it too). */
+export declare const INPUT_PREVIEW_MAX_CHARS = 4000;
+/**
+ * The run's permission prompt as the main chat's approval card reads it. A
+ * shell tool shows its command as the main chat's shell approval does; any
+ * other tool shows its input preview in the card's monospace content block.
+ */
+export declare function toApprovalRequest(permission: SessionAgentPermissionPrompt, agent: string, t: Translate): PermissionRequest;
+/**
+ * A finished run the daemon offers to run again (`retryable`): failed by a
+ * restart, offline, or one whose record a restart lost. Never a stopped one.
+ */
+export declare function canRetryRun(run: SessionAgentRunFrame): boolean;
+/** A delegated member in a squad engagement. */
+export interface SquadMemberView {
+    name: string;
+    /** The agent's color, tinting its avatar as on its replies. */
+    color?: string;
+    /** `replied`: its run completed and its reply is on the way to the leader. */
+    state: 'working' | 'replied';
+}
+/** One squad engagement as the live runs show it. */
+export interface SquadEngagementView {
+    squadId: string;
+    squadName: string;
+    /** The leader, while its squad-mode run is queued or running. */
+    leader?: string;
+    leaderColor?: string;
+    /** Delegated members, in arrival order. */
+    members: SquadMemberView[];
+}
+/**
+ * Squad engagements under way in this session, derived from live run frames
+ * carrying `squadId`: a leader run names its squad on its author; a member
+ * run the leader waits on carries the squad id (and name) on the frame. A
+ * member's completed frame keeps them while its record is pending, which is
+ * the only time a finished run is still in the list: that member `replied`.
+ */
+export declare function squadEngagements(runs: readonly SessionAgentRunFrame[]): SquadEngagementView[];
+/**
+ * A small bar per active squad engagement: the squad's tag, then one entry per
+ * participant (avatar, name, state): the leader "deciding", a member working
+ * (spinner) or replied (check).
+ */
+export declare function SquadEngagementBar({ runs, }: {
+    runs: readonly SessionAgentRunFrame[];
+}): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * The session's live agent runs, rendered at the bottom of the message list as
+ * the agents' messages-in-progress. Each is replaced by the agent's recorded
+ * reply once that lands in the transcript.
+ *
+ * Mounted only by App (through MessageList's `tailContent`), never by the
+ * exported transcript, so it may use the collaboration dictionary.
+ */
+export declare function SessionAgentLiveRuns({ runs, onCancel, onRespond, onRetry, }: {
+    runs: readonly SessionAgentRunFrame[];
+    onCancel: (runId: string) => Promise<void>;
+    onRespond: (runId: string, requestId: string, optionId: string) => Promise<void>;
+    /** Offered on a failed run the daemon marked retryable. */
+    onRetry?: (runId: string) => Promise<void>;
+}): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * The user's @-mentions the daemon holds until the running main-model turn
+ * settles, shown as their messages until the recorded ones replace them.
+ */
+export declare function PendingAgentMentions({ mentions, }: {
+    mentions: ReadonlyArray<{
+        id: string;
+        text: string;
+    }>;
+}): import("react/jsx-runtime").JSX.Element | null;
+/** Shown near the composer while any agent in this session is working. */
+export declare function StopAllAgentsButton({ onStopAll, }: {
+    onStopAll: () => Promise<void>;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/workspace-agents/session-agents-api.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { SessionAgentEventFrame, SessionAgentRunFrame, SessionAgentRunStatus } from '@qwen-code/sdk/daemon';
+import { type AgentStreamState } from './agent-events';
+/** 202 body of `POST sessions/:sessionId/mentions`. */
+export interface SessionMentionResult {
+    recordId: string;
+    deferred?: boolean;
+    runs: Array<{
+        runId: string;
+        agentId: string;
+        status: SessionAgentRunStatus;
+    }>;
+    /** Why some mentioned squads were not started (the others were). */
+    squadError?: string;
+}
+/**
+ * The session-scoped collaboration routes: agents answering @-mentions inside
+ * an ordinary chat session.
+ */
+export interface SessionAgentsApi {
+    listRuns(sessionId: string): Promise<{
+        frames: SessionAgentRunFrame[];
+    }>;
+    mention(sessionId: string, input: {
+        text: string;
+        clientMessageId: string;
+    }): Promise<SessionMentionResult>;
+    cancelRun(sessionId: string, runId: string): Promise<unknown>;
+    /** Runs a failed run marked `retryable` again. */
+    retryRun(sessionId: string, runId: string): Promise<unknown>;
+    stopAll(sessionId: string): Promise<unknown>;
+    respondToPermission(sessionId: string, runId: string, requestId: string, optionId: string): Promise<unknown>;
+    subscribe(sessionId: string, onEvent: (event: SessionAgentEventFrame) => void, onState: (state: AgentStreamState) => void): () => void;
+}
+export declare function createSessionAgentsHttpApi(baseUrl: string, token: string | undefined, workspaceCwd: string): SessionAgentsApi;

package/dist/types/components/workspace-agents/squads-section.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { SessionSquadView } from '@qwen-code/sdk/daemon';
+import type { WorkspaceAgentSummaryView } from './ThreadsPage';
+import type { SquadInput } from './threads-api';
+export interface SquadsSectionProps {
+    squads: readonly SessionSquadView[];
+    agents: readonly WorkspaceAgentSummaryView[];
+    pending?: boolean;
+    /** The New squad form is open (its button is in the page header). */
+    creating: boolean;
+    onCreatingChange: (creating: boolean) => void;
+    onCreate: (input: SquadInput) => Promise<boolean>;
+    onUpdate: (squadId: string, input: SquadInput) => Promise<boolean>;
+    onRetire: (squadId: string) => void;
+    /** Puts `@name ` into the chat composer; absent hides the button. */
+    onMention?: (name: string) => void;
+}
+/** No squads (or a daemon without squad routes). */
+export declare function SquadsEmpty(): import("react/jsx-runtime").JSX.Element;
+/**
+ * The Agents page's Squads view: list, create, edit, retire. A squad is
+ * addressed by `@name` in a chat, which wakes its leader (session-multi-agent design §11.5).
+ */
+export declare function SquadsSection({ squads, agents, pending, creating, onCreatingChange, onCreate, onUpdate, onRetire, onMention, }: SquadsSectionProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workspace-agents/threads-api.d.ts

@@ -3,29 +3,30 @@
  * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { AgentCapabilitiesView, AgentConfigPatch, NewThread, NewWorkspaceAgent, WorkspaceAgentRuntimeView, WorkspaceAgentSummaryView } from './ThreadsPage';
-import type { ThreadDetailView } from './ThreadView';
-import type { RoutingPreviewTarget, ThreadSummaryView } from './agents-view-logic';
-import { type AgentLiveEvent, type AgentStreamState } from './agent-events';
-import type { JoinToken } from './add-runtime-dialog';
+import type { AgentConfigPatch, NewWorkspaceAgent, WorkspaceAgentRuntimeView, WorkspaceAgentSummaryView } from './ThreadsPage';
+import type { ConnectExistingInput, JoinCoordinatorInput, JoinToken } from './add-runtime-dialog';
 import type { AgentShare, AgentShareSummary } from './share-agent-dialog';
-interface CreateThreadResult {
-    id: string;
+import type { SessionSquadView } from '@qwen-code/sdk/daemon';
+/** Body of a squad create; on update, `null` clears a text field. */
+export interface SquadInput {
+    name: string;
+    description: string | null;
+    instructions: string | null;
+    leaderAgentId: string;
+    members: Array<{
+        agentId: string;
+        role?: string;
+    }>;
 }
+/** Agent roster, runtimes, enrollment and sharing for one workspace. */
 export interface ThreadsApi {
-    connectRemoteHost?(input: {
-        remoteUrl: string;
-        remoteToken: string;
-        remoteCwd: string;
-        serverUrl: string;
-        provider: 'qwen';
-        allowHttp: boolean;
-    }): Promise<unknown>;
+    connectRemoteHost?(input: ConnectExistingInput): Promise<unknown>;
+    /** Makes this daemon a runtime of another coordinator. */
+    joinCoordinator?(input: JoinCoordinatorInput): Promise<unknown>;
     listAgents(): Promise<{
         agents: WorkspaceAgentSummaryView[];
         runtime?: WorkspaceAgentRuntimeView;
         runtimes?: WorkspaceAgentRuntimeView[];
-        capabilities?: AgentCapabilitiesView;
     }>;
     /** A single-use token for `qwen serve --join` on another machine. */
     createJoinToken?(supersedesHostId?: string): Promise<JoinToken>;
@@ -35,29 +36,17 @@ export interface ThreadsApi {
         shares: AgentShareSummary[];
     }>;
     revokeShare?(agentId: string, callerId: string): Promise<unknown>;
-    listThreads(): Promise<{
-        threads: ThreadSummaryView[];
-    }>;
-    getThread(id: string): Promise<ThreadDetailView>;
     createAgent(input: NewWorkspaceAgent): Promise<unknown>;
     deleteAgent(id: string): Promise<unknown>;
     setAgentEnabled(id: string, enabled: boolean): Promise<unknown>;
     updateAgent(id: string, patch: AgentConfigPatch): Promise<unknown>;
-    createThread(input: NewThread): Promise<CreateThreadResult>;
-    previewThread(assignee?: string): Promise<{
-        targets: RoutingPreviewTarget[];
-    }>;
-    assignThread(id: string, assignee?: string): Promise<unknown>;
-    previewReply(id: string, text: string): Promise<{
-        targets: RoutingPreviewTarget[];
+    /** Squads; absent on a daemon without them. */
+    listSquads?(): Promise<{
+        squads: SessionSquadView[];
     }>;
-    postReply(id: string, text: string): Promise<unknown>;
-    markDone(id: string): Promise<unknown>;
-    cancelRun(threadId: string, runId: string): Promise<unknown>;
-    /** Live events; absent in tests and older daemons, which then poll. */
-    subscribe?(onEvent: (event: AgentLiveEvent) => void, onState: (state: AgentStreamState) => void): () => void;
-    /** Answers a tool approval an agent is waiting on. */
-    respondToPermission?(sessionId: string, requestId: string, optionId: string): Promise<unknown>;
+    createSquad?(input: SquadInput): Promise<unknown>;
+    updateSquad?(id: string, input: Partial<SquadInput>): Promise<unknown>;
+    /** Retires the squad (it keeps its name and history). */
+    retireSquad?(id: string): Promise<unknown>;
 }
 export declare function createThreadsHttpApi(baseUrl: string, token: string | undefined, workspaceCwd: string): ThreadsApi;
-export {};

package/dist/types/components/workspace-agents/use-session-agent-runs.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type DaemonTranscriptBlock, type SessionAgentRunFrame, type SessionAgentRunStatus } from '@qwen-code/sdk/daemon';
+import type { SessionAgentsApi } from './session-agents-api';
+export declare function isTerminalRunStatus(status: SessionAgentRunStatus): boolean;
+/**
+ * The runs whose `agent_message` is already in the transcript, as one string
+ * (run ids joined by newlines) so a caller can memoize a Set on it: the blocks
+ * change on every streamed delta, the answer almost never.
+ */
+export declare function settledAgentRunKey(blocks: readonly DaemonTranscriptBlock[]): string;
+interface TrackedFrame {
+    frame: SessionAgentRunFrame;
+    /** Arrival order, so the list does not reshuffle as frames update. */
+    order: number;
+    /**
+     * The run is off the screen for good: its record is in the transcript, or
+     * none will be written. Kept, slimmed, so that a stale snapshot cannot put
+     * the card back.
+     */
+    settled?: true;
+}
+export type RunFrameMap = ReadonlyMap<string, TrackedFrame>;
+/**
+ * Whether a frame ends the run's card (contract `recorded`): a terminal frame
+ * keeps it only while `recorded` is `false` (record pending, or the run is
+ * retryable). `true` means the record now renders; absent means none will be
+ * written (cancelled while queued, dismissed, retried).
+ */
+export declare function isSettledRunFrame(frame: SessionAgentRunFrame): boolean;
+/**
+ * Folds one frame into the map. A frame seen twice (the stream opens with a
+ * snapshot that a GET may already have delivered) is harmless; an older frame
+ * never overwrites a newer one, a terminal run never comes back to life, and
+ * a settled run stays settled (a snapshot polled before the record landed can
+ * arrive after the frame that settled it).
+ */
+export declare function applyRunFrame(current: RunFrameMap, frame: SessionAgentRunFrame, order: number): RunFrameMap;
+/**
+ * Settles runs whose `agent_message` the transcript already shows (it can
+ * land before the frame that says so). Returns `current` when nothing
+ * changed.
+ */
+export declare function pruneRunFrames(current: RunFrameMap, settledRunIds: ReadonlySet<string>): RunFrameMap;
+/**
+ * Live agent runs of one chat session: the `runs` snapshot, then the
+ * `session-events` stream. A run keeps its card, finished or not, until a
+ * frame settles it (see {@link isSettledRunFrame}) or its `agent_message`
+ * shows up in the transcript (`settledRunIds`), which is what replaces it on
+ * screen. A finished run whose record waits behind a main-model turn, or a
+ * run a daemon restart cut short, stays until then.
+ */
+export declare function useSessionAgentRuns({ api, sessionId, settledRunIds, }: {
+    api: SessionAgentsApi | undefined;
+    sessionId: string | undefined;
+    settledRunIds: ReadonlySet<string>;
+}): {
+    runs: SessionAgentRunFrame[];
+    anyLive: boolean;
+    /** Runs a `retryable` run again; rejects when the daemon refuses. */
+    retry: (runId: string) => Promise<void>;
+};
+export {};