@openagt/dashboard 0.0.0-stage → 0.8.0

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

@@ -0,0 +1,102 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { FrameworkEvent } from '../events.js';
+import type { PreferencesStore } from '../registry.js';
+import type { QuotaSource } from './quota.js';
+import type { ModelsSource } from './models.js';
+import type { BridgeBrowserOwner } from '../bridge-browser.js';
+import type { ProjectErrorsReader } from '../project-errors.js';
+import type { AddProjectResult, StartAgentOptions, StartAgentResult } from './types.js';
+import type { AgentMeta } from '../store/index.js';
+/** Wired by the daemon so `sendStart` can reach the daemon's own `startAgent` closure. */
+export type StartAgentHandler = (prompt: string, options: StartAgentOptions, projectId?: string) => StartAgentResult | Promise<StartAgentResult>;
+/** Wired by the daemon so `sendAddProject` can install + register a repo (#433). */
+export type AddProjectHandler = (path: string) => AddProjectResult | Promise<AddProjectResult>;
+/** Resolve an agent to its live event stream: the relay feeds `onEvents` from its own in-memory stream
+ * rather than a file on disk (#426), and the daemon feeds an agent it is relaying from a device (#1067).
+ * Returns undefined when there is no in-memory stream, so `onEvents` falls back to tailing the log. */
+export type EventsSource = (projectId: string, agentId?: string) => AsyncIterable<FrameworkEvent> | undefined;
+/** Look up the device a relayed agent (#1067) executes on, or undefined for an ordinary local agent. The
+ *  daemon wires this from its live relayed-agent map; a run-scoped RPC uses it to forward a remote agent's
+ *  read/steer/handoff to that device instead of resolving a (nonexistent) local checkout. */
+export interface RemoteAgents {
+    target(agentId: string | undefined): {
+        url: string;
+        token: string;
+    } | undefined;
+    /** A project's relayed run stubs (#1077), so `onAgents` can show a remote agent in the list and re-open it after a reload. */
+    list(projectId: string): AgentMeta[];
+}
+/**
+ * What every RPC acts through.
+ *
+ * Every field is required (D3). These used to be optional because three hosts served this same
+ * surface — the daemon, a per-session foreground dashboard, and a public relay — each wiring a
+ * different subset, so every RPC carried an "absent capability" branch and the client rendered a
+ * degradation matrix. There is one host now, and it wires all of it.
+ */
+export interface DashboardContext {
+    startAgent: StartAgentHandler;
+    addProject: AddProjectHandler;
+    /** The in-memory event stream for an agent relayed from a connected device (#1067), else undefined. */
+    eventsSource: EventsSource;
+    /** The relayed-agent lookup (#1067 slice 2), so a run-scoped RPC can tell a local agent from one
+     *  running on a connected device and forward the call there. */
+    remote: RemoteAgents;
+    /** The user-preferences store (#410), over the registry file. */
+    preferences: PreferencesStore;
+    /** The quota source behind the usage panel (#533). */
+    quota: QuotaSource;
+    /** Which models each coding agent offers, for the agent and model menu. */
+    models: ModelsSource;
+    /** What a project currently suffers from (#1500): the daemon's error state, read per project. */
+    projectErrors: ProjectErrorsReader;
+    /** The daemon's own bridge browser (#1332): status, and show/hide/restart on request. */
+    bridgeBrowser: BridgeBrowserOwner;
+}
+/**
+ * CSRF guard for the state-changing RPCs. A browser attaches an `Origin`
+ * header to every cross-site request, so we reject any POST whose Origin is not this
+ * same server (or a loopback host) — otherwise a page on `evil.com` could `fetch()` the
+ * localhost dashboard and start or steer a run. An absent Origin means a non-browser caller
+ * (curl, the test suite) with no ambient session to abuse, so it passes. Lives here beside
+ * the mount, its only caller.
+ */
+export declare function isSameOriginRequest(req: IncomingMessage): boolean;
+/**
+ * DNS-rebinding guard, the other half of the CSRF check above. A page on `evil.com` whose DNS
+ * re-answers as `127.0.0.1` is *same-origin* with this server as far as the browser is concerned,
+ * so its `fetch()` takes the passing branch of {@link isSameOriginRequest} — and every RPC behind
+ * the mount, `sendStart` included, is reachable from a page the user merely visited.
+ *
+ * The `Host` header is what still gives the attacker away: it carries the name the browser was
+ * asked for (`evil.com`), not the address it resolved to. So when we are bound to loopback, the
+ * only `Host` a real user's browser can send is a loopback one (or the bound address itself) —
+ * anything else is a rebound name and is rejected. An absent `Host` is rejected too when we are
+ * enforcing: HTTP/1.1 requires it, and every browser sends it.
+ *
+ * A non-loopback bind (`--host`, #1051) is reached by a hostname we cannot predict, so there is
+ * no allowlist to check against; that case gates behind the shared daemon token instead. Hosts
+ * that never pass a bind host at all (the relay, which serves a public domain) are unaffected.
+ */
+export declare function isExpectedHost(req: IncomingMessage, boundHost: string | undefined): boolean;
+/** Where the dashboard's RPCs live. One prefix, so the static handler can decline it by path. */
+export declare const RPC_PREFIX = "/_rpc";
+/**
+ * Mount the dashboard's RPC surface (#405) on the daemon's `node:http` server: `POST /_rpc/<name>`
+ * for the calls, `GET /_rpc/events` for the live stream. It runs in the daemon process, so
+ * `sendStart` reaches the daemon's own `startAgent` through the wired {@link DashboardContext}.
+ *
+ * Cross-origin POSTs are rejected (CSRF: a page on evil.com must not steer or start a session), as
+ * are requests carrying someone else's `Host` when we are bound to loopback (DNS rebinding: the
+ * same page must not reach us by pointing its own name at `127.0.0.1`). Pass `opts.host` — the
+ * address the server is bound to — to enable that second check. Returns whether the request was
+ * the RPC surface's.
+ *
+ * This replaced Telefunc (F3), which required a build-time transform over every `.telefunc.ts`
+ * file, a registration table pinning each RPC to the client-baked key of the *dashboard* source
+ * path it was re-exported from, and a request-context indirection for wiring that never varied
+ * per request. What it bought over this was type-safety across a package boundary that A7 removed.
+ */
+export declare function makeRpcMount(context: DashboardContext, opts?: {
+    host?: string;
+}): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;

