@markmo/europacore-session-ui 0.2.0 → 0.4.0

package/dist/features/artifacts/ArtifactStats.d.ts

@@ -0,0 +1,9 @@
+import type { ArtifactInfo } from '../../api/wire';
+export declare function ArtifactStats({ list, project, onOpen, onLedger, }: {
+    list: ArtifactInfo[];
+    /** The repository of the session the page was opened from, for `p`. */
+    project: string | null;
+    onOpen: (a: ArtifactInfo) => void;
+    /** Open the ledger on these, oldest first (untouched) or as they come (stale). */
+    onLedger: (only: 'untouched' | 'stale') => void;
+}): import("react").JSX.Element;

package/dist/features/artifacts/ArtifactsPage.d.ts

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

package/dist/features/artifacts/artifactsCommands.d.ts

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

package/dist/features/artifacts/artifactsStore.d.ts

@@ -0,0 +1,27 @@
+import type { ArtifactInfo } from '../../api/wire';
+export interface ArtifactsState {
+    /** The user's own, newest first; with a session named, that session's first. */
+    list: ArtifactInfo[];
+    /** What others share with the user, on a server that keeps access. */
+    shared: ArtifactInfo[];
+    /** The repository of the session named, when it is in one. */
+    project: string | null;
+    /** The session the list was loaded for. */
+    session: string | null;
+    loaded: boolean;
+    loading: boolean;
+    error: string | null;
+}
+/** How long a burst of artifact events must be quiet before the list reloads. */
+export declare const RELOAD_SETTLE_MS = 250;
+export declare function artifactsState(): ArtifactsState;
+/** Load the list (again); with `session`, that session's first. A quiet load keeps what is shown while it runs. */
+export declare function loadArtifacts(session?: string | null, quiet?: boolean): Promise<void>;
+/** One artifact changed here (its access, a take-down): put the server's answer in place. */
+export declare function replaceArtifact(updated: ArtifactInfo): void;
+/** Artifacts deleted here, gone from the list before the reload says so. */
+export declare function dropArtifacts(ids: readonly string[]): void;
+export declare function subscribeArtifacts(listener: () => void): () => void;
+export declare function useArtifacts(): ArtifactsState;
+/** For tests: forget everything. */
+export declare function resetArtifacts(): void;

package/dist/features/artifacts/artifactsUi.d.ts

@@ -0,0 +1,33 @@
+import type { ArtifactInfo } from '../../api/wire';
+import { type ExportKind, type ExportScope } from '../chat/model/artifactExport';
+import { type SessionLink } from '../chat/model/artifacts';
+export declare function FormatTag({ format }: {
+    format: string;
+}): import("react").JSX.Element;
+export declare function AccessBadge({ artifact }: {
+    artifact: ArtifactInfo;
+}): import("react").JSX.Element | null;
+/** Where its published copy stands, as a badge: live, behind, expiring, expired; nothing when unpublished. */
+export declare function PublicationBadge({ artifact, now }: {
+    artifact: ArtifactInfo;
+    now?: number;
+}): import("react").JSX.Element | null;
+/** What became of each session `ids` names: looked up as they are asked for, the answer kept. */
+export declare function useSessionLinks(ids: readonly (string | null)[]): (id: string | null) => SessionLink;
+/** A session's title as a link names it, or null while unknown. */
+export declare function sessionTitleOf(link: SessionLink): string | null;
+/** The artifact with a viewer link that still opens: a fresh one from the server when it expires within a minute. */
+export declare function freshArtifact(a: ArtifactInfo): Promise<ArtifactInfo>;
+/** The link to open or copy: the published page while it is up, else the viewer's (absolute); `version` pins one. */
+export declare function linkFor(a: ArtifactInfo, version?: number): Promise<{
+    url: string;
+    what: 'published' | 'viewer';
+}>;
+/** Open a link in a new tab. The tab opens at once (a popup blocker allows that) and goes to the link once known. */
+export declare function openInTab(link: () => Promise<string>): Promise<void>;
+export declare function download(name: string, data: BlobPart, type: string): void;
+/**
+ * Export `scope` as `kind`, as a download; what it says it did. The CSV never holds a viewer link. A PDF opens the
+ * page for the browser to print (europacorecli prints it with Chrome).
+ */
+export declare function exportArtifacts(kind: ExportKind, scope: ExportScope, sessionTitle: (id: string | null) => string | null): Promise<string>;

