@openagt/dashboard 0.0.0-stage → 0.9.0

package/dist/module-types/src/dashboard-rpc/reads.d.ts

@@ -0,0 +1,184 @@
+import type { BridgeBrowserStatus } from '../bridge-browser.js';
+import { type AgentMeta } from '../store/index.js';
+import { type GitHostHome } from '../store/git-host.js';
+import { type RepositoryOffer } from '../store/repository.js';
+import { type WorkspaceDoc } from '../dashboard/docs.js';
+import { type ProjectQueue } from '../dashboard/queue.js';
+import { type Overview, type RecentAgent } from '../dashboard/overview.js';
+import { type Intervention } from '../dashboard/interventions.js';
+import type { ProjectionRead } from '../dashboard/projects.js';
+import { type OpenQuestion } from '../dashboard/open-questions.js';
+import { type Activity } from '../dashboard/activity.js';
+import { type DashboardData } from '../dashboard/dashboard.js';
+import { type GitStatus } from '../dashboard/git-status.js';
+import { type AgentHandoff } from '../dashboard/agent-handoff.js';
+import type { AgentWorktree } from '../dashboard/types.js';
+import type { OpenAgentEvent } from '../events.js';
+import type { BridgeEvent, BridgeHello, BridgeQuestion } from '../dashboard/bridge-endpoints.js';
+import type { BridgeAnswer, BridgeContact, BridgeVersion } from '../dashboard/bridge-store.js';
+/**
+ * The project's runs, most-recent first (or `[]`). The archived (finished) runs
+ * from `agents/`, plus every live agent prepended — so the sidebar shows an in-progress
+ * run with a `running` status the moment it starts, not only after it closes.
+ *
+ * Since #736 a project has any number of live agents, each in its own worktree, so this reads
+ * them all (#738) instead of the single one that used to sit at the project path. They come
+ * back as {@link LiveAgent}s, carrying the `cwd` of the checkout that agent is editing.
+ *
+ * One row per id, and where both a live and an archived copy exist the live one wins (#768): a
+ * continued run (#762) has an archive from its first leg while being live again, and the archive
+ * would otherwise show a running agent as finished. The status is not filtered on: `readLiveMeta`
+ * may have just self-healed a dead agent to `stopped` (#716), and that freshly-archived row can
+ * lag `listAgents` by a poll — keeping it regardless leaves the row visible with no flicker.
+ *
+ * An agent relayed to a connected device (#1067) lives only in the daemon's memory, never on disk, so
+ * its in-memory stub is merged in too (#1077): that is what re-opens it after a dashboard reload
+ * instead of losing it.
+ */
+export declare function onAgents(projectId: string): Promise<AgentMeta[]>;
+/**
+ * A web run whose cloud session is waiting on a human — the bridge holds its parked question, or
+ * claude.ai's session list shows it awaiting input (#1332) — is marked waiting (#1668), so its row
+ * says so instead of "in cloud": the archive on disk cannot know, only the daemon's bridge store
+ * does. Every other run passes through untouched.
+ */
+export declare function markCloudWaiting(agent: AgentMeta): AgentMeta;
+/**
+ * A run another machine's daemon started is marked as from another host (#1648): the data branch
+ * is shared precisely so other machines' runs show up here, and a row that looked exactly like
+ * one of this daemon's own sent the user reading the archive by hand to learn whose it was. A run
+ * with no recorded host predates the field and passes through untouched.
+ */
+export declare function markOtherHost(agent: AgentMeta, thisHost?: string): AgentMeta;
+/**
+ * A run that ended clean while the process its card names is still alive on this host is marked
+ * saving: the tool that runs it saves the run's record and cleans up its checkout after the card says
+ * done, and a row that said "done" through that window read as finished with nothing coming. A
+ * run of another host, or with no recorded process, passes through untouched.
+ */
+export declare function markSaving(agent: AgentMeta, thisHost?: string, alive?: (pid: number) => boolean): AgentMeta;
+/**
+ * The agent ids that still have a worktree on disk (#737). An agent that failed or was stopped keeps
+ * its checkout so you can go look at what it was holding; this is how the dashboard knows which
+ * finished run has one to offer removing. Live agents are excluded — their worktree is in use.
+ */
+export declare function onRetainedWorktrees(projectId: string): Promise<string[]>;
+/**
+ * Where a session is working (#798): the checkout it has, its branch, whether it is holding
+ * uncommitted changes, and — once it is no longer live — what that checkout costs on disk.
+ *
+ * The dashboard could not answer "where is this session working". The git status bar reads the
+ * *project*, so a session's own branch was visible nowhere, and a worktree an agent kept (#737) was
+ * a name in a list with no size and no way in.
+ *
+ * Every run works in a checkout of its own, so once that checkout is gone there is no tree left to
+ * be clean or dirty: the answer is then only what the run recorded, its branch and its pull
+ * request. It used to fall back to the project's root and report the user's own checkout (their
+ * branch, their "clean") as the run's.
+ */
+export declare function onAgentWorktree(projectId: string, agentId: string): Promise<AgentWorktree | null>;
+/** One archived agent's event log for replay (or `[]` when the agent or project is gone). */
+export declare function onAgent(projectId: string, agentId: string): Promise<OpenAgentEvent[]>;
+/** What each of the named runs of a project is doing now, by id; a run that is not working has no entry. */
+export declare function onAgentsDoing(projectId: string, agentIds: string[]): Promise<Record<string, string>>;
+/** The surfaced PLAN/TODO docs at the workspace root, in sidebar order (or `[]`). */
+export declare function onDocs(projectId: string): Promise<WorkspaceDoc[]>;
+/** The aggregated open TODO queue across every registered project (#438), most-open first. */
+export declare function onQueue(): Promise<ProjectQueue[]>;
+/** The cross-project Overview (#437): what is running now, the queue size, and recent projects. */
+export declare function onOverview(): Promise<Overview>;
+/** Recent sessions pooled across every project (#shared-shell), newest first, for the home rail. */
+export declare function onRecentAgents(): Promise<RecentAgent[]>;
+/**
+ * The cross-project interventions queue (#632, Queue #624): open PRs that need review, newest first,
+ * plus which projects were read whole (#1625).
+ *
+ * The panels render `items` and ignore the rest. The browser's notifier is the caller that cannot:
+ * it keeps a baseline of what was already waiting when the page opened, and a queue that came back
+ * empty because the git host was unreachable is not a baseline — taking it for one announces the whole
+ * backlog the moment the git host answers.
+ */
+export declare function onInterventions(): Promise<ProjectionRead<Intervention>>;
+/** Every session's open question with its full gate (#1455), longest-waiting first: the launcher's hub. */
+export declare function onOpenQuestions(): Promise<OpenQuestion[]>;
+/**
+ * The cross-project "New activity" feed (#627): recent run started/finished transitions, newest
+ * first, with the projects that were read whole beside them (#1625) — see {@link onInterventions}.
+ */
+export declare function onActivity(): Promise<ProjectionRead<Activity>>;
+/** The Overview dashboard page (#471): the {@link onOverview} rollup plus agent counts, run-status totals, and activity. */
+export declare function onDashboard(): Promise<DashboardData>;
+/**
+ * The project's files for the `#` context picker (#504) and the Context's file count (#661): every
+ * file git sees (tracked + untracked, honoring .gitignore), repo-relative and sorted, via
+ * `git ls-files`. Localhost-only by nature — the relay has no checkout, so it resolves `[]`.
+ * Pass a live `agentId` to list that agent's worktree instead of the project root (#738). The
+ * Files tab reads its own list, through its module.
+ */
+export declare function onProjectFiles(projectId: string, agentId?: string): Promise<string[]>;
+/** The project's page on its git host and the git host's name (#489, #1820), or null: no git host package, no remote there, or the relay. */
+export declare function onGitHostHome(projectId: string): Promise<GitHostHome | null>;
+/** The repository the project's provider offers to create for it (a project with no remote), or null: no provider, a remote already there, the host out of reach, or the relay. */
+export declare function onRepositoryOffer(projectId: string): Promise<RepositoryOffer | null>;
+/**
+ * The project's git status (#491): active branch, dirty flag, linked PR. Null when not a repo /
+ * relay. Pass a live `agentId` to read that agent's worktree, which is the branch and the dirty
+ * state that actually belong to it (#738). A run-scoped read is since-filtered (#1255): an agent on
+ * a reused pinned branch must not wear a predecessor's merged PR as its own badge.
+ */
+export declare function onGitStatus(projectId: string, agentId?: string): Promise<GitStatus | null>;
+/**
+ * The end-of-session handoff (#799): the branch a finished session left its work on, what it
+ * committed, what it changed, and whether that has been pushed or opened as a PR.
+ *
+ * Read from the *project* checkout against the session's branch, not from the session's worktree.
+ * A clean agent's worktree is removed when it finishes, and `resolveAgentPath` then falls back to the
+ * project root — so a worktree-addressed read reports the project's own branch and the user's own
+ * uncommitted changes as though they were the session's. The branch is what outlives the agent, so
+ * the branch is what this asks about.
+ */
+export declare function onAgentHandoff(projectId: string, agentId: string): Promise<AgentHandoff | null>;
+/**
+ * The question a Claude web session is parked on, as reported by the browser bridge (#1237).
+ *
+ * Keyed by cloud session id rather than agent id because that is what the bridge can see: it reads
+ * a claude.ai page, which knows its session and nothing about our runs. The agent view already
+ * derives that id from the agent's own `cloud <url>` event, so the join happens on the client
+ * without the daemon having to index runs by session.
+ *
+ * Returns null for anything unrecognised, so an agent with no bridge, no question, or a target that
+ * is not `web` renders exactly as it did before.
+ */
+export declare function onBridgeQuestion(sessionId: string): Promise<BridgeQuestion | null>;
+/**
+ * Whether anything has reached the browser bridge, and how it went (#1237).
+ *
+ * A misconfigured extension and an uninstalled one both leave no question behind, so "nothing is
+ * showing" cannot be diagnosed from the questions alone. A refused request at least proves
+ * something is trying, and its status says which half is wrong.
+ */
+export declare function onBridgeStatus(): Promise<{
+    lastContact: BridgeContact | null;
+    questions: number;
+    page: BridgeHello | null;
+    version: BridgeVersion | null;
+}>;
+/**
+ * The bridge token, for the setup step where a user pastes it into the extension (#1237).
+ *
+ * Only while the bridge is on, so a daemon with the feature off never hands the secret to a
+ * page. Revealing it here is not a new exposure: anyone who can load this dashboard can already
+ * start runs on this machine, and on a non-loopback bind their browser is holding the same token
+ * as a cookie. What it replaces is the alternative, which was telling people to open
+ * `~/.openagent.json` and copy a field out of it.
+ */
+export declare function onBridgeToken(): Promise<string | null>;
+/**
+ * Where the answer picked for that session's question stands (#1237): queued for the
+ * extension, delivered, or failed with the extension's reason. Null when nothing was picked.
+ */
+export declare function onBridgeAnswer(sessionId: string): Promise<BridgeAnswer | null>;
+/** What a Claude web session has said so far, as scraped by the browser bridge (#1237). */
+export declare function onBridgeEvents(sessionId: string): Promise<BridgeEvent[]>;
+/** Where the daemon's own bridge browser stands (#1332): off, starting (and on which step), running, or stopped and why. */
+export declare function onBridgeBrowser(): Promise<BridgeBrowserStatus>;