package/dist/module-types/src/dashboard/run-inbox.d.ts

@@ -0,0 +1,30 @@
+import { type InboxLine } from '@openagt/agent-driver';
+/**
+ * What a person says to a run (#1774): their own words, or their answer to the question the run
+ * stopped on. The daemon runs no agent, so the line reaches the run through what the run's tool
+ * reads: the inbox file in the run's checkout while the run works, the project's `resume` hook
+ * line once it has ended. The framework names no tool in either.
+ */
+/**
+ * The inbox of a run, in its checkout's `.the-framework/`: the file agent-driver's session reads
+ * when a turn ends, one JSON line per message or answer. The run's tool hands the session the
+ * same path.
+ */
+export declare const RUN_INBOX_FILE = "inbox.jsonl";
+/** What a write to a run came to: done, or why not, in words the surface shows. */
+export type SteerResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Hand one line to a run of the project at `cwd`. A run that is working takes it from its inbox
+ * when its turn ends. A run that has ended (done, stopped, failed, or waiting on its question) is
+ * continued through the project's `resume` hook. A run that ends while the line is on its way
+ * would leave it in an inbox nobody reads, so the run is looked at again after the write, and
+ * what is still in the inbox then is taken back and resumes the run instead.
+ */
+export declare function sayToRun(cwd: string, agentId: string, line: InboxLine, deps?: {
+    isWorking?: (cwd: string, agentId: string) => Promise<boolean>;
+}): Promise<SteerResult>;

package/dist/module-types/src/dashboard/scheduler-state.d.ts