package/dist/features/bootstrap.d.ts

@@ -1,2 +1,3 @@
 import './chat/panels/CorePanels';
+import './chat/panels/ProgressPanel';
 export declare function bootstrapFeatures(): void;

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

@@ -0,0 +1,50 @@
+/**
+ * Who can open an artifact, and how often it was opened (europacore `docs/artifacts.md`, "Access"): private to its
+ * owner, shared with everyone signed in to the workspace, or public to anyone with the link; and what changing that
+ * does to the links already given out. A server from before access has none of it: there, anyone with the link can
+ * open the page, as ever. Nothing here draws.
+ */
+import type { ArtifactAccess, ArtifactInfo } from '../../../api/wire';
+/** Who can open it; null from a server that keeps no access, where anyone with the link can. */
+export declare function accessOf(a: ArtifactInfo): ArtifactAccess | null;
+/** Someone else's artifact, shared with the caller: it can be opened, not changed. */
+export declare const isTheirs: (a: ArtifactInfo) => boolean;
+/** What rows and ticks are keyed by: the id for one's own, `owner/id` for another's (ids are unique per owner). */
+export declare function artifactKey(a: ArtifactInfo): string;
+export declare const ACCESS_LABEL: Record<ArtifactAccess, string>;
+/** Who can open it, in a few words: "Private · only you". */
+export declare function accessLine(a: ArtifactInfo): string | null;
+/** The opens in the last 30 days by anyone but the owner: through the public link, or others' own links. */
+export declare function othersOpens(a: ArtifactInfo): number;
+/** How often it was opened, in a line: "14 opens in 30 days · 3 people · 9 by link · last 2h ago". */
+export declare function viewsLine(a: ArtifactInfo, now?: number): string | null;
+export type AccessChange = ArtifactAccess | 'revoke';
+export interface AccessChoice {
+    key: string;
+    change: AccessChange;
+    label: string;
+    what: string;
+    /** It is already this. */
+    current?: boolean;
+    /** Why it cannot be chosen; absent when it can. */
+    unavailable?: string;
+}
+/** What `A` offers for `items`: each level, the current one marked, and revoking every link. */
+export declare function accessChoices(items: ArtifactInfo[]): AccessChoice[];
+/**
+ * The question to ask before `change`, or null when none is needed: making something public, ending a public link
+ * (for good: making it public again gives a new one), and revoking every link.
+ */
+export declare function confirmFor(items: ArtifactInfo[], change: AccessChange): string | null;
+/** Which way a change goes: "Private", "Shared with your workspace", "Public", "Links revoked". */
+export declare function changedText(change: AccessChange): string;
+/** What a copied or opened link does, honestly: who it opens for, and until when. */
+export declare function linkNote(a: ArtifactInfo, now?: number): string;
+/** A link that expires within this long is fetched afresh before it is opened or copied. */
+export declare const LINK_MARGIN_MS = 60000;
+/** Its link has expired, or is about to. */
+export declare function linkStale(a: ArtifactInfo, now?: number): boolean;
+/** What deleting it takes from others: their access, and the opens it has had lately. */
+export declare function sharedBreaks(a: ArtifactInfo): string[];
+/** Deleting it should ask for its word, not a plain yes: others can open it, or have lately. */
+export declare function sharedOrSeen(a: ArtifactInfo): boolean;

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