package/dist/module-types/src/dashboard-rpc/relay-agent.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Run a run-scoped RPC locally, or relay it to the device when `agentId` names an agent this daemon is
+ * relaying to a connected one (#1067 slice 2). For an ordinary local agent the remote lookup is empty and
+ * `local()` runs unchanged. For a remote agent there is no local checkout, so the call is forwarded to the
+ * device over the token; if the device is unreachable, `unreachable` is returned - the same empty/error
+ * shape `local()` gives on a failed read - so the caller never special-cases a remote agent.
+ */
+export declare function relayOr<T>(agentId: string | undefined, fn: string, args: unknown[], local: () => Promise<T>, unreachable: T): Promise<T>;

package/dist/module-types/src/dashboard-rpc/stream-forward.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Forward an async-iterable of events to a `send` sink until the source is exhausted or
+ * the returned stop function is called (#426). This is the bridge behind a relayed
+ * run's live feed: the agent is an `AsyncIterable` that replays its buffered history then follows
+ * live, and each value becomes one `send(event)`. Transport-agnostic on purpose — a plain
+ * callback, so the pump is driven and tested on its own, and the mount decides what a value
+ * becomes on the wire.
+ *
+ * `onDone` fires when the source runs out on its own — a relayed agent that finished. Without it a
+ * consumer cannot tell "nothing more is coming" from "nothing has happened yet", so an SSE
+ * response would stay open forever on a stream that was already over.
+ *
+ * Returns a stop function that halts forwarding and cancels the iterator, releasing the
+ * follower waiting on the next event. Idempotent. An absent source is a no-op.
+ */
+export declare function forwardStream<T>(iterable: AsyncIterable<T> | undefined, send: (value: T) => void, onDone?: () => void): () => void;

package/dist/module-types/src/driver-names.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The driver vocabulary (#542), node-free so every surface shares one copy: the registry's
+ * preference sanitizer and the dashboard bundle. The names are agent-driver's own, the ones a
+ * run's card carries, so the pick handed to a project's start hook as `DRIVER` and the record
+ * that comes back say the same word. The dashboard's per-driver UI table is keyed by
+ * {@link DriverName}, so a missing entry there is a compile error, not a silent gap.
+ */
+/** The coding agents a person can pick for a run, in the order surfaces list them. */
+export declare const DRIVERS: readonly ['claude-code', 'codex'];
+/** A driver the user can pick. */
+export type DriverName = (typeof DRIVERS)[number];
+/** Whether `value` names a driver we can run. */
+export declare function isDriverName(value: string | undefined): value is DriverName;
+/** How each driver reads in a sentence or on a button. */
+export declare const DRIVER_LABELS: Record<DriverName, string>;
+/**
+ * The pick behind the driver a run's record names (#831). Every surface Claude ran on is still
+ * Claude (#1263): older records name its cloud session and its Actions runner. `undefined` for a
+ * driver no pick claims (a fake one, or a record from a newer version).
+ */
+export declare function driverFromImpl(impl: string | undefined): DriverName | undefined;

package/dist/module-types/src/error-message.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The message of an unknown caught value. `catch` hands back `unknown`, and this ternary was
+ * spelled out at over twenty call sites; the next variation in one of them would be a bug (a
+ * dropped `String()` turns a thrown string into `[object Object]`'s sibling problems), so the
+ * idiom gets one home. Node-free, exported through /client for the dashboard's use too.
+ */
+export declare function errorMessage(err: unknown): string;

package/dist/module-types/src/event-stream.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A replayable, multi-consumer stream of events: buffer every event, hand out live async
+ * iterators, and replay history from an offset (tail=N replay).
+ *
+ * Absorbed from `@gemstack/ai-autopilot` when that package was deleted (A2). Its element type
+ * used to default to the supervisor's event; the only caller here passes `OpenAgentEvent`, so
+ * the parameter is now required.
+ */
+export declare class EventStream<E> {
+    private readonly buffer;
+    private readonly waiters;
+    private closed;
+    /** Append an event. Wire this in as an `onEvent` sink. Ignored once closed. */
+    readonly push: (event: E) => void;
+    /** Alias for {@link push}, reads well at the `onEvent:` call site. */
+    get sink(): (event: E) => void;
+    /** Events buffered so far, from `fromOffset` (default 0) — Flue-style tail replay. */
+    history(fromOffset?: number): E[];
+    /** Number of events buffered. */
+    get length(): number;
+    /** True once {@link close} has run. */
+    get isClosed(): boolean;
+    /** End the stream: live iterators drain their backlog, then finish. Idempotent. */
+    close(): void;
+    /**
+     * A fresh async iterator that replays every buffered event, then yields new
+     * ones as they arrive, and finishes once the stream is closed and drained.
+     * Independent iterators each keep their own cursor, so late consumers still
+     * see the full history.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<E>;
+}

package/dist/module-types/src/events.d.ts

@@ -0,0 +1,235 @@
+import type { DriverEvent } from '@openagt/agent-driver';
+/** One selectable option in an interactive {@link ChoiceRequest} (#304). */
+export interface ChoiceOption {
+    /** Stable id posted back when this option is picked. */
+    id: string;
+    /** The option shown to the user. */
+    label: string;
+    /** Optional one-line detail under the label (e.g. why an alternative lost). */
+    detail?: string;
+    /** In a multi-select ({@link ChoiceRequest.multi}), whether this option starts checked. Ignored for single-select. */
+    default?: boolean;
+}
+/**
+ * An interactive choice the agent pauses on until a pick arrives (#304). Emitted as
+ * a `choice` {@link OpenAgentEvent}; the dashboard renders it in a panel and posts
+ * the pick back. The recommended option is what an agent nobody is watching takes.
+ */
+export interface ChoiceRequest {
+    /** Unique id for this pending choice; the pick is posted back against it. */
+    id: string;
+    /** The question shown above the options (e.g. "Approve this plan?"). */
+    title: string;
+    /** The options to choose between (at least one). */
+    options: readonly ChoiceOption[];
+    /**
+     * The option id pre-selected as the default (taken when nobody is watching). Required
+     * for a single-select; omitted for a {@link multi} select, where each option's own
+     * {@link ChoiceOption.default} drives the pre-checked set instead.
+     */
+    recommended?: string;
+    /**
+     * Render as a multi-select checklist (#332): each option is a checkbox pre-checked
+     * per its {@link ChoiceOption.default}, and the pick resolves to the selected
+     * *subset* of ids rather than one. Absent = the single-select gate (#304).
+     */
+    multi?: boolean;
+    /** The markdown file under approval (e.g. `PLAN_<slug>.agent.md`); the doc sidebar renders it. */
+    file?: string;
+}
+/** Who resolved a {@link ChoiceRequest}: a human, or a headless auto-accept. */
+export type ChoiceBy = 'user' | 'auto';
+/** What a {@link import('./agent.js').RunOpenAgentOptions.requestChoice} handler resolves with. */
+export interface ChoicePick {
+    /** The picked option id, or (for a {@link ChoiceRequest.multi} select) the selected subset of ids. */
+    picked: string | readonly string[];
+    /** Who picked it. Default `'user'`. */
+    by?: ChoiceBy;
+}
+/** Normalize a {@link ChoicePick} (single id or subset) to a list of picked ids. */
+export declare function pickedIds(picked: string | readonly string[]): string[];
+/**
+ * The single type a run's timeline is read as. OpenAgent emits none of these itself (#1774):
+ * a run's tool writes the run's diary, and every line of it is read as one of these so the
+ * dashboard and the terminal render one timeline whatever wrote it.
+ *
+ * What a diary yields today is the agent's own progress (`driver`), the session id it reports
+ * (`session-update`), the question a turn ended on (`choice`), what it cost (`usage`) and how it
+ * ended (`end`). **The rest of this union is a reading vocabulary for runs recorded before the
+ * daemon stopped running agents** — OpenAgent's own narration back then. They are kept
+ * because that history is still on the data branch and still has to render.
+ *
+ * Every event read from a diary line that says when it was written carries that time as `at`
+ * (ISO 8601), so the timeline shows the same times live, after a reload, and once the run has
+ * ended. Lines written before the diary kept times have none, and show none.
+ */
+export type OpenAgentEvent = {
+    at?: string;
+} & (
+/**
+ * Emitted once at start: which agent is wrapped, the workspace, and a link. `model` is the
+ * model id the driver was started with (#1438), recorded per leg — a continuation (#762) emits
+ * its own `session` event and may run a different model, so readers fold the latest rather
+ * than pinning the first. Absent when the agent left the agent on its own default.
+ */
+{
+    kind: 'session';
+    driver: string;
+    workspace: string;
+    fake: boolean;
+    sessionLink?: string;
+    model?: string;
+}
+/**
+ * Emitted once the wrapped agent reports its real session id (not known at
+ * start). Carries the live id and, when a link template was supplied, the
+ * resolved URL to jump into that session (#165). Re-emitted if the id changes
+ * (each Claude Code prompt is a fresh session), keeping the link current.
+ */
+ | {
+    kind: 'session-update';
+    sessionId: string;
+    sessionLink?: string;
+}
+/** What this session was asked for, emitted once as it opens (#211). */
+ | {
+    kind: 'intent';
+    text: string;
+}
+/** The wrapped agent's own progress, forwarded verbatim (never gated on). */
+ | {
+    kind: 'driver';
+    event: DriverEvent;
+}
+/**
+ * A live screen something the agent ran is showing: a page on this machine's loopback, shown in
+ * the chat where the line is, while it is the newest open screen at that address and the run
+ * has not ended. `label` names what it showed then. The same address with `ended` says the
+ * screen has gone. A diary line a command appends itself (agent-driver's `DIARY_ENV`);
+ * OpenAgent knows nothing of what the page is.
+ */
+ | {
+    kind: 'screen';
+    url: string;
+    label: string;
+    ended?: true;
+}
+/** An OpenAgent-level log line. */
+ | {
+    kind: 'log';
+    message: string;
+}
+/**
+ * Something went wrong that only the user can fix (#1500), reported by the agent itself
+ * through an `error` block rather than left in prose the reader has to notice. The headline
+ * is the first line, the detail is the rest.
+ *
+ * An event, not a status: it says what happened at this point in the run and stays in the log
+ * as history — nothing clears it, because nothing can un-happen it. The project-level errors a
+ * background job finds between runs are the other half (project-errors.ts): those are
+ * conditions that are true *now*, and clear themselves when the condition is gone.
+ */
+ | {
+    kind: 'error';
+    headline: string;
+    detail?: string;
+}
+/**
+ * An ad-hoc markdown view the agent pushed to show the user (#441), e.g. a plan,
+ * a summary, or a diff writeup. Non-blocking (unlike a `choice`): the dashboard
+ * renders it as a view in the right rail. `id` is stable per title, so re-showing
+ * the same view updates it in place rather than stacking a duplicate.
+ */
+ | {
+    kind: 'view';
+    id: string;
+    title: string;
+    markdown: string;
+}
+/**
+ * The pull request this session's work is on (E6), the moment one is opened for it.
+ *
+ * An event for the same reason `branch` is: only an event reaches the agent's meta,
+ * and the meta is what every later surface reads. Before this, each of them re-resolved the PR
+ * live from the branch — trying the recorded branch, then the session-name branch, then the
+ * run-id branch, and filtering the results by whether the PR predated the session — which is a
+ * three-way guess plus a timestamp heuristic standing in for one integer nobody had written down.
+ */
+ | {
+    kind: 'pull-request';
+    number: number;
+    url: string;
+}
+/**
+ * The branch the agent's work is on (#1277), observed off the checkout rather than guessed:
+ * emitted at start with the branch the agent actually begins on, and again whenever a later
+ * read finds it changed — the agent renames its branch itself, through `branches name`
+ * (#1725). Folded to `AgentMeta.branch`, which every surface resolves first — before this event the
+ * branch was stamped only at teardown (#799), so any read before that guessed between three
+ * naming schemes.
+ */
+ | {
+    kind: 'branch';
+    branch: string;
+}
+/**
+ * The hand-off anchor a cloud run pushed for its session to clone at (#1601): an empty commit
+ * unique to this run, so the branch the session actually works on — a `claude/*` name of the
+ * cloud's own choosing, never the designated run branch — is recognizable later by plain
+ * ancestry. Folded to `AgentMeta.cloudAnchor`, which the daemon's adoption pass matches
+ * against origin's `claude/*` heads once the session has pushed its work.
+ */
+ | {
+    kind: 'cloud-anchor';
+    sha: string;
+}
+/**
+ * The work has settled and the agent is parked on the user (#785): it stays open as a
+ * conversation (#714), so its process is still alive and it still takes messages, but
+ * the agent is not doing anything until you say something.
+ *
+ * Emitted each time the agent parks, and undone by the next `driver` `start` — so "is it
+ * working or waiting for me" is answerable from the event log rather than inferred from
+ * a status that only changes when the agent ends.
+ */
+ | {
+    kind: 'settled';
+}
+/**
+ * The price of one turn in USD (#322): the run's record keeps a cost line per turn the
+ * coding agent priced, and no token counts, so a turn without a price has no usage event
+ * (#540). The dashboard adds them up into its spend readout. Nothing gates on it: an
+ * agent already running is never cut short over spending, and the account's quota
+ * decides what may *start* instead.
+ */
+ | {
+    kind: 'usage';
+    costUsd: number;
+}
+/**
+ * The agent paused on an interactive choice (#304) and is awaiting a pick. The
+ * dashboard renders the options with the recommended default pre-selected and
+ * posts the pick back; a headless agent auto-accepts the recommended option.
+ */
+ | ({
+    kind: 'choice';
+} & ChoiceRequest)
+/** A pending {@link ChoiceRequest} was resolved — the agent continues on `picked` (one id, or the selected subset). */
+ | {
+    kind: 'choice-resolved';
+    id: string;
+    picked: string | readonly string[];
+    by: ChoiceBy;
+}
+/**
+ * The agent finished. `ok` is false when it threw. `stopped` marks the common,
+ * non-error case where the user interrupted it (the dashboard Stop button /
+ * Ctrl+C), so a surface can show "stopped" rather than "failed".
+ */
+ | {
+    kind: 'end';
+    ok: boolean;
+    stopped?: boolean;
+    waiting?: boolean;
+    detail?: string;
+});

package/dist/module-types/src/format-bytes.d.ts

@@ -0,0 +1,2 @@
+/** `1536` → `1.5 KB`. Absent, negative, or unparseable reads as an en dash, like a missing date. */
+export declare function formatBytes(bytes: number | undefined, fallback?: string): string;

package/dist/module-types/src/has-remote.d.ts

@@ -0,0 +1,7 @@
+import { type GitRunner } from '@openagt/agent-data';
+/**
+ * Whether the repository at `cwd` has an `origin` remote: the one every push and pull request
+ * goes to. A remote under another name counts as none, as for the data sync. A directory that is
+ * no repository has none.
+ */
+export declare function hasRemote(cwd: string, git?: GitRunner): Promise<boolean>;

package/dist/module-types/src/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The types the dashboard reads the daemon's answers as.
+ *
+ * Not a library API: nothing imports this package by name, and the browser gets its *values* from
+ * `client.ts` (the node-free entry) and its data over `POST /_rpc/<name>`. What is left here is the
+ * vocabulary of those answers — one import site for a browser file that would otherwise reach into
+ * two dozen modules to name what an RPC returns.
+ *
+ * Type-only on purpose. A value re-exported here would pull the module that defines it into the
+ * browser bundle, which is the failure `client.ts` exists to prevent; `export type` erases at build.
+ *
+ * Every name below is imported by a file under `dashboard/`. That is the whole rule: this file
+ * ends where its consumers end, so a name nothing renders cannot quietly live on in it.
+ */
+export type { AgentError, SessionInfo } from './agent-view.js';
+export type { ChoiceRequest, OpenAgentEvent } from './events.js';
+export type { QuotaBoundary } from './quota-boundary.js';
+export type { CustomPreset, Preferences } from './registry.js';
+export type { PublishPick } from './publish-levels.js';
+export type { DriverQuotaWindow } from '@openagt/agent-driver';
+export type { AgentMeta, AgentStatus } from './store/agent-store.js';
+export type { Activity } from './dashboard/activity.js';
+export type { AgentHandoff } from './dashboard/agent-handoff.js';
+export type { GitHostHome } from './store/git-host.js';
+export type { RepositoryOffer, CreateRepositoryResult } from './store/repository.js';
+export type { BranchReach as RecordsReach } from '@openagt/agent-data';
+export type { BridgeEvent } from './dashboard/bridge-endpoints.js';
+export type { BridgeOption, BridgeQuestion } from './dashboard/bridge-question.js';
+export type { BridgeAnswer } from './dashboard/bridge-store.js';
+export type { DashboardData } from './dashboard/dashboard.js';
+export type { WorkspaceDoc } from './dashboard/docs.js';
+export type { GitStatus } from './dashboard/git-status.js';
+export type { Intervention } from './dashboard/interventions.js';
+export type { OpenQuestion } from './dashboard/open-questions.js';
+export type { ActiveAgent, Overview, RecentAgent } from './dashboard/overview.js';
+export type { ProjectSummary, ProjectionRead } from './dashboard/projects.js';
+export type { ProjectError, ProjectErrorCode } from './project-errors.js';
+export type { ProjectQueue } from './dashboard/queue.js';
+export type { QuotaView } from './dashboard/quota.js';
+export type { Ticket } from './store/tickets.js';
+export type { AgentWorktree, CleanupReport, OnboardingSuggestion } from './dashboard/types.js';

package/dist/module-types/src/jsonl-tail.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Tails an append-only JSONL log, calling `onLine` for each complete line as it
+ * is written. Reads only the bytes appended since the last {@link pull},
+ * buffering a torn trailing line until its newline arrives. A file that shrinks
+ * (a fresh agent truncated the log) resets to the start so the new content is
+ * picked up. The generic base behind the daemon's event tail and the agent's
+ * control tail (#344) — one tailer, two directions.
+ */
+export declare class JsonlTailer<T> {
+    private path;
+    private readonly onLine;
+    /** Told when the log is found rewritten, before its lines are read again from the top. */
+    private readonly onReset?;
+    private offset;
+    private partial;
+    private lastMtimeMs;
+    private adoptMtime;
+    constructor(path: string, onLine: (value: T) => void, 
+    /** Told when the log is found rewritten, before its lines are read again from the top. */
+    onReset?: (() => void) | undefined);
+    /**
+     * Point the tailer at the log's new home, keeping the read offset. For a log that is
+     * *relocated with its content intact* — a run's diary is copied verbatim onto the data branch
+     * when the run ends and its checkout is reclaimed — the bytes already consumed are a prefix of
+     * the new file, so the next {@link pull} delivers exactly the lines the move would otherwise
+     * have swallowed, without replaying what was already delivered.
+     *
+     * The first pull after a retarget adopts the new home's mtime instead of running the
+     * same-length-rewrite check: the copy is younger than the original by construction, and a
+     * fully-consumed log would otherwise read as "rewritten to the same length" and replay
+     * every line it already delivered.
+     */
+    retarget(path: string): void;
+    /** Read and dispatch any lines appended since the previous call. */
+    pull(): Promise<void>;
+}
+/** Options for {@link followFile}. */
+export interface FollowFileOptions {
+    /** How often the backstop poll runs. */
+    pollMs: number;
+    /**
+     * Let the process exit with the tail still running (steering must never hold it open).
+     * Covers both handles this opens — the poll timer *and* the `fs.watch` — since either one
+     * on its own is enough to keep the event loop alive.
+     */
+    unref?: boolean;
+}
+/**
+ * Drive a {@link JsonlTailer} as the file grows: an `fs.watch` on `dir` for latency, plus a
+ * poll backstop because `fs.watch` is unreliable across platforms. Pulls are serialized (a
+ * pull already in flight swallows the next trigger) and stop for good once the returned
+ * function is called. Shared by the agent's control tail and the dashboard's event tail, which
+ * hand-rolled this separately and drifted apart.
+ *
+ * Nothing here may throw at the process: a failed pull and a watcher error are both survivable,
+ * and the poll alone is a complete tail (#996).
+ */
+export declare function followFile(dir: string, pull: () => Promise<void>, opts: FollowFileOptions): () => void;

package/dist/module-types/src/loopback-host.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Loopback-address helpers, shared by the daemon (deciding whether a bind gates behind the
+ * token, #1051) and the RPC mount (rejecting a rebound `Host`). A leaf module on purpose:
+ * `daemon.ts` imports the dashboard, so the mount cannot import these back out of it.
+ */
+/**
+ * True when `host` is a loopback address the browser reaches without leaving the machine (#1051).
+ * A bind-all (`0.0.0.0`, `::`) or a routable address is not, and gates behind the shared token.
+ *
+ * The IPv4 check matches the whole `127.0.0.0/8` range but only as an address: a bare
+ * `startsWith('127.')` also accepts a *registrable name* like `127.evil.com`, which is exactly the
+ * rebound `Host` the DNS-rebinding guard exists to reject (it can resolve to `127.0.0.1`).
+ */
+export declare function isLoopbackHost(host: string): boolean;
+/**
+ * The hostname a `Host` header names, with the port dropped. Keeps the bracketed IPv6 form
+ * (`[::1]:4200` → `[::1]`), which splitting on the first colon would mangle.
+ */
+export declare function hostnameFromHostHeader(header: string): string;