@markmo/europacore-session-ui 0.2.0 → 0.3.0

package/dist/api/agentClient.d.ts

@@ -1,7 +1,7 @@
 import type { BackgroundSubagent } from '../features/chat/model/subagents';
 import { type Transport } from '../host';
 import { type ConnectionState, type SseHandle } from './chatStream';
-import type { AcceptResult, AddedDir, AgentInfo, BackgroundTask, ContextUsage, CreateRun, CreateSession, Envelope, FleetRunSummary, FleetTaskDiff, McpServer, ModelInfo, Page, RedoResult, RestoreResult, ResumeRequest, Run, ServerInfo, Session, SessionPullRequest, SessionStatus, SnapshotInfo, TaskInfo, TranscriptItem, UndoRequest, UndoResult, WorkspaceDiff, WorkspaceInfo } from './wire';
+import type { AcceptResult, AddedDir, AgentInfo, BackgroundTask, ContextUsage, CreateRun, CreateSession, Envelope, FleetRunSummary, FleetTaskDiff, McpServer, RunInspection, RunSummary, ModelInfo, Page, RedoResult, RestoreResult, ResumeRequest, Run, ServerInfo, Session, SessionPullRequest, SessionStatus, SnapshotInfo, TaskInfo, TranscriptItem, UndoRequest, UndoResult, WorkspaceDiff, WorkspaceInfo } from './wire';
 export interface StreamHandlers {
     onEnvelope: (env: Envelope) => void;
     onState?: (state: ConnectionState, detail?: string) => void;
@@ -70,6 +70,10 @@ export declare class EuropacoreClient {
     compact(id: string, instructions?: string): Promise<Record<string, unknown>>;
     /** The slash commands the session's agent runs itself. */
     commands(id: string): Promise<ServerCommand[]>;
+    /** The session's runs from its journal, oldest first. */
+    runs(id: string): Promise<RunSummary[]>;
+    /** One run step by step: tokens, cache and cost per call, tool calls with arguments and results, events. */
+    runSteps(id: string, runId: string): Promise<RunInspection>;
     /** The session's agent's MCP servers and how each is doing. */
     mcpServers(id: string): Promise<McpServer[]>;
     /** Connect an enabled MCP server again, after it failed or its process died. */

package/dist/api/wire.d.ts

@@ -590,6 +590,8 @@ export interface McpServer {
 }
 export interface HarnessResult {
     output: Record<string, unknown> | null;
+    /** What to change when the run stopped short (europacore's `agents.stop_hints`); null when it ended normally. */
+    hint?: string | null;
     text?: string | null;
     error: string | null;
     error_code: string | null;
@@ -659,6 +661,31 @@ export type ToolDisplay = {
 export declare function isDiffDisplay(display: ToolDisplay | null | undefined): display is DiffDisplay;
 export declare function isExecDisplay(display: ToolDisplay | null | undefined): display is ExecDisplay;
 export declare function isAnswersDisplay(display: ToolDisplay | null | undefined): display is AnswersDisplay;
+/** How the model router decided a turn's tier (`model_route`; europacore's docs/model-routing.md). */
+export type RouteBasis = 'choice' | 'probability' | 'baseline' | 'floor' | 'escalation' | 'budget' | 'held' | 'shadow' | 'pinned';
+/** `model_route`: the tier and model a turn runs on, and why; sent per turn and when the tier changes within it. */
+export interface ModelRouteData {
+    /** `fast`, `standard` or `capable`; null when the session's model is not routed (`pinned`). */
+    tier: string | null;
+    /** The model serving the turn (in shadow mode, the one still serving it). */
+    model: string | null;
+    basis: RouteBasis;
+    reason: string;
+    /** The classifier's answer: its tier, confidence and each option's probability. */
+    judged?: string | null;
+    confidence?: number | null;
+    probabilities?: Record<string, number>;
+    classifier?: string | null;
+    latency_ms?: number | null;
+    spent_usd?: number | null;
+    budget_usd?: number | null;
+    /** The model the turn was on before; the cache gate weighed staying on it. */
+    incumbent?: string | null;
+    cache_warm?: boolean | null;
+    /** What staying and switching would cost over the gate's horizon, when it weighed a switch. */
+    stay_usd?: number | null;
+    switch_usd?: number | null;
+}
 export interface TokenUsageData {
     last_call_tokens?: number;
     total_tokens?: number;
@@ -777,3 +804,55 @@ export interface HandoffFinding {
     line: number | null;
     reason: string;
 }
+/** One run of a session, from its journal (`GET /v1/sessions/{sid}/runs`). */
+export interface RunSummary {
+    run_id: string;
+    status: 'running' | 'completed' | 'failed' | 'paused' | 'cancelled' | 'abandoned' | string;
+    started_at?: string | null;
+    ended_at?: string | null;
+    input?: string | null;
+    steps: number;
+    total_tokens: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    cost_usd?: number | null;
+    wall_seconds?: number | null;
+    stop_reason?: string | null;
+    error_code?: string | null;
+    error?: string | null;
+    hint?: string | null;
+}
+/** One tool call of a step, with its arguments and result. */
+export interface ToolCallView {
+    call_id: string;
+    name: string;
+    arguments?: unknown;
+    status?: string | null;
+    result?: string | null;
+}
+/** One step of a run: its model call, tool calls and other events. */
+export interface StepView {
+    step: number;
+    model?: string | null;
+    input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    cost_usd?: number | null;
+    text?: string | null;
+    tools: ToolCallView[];
+    events: {
+        type: string;
+        name?: string | null;
+        data?: Record<string, unknown>;
+    }[];
+}
+/** A run step by step (`GET /v1/sessions/{sid}/runs/{rid}/steps`). */
+export interface RunInspection {
+    summary: RunSummary;
+    session_id?: string | null;
+    steps: StepView[];
+    pause?: Record<string, unknown> | null;
+    output?: unknown;
+}

package/dist/features/chat/model/entries.d.ts

@@ -1,3 +1,4 @@
+import type { RouteView } from './routing';
 import type { ImageInput, Pause, PlanItem, RunKind, ToolDisplay, ToolStatus } from '../../../api/wire';
 /** One row of the transcript. Entries are append-only; their contents change in place. */
 export type Entry = UserEntry | AssistantEntry | ToolEntry | NoticeEntry | SteerEntry | DecisionEntry | RunEndEntry | DiffEntry | WakeEntry;
@@ -91,6 +92,8 @@ export interface RunEndEntry {
     waiting?: string | null;
     /** Calls the permission rules or mode turned down in the run. */
     denied?: number;
+    /** What to change, when the run stopped short (`HarnessResult.hint`). */
+    hint?: string | null;
 }
 export interface ActiveRun {
     id: string;
@@ -111,6 +114,8 @@ export interface UsageView {
     inputTokens: number;
     sessionCostUsd: number | null;
     costComplete: boolean;
+    /** The model router's tier for the turn (`model_route`); null when the session's model is not routed. */
+    route: RouteView | null;
 }
 export interface PlanView {
     items: PlanItem[];

package/dist/features/chat/model/fleet.d.ts

@@ -49,3 +49,14 @@ export declare function taskProgress(task: FleetTaskEntry): string | null;
 export declare function pauseOf(pauses: Pause[], pendingId: string | null | undefined): Pause | null;
 /** The message that sends a fleet session's run a command (europacore's fleet agent parses it). */
 export declare function fleetCommand(kind: 'cancel' | 'retry' | 'steer' | 'approve' | 'release', task?: string | null, text?: string): string;
+/** A fleet spec sent as a prompt, read back for a person: its name, and what it runs. */
+export interface FleetSpecSummary {
+    name: string | null;
+    /** "3 tasks", or for one task run several ways, "add token refresh · 3 variants (a, b, c)". */
+    runs: string;
+}
+/**
+ * What a fleet spec (JSON, or TOML as `/fleet` sends it) runs, or null when `text` is not one. The fleet agent's
+ * prompt is the whole spec; the transcript and the brief show this instead, with the spec one click away.
+ */
+export declare function fleetSpecSummary(text: string): FleetSpecSummary | null;

package/dist/features/chat/model/inspect.d.ts

@@ -0,0 +1,11 @@
+import type { RunSummary, StepView, ToolCallView } from '../../../api/wire';
+/** ``value`` on one line, cut to ``limit`` characters (0: whole). */
+export declare function clip(value: unknown, limit?: number): string;
+/** Why the run stopped, in a word: its stop reason, else its error code, else its status. */
+export declare function stoppedBecause(run: RunSummary): string;
+/** A run's line in the list: steps, tokens, cost and why it stopped. */
+export declare function runLine(run: RunSummary): string;
+/** A step's model call: model, tokens in and out, cache read/written, cost. */
+export declare function stepLine(step: StepView): string;
+/** A tool call: its name with arguments, how it ended and what it returned. */
+export declare function toolLine(call: ToolCallView, limit?: number): string;

package/dist/features/chat/model/memory.d.ts

@@ -90,7 +90,7 @@ export type MemoryArgs = {
 } | {
     error: string;
 };
-/** Parses the arguments of /memory. */
+/** Parses the arguments of /decisions. */
 export declare function parseMemoryArgs(args: string): MemoryArgs;
 /** Decisions and requirements the agent marked in its text: "Decision: …" lines and "## Decisions" sections. */
 export declare function extractMarked(text: string): MarkedItem[];
@@ -101,7 +101,7 @@ export declare function parseExtraction(text: string): {
 } | {
     error: string;
 };
-/** Sent by /memory extract. Avoids the words the mock server picks scenarios from. */
+/** Sent by /decisions extract. Avoids the words the mock server picks scenarios from. */
 export declare const EXTRACT_PROMPT = "List the key decisions and requirements agreed so far in this conversation. Reply with only a ```json fence containing a JSON array of objects with the fields kind (\"decision\" or \"requirement\"), text and rationale (a string or null). Reply with [] when there are none.";
 /** A well-formed copy of a stored or mirrored entry, or null when it is malformed. */
 export declare function parseEntry(value: unknown): MemoryEntry | null;
@@ -109,7 +109,7 @@ export declare function parseEntry(value: unknown): MemoryEntry | null;
 export declare function mirroredEntries(metadata: Record<string, unknown> | null | undefined): MemoryEntry[];
 /** Register order: decisions before requirements, then by id number. */
 export declare function compareEntries(a: MemoryEntry, b: MemoryEntry): number;
-/** The /memory notice: counts, one line per entry (rationale below it) and the commands. */
+/** The /decisions notice: counts, one line per entry (rationale below it) and the commands. */
 export declare function formatMemoryList(entries: MemoryEntry[], heading: string, now?: number): string;
 /** "D-001 Use pnpm for…" for pickers and notices. */
 export declare function memoryLabel(entry: MemoryEntry, width?: number): string;

package/dist/features/chat/model/routing.d.ts

@@ -0,0 +1,20 @@
+/** The model router's `model_route` events as a transcript notice and a footer badge. */
+import type { ModelRouteData } from '../../../api/wire';
+import type { NoticeLevel } from './entries';
+/** The turn's tier as the footer shows it; null when the session's model is not routed. */
+export interface RouteView {
+    tier: string;
+    /** The model serving the turn, which may differ from the session's model id (`router`). */
+    model: string | null;
+    shadow: boolean;
+}
+/**
+ * One line saying which tier and model a turn runs on and why, or null for a session whose model is not
+ * routed: the server sends `pinned` every turn, and saying so each time would only be noise.
+ */
+export declare function routeNotice(data: ModelRouteData): {
+    level: NoticeLevel;
+    text: string;
+} | null;
+/** The footer's badge for a route, or null when the session's model is not routed. */
+export declare function routeView(data: ModelRouteData): RouteView | null;

package/dist/features/chat/model/store.d.ts

@@ -20,6 +20,11 @@ export interface ViewState {
     plan: PlanView | null;
     usage: UsageView;
     undeliveredSteers: string[];
+    /** The hint of a run whose `run.result` came with an error, kept for the `run.failed` that follows. */
+    pendingHint: {
+        runId: string;
+        hint: string;
+    } | null;
     /** The session's workspace status (spec §3.7), refreshed by `workspace.updated`. */
     workspace: WorkspaceInfo | null;
     connection: ConnectionState;

package/dist/features/chat/session/ComposerHistory.d.ts

@@ -6,7 +6,7 @@ import { type KeyboardEvent, type RefObject } from 'react';
  */
 export declare function useHistoryWalk(text: string, setText: (value: string) => void, textarea: RefObject<HTMLTextAreaElement | null>): {
     onKeyDown: (event: KeyboardEvent<HTMLTextAreaElement>) => boolean;
-    reset: () => null;
+    reset: () => void;
 };
 /**
  * Ctrl+R: the prompts sent, newest first (this workspace's before the rest), narrowed by the words typed in any

package/dist/features/commands/InspectDialog.d.ts

@@ -0,0 +1,3 @@
+import type { DialogProps } from './dialogs';
+/** `/inspect`: the session's runs from the server's journal; choose one to see it step by step. */
+export declare function InspectDialog({ open, onClose }: DialogProps): import("react").JSX.Element | null;

package/dist/features/commands/dialogs.d.ts

@@ -5,7 +5,7 @@ export interface DialogProps {
     onClose: () => void;
     [key: string]: unknown;
 }
-/** Features register the dialogs commands open: `/undo` opens "undo", `/memory` "memory", and so on. */
+/** Features register the dialogs commands open: `/undo` opens "undo", `/decisions` "decisions", and so on. */
 export declare function registerDialog(kind: string, component: ComponentType<DialogProps>): void;
 export declare function openDialog(kind: string, props?: Record<string, unknown>): void;
 export declare function closeDialog(): void;

package/dist/features/commands/registry.d.ts

@@ -1,5 +1,5 @@
 import type { SessionController } from '../chat/session/SessionController';
-export type CommandGroup = 'Session' | 'Decide' | 'Workspace' | 'Fleet' | 'Memory' | 'Go to' | 'App' | 'Prompt' | "This session's";
+export type CommandGroup = 'Session' | 'Decide' | 'Workspace' | 'Fleet' | 'Decisions' | 'Go to' | 'App' | 'Prompt' | "This session's";
 export interface Completion {
     value: string;
     description?: string;

package/dist/features/memory/MemoryDialog.d.ts

@@ -7,7 +7,7 @@ export declare function MemoryDialog({ open, onClose, controller, initialView, }
     open: boolean;
     onClose: () => void;
     controller: MemoryController;
-    /** `/memory all` opens on the whole scope. */
+    /** `/decisions all` opens on the whole scope. */
     initialView?: View;
 }): import("react").JSX.Element;
 export default MemoryDialog;

package/dist/features/memory/memoryService.d.ts

@@ -101,15 +101,15 @@ export declare function recordApproval(controller: MemoryController, info: Decid
 export interface MemoryList {
     heading: string;
     scope: string;
-    /** Whole scope (`/memory all`) or just this session. */
+    /** Whole scope (`/decisions all`) or just this session. */
     all: boolean;
     entries: MemoryEntry[];
 }
 /** The scope's entries as this window knows them, the controller's session read from its live copy. */
 export declare function scopeOf(controller: MemoryController, sessions?: Iterable<MemorySession>): MemoryEntry[];
-/** `/memory` (this session's entries) and `/memory all` (the whole scope's), for the memory dialog. */
+/** `/decisions` (this session's entries) and `/decisions all` (the whole scope's), for the decisions dialog. */
 export declare function listMemory(controller: MemoryController, all?: boolean): MemoryList;
-/** Active labels, for completing `/memory retire|edit|supersede <id>`. */
+/** Active labels, for completing `/decisions retire|edit|supersede <id>`. */
 export declare function memoryIds(controller: MemoryController): string[];
 export interface ScopeTarget {
     scope: string;
@@ -137,18 +137,18 @@ export declare function supersedeIn(scope: ScopeTarget, id: string, text: string
 }): Promise<MemoryResult & {
     sessions?: Session[];
 }>;
-/** `/memory retire <id>`. */
+/** `/decisions retire <id>`. */
 export declare function retire(controller: MemoryController, id: string, options?: WriteOptions): Promise<MemoryResult<MemoryEntry> & {
     session?: Session | null;
 }>;
-/** `/memory edit <id> <text> [-- why]`. */
+/** `/decisions edit <id> <text> [-- why]`. */
 export declare function edit(controller: MemoryController, id: string, text: string | {
     text: string;
     rationale?: string | null;
 }, options?: WriteOptions): Promise<MemoryResult<MemoryEntry> & {
     session?: Session | null;
 }>;
-/** `/memory supersede <id> <text> [-- why]`. */
+/** `/decisions supersede <id> <text> [-- why]`. */
 export declare function supersede(controller: MemoryController, id: string, text: string | {
     text: string;
     rationale?: string | null;
@@ -174,7 +174,7 @@ export declare function awaitAnswer(controller: MemoryController, runId: string,
     text: string;
 }>;
 /**
- * `/memory extract`: asks the agent for the decisions and requirements agreed so far, waits for its answer and
+ * `/decisions extract`: asks the agent for the decisions and requirements agreed so far, waits for its answer and
  * reads it. The proposal's `fresh` items are the ones to confirm (ExtractConfirmDialog), then `addExtracted`.
  */
 export declare function extract(controller: MemoryController, options?: WriteOptions & {
@@ -204,10 +204,10 @@ export type MemoryCommand = {
 } | {
     error: string;
 };
-/** The command a memory slash command names (`decision`, `dec`, `requirement`, `req`, `memory`, `register`), or null. */
-export declare function memoryCommandName(name: string): 'decision' | 'requirement' | 'memory' | 'register' | null;
+/** The command a register slash command names (`decision`, `dec`, `requirement`, `req`, `decisions`, `register`), or null. */
+export declare function memoryCommandName(name: string): 'decision' | 'requirement' | 'decisions' | 'register' | null;
 /**
- * Parses a memory slash command: `parseMemoryCommand(args)` for `/memory <args>`, or with a command name
+ * Parses a register slash command: `parseMemoryCommand(args)` for `/decisions <args>`, or with a command name
  * (`/dec`, `/req`, …) for the others. Builds on parseMemoryArgs.
  */
 export declare function parseMemoryCommand(args: string, command?: string): MemoryCommand;