@@ -0,0 +1,11 @@
+/**
+ * The artifacts as a CSV file (`X` in the ledger and the usage view): a row each, for a spreadsheet. The viewer
+ * link is left out: its token is the key to the page, and a file is easily passed on. Nothing here writes.
+ */
+import type { ArtifactInfo } from '../../../api/wire';
+/**
+ * One cell, quoted when it must be. A cell a spreadsheet would read as a formula (`=`, `+`, `-`, `@`) gets a
+ * leading `'`, so a title cannot run anything when the file is opened.
+ */
+export declare function csvCell(value: string | number | null | undefined): string;
+export declare function artifactsCsv(list: ArtifactInfo[], sessionTitle: (id: string | null) => string | null): string;

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

@@ -0,0 +1,45 @@
+/**
+ * What `X` on the artifacts screen can export, and what the files are called. The rows go to CSV; an artifact's
+ * files to a ZIP; its page, as printed, to a PDF; and its source as it was written, Markdown for a Markdown
+ * artifact and the page's HTML for an HTML one. Each is a download (europacorecli writes them to
+ * `.europa/exports/` in the workspace). A port of its `src/state/artifact-export.ts`; nothing here reads, writes or draws.
+ */
+import type { ArtifactInfo } from '../../../api/wire';
+export type ExportKind = 'csv' | 'zip' | 'pdf' | 'source';
+export interface ExportChoice {
+    kind: ExportKind;
+    /** The key that picks it in the menu. */
+    key: string;
+    label: string;
+    /** What would be written, in words. */
+    what: string;
+    /** Why it cannot be picked here; absent when it can. */
+    unavailable?: string;
+}
+/** What is being exported: the rows (for CSV), the artifacts whose files go, and a version, from the versions view. */
+export interface ExportScope {
+    rows: ArtifactInfo[];
+    targets: ArtifactInfo[];
+    version?: number;
+    /** How the rows were chosen, for the CSV's line: "shown", "ticked", "counted". */
+    rowsAre: string;
+}
+/** More pages than this at once are too many to print: export them as a ZIP instead (the web prints one at a time). */
+export declare const PDF_LIMIT = 10;
+/** The version of `a` that goes: the one picked in the versions view, else the newest. */
+export declare function versionOf(a: ArtifactInfo, scope: Pick<ExportScope, 'version' | 'targets'>): number;
+/**
+ * The choices for `scope`. `pdfMissing` says why there is nothing to print with, or is null.
+ * The source is offered when every target has the same format, as its own kind of file.
+ */
+export declare function exportChoices(scope: ExportScope, pdfMissing: string | null): ExportChoice[];
+/** A name safe to put in a path from an artifact's id; the server's ids already are, but a file name must be. */
+export declare function safeName(id: string): string;
+/** The file one artifact's version exports to: `latency-dashboard-v2.pdf`. */
+export declare function exportFileName(a: Pick<ArtifactInfo, 'id'>, version: number, ext: string): string;
+/** A name for an export of several, by the time it was made: `artifacts-20261030-141500.csv`. */
+export declare function stampedName(ext: string, now?: Date): string;
+/** A version's file path is safe in an archive: relative, forward slashes, no `.` or `..` parts. */
+export declare function safeEntryPath(file: string): boolean;
+/** Where a file goes inside the ZIP: under `<id>-v<n>/` for one artifact, `<id>/v<n>/` for several. */
+export declare function zipEntryPath(a: Pick<ArtifactInfo, 'id'>, version: number, file: string, several: boolean): string;

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

