@markmo/europacore-session-ui 0.2.0 → 0.4.0

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/format.d.ts

@@ -9,3 +9,9 @@ export declare function compactJson(value: unknown, max?: number): string;
 export declare function relativeTime(iso: string, now?: number): string;
 /** A short span for a column: "42s", "5m", "3h", "2d". */
 export declare function formatSpan(ms: number | null | undefined): string;
+/** A size for a column: "412 B", "8.1 KB", "412 KB", "1.4 MB". */
+export declare function formatBytes(n: number | null | undefined): string;
+/** How long until `iso`, as a short span ("42m"); "" once it has passed or when it is no time at all. */
+export declare function timeUntil(iso: string | null | undefined, now?: number): string;
+/** A moment as a clock time, "14:32", with the day in front when it is not today: "29 Oct 14:32". */
+export declare function clockTime(iso: string | null | undefined, now?: number): string;

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/memoryRecords.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Long-term memories as the memories screen shows them: its scopes and smart views, the rows each shows, the
+ * text of a flag, and the markdown a memory is edited as. Pure: no client, no browser. Not the decision register
+ * (`model/memory.ts`), which is the client's own. A port of europacorecli's `src/state/memory-records.ts`.
+ */
+import type { MemoryFlag, MemoryFlagName, MemoryPatch, MemoryRecord, MemoryRecordKind, MemoryRevision, MemoryScopeName } from '../../../api/wire';
+export declare const MEMORY_SCOPES: MemoryScopeName[];
+export declare const MEMORY_KINDS: MemoryRecordKind[];
+/** The caps the server enforces, checked here too so an edit is refused before it is sent. */
+export declare const DESCRIPTION_MAX = 200;
+export declare const BODY_MAX = 4000;
+export type SmartView = MemoryFlagName | 'forgotten';
+/** The smart views, by flag; "forgotten" lists the merged and pruned memories, which restore brings back. */
+export declare const SMART_VIEWS: {
+    view: SmartView;
+    label: string;
+}[];
+/** How each flag is written: a word when there is room, a letter when not. */
+export declare const FLAG_TEXT: Record<MemoryFlagName, {
+    word: string;
+    letter: string;
+    label: string;
+}>;
+/** One line of the scopes pane: everything, one scope (one project), or a smart view. */
+export interface ScopeNode {
+    id: string;
+    kind: 'all' | 'scope' | 'view';
+    label: string;
+    /** Null for a project not loaded yet. */
+    count: number | null;
+    scope?: MemoryScopeName;
+    project?: string | null;
+    view?: SmartView;
+}
+export declare function isActive(record: MemoryRecord): boolean;
+export declare function hasFlag(record: MemoryRecord, flag: MemoryFlagName): boolean;
+/** A project id's label: "project markmo/europacore". */
+export declare function projectLabel(project: string): string;
+/**
+ * The scopes pane: all memories, the org, the user, each project (the session's first, then the other projects
+ * the caller has memories in), then the smart views. Counts are of active memories; a project not loaded has none.
+ */
+export declare function scopeNodes(records: MemoryRecord[], labels: Partial<Record<MemoryScopeName, string>>, projects: string[], loaded: ReadonlySet<string>): ScopeNode[];
+/** Whether `record` matches a filter: every word in its name, description or body; `k:kind`, `s:source`. */
+export declare function matchesQuery(record: MemoryRecord, query: string): boolean;
+/**
+ * The rows `node` shows, in the index's order (scope, kind, name). `keep` holds memories changed here, which stay
+ * where they were whatever their status now, so forgetting one does not make it vanish from under the cursor.
+ */
+export declare function recordsFor(node: ScopeNode, records: MemoryRecord[], query: string, keep?: ReadonlySet<string>): MemoryRecord[];
+/** The flags column: the words when they fit `width`, else their letters. */
+export declare function flagCell(record: MemoryRecord, width: number): string;
+/** What a flag means for this memory, for its callout. */
+export declare function flagCallout(flag: MemoryFlag): string;
+/** When the memory reaches a model. */
+export declare function loadsWhen(record: MemoryRecord): string;
+/** Who wrote it, in which session, and when. */
+export declare function writtenBy(record: MemoryRecord, now?: number): string;
+/** A memory as `$EDITOR` shows it, parsed back. */
+export interface ParsedMemoryMarkdown {
+    name: string | null;
+    description: string;
+    kind: MemoryRecordKind;
+    body: string;
+}
+/**
+ * The markdown the server renders a memory as (`name`, `description` and `type` in the frontmatter, then the
+ * body), parsed back with the server's own rules, but strictly: what the server would quietly repair (a missing
+ * frontmatter, a description too long) is an error here, so an edit never saves something the person did not see.
+ */
+export declare function parseMemoryMarkdown(text: string): ParsedMemoryMarkdown | {
+    error: string;
+};
+/** The change an edit makes, against the revision it was read at; null when nothing changed. */
+export declare function memoryPatch(current: MemoryRecord, parsed: ParsedMemoryMarkdown): MemoryPatch | null | {
+    error: string;
+};
+/** What one revision changed, a line per field. */
+export declare function revisionChanges(revision: MemoryRevision): string[];

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