@@ -0,0 +1,72 @@
+import type { ProjectSummary } from './projects.js';
+import { type PublishLevel, type PublishPick } from '../publish-levels.js';
+import { type GitHostFor } from '../store/git-host.js';
+/** The file the scheduler keeps its state in, at the project's root; per user, hidden from git by the tool. */
+export declare const SCHEDULER_STATE_FILE = ".agent-scheduler/state.json";
+/** What the last tick decided for one scheduled command, one line for a person. */
+export interface SchedulerDecision {
+    command: string;
+    outcome: string;
+    /** The run's id when the tick started one: the same id the agent's record and checkout carry. */
+    run?: string;
+}
+/** The last tick as the state file remembers it. */
+export interface SchedulerTick {
+    /** ISO timestamp. */
+    at: string;
+    decisions: SchedulerDecision[];
+    /** Why the tick decided nothing, when it could not. */
+    note?: string;
+}
+/** One command of the project's schedule, as the scheduler's last tick read it, with this machine's switch and publish pick. */
+export interface SchedulerCommand {
+    command: string;
+    /** How often at most, as written (`1d`). */
+    every?: string;
+    /** The check, when the line has one. */
+    when?: string;
+    /** Whether it runs on this machine: the machine's switch, else what the line says. */
+    on: boolean;
+    /** How far a run of the command publishes its work, when the line says: `branch`, `pr` or `merge`. A line that says nothing publishes nothing. */
+    publish?: PublishLevel;
+    /** This machine's publish pick for the command, which stands in for the line's level; absent when nobody picked here. */
+    publishPick?: PublishPick;
+}
+/** A project's scheduler as the card shows it. */
+export interface SchedulerState {
+    /** Whether the state file exists and parses: a project without it has no scheduler set up. */
+    present: boolean;
+    /** Whether ticks start agents. */
+    on: boolean;
+    /** Whether the scheduler's process outlives the dashboard that started it. */
+    keepAlive: boolean;
+    /** Whether the scheduler's own process is alive on this machine. */
+    running: boolean;
+    /** The model every run starts on. */
+    model?: string;
+    /** How far past the quota boundary this project's unattended runs may start, in percentage points. */
+    spendOffset?: number;
+    lastTick?: SchedulerTick;
+    /** The schedule's commands with their switches; empty until the scheduler has ticked once with a schedule. */
+    commands: SchedulerCommand[];
+}
+export interface ProjectScheduler extends SchedulerState {
+    projectId: string;
+    projectName: string;
+    /** Whether one of the project's packages provides a git host; without one no pull request can be opened, so a publish pick stops at the branch. */
+    gitHost: boolean;
+}
+/**
+ * Read one project's scheduler state. `isAlive` is the process probe; injectable so a test can
+ * decide what "running" means without holding a process.
+ */
+export declare function readSchedulerState(cwd: string, isAlive?: (pid: number) => boolean): Promise<SchedulerState>;
+/** Every registered project's scheduler, one row per project in registry order, a failing read as not set up. */
+export declare function collectSchedulers(projects: ProjectSummary[], read?: (cwd: string) => Promise<SchedulerState>, gitHost?: GitHostFor): Promise<ProjectScheduler[]>;
+/**
+ * The spend offset the usage panel draws (#960), read off the projects' schedulers: the loosest
+ * one, since it is the one that lets unattended work spend the furthest; `undefined` when no
+ * scheduler names one. The panel's slider writes it back through each project's `offset` hook,
+ * so the schedulers agree unless one was set by hand.
+ */
+export declare function loosestSpendOffset(states: readonly SchedulerState[]): number | undefined;

package/dist/module-types/src/dashboard/subagent-settings.d.ts

@@ -0,0 +1,25 @@
+import { runSubagentsHook } from '../project-hooks.js';
+import { type SubagentSettings } from '../subagent-settings.js';
+import type { ProjectSummary } from './projects.js';
+/** The settings in force, and how many projects have the line that writes them. */
+export interface SubagentSettingsView {
+    settings: SubagentSettings;
+    /** Projects with a `subagents` line; none means Settings can save nothing. */
+    hooked: number;
+}
+/**
+ * The settings of the first project, in registry order, that has the line and a file: Settings
+ * writes every project alike, so they differ only where a file was edited by hand.
+ */
+export declare function readSubagentSettings(projects: readonly ProjectSummary[]): Promise<SubagentSettingsView>;
+/**
+ * Save the settings whole, through the `subagents` line of each project given. Only settings of the
+ * promised shape are passed on. A project without the line is skipped; none having it, or a line
+ * that fails, is the answer's error, each failing project named.
+ */
+export declare function setSubagentSettings(projects: readonly ProjectSummary[], settings: SubagentSettings, run?: typeof runSubagentsHook): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;

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