@@ -0,0 +1,79 @@
+/**
+ * What the artifacts' usage view adds up (`/artifacts --stats`, `u`): the totals, the ≈tokens the writing runs
+ * spent week by week, storage over every version the server keeps, what is published, what has gone untouched,
+ * and the heaviest. Every figure is over the artifacts the server still has: a deleted one's spend leaves the
+ * history with it. Nothing here draws.
+ */
+import type { ArtifactInfo } from '../../../api/wire';
+/** The chart's windows, in weeks, as `w` steps through them. */
+export declare const WINDOWS: readonly [4, 8, 12, 26];
+/** An artifact nobody has written to for this long is untouched, and worth a look before keeping it. */
+export declare const UNTOUCHED_DAYS = 30;
+/** Monday 00:00, local time, of the week `ms` falls in. */
+export declare function weekStart(ms: number): number;
+/** A week's label, its Monday: "5 Oct". */
+export declare function weekLabel(start: number): string;
+export interface Week {
+    start: number;
+    end: number;
+    /** What the versions written in it took, where their run's usage was measured. */
+    tokens: number;
+    versions: number;
+}
+export interface ArtifactStats {
+    count: number;
+    /** Made since this week's Monday. */
+    newThisWeek: number;
+    /** Null when no version carries usage (an older server); `tokensPartial` when only some do. */
+    tokens: number | null;
+    tokensPartial: boolean;
+    /** Per artifact that carries usage. */
+    perArtifact: number | null;
+    /** Summed over the versions whose runs were priced; `costPartial` when some were not, or carry no usage. */
+    cost: number | null;
+    costPartial: boolean;
+    /** Every version's files, which the server keeps until the artifact is deleted; null from older servers. */
+    bytes: number | null;
+    files: number;
+    versions: number;
+    published: {
+        live: number;
+        temporary: number;
+        permanent: number;
+    };
+    /** Published at an older version, or a temporary page past its expiry. */
+    stale: number;
+    /** Their ≈tokens and storage, null when none of them was measured; how many others still opened lately. */
+    untouched: {
+        count: number;
+        tokens: number | null;
+        bytes: number | null;
+        openedLately: number;
+    };
+    /** What others can open, and their opens in 30 days; null from a server that keeps no access. */
+    shared: {
+        count: number;
+        workspace: number;
+        public: number;
+        opens: number;
+    } | null;
+    byFormat: {
+        tag: string;
+        format: string;
+        count: number;
+    }[];
+    heaviest: ArtifactInfo[];
+    /** The window's weeks, oldest first; the last is this one. */
+    weeks: Week[];
+}
+/** Every version's bytes, or null when the server measures none. */
+export declare function storageOf(a: ArtifactInfo): number | null;
+/** Nobody has written to it for `UNTOUCHED_DAYS`. */
+export declare function isUntouched(a: ArtifactInfo, now?: number): boolean;
+/** A version of it was written in `[start, end)`. */
+export declare function writtenIn(a: ArtifactInfo, start: number, end: number): boolean;
+/** A version of it was written in the repository `project`. An older server records none, so none match. */
+export declare function inProject(a: ArtifactInfo, project: string): boolean;
+/** The last `count` weeks, oldest first, with what the versions written in each took. */
+export declare function weeksOf(list: ArtifactInfo[], now: number, count: number): Week[];
+export declare function artifactStats(list: ArtifactInfo[], now: number, weeks: number): ArtifactStats;

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