@@ -0,0 +1,11 @@
+import type { MonitorEnd, MonitorOutput } from '../../../api/wire';
+import type { MonitorEntry } from './entries';
+/**
+ * A monitor's output as the server sends it (a `monitor_output` event's data, or a `monitor` notice's `monitor`),
+ * or null when it lacks what a row needs.
+ */
+export declare function monitorOutputOf(data: unknown): MonitorOutput | null;
+/** The transcript row for what the agent was given of a monitor's output. */
+export declare function monitorEntry(key: string, output: MonitorOutput): MonitorEntry;
+/** How a monitor ended, in a phrase: "its command exited with code 1 after 12s (3 events): Traceback…". */
+export declare function monitorEndText(end: MonitorEnd, files: boolean): string;

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

@@ -0,0 +1,73 @@
+import type { ViewState } from './store';
+export type StepStatus = 'completed' | 'in_progress' | 'pending';
+export interface ProgressStep {
+    text: string;
+    status: StepStatus;
+}
+/** A page the session wrote; never its viewer url, which carries a token. */
+export interface ArtifactOutput {
+    id: string;
+    title: string;
+    format: string;
+    version: number;
+    published: boolean;
+}
+export interface PullRequestOutput {
+    number: number;
+    state: 'open' | 'merged' | 'closed';
+    hint: string;
+    ready: boolean;
+}
+/** A file the agent wrote: its writes summed, which can be more than the net change. */
+export interface FileOutput {
+    path: string;
+    added: number;
+    deleted: number;
+    writes: number;
+}
+export interface Progress {
+    steps: ProgressStep[];
+    done: number;
+    artifacts: ArtifactOutput[];
+    pullRequests: PullRequestOutput[];
+    files: FileOutput[];
+    /** Web search queries, each once, in the order first asked. */
+    searches: string[];
+    sites: {
+        host: string;
+        fetches: number;
+    }[];
+    connectors: {
+        server: string;
+        calls: number;
+    }[];
+    skills: string[];
+    /** Skills loaded whose name the server did not send. */
+    unnamedSkills: number;
+    /** Images sent with the session's turns. */
+    images: number;
+}
+export declare const EMPTY_PROGRESS: Progress;
+/** The host a fetched url is on, without `www.`; null for anything that is not a web address. */
+export declare function hostOf(url: string): string | null;
+/** The server an MCP tool belongs to: `mcp__github__search_issues` is github's. */
+export declare function mcpServerOf(toolName: string): string | null;
+export declare function progressOf(state: Pick<ViewState, 'plan' | 'session' | 'entries'>): Progress;
+/** Nothing to show yet: no step, no output and no source. */
+export declare function isEmptyProgress(p: Progress): boolean;
+/**
+ * Whether a change to the view can change its progress: the plan, the session's metadata, a reload, or a turn or
+ * tool call. Streamed text only touches assistant entries and the run, so it never does.
+ */
+export declare function touchesProgress(changed: ReadonlySet<string>): boolean;
+/**
+ * Which of a plan's steps to show, at most `max`: from `before` steps ahead of the first one not done. The done steps
+ * ahead of the window are counted rather than shown. `fill` moves the window back to use all of `max` when the plan
+ * ends sooner, so a short plan shows whole.
+ */
+export declare function stepWindow(items: readonly {
+    status: string;
+}[], max: number, before?: number, fill?: boolean): {
+    start: number;
+    end: number;
+};

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/model/tasks.d.ts