@@ -0,0 +1,108 @@
+import type { LinkedPr } from './pull-requests.js';
+import type { PublishPick } from '../publish-levels.js';
+/** The outcome of removing a retained worktree (#737). */
+export type RemoveWorktreeResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/** The outcome of deleting a session — its records and worktree (#1032). */
+export type DeleteAgentResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/** The outcome of an add-project attempt (#396): registered, or was already, or why not. */
+export type AddProjectResult = {
+    ok: true;
+    alreadyActivated: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * What the Onboarding checklist (#958) needs and no other read carries: the server's own
+ * working directory, offered as the one-click first project.
+ *
+ * Both fields are null where adding projects is not wired (the relay), so a public host
+ * never discloses its filesystem layout.
+ */
+export interface OnboardingSuggestion {
+    /** The server's working directory, or null when it cannot be offered. */
+    cwd: string | null;
+    /** The project id for {@link cwd} when it is already registered, else null. */
+    cwdProjectId: string | null;
+}
+/**
+ * What a Start carries besides its prompt (#1774): the person's picks, handed to the project's
+ * `start` hook line as `DRIVER`, `MODEL`, `PUBLISH` and `BASE`. Absent leaves each to the tool the line names.
+ */
+export interface StartAgentOptions {
+    /** The model to run on. */
+    model?: string;
+    /** Which coding agent the run is on: `claude-code` or `codex`. */
+    driver?: string;
+    /** The person's saved pick of how far the run takes its work when the agent finishes. Absent, none is saved: the daemon starts the run as far as the project goes with no pull request. A pick the project is not offered is held to that too. */
+    publish?: PublishPick;
+    /**
+     * The branch the agent's own branch starts from, as this machine has it, commits that are not
+     * pushed included: the launcher's "My local branch" pick. Absent, origin's default branch. A
+     * word that is no branch name refuses the Start. Not sent to a device: its branches are its own.
+     */
+    base?: string;
+    /**
+     * The follow-up's prompt: once the run ends done with a pull request, a fresh agent works its
+     * branch from it before the request merges. The launcher's "Post-merge cleanup" box.
+     */
+    then?: string;
+    /**
+     * Run this session on a connected device (#1067): the local daemon relays the start to the remote
+     * daemon at `url` (authenticating with `token` as the `fw_daemon` cookie) and streams its events
+     * back into the local agent view. The device `label` rides along (memory-only, like `url`/`token`) so
+     * the local session list + notice can show which device the agent is on after a reload (#1077).
+     * Memory-only relay config the dashboard sets at submit time from a saved device. NEVER persisted to
+     * Preferences or the registry: a device token is a per-browser secret. Absent = run locally.
+     * Stripped before the start is forwarded, so the remote starts an ordinary local run and does not
+     * relay onward.
+     */
+    remote?: {
+        url: string;
+        token: string;
+        label?: string;
+    };
+}
+/** The outcome of a Start attempt (#345): the id of the run the project's start hook began, or why there is none. */
+export type StartAgentResult = {
+    ok: true;
+    agentId: string;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Where a session is working (#798): its checkout, its branch, and what it is holding. Read by
+ * the dashboard so a session's action bar can say which worktree it has, rather than leaving the
+ * user to infer it from an agent id.
+ *
+ * Only what is true of the run: once its checkout is gone there is no tree to be clean or dirty,
+ * so {@link checkout} is absent and the branch is the one the run recorded.
+ */
+export interface AgentWorktree {
+    /** The run's own checkout while it exists. */
+    checkout?: {
+        /** Absolute path of the checkout. */
+        path: string;
+        /** Uncommitted changes present in it. */
+        dirty: boolean;
+        /** Size on disk, bytes. Only read once nothing is writing to it, and best-effort even then. */
+        sizeBytes?: number;
+    };
+    /** The branch the run's work is on: its checkout's while it has one, else the one it recorded. */
+    branch?: string;
+    /** The PR opened for this run's branch (#809), when there is one. */
+    pr?: LinkedPr;
+    /** The PR is not known yet, rather than absent (#1028): the lookup is still running. */
+    prPending?: boolean;
+}

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

@@ -0,0 +1,53 @@
+import { type ProjectsProvider } from '../dashboard/projects.js';
+import type { DashboardContext, EventsSource, RemoteAgents } from '../dashboard/rpc-serve.js';
+import type { PreferencesStore } from '../registry.js';
+import type { QuotaSource } from '../dashboard/quota.js';
+import type { ModelsSource } from '../dashboard/models.js';
+import type { ProjectErrorsReader } from '../project-errors.js';
+import type { BridgeBrowserOwner } from '../bridge-browser.js';
+/** Wire the dashboard's capabilities. The daemon calls this once at start-up; a test calls it per case. */
+export declare function setDashboardContext(context: DashboardContext): void;
+/** The projects every RPC resolves a project id against: the global registry. */
+export declare function contextProjects(): ProjectsProvider;
+/** The workspace path for a project id, or undefined when no project has that id. */
+export declare function resolveProjectPath(projectId: string): Promise<string | undefined>;
+/**
+ * The checkout a call should act on: a live agent's own worktree when `agentId` names one (#738/#749),
+ * else the project root. Since #736 an agent reads and writes inside its worktree — its event log,
+ * its control log, its working tree — so anything addressed at a *run* has to resolve here, not
+ * at the project path, or it reads an empty log and steers an agent that is not listening. The
+ * resolution itself (and its #766 first-seconds subtlety) lives in the store's
+ * {@link resolveAgentCheckout}, shared with the daemon; this adds only the project-id lookup.
+ */
+export declare function resolveAgentPath(projectId: string, agentId?: string): Promise<string | undefined>;
+/**
+ * The in-memory {@link EventsSource} (#426). It answers only for a run this daemon is relaying
+ * from a connected device (#1067) — such a run has no diary on this machine, since it works in a
+ * checkout over there — and returns undefined for an ordinary local run, whose diary `onEvents`
+ * tails off disk.
+ */
+export declare function contextEventsSource(): EventsSource;
+/**
+ * The relayed-agent lookup (#1067 slice 2). A run-scoped RPC uses it to tell an ordinary local agent
+ * (resolve a local checkout) from one running on a connected device (forward the call there).
+ *
+ * The one accessor with a default rather than a throw, because "unwired" has a real meaning here:
+ * a call arriving over `/_relay/rpc` is the *device* side of the relay, and the agent it names is
+ * local to that device. Forwarding it onward would be a loop, so the honest answer there is that
+ * nothing is relayed from here.
+ */
+export declare function contextRemote(): RemoteAgents;
+/** The user-preferences store (#410), over the registry file. */
+export declare function contextPreferences(): PreferencesStore;
+/** The quota source behind the usage panel (#533). */
+export declare function contextQuota(): QuotaSource;
+/** Which models each coding agent offers. */
+export declare function contextModels(): ModelsSource;
+/** What a project currently suffers from (#1500), as the daemon's background jobs last recorded it. */
+export declare function contextProjectErrors(): ProjectErrorsReader;
+/** The daemon's own bridge browser (#1332). */
+export declare function contextBridgeBrowser(): BridgeBrowserOwner;
+/** The daemon's own `startAgent`, so a start from the dashboard is the same start the CLI makes. */
+export declare function contextStartAgent(): DashboardContext['startAgent'];
+/** Install + register a repo (#433), which only the daemon can do. */
+export declare function contextAddProject(): DashboardContext['addProject'];

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

@@ -0,0 +1,123 @@
+import { type SteerResult } from '../dashboard/run-inbox.js';
+export type { SteerResult };
+import { type OpenTarget, type OpenResult } from '../dashboard/open-in-app.js';
+import type { BridgeBrowserAction } from '../bridge-browser.js';
+import { type HandoffResult } from '../dashboard/agent-handoff.js';
+import { type CreateRepositoryResult } from '../store/repository.js';
+import type { DeleteAgentResult, RemoveWorktreeResult, StartAgentOptions, StartAgentResult } from '../dashboard/types.js';
+/**
+ * The key every action on one run locks under (`agent-locks.ts`): a Remove, a Delete and an Open
+ * PR on the same run each run their own git; serialized, whichever runs second finds the state
+ * the first one left and acts on that. The project and the run's id, not the checkout's path:
+ * the path is the branches provider's to know, and an Open PR on a run whose checkout is gone
+ * still locks the run.
+ */
+export declare function agentLockKey(cwd: string, agentId: string): string;
+/**
+ * Stop a live agent (the Stop button): SIGINT to the process the run's own card names, when it is
+ * this machine's and alive. The card is the file the dashboard shows the run from, and its pid is
+ * whoever runs the agent; the framework names no tool. Nothing else: a run without a live pid
+ * here has nothing to stop.
+ */
+export declare function sendStop(projectId: string, agentId?: string): Promise<void>;
+/**
+ * Answer the question a run stopped on (#304, #1774). `pick` is one option id, or the chosen
+ * subset of a multi-select; the answer handed to the run is the chosen labels, read off the
+ * question as the run's own diary holds it, so only what the agent offered can be answered.
+ */
+export declare function sendChoice(projectId: string, id: string, pick: string | string[], agentId?: string): Promise<SteerResult>;
+/**
+ * Queue the user's pick for the question a Claude web session is parked on (#1237).
+ *
+ * Not a line for a run like {@link sendChoice}: a cloud agent has no run here to hand it to, so
+ * the pick goes to the bridge store, where the browser extension collects it, types
+ * it into the session's composer and submits. Only labels of the currently parked question are
+ * accepted — one, or a multi-select's subset — and the daemon composes the text typed from them,
+ * so this can never put arbitrary text in front of another product's agent. Local only, no
+ * relay: the bridge lives on the daemon the extension talks to.
+ */
+export declare function sendBridgeAnswer(sessionId: string, labels: string[]): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+/** Withdraw a queued bridge answer (#1237). A no-op once the extension has delivered it. */
+export declare function sendBridgeAnswerCancel(sessionId: string): Promise<void>;
+/**
+ * Say something to a run (#714, #1774): the person's own words, the next prompt of the same
+ * conversation. A run that is working takes them when its turn ends; an ended run is resumed
+ * with them. Empty messages are dropped.
+ */
+export declare function sendMessage(projectId: string, text: string, agentId?: string): Promise<SteerResult>;
+/**
+ * Remove a retained worktree (#737). An agent that failed or was stopped keeps its checkout so you
+ * can inspect it; this is the explicit cleanup for one, since nothing removes them on a timer.
+ *
+ * The checks and the removal are {@link removeProjectWorktree}'s, shared with the CLI's removal
+ * path (#982) so the surfaces cannot drift again; this adds only the agent lock around them.
+ */
+export declare function sendRemoveWorktree(projectId: string, agentId: string): Promise<RemoveWorktreeResult>;
+/**
+ * Delete a session (#1032): remove it from the dashboard, records and all — the sibling of
+ * {@link sendRemoveWorktree}, and the one destructive-of-history action, so its surface confirms
+ * first. The checks, the worktree removal and what it leaves behind (the branch and its
+ * commits) are all {@link deleteProjectAgent}'s; this adds only the agent lock around them.
+ */
+export declare function sendDeleteAgent(projectId: string, agentId: string): Promise<DeleteAgentResult>;
+/**
+ * Start a run in the project (#405, #1774): the project's own `start` hook line, reached through
+ * the daemon's wired `startAgent` (which relays to a connected device when the options name
+ * one). Answers the id of the run the hook began, or why there is none: a project without the
+ * line cannot start a run from here.
+ */
+export declare function sendStart(projectId: string, prompt: string, options?: StartAgentOptions): Promise<StartAgentResult>;
+/**
+ * Open a project in the OS file manager or an editor (#490). Localhost-only: the daemon
+ * spawns a local command against the project's own registered path. A public host has no
+ * local path to resolve, so it returns an error rather than spawning anything.
+ *
+ * With a `agentId` it opens that session's own checkout instead (#798) — the whole point of
+ * opening it is to look at what the agent is doing, which is not in the project's tree.
+ */
+export declare function sendOpenInApp(projectId: string, target: OpenTarget, agentId?: string): Promise<OpenResult>;
+/**
+ * Open a PR for a finished session's branch (#799): the project's branches provider pushes it
+ * first if the remote lacks it (#1774).
+ *
+ * The title and body come from what the agent already recorded: the branch the agent named its
+ * work with and the intent the user asked for. Nothing new is invented and nothing extra is asked
+ * of the user, which is the point of "offer the next step rather than describe it".
+ */
+export declare function sendOpenPullRequest(projectId: string, agentId: string, options?: {
+    draft?: boolean;
+}): Promise<HandoffResult>;
+/**
+ * The user's Publish branch action (#1820): push a finished run's branch and open no pull request,
+ * the last step where the project has no git host package. Under the agent lock, as Open PR is, so the push cannot race a Remove.
+ */
+export declare function sendPush(projectId: string, agentId: string): Promise<HandoffResult>;
+/**
+ * The user's "Create a repository" action, for a project with no remote: the project's repository
+ * provider creates it private, sets it as the origin and pushes. The git host is looked up again
+ * afterwards: the project has a page there now.
+ */
+export declare function sendCreateRepository(projectId: string): Promise<CreateRepositoryResult>;
+/**
+ * The user's "Merge into main" action: merge a finished run's branch into the project's default
+ * branch on this machine, for a project with no remote to push to. Under the agent lock, as the
+ * push is, so the merge cannot race a Remove.
+ */
+export declare function sendMergeBranch(projectId: string, agentId: string): Promise<HandoffResult>;
+/**
+ * The user's Merge action (#1391): merge a finished run's open pull request, directly. A run
+ * that is still working has no Merge: its agent is still writing its branch, and the button comes
+ * with the ended view.
+ */
+export declare function sendMerge(projectId: string, agentId: string): Promise<HandoffResult>;
+/**
+ * Ask the daemon's bridge browser to show its window (for the one-time sign-in), hide it again,
+ * or restart (#1332). Anything else is refused; a browser that is not running ignores show/hide.
+ */
+export declare function sendBridgeBrowser(action: BridgeBrowserAction): Promise<{
+    ok: boolean;
+    error?: string;
+}>;

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

@@ -0,0 +1,8 @@
+/** One device to health-check: its profile id plus the origin and token to reach it with. */
+export interface DeviceCheck {
+    id: string;
+    url: string;
+    token: string;
+}
+/** Ping each saved device and map its id to whether it answered (#1072). Bad entries are dropped. */
+export declare function checkDevices(devices: DeviceCheck[]): Promise<Record<string, boolean>>;

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

@@ -0,0 +1,67 @@
+/**
+ * Tail a JSONL log: read what is already in it, then follow appends. Each complete line is
+ * parsed and handed to `onEvent`; malformed lines are skipped. Returns a stop function that
+ * removes the watcher and the poll.
+ *
+ * The reading is {@link JsonlTailer} and the following is {@link followFile}. This used to be
+ * its own copy of both, which is how it ended up missing the tailer's same-length-rewrite
+ * detection (#567).
+ *
+ * `onReplayed` is told once the first pull — the replay of everything already logged — has
+ * been delivered (#1383). That boundary is what lets a reconnecting client buffer the replay
+ * and swap its feed atomically instead of blanking while history re-streams. The follower
+ * only starts after it, so no appended line can slip in ahead of the marker. Best-effort on
+ * a failed first read: the marker still fires (the poll retries the read), because a client
+ * waiting on it forever would freeze its feed.
+ *
+ * Kept transport-agnostic (a plain `onEvent` callback, not a stream) so the file
+ * side can be driven on its own; `events.ts` wires it to the SSE endpoint.
+ */
+export declare function tailEvents<T = unknown>(path: string, onEvent: (event: T) => void, onReplayed?: () => void): () => void;
+/**
+ * Reads the message a run is writing, from the live file beside its diary, for
+ * {@link tailAgentEvents}' `afterPull`: the file changes in the diary's directory, so the diary's
+ * watch reads it too. `send` gets the text when it changed, and `''` once the file is gone.
+ */
+export declare function partialReader(send: (text: string) => void): (diary: string) => Promise<void>;
+/** Where a relocating tail reads now: a file it follows, a finished run's lines, whole, or nowhere yet (`pending`: ask again shortly). */
+export type TailTarget<T> = {
+    file: string;
+} | {
+    finished: T[];
+} | {
+    pending: true;
+};
+/**
+ * Tail a run's diary across its relocations: the same read-then-follow as {@link tailEvents},
+ * but where the diary is is asked again whenever the tailed file is not there.
+ *
+ * A run's diary does not sit still. While the run works it is a file in the run's checkout; when
+ * the run ends its tool records it and reclaims the checkout, and from then on the diary is the
+ * finished run's, read whole from the project's runs provider. A fixed-path tail whose file was
+ * retired went silent *without the final lines* whenever the last `fs.watch` signal was lost —
+ * the 1s poll then found the file gone and had nothing to read, so the feed never learned the run
+ * ended. This tail treats a missing file as the question it is: it asks `resolve` where the diary
+ * is now (`resolveAgentDiary` answers the finished run once the checkout is gone, #1472). A new
+ * file retargets the same tailer and follows it. A finished run's lines are the same lines the
+ * file had, in the same order, so the ones past the count already delivered are sent and the tail
+ * ends: a finished diary does not grow. The same file, or no answer, means the diary has not
+ * moved, and the tail keeps waiting where it is. A diary that is nowhere yet (`pending`: the run
+ * was started a moment ago and its tool has not made the checkout, or it is being continued and
+ * its checkout is on its way back) is asked for again on the same cadence until it has a home,
+ * and only then followed; the replay boundary is reported once what that home holds has been
+ * delivered, not before: a feed that reconnects swaps what it shows for the replay at the
+ * boundary, and a boundary reported with nothing delivered emptied a chat that was full, for as
+ * long as the diary took to have a home. Asking even when the file was never seen matters for a
+ * short run (#1774): started, ended and reclaimed between two polls, its diary was only ever
+ * visible as a finished run.
+ *
+ * `onReplayed` keeps {@link tailEvents}' once-per-subscription contract: a relocation is not a
+ * new replay boundary, so it never fires twice.
+ *
+ * `afterPull` is told the diary's path after each read of it: the files beside the diary change
+ * with it, and a caller reads them there, on the same watch.
+ */
+export declare function tailAgentEvents<T = unknown>(resolve: (opts?: {
+    cached?: boolean;
+}) => Promise<TailTarget<T> | undefined>, onEvent: (event: T) => void, onReplayed?: () => void, afterPull?: (diary: string) => Promise<void>): () => void;

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

@@ -0,0 +1,38 @@
+import type { FrameworkEvent } from '../events.js';
+/**
+ * The end-of-replay marker (#1383). A subscribe replays the whole log before following live,
+ * and without a boundary a reconnecting client cannot tell "replay still streaming" from "the
+ * log is genuinely this short" — so it blanked a populated feed and refilled it line by line.
+ * Sent once per subscription, after the on-disk replay is delivered. Wire-only: it is not a
+ * {@link FrameworkEvent}, is never written to any journal, and the client swallows it.
+ */
+export type StreamSync = {
+    kind: 'stream-sync';
+};
+/**
+ * The message the agent is writing, as far as it has got (the run's live file, beside its diary);
+ * empty once there is none. Wire-only like {@link StreamSync}: the pieces are never in the diary,
+ * and the page shows them until the whole message's line arrives.
+ */
+export type PartialMessage = {
+    kind: 'partial';
+    text: string;
+};
+/** What `onEvents` streams: the agent's events, plus the wire-only end-of-replay marker and partial message. */
+export type LiveFeedEvent = FrameworkEvent | StreamSync | PartialMessage;
+/**
+ * Follow one agent's events: `send` is called per event until the returned stop function runs.
+ * Returns undefined when there is nothing to stream (an unknown project), which the mount ends as
+ * a clean close — mirroring the read model's empty results rather than throwing at the client.
+ *
+ * The `agentId` names the run whose diary is followed; without one there is nothing to stream.
+ *
+ * Two sources, chosen by what is wired. An in-memory stream wins: an agent the daemon is relaying
+ * from a device (#1067). Otherwise the on-disk log. The daemon's source answers only for relayed
+ * runs, so an ordinary local agent falls through to tailing the log.
+ *
+ * Only the on-disk tail sends the {@link StreamSync} marker: the in-memory sources have no replay
+ * boundary to report, so a reconnecting client falls back to a grace deadline before swapping its
+ * feed (see use-live-events in the dashboard).
+ */
+export declare function streamAgentEvents(projectId: string, agentId: string | undefined, send: (value: LiveFeedEvent) => void, onDone?: () => void): Promise<(() => void) | undefined>;