@@ -0,0 +1,151 @@
+/**
+ * The pages agents make (`artifact_write`), as `/v1/artifacts` lists them, and what the artifacts screen needs
+ * from them: which show under each filter, how they group by session and sort, where a published copy stands,
+ * and what deleting them breaks (europacore docs/artifacts.md). Nothing here draws. A port of europacorecli's
+ * `src/state/artifacts.ts`, without the workspace archive (a browser saves a download instead).
+ */
+import type { ArtifactInfo, Session, SessionArtifact } from '../../../api/wire';
+/** `/artifacts [--table|--stats] [id|words]`: the view, and an artifact's id or words to search for. */
+export declare function parseArtifactsArgs(args: string): {
+    view: 'list' | 'table' | 'stats';
+    target: string;
+};
+/** A temporary page this close to its expiry is expiring soon. */
+export declare const EXPIRING_SOON_MS: number;
+/** What a session wrote, from its server-owned `metadata.artifacts`, the newest write last. */
+export declare function artifactsOf(session: Pick<Session, 'metadata'> | null): SessionArtifact[];
+/** The format as a tag: HTML, MD. */
+export declare function formatTag(format: string): string;
+/** The newest version's file count. */
+export declare function fileCount(a: ArtifactInfo): number;
+/** Where an artifact's published copy stands. */
+export interface Publication {
+    url: string;
+    target: string;
+    /** The version that was published: the newest with a publication. */
+    version: number;
+    claimUrl: string | null;
+    expiresAt: string | null;
+    /** A temporary page past its expiry. The record cannot tell whether someone claimed it first. */
+    expired: boolean;
+    /** Under `EXPIRING_SOON_MS` left. */
+    soon: boolean;
+    /** Published at an older version than the latest. */
+    behind: boolean;
+}
+export declare function publication(a: ArtifactInfo, now?: number): Publication | null;
+/** The newest copy taken down, when none is up: where it was, and when it came down. */
+export declare function takenDown(a: ArtifactInfo, now?: number): {
+    url: string;
+    at: string;
+} | null;
+/**
+ * Whether its published copy can be taken down from here, or why not: only a permanent Cloudflare copy can, on a
+ * server with its credentials; a temporary one belongs to no account until claimed, and only expires.
+ */
+export declare function unpublishable(a: ArtifactInfo, serverCan: boolean, now?: number): {
+    ok: true;
+} | {
+    ok: false;
+    why: string;
+};
+/** A published copy that needs doing again: it shows an older version, or a temporary one has expired. */
+export declare function isStale(a: ArtifactInfo, now?: number): boolean;
+/**
+ * The list's tabs. `shared` is one's own that others can open; `others` is what others share with one. The last two
+ * are only for a server that keeps access.
+ */
+export type ArtifactFilter = 'all' | 'session' | 'published' | 'stale' | 'shared' | 'others';
+export declare const FILTERS: ArtifactFilter[];
+export declare function filtersFor(keepsAccess: boolean): ArtifactFilter[];
+/** The session the screen was opened from, and the artifacts it wrote or changed. */
+export interface Here {
+    id: string | null;
+    touched: ReadonlySet<string>;
+}
+/**
+ * The sessions that made, changed or published an artifact: the one that made it, then each version's writer
+ * and publisher, as far as the server says (an older one names only the first).
+ */
+export declare function writersOf(a: ArtifactInfo): string[];
+/**
+ * "This session" is what it made or changed: an artifact names the session that made it, its versions (on newer
+ * servers) the sessions that wrote them, and the session's own metadata lists what it wrote.
+ */
+export declare function hereOf(session: Pick<Session, 'id' | 'metadata'> | null): Here;
+export declare function inFilter(a: ArtifactInfo, filter: ArtifactFilter, here: Here, now?: number): boolean;
+/** Each tab's count: one's own under the first five, and what others share under the last. */
+export declare function filterCounts(list: ArtifactInfo[], here: Here, now?: number, theirs?: ArtifactInfo[]): Record<ArtifactFilter, number>;
+/** What `/` searches: the title, the id, the description and the session's title. */
+export declare function searchText(a: ArtifactInfo, sessionTitle: string | null): string;
+/**
+ * What became of the session an artifact names. `deleted`: the server says there is no such session (404);
+ * `none`: no session made it; `unknown`: not asked yet, or the server did not say. Only the first two are orphans.
+ */
+export type SessionLink = {
+    kind: 'session';
+    session: Session;
+    live: boolean;
+} | {
+    kind: 'deleted';
+} | {
+    kind: 'none';
+} | {
+    kind: 'unknown';
+};
+export declare const isOrphan: (link: SessionLink) => link is {
+    kind: "deleted";
+} | {
+    kind: "none";
+};
+export interface SessionGroup {
+    id: string;
+    link: SessionLink;
+    artifacts: ArtifactInfo[];
+}
+/** The artifacts by the session that made each, in the list's order; orphans apart, to show last. */
+export declare function groupBySession(list: ArtifactInfo[], link: (id: string | null) => SessionLink): {
+    groups: SessionGroup[];
+    orphans: ArtifactInfo[];
+};
+export type SortColumn = 'type' | 'title' | 'session' | 'created' | 'updated' | 'version' | 'tokens' | 'size' | 'published' | 'access' | 'views';
+/** Sorted by a column; artifacts without a value (an older server's tokens and sizes) go last either way. */
+export declare function sortArtifacts(list: ArtifactInfo[], by: SortColumn, descending: boolean, sessionTitle: (id: string | null) => string | null, now?: number): ArtifactInfo[];
+export interface Totals {
+    count: number;
+    versions: number;
+    published: number;
+    /** Null when no artifact carries the figure; `partial` when only some do. */
+    tokens: number | null;
+    bytes: number | null;
+    partial: boolean;
+}
+export declare function totals(list: ArtifactInfo[], now?: number): Totals;
+/** The link to open or copy: the published page while it is up, else the viewer page. */
+export declare function shareLink(a: ArtifactInfo, now?: number): {
+    url: string;
+    what: 'published' | 'viewer';
+};
+/** A viewer link at one version. */
+export declare function versionLink(link: string, version: number): string;
+/** A viewer link with its token hidden: the token is the key to the page, and a screen can be seen or shared. */
+export declare function maskToken(link: string): string;
+/** What a published title asks to be typed before it is deleted: its first word, in lower case, else its id's. */
+export declare function confirmWord(a: Pick<ArtifactInfo, 'title' | 'id'>): string;
+export interface Breakage {
+    breaks: string[];
+    /** What deleting here leaves up: published copies, which the server does not take down. */
+    staysUp: string[];
+    /** `yes`: a plain y/N; `type`: the word (or, for several, their count) must be typed. */
+    confirm: {
+        kind: 'yes';
+    } | {
+        kind: 'type';
+        word: string;
+    };
+}
+/**
+ * What deleting `items` breaks and what it leaves up, and how sure the person must be. A session still on the
+ * server keeps its transcript, whose cards for the page stop opening; a deleted one has nothing left to break.
+ */
+export declare function whatBreaks(items: ArtifactInfo[], link: (id: string | null) => SessionLink, now?: number): Breakage;

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