@@ -3,7 +3,7 @@ import type { ToolEntry } from './entries';
 import type { SessionStore } from './store';
 /** Entry keys of background tasks: they outlive the run that started them. */
 export declare const TASK_KEY_PREFIX = "task:";
-/** True for an entry that stands for a background command or sub-agent. */
+/** True for an entry that stands for a background command, sub-agent or monitor. */
 export declare function isBackgroundTask(entry: {
     key: string;
 }): boolean;

package/dist/features/chat/panels/ProgressPanel.d.ts

@@ -0,0 +1,8 @@
+import type { SessionController } from '../session/SessionController';
+/**
+ * The session's progress (europacorecli's progress panel): the plan's steps, what the agent made (pages, pull
+ * requests, files) and what it used on the way (searches, sites, MCP connectors, skills, images).
+ */
+export declare function ProgressPanel({ controller }: {
+    controller: SessionController;
+}): import("react").JSX.Element;

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/chat/session/SessionController.d.ts

@@ -1,12 +1,13 @@
 import { type ServerCommand } from '../../../api/agentClient';
-import type { AgentInfo, FormField, ImageInput, McpServer, Pause, QuestionAnswers, Run, Session, Stage } from '../../../api/wire';
+import type { AgentInfo, Envelope, FormField, ImageInput, McpServer, Pause, QuestionAnswers, Run, Session, Stage } from '../../../api/wire';
 import { type FleetParent } from '../model/fleet';
 import { SessionStore } from '../model/store';
 /** What /continue sends when it is given no instructions of its own. */
 export declare const CONTINUE_PROMPT = "Continue where you left off.";
 /** What /recap sends. */
 export declare const RECAP_PROMPT = "In two or three lines, recap this session: the goal, what has been decided so far, and what remains. Reply with only the recap.";