@@ -0,0 +1,102 @@
+/**
+ * File claims between the sessions of one repository (europacore docs/peers.md). The server keeps them: a session
+ * that writes a file owns it until the change is committed, a write to a file another session owns is refused, and
+ * the owner's agent is asked for it. The owner answers per path, the contender may counter once, and the owner's
+ * reply is final. The web shows what was asked and answered, and lets the user release, hand over or ask. A port
+ * of europacorecli's `src/state/claims.ts`.
+ *
+ * Every title, user name, path and boundary here comes from the server or another session's agent: it is made one
+ * plain line before it is put in a sentence.
+ */
+import type { Claim, ClaimRequest, ClaimsView, Disposition, PeerMessage, PeerSession, Ref, Session } from '../../../api/wire';
+import type { NoticeLevel } from './entries';
+/** A session's `metadata.claims`, with its paths read whether the server lists them as paths or as claims. */
+export interface SessionClaims {
+    repo: string;
+    checkout: string;
+    changed: string[];
+    declared: string[];
+    requests: ClaimRequest[];
+    pending: PeerMessage[];
+    attention: string | null;
+    /** Why it needs its user, in the server's words. */
+    attentionReason: string | null;
+}
+/** What the server's `metadata.claims` says of a session's claims; null when it keeps none for it. */
+export declare function claimsOf(metadata: Record<string, unknown> | null | undefined): SessionClaims | null;
+/** A session as others see it: “title”, its user's name when it is a teammate's, and ☁ when it runs in the cloud. */
+export declare function refLabel(ref: (Pick<Ref, 'title' | 'user' | 'mine' | 'session_id'> & {
+    cloud?: boolean;
+}) | null | undefined): string;
+/** A few paths, in one line: "a.py, b.py and 2 more". */
+export declare function pathsLabel(paths: readonly string[]): string;
+/** Which side of a request a session is on. */
+export declare function sideOf(request: ClaimRequest, sessionId: string | null | undefined): 'owner' | 'contender' | null;
+/** An answer as its dispositions, with no one named: "give a.py · share b.py: the top half". */
+export declare function dispositionsLine(answer: Record<string, Disposition> | null | undefined, boundary?: string | null): string;
+/** Who answers and who asked, and which of them reads it: their own name becomes "you" where that reads better. */
+export interface AnswerContext {
+    owner?: Ref | null;
+    contender?: Ref | null;
+    boundary?: string | null;
+    side?: 'owner' | 'contender' | null;
+}
+/**
+ * An answer in words: "“A” gave a.py to “B”, keeps src/x/; “A” and “B” share b.py: the top half". Without the two
+ * sessions (a tool row's own answer), its dispositions.
+ */
+export declare function describeAnswer(answer: Record<string, Disposition> | null | undefined, ctx?: AnswerContext): string;
+/** One notice: what a `claim.*` event says to the session whose stream it came on. */
+export interface ClaimNotice {
+    level: NoticeLevel;
+    text: string;
+}
+/** The request a `claim.*` event carries: its data, or its data's `request`. */
+export declare function requestOf(data: unknown): ClaimRequest | null;
+/** What `claim.requested`, `claim.answered` or `claim.resolved` tells the session `sessionId`; null for nothing. */
+export declare function claimNotice(type: string, request: ClaimRequest, sessionId: string | null | undefined): ClaimNotice | null;
+/** Where a request has got to, for the session `sessionId`: "waiting for “A”'s answer". */
+export declare function requestState(request: ClaimRequest, sessionId: string | null | undefined): string;
+/** A claim in one line: its path, kind, the other holder and boundary of a shared one, and who waits for it. */
+export declare function claimLine(claim: Claim, sessionId: string | null | undefined): string;
+/** `/claims`: this session's claims, the others' in the repository, the open requests with their round, and what waits. */
+export declare function claimsLines(view: ClaimsView, sessionId: string | null | undefined): string;
+/**
+ * Another session of the listing as a reference. Whether it is a teammate's is the listing's `mine`; a server
+ * without it is read from a reference to it elsewhere in the view, or else from its user being this session's.
+ */
+export declare function peerRef(o: PeerSession, view: ClaimsView, sessionId: string | null | undefined): Ref;
+/** Whether a claim on `claimed` covers `path`: the same path, or a directory (`dir/`) above it. */
+export declare function covers(claimed: string, path: string): boolean;
+/** Who holds `path` in a claims view: this session, another listed one, or no one. */
+export declare function holderOf(view: ClaimsView, path: string): {
+    claim: Claim;
+    session: PeerSession | null;
+} | null;
+/** The session a `/claims give` names: by id, or by a title only one of the others has. */
+export declare function findSession(view: ClaimsView, name: string): PeerSession | 'ambiguous' | null;
+/** The inbox's reasons for a contested session: who keeps what it asked for. */
+export declare function contestedLines(claims: SessionClaims, sessionId: string): string[];
+/** Whether a session needs its user for its claims: a request it made could not be settled. */
+export declare function isContested(session: Pick<Session, 'metadata'> | null | undefined): boolean;
+/** What `/claims` was asked to do. */
+export type ClaimsCommand = {
+    verb: 'list';
+} | {
+    verb: 'release';
+    paths: string[];
+} | {
+    verb: 'give';
+    path: string;
+    to: string | null;
+} | {
+    verb: 'ask';
+    path: string;
+    reason: string | null;
+} | {
+    verb: 'usage';
+    text: string;
+};
+export declare const CLAIMS_USAGE = "Usage: /claims [release <path> | give <path> [session] | ask <path> [reason]]";
+/** `/claims` arguments: list, `release <path>…`, `give <path> [session]` or `ask <path> [reason]`. */
+export declare function parseClaimsCommand(args: string): ClaimsCommand;

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

@@ -0,0 +1,41 @@
+/**
+ * A session's context sources (what it loads, in order) as the context view shows them: grouped for the stacked
+ * bar, merged into one text whose lines say where they came from, and read for diagnostics. Pure. A port of
+ * europacorecli's `src/state/context-sources.ts`.
+ */
+import type { ContextSource, ContextSourceKind, MemoryRecord } from '../../../api/wire';
+/** A slice of the context: its glyph in the stacked bar (each its own, so it reads without colour). */
+export interface SourceGroup {
+    key: string;
+    label: string;
+    glyph: string;
+    kinds: ContextSourceKind[];
+}
+export declare const SOURCE_GROUPS: SourceGroup[];
+/** The window the context has not used. */
+export declare const FREE_GLYPH = "\u00B7";
+export declare function groupOf(kind: ContextSourceKind): SourceGroup;
+/** Each group's tokens, in the groups' order, those with none left out. */
+export declare function groupTotals(sources: ContextSource[]): (SourceGroup & {
+    tokens: number;
+})[];
+/** One line of the merged view: the source it came from, and whether it is that source's first. */
+export interface MergedLine {
+    n: number;
+    text: string;
+    first: boolean;
+}
+/** What a source shows in place of text it does not have: the tools, the conversation, a prompt not rendered. */
+export declare function placeholder(source: ContextSource): string;
+/** Every source's text in load order, each line tagged with its source's number. */
+export declare function mergedLines(sources: ContextSource[]): MergedLine[];
+/** The index of a source's first merged line, for jumping to it. */
+export declare function firstLineOf(lines: MergedLine[], n: number): number;
+/** One diagnostic card. */
+export interface Diagnostic {
+    title: string;
+    tone: 'warning' | 'accent' | 'muted';
+    lines: string[];
+}
+/** What is worth knowing about the context: what memory costs every call, and the memories to look at. */
+export declare function diagnostics(sources: ContextSource[], records: MemoryRecord[], window: number | null): Diagnostic[];

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