-/** Keys of the controller's own state, reported alongside the store's. */
+/** Hear every event of every followed session; the returned function stops. */
+export declare function onSessionEnvelope(listener: (sessionId: string, env: Envelope) => void): () => void;
 export declare const LOCAL: {
     readonly followUps: "@followUps";
     readonly images: "@images";

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

@@ -1,7 +1,20 @@
+import type { ArtifactInfo } from '../../../api/wire';
 import type { SessionController } from './SessionController';
-/** The `@query` at the end of the draft, when it is typing a file mention. */
+/** A completion for `@`: what goes after the `@`, and how the list shows it. */
+export interface Mention {
+    value: string;
+    label: string;
+    detail?: string;
+    kind: 'file' | 'artifact';
+}
+/** The `@query` at the end of the draft, when it is typing a mention. */
 export declare function mentionQuery(draft: string): string | null;
-/** `draft` with its trailing `@query` replaced by `@path `. */
-export declare function insertMention(draft: string, path: string): string;
-/** Files of the session's workspace matching the `@query` being typed (the app's `WorkspaceService.files`). */
-export declare function useFileMentions(controller: SessionController, query: string | null): string[];
+/** `draft` with its trailing `@query` replaced by `@value `. */
+export declare function insertMention(draft: string, value: string): string;
+/** The artifacts matching `query`, as mentions: `@artifact:<id>`, which the agent reads with `artifact_read`. */
+export declare function artifactMentions(list: ArtifactInfo[], query: string, limit: number): Mention[];
+/**
+ * What `@query` completes: the session's workspace files (the app's `WorkspaceService.files`), then the artifacts
+ * whose title, id or description match; `@artifact:` completes only artifacts.
+ */
+export declare function useFileMentions(controller: SessionController, query: string | null): Mention[];

package/dist/features/chat/transcript/ArtifactCard.d.ts

@@ -0,0 +1,8 @@
+import type { ArtifactDeletedDisplay, ArtifactDisplay } from '../../../api/wire';
+export declare function ArtifactCard({ display: d, sessionId }: {
+    display: ArtifactDisplay;
+    sessionId: string | null;
+}): import("react").JSX.Element;
+export declare function ArtifactDeletedCard({ display: d }: {
+    display: ArtifactDeletedDisplay;
+}): import("react").JSX.Element;

package/dist/features/chat/transcript/Rows.d.ts

@@ -1,5 +1,5 @@
 import { type PlanItem } from '../../../api/wire';
-import type { AssistantEntry, DecisionEntry, DiffEntry, NoticeEntry, RunEndEntry, SteerEntry, ToolEntry, UserEntry, WakeEntry } from '../model/entries';
+import type { AssistantEntry, DecisionEntry, DiffEntry, MonitorEntry, NoticeEntry, PeerEntry, RunEndEntry, SteerEntry, ToolEntry, UserEntry, WakeEntry } from '../model/entries';
 import type { SessionController } from '../session/SessionController';
 export declare const UserRow: import("react").NamedExoticComponent<{
     controller: SessionController;
@@ -49,6 +49,17 @@ export declare function RunEndRow({ entry }: {
 export declare function WakeRow({ entry }: {
     entry: WakeEntry;
 }): import("react").JSX.Element;
+/** A message from another session's agent: input for this session's agent, not the user's word. */
+export declare function PeerRow({ entry }: {
+    entry: PeerEntry;
+}): import("react").JSX.Element;
+/**
+ * What the agent was given of a monitor's output: the monitor, its lines (the command's output, so untrusted, shown
+ * as text) and how it ended.
+ */
+export declare function MonitorRow({ entry }: {
+    entry: MonitorEntry;
+}): import("react").JSX.Element;
 export declare function DiffBlock({ entry, renderDiff }: {
     entry: DiffEntry;
     renderDiff?: (patch: string) => React.ReactNode;

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/memories/MemoriesPage.d.ts

@@ -0,0 +1 @@
+export default function MemoriesPage(): import("react").JSX.Element;

package/dist/features/memories/memoriesCommands.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from '../commands/registry';
+export declare const memoriesCommand: Command;
+export declare function registerMemoriesCommands(): void;

package/dist/features/memories/memoriesController.d.ts

@@ -0,0 +1,81 @@
+import type { ContextSources, MemoryRecord, MemoryRevision, MemoryScopeStatus } from '../../api/wire';
+export interface MemoriesView {
+    records: MemoryRecord[];
+    statuses: MemoryScopeStatus[];
+    projects: string[];
+    loaded: ReadonlySet<string>;
+    kept: ReadonlySet<string>;
+    revisions: MemoryRevision[] | null;
+    sources: ContextSources | null;
+    sourcesNote: string;
+    error: string;
+    busy: boolean;
+    version: number;
+}
+/** What a change says back: shown as a toast. */
+export interface Outcome {
+    ok: boolean;
+    message: string;
+}
+export declare class MemoriesController {
+    /** The session the context view describes, and whose project's memories open first. */
+    private readonly sessionId;
+    /** The server lists sessions' context sources (`context_sources`). */
+    private readonly contextSourcesServed;
+    private data;
+    private statuses;
+    private projectIds;
+    private readonly loadedProjects;
+    private readonly changed;
+    private revisionList;
+    private found;
+    private note;
+    private error;
+    private busy;
+    /** Answers to an earlier open are dropped. */
+    private generation;
+    private project;
+    /** Edits the server refused, by memory, reopened by the next edit. */
+    private readonly drafts;
+    private readonly listeners;
+    private snapshot;
+    constructor(
+    /** The session the context view describes, and whose project's memories open first. */
+    sessionId: string | null, 
+    /** The server lists sessions' context sources (`context_sources`). */
+    contextSourcesServed: () => boolean);
+    private view;
+    private render;
+    subscribe: (listener: () => void) => (() => void);
+    getSnapshot: () => MemoriesView;
+    /** The project whose memories open first: the session's. */
+    get sessionProject(): string | null;
+    /** Read everything afresh: the session's context first, for its project. */
+    open(): Promise<void>;
+    private load;
+    /** The session's context sources; why there are none when there aren't. */
+    loadSources(): Promise<void>;
+    /** Read everything again, keeping the projects opened and the memories changed here. */
+    reload(): Promise<void>;
+    /** Another of the caller's projects, read when its scope is first chosen; what went wrong, or null. */
+    loadProject(project: string): Promise<string | null>;
+    history(record: MemoryRecord): Promise<Outcome | null>;
+    closeHistory(): void;
+    private replace;
+    forget(record: MemoryRecord): Promise<Outcome>;
+    restore(record: MemoryRecord): Promise<Outcome>;
+    /**
+     * What an edit starts from: the draft the server refused last time, else the memory as markdown, read afresh;
+     * with the record read, whose revision the save is made against.
+     */
+    startEdit(record: MemoryRecord): Promise<{
+        text: string;
+        current: MemoryRecord;
+        draft: boolean;
+    } | Outcome>;
+    /** Save an edit against the revision read; one refused is kept as the draft the next edit reopens. */
+    save(current: MemoryRecord, edited: string): Promise<Outcome>;
+    /** Throw away a refused edit. */
+    dropDraft(id: string): void;
+}
+export declare function useMemories(controller: MemoriesController): MemoriesView;

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;

package/dist/features/workspace/claimsCommands.d.ts

@@ -0,0 +1,26 @@
+import type { Envelope } from '../../api/wire';
+import type { SessionController } from '../chat/session/SessionController';
+import type { Command, CommandContext } from '../commands/registry';
+type Toast = (message: string, tone?: 'info' | 'ok' | 'danger') => void;
+/** What a claim event or a contested session says, given the sessions the browser follows. */
+export interface ClaimsEnv {
+    /** A followed session, by id. */
+    get(id: string): Pick<SessionController, 'id' | 'store' | 'title' | 'notice'> | undefined;
+    /** The session on screen. */
+    shownId(): string | null;
+    toast: Toast;
+}
+/**
+ * A request opened, answered or ended, on session `id`'s stream: a toast, the session's title first when it is out
+ * of view. Both sides' streams carry it, so when the other side is on screen, that one says it in its own words.
+ */
+export declare function claimToast(env: ClaimsEnv, id: string, envelope: Envelope): void;
+/**
+ * Session `id`'s metadata changed: say once when a request it made could not be settled, which puts it in the inbox
+ * until the user's next message. The first read only takes stock.
+ */
+export declare function contestedCheck(env: ClaimsEnv, id: string): void;
+/** `/claims [release <path> | give <path> [session] | ask <path> [reason]]`. */
+export declare function runClaims(ctx: Pick<CommandContext, 'controller' | 'toast'>, args: string): Promise<void>;
+export declare const claimsCommand: Command;
+export {};

package/dist/features/workspace/collisionsWatcher.d.ts

@@ -12,6 +12,12 @@ export interface CollisionOptions {
     repoOf?: (controller: Watched) => string | null;
     /** A new hard collision, in words (the TUI flashes it); by default a warning in both sessions' transcripts. */
     warn?: (text: string, a: Watched | null, b: Watched | null) => void;
+    /**
+     * Whether a hard collision switches its sessions to asking. By default not once the server keeps file claims
+     * (`capabilities.peers`): it refuses a write to a file another session owns itself, and the agents settle it. A
+     * mode switched by an earlier collision still goes back.
+     */
+    gate?: () => boolean;
 }
 /** The repository a session works in, as the browser can tell: its workspace's top level. */
 export declare function defaultRepoOf(controller: Watched): string | null;
@@ -35,6 +41,7 @@ export declare class CollisionWatcher {
     private readonly listeners;
     private version;
     private readonly repoOf;
+    private readonly gates;
     private readonly warn;
     constructor(options?: CollisionOptions);
     subscribe: (listener: Listener) => (() => void);

package/dist/features/workspace/useSessionPageHooks.d.ts

@@ -1,6 +1,6 @@
 /**
  * Fill in the session page's hooks from the workspace feature: collisions
  * between the followed sessions (hold or leave a file on the approval card),
- * and the full diff viewer for `/diff` in the transcript.
+ * the file claims' toasts, and the full diff viewer for `/diff` in the transcript.
  */
 export declare function useSessionPageHooks(): void;