@@ -1,6 +1,7 @@
-import type { ImageInput, Pause, PlanItem, RunKind, ToolDisplay, ToolStatus } from '../../../api/wire';
+import type { RouteView } from './routing';
+import type { ImageInput, MonitorEnd, Pause, PeerAbout, PeerDelivery, PlanItem, Ref, 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;
+export type Entry = UserEntry | AssistantEntry | ToolEntry | NoticeEntry | SteerEntry | DecisionEntry | RunEndEntry | DiffEntry | WakeEntry | MonitorEntry | PeerEntry;
 export interface UserEntry {
     kind: 'user';
     key: string;
@@ -42,6 +43,8 @@ export interface ToolEntry {
     arguments: unknown;
     startedAt: number | null;
     durationMs: number | null;
+    /** A monitor's task row: the batches of output it has had so far, which /tasks shows. */
+    events?: number;
 }
 export type NoticeLevel = 'info' | 'warn' | 'error';
 export interface NoticeEntry {
@@ -71,6 +74,34 @@ export interface WakeEntry {
     runId: string | null;
     text: string;
 }
+/** A message from another session's agent (`peer.message`): input for this session's agent, not the user's word. */
+export interface PeerEntry {
+    kind: 'peer';
+    key: string;
+    /** The sending session; null when the claims themselves say it (a path come free, a cycle broken). */
+    from: Ref | null;
+    about: PeerAbout | null;
+    requestId: string | null;
+    text: string;
+    /** How it reached the agent; null when read back from the transcript, where the agent has read it. */
+    delivery: PeerDelivery | null;
+}
+/**
+ * What the agent was given of a monitor's output (`monitor_output`): new lines from a command it left running, or
+ * changes to files it watches, and how the monitor ended. The lines are the command's, so untrusted.
+ */
+export interface MonitorEntry {
+    kind: 'monitor';
+    key: string;
+    monitorId: string;
+    description: string;
+    /** A file watch (`watch_files`), not a command. */
+    files: boolean;
+    lines: string[];
+    /** Lines that arrived but were not passed on. */
+    dropped: number;
+    end: MonitorEnd | null;
+}
 /** A workspace diff the user asked for (/diff), shown in full. */
 export interface DiffEntry {
     kind: 'diff';
@@ -91,6 +122,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 +144,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[];