@openagt/dashboard 0.15.0 → 0.17.0

package/dist/module-types/dashboard/components/PaneHeader.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from 'react';
+export interface PaneHeaderSlots {
+    title: HTMLElement | null;
+    actions: HTMLElement | null;
+}
+export declare const PaneHeaderContext: import("react").Context<PaneHeaderSlots>;
+/** In place of the pane's name in its card's header. */
+export declare function PaneTitle({ children }: {
+    children: ReactNode;
+}): import("react").ReactPortal | null;
+/** In the pane's card's header, before the buttons that let it fill the page and close it. */
+export declare function PaneActions({ children }: {
+    children: ReactNode;
+}): import("react").ReactPortal | null;

package/dist/module-types/dashboard/components/SettingsRows.d.ts

@@ -1,8 +1,9 @@
 import type { ReactNode } from 'react';
-/** One section of the Settings page: a titled card of rows. */
-export declare function SettingsSection({ title, description, children }: {
+/** One section of the Settings page: a titled card of rows, with what it offers as a whole (`action`, a button) beside its title. */
+export declare function SettingsSection({ title, description, action, children }: {
     title: string;
     description?: string;
+    action?: ReactNode;
     children: ReactNode;
 }): import("react").JSX.Element;
 /** One setting: what it is and what it does on the left, its control on the right. */

package/dist/module-types/dashboard/components/ui/context-menu.d.ts

@@ -0,0 +1,3 @@
+import { ContextMenu as BaseContextMenu } from '@base-ui-components/react/context-menu';
+export declare const ContextMenu: typeof BaseContextMenu.Root;
+export declare const ContextMenuTrigger: import("react").ForwardRefExoticComponent<import("@base-ui-components/react/context-menu").ContextMenuTriggerProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/module-types/dashboard/components/ui/copy-button.d.ts

@@ -0,0 +1,5 @@
+export declare function CopyButton({ text, label, className }: {
+    text: string;
+    label: string;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/dialog.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+export declare function Dialog({ open, onOpenChange, title, children, }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: ReactNode;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/scroll-area.d.ts

@@ -1,8 +1,5 @@
-import type { Ref } from 'react';
 import { ScrollArea as ScrollAreaPrimitive } from '@base-ui-components/react/scroll-area';
-export declare function ScrollArea({ className, children, viewportRef, viewportClassName, ...props }: ScrollAreaPrimitive.Root.Props & {
-    /** The scrolled element, for a rail that scrolls itself (ViewsRail). */
-    viewportRef?: Ref<HTMLDivElement>;
+export declare function ScrollArea({ className, children, viewportClassName, ...props }: ScrollAreaPrimitive.Root.Props & {
     /** Extra classes on the viewport — where the height cap belongs when the Root has no definite
      *  height. A `max-h-*` on the Root only caps the box; the viewport's `h-full` cannot resolve
      *  against a parent's max-height, so the content grows instead of scrolling. Put the cap here. */

package/dist/module-types/dashboard/lib/machines.d.ts

@@ -0,0 +1,15 @@
+import { type AddMachineResult, type Machine, type RemoveMachineResult } from '../rpc/machines.js';
+export type { Machine };
+/** Read the list from the daemon again. A read that fails keeps what is shown. */
+export declare function refreshMachines(): Promise<void>;
+/** Save the machine a pasted link names; the list is read again once the daemon has it. */
+export declare function addMachine(pasted: string, label?: string): Promise<AddMachineResult>;
+/**
+ * Take a saved machine off the list, and answer whether the daemon did, with its reason when it
+ * did not. The list is read again either way, so a machine the daemon did not remove is still shown.
+ * A removed machine is no longer where the next run starts (#1072): that run would point at
+ * something that is not in the list.
+ */
+export declare function removeMachine(id: string): Promise<RemoveMachineResult>;
+/** The saved machines as reactive state: empty until the daemon has answered. */
+export declare function useMachines(): Machine[];

package/dist/module-types/dashboard/lib/models.d.ts

@@ -14,6 +14,18 @@ export declare function driverOptions(models: ModelsView | undefined): DriverOpt
  * the id itself: that is what the run was given or ran.
  */
 export declare function modelName(models: DriverModels | undefined, id: string): string;
+/**
+ * The effort levels the picked model offers, by the coding agent's own names and in its own order
+ * (`DriverModel.efforts`). Empty for a model that takes none, for an agent that could not list its
+ * models, and before the daemon has answered — the control is simply not there then.
+ */
+export declare function modelEfforts(models: ModelsView | undefined, driver: string | undefined, id: string | undefined): readonly string[];
+/**
+ * How much conversation the picked model holds, by the coding agent's own word (Codex says it; for
+ * Claude it is what the driver knows of the family). `undefined` for a model nobody has said it
+ * of — nothing here guesses one.
+ */
+export declare function modelContextWindow(models: ModelsView | undefined, driver: string | undefined, id: string | undefined): number | undefined;
 export type { DriverModels, ModelsView };
 /** A coding agent as a module offers it: its name for the run (`claude-code`), its label, its models, and why it lists none. */
 export type CodingAgent = DriverOption;

package/dist/module-types/dashboard/lib/remote-target.d.ts

@@ -0,0 +1,6 @@
+/** Pick a saved machine (by id) as the run's target, or null to go back to this machine. */
+export declare function selectMachine(id: string | null): void;
+/** The picked machine's id, read at submit time to say where the run starts. */
+export declare function getSelectedMachineId(): string | null;
+/** The picked machine's id as reactive state; null on the server and until one is picked. */
+export declare function useSelectedMachineId(): string | null;

package/dist/module-types/dashboard/lib/use-modules.d.ts

@@ -14,7 +14,7 @@ export interface MountedCard extends ModuleCard {
     package: string;
     projects: string[];
 }
-/** A side-rail tab as the shell mounts it: the tab, plus the package it came from and the projects that have it. */
+/** A pane as the shell mounts it: the pane, plus the package it came from and the projects that have it. */
 export interface MountedPanel extends ModulePanel {
     package: string;
     projects: string[];
@@ -45,7 +45,7 @@ export interface MountedModules {
     /** Every package's cards, in the order the Overview draws the ones it draws: by `order`, then by package name. */
     cards: MountedCard[];
     linkActions: MountedLinkAction[];
-    /** The side-rail tabs, in package order. */
+    /** The panes beside the chat, in package order. */
     panels: MountedPanel[];
     /** The run slots, one entry per module that has any, in package order. */
     runSlots: MountedRunSlots[];
@@ -68,7 +68,7 @@ export declare function byMountOrder(a: {
 }): number;
 /**
  * What the registered projects' modules add (#1774), in package order: the pages, a segment two
- * modules claim going to the first, the cards (#1818), sorted by their order then their package, the link actions, the side-rail tabs, the run slots, the Settings sections (sorted as the cards are) and the usage bar's stop line (the first module's that declares one),
+ * modules claim going to the first, the cards (#1818), sorted by their order then their package, the link actions, the panes, the run slots, the Settings sections (sorted as the cards are) and the usage bar's stop line (the first module's that declares one),
  * every one of them, each carrying the package it came from and the projects that have it. `loaded` is false until the module list has
  * been read and every module in it imported, so the shell can tell "no such page" from "not
  * loaded yet". A change of `reloadKey` reads the list again at once; what is mounted stays until

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

@@ -176,7 +176,7 @@ export interface ModuleSchedule {
     read(host: ModuleHost, project: ModuleProject): Promise<ModuleScheduledCommand[]>;
 }
 /**
- * The Context as a side-rail tab sees it (#504): the files the next run is pointed at. A tab may
+ * The Context as a pane sees it (#504): the files the next run is pointed at. A pane may
  * show which files are in it and add or remove one.
  */
 export interface ModuleContext {
@@ -185,19 +185,19 @@ export interface ModuleContext {
     /** Add the path to the Context, or take it out when it is in. */
     toggle(path: string): void;
 }
-/** What a side-rail tab is rendered with: the project on screen, the run selected in it (if any), the Context. */
+/** What a pane is rendered with: the project on screen, the run selected in it (if any), the Context. */
 export interface ModulePanelProps {
     projectId: string;
     /** The run whose page this is; absent on the project's own page. */
     agentId?: string;
     /**
      * How many events the run's feed has shown: it grows each time the agent does something, so a
-     * tab showing what the agent changes reads again then, rather than on its next poll. Absent on
+     * pane showing what the agent changes reads again then, rather than on its next poll. Absent on
      * the project's own page.
      */
     activity?: number;
     /**
-     * On a tab that lists what a run changed (`changes`): the changed file a click in the chat
+     * On a pane that lists what a run changed (`changes`): the changed file a click in the chat
      * asked to see, by its path in the run's checkout. `at` tells one ask from the next for the
      * same file. Absent until a file is asked for.
      */
@@ -208,30 +208,33 @@ export interface ModulePanelProps {
     context: ModuleContext;
 }
 /**
- * A tab a module adds to the side rail (#492), shown on every project's page and every run's page
- * of the projects that have the module, before the dashboard's own tabs. A tab with nothing to
- * show says so inside it: the rail cannot know a module is empty without rendering it.
+ * A pane a module adds beside the chat (#492), on every project's page and every run's page of
+ * the projects that have the module: an icon at the end of the page's top bar opens it, in a
+ * column with the other open panes. A pane with nothing to show says so inside it: the top bar
+ * cannot know a module is empty without rendering it.
  */
 export interface ModulePanel {
-    /** Which tab this is among the module's own, for the rail's key and its remembered pick. */
+    /** Which pane this is among the module's own, for its key and for remembering that it is open. */
     id: string;
-    /** The tab's label. */
+    /** The pane's name: on its card, and what its icon is called. */
     label: string;
-    /** The tab's tooltip: one sentence on what it shows. */
+    /** The icon's tooltip: one sentence on what the pane shows. */
     help: string;
-    /** A count shown on the tab beside its label; none when absent or 0. */
-    count?(props: ModulePanelProps): number;
+    /** The pane's icon in the top bar, drawn at the size its `className` gives. */
+    icon: ComponentType<{
+        className?: string;
+    }>;
     /**
-     * This tab lists what a run changed. The chat's row of a changed file then opens the side panel
-     * on it, and hands it the file as `reveal`. Without such a tab, those rows open nothing.
+     * This pane lists what a run changed. The chat's row of a changed file then opens it, and
+     * hands it the file as `reveal`. Without such a pane, those rows open nothing.
      */
     changes?: true;
     /**
-     * This tab shows a run's live screen ({@link ModuleHost.watchScreen}). The chat's row of a live
-     * screen then opens the side panel on it. Without such a tab, that row is a line of text.
+     * This pane shows a run's live screen ({@link ModuleHost.watchScreen}). The chat's row of a live
+     * screen then opens it. Without such a pane, that row is a line of text.
      */
     screen?: true;
-    /** The tab's contents. */
+    /** The pane's contents. They may put their own things in the card's header: {@link PaneTitle}, {@link PaneActions}. */
     Panel: ComponentType<ModulePanelProps>;
 }
 /** What a run slot is rendered with: the run, and whether its agent is working. */
@@ -257,7 +260,7 @@ export interface ModuleDefinition {
     cards?: ModuleCard[];
     /** The actions the module offers on the links dashboard pages show, wherever the link's project has the module's package. */
     linkActions?: LinkAction[];
-    /** The tabs the module adds to the side rail. */
+    /** The panes the module adds beside the chat. */
     panels?: ModulePanel[];
     /** What the module adds to a run's page. */
     run?: ModuleRunSlots;
@@ -348,6 +351,11 @@ export interface ModuleHost {
      * pastes it under Machines. This computer is let in there with it, once, and keeps its key.
      */
     addMachine(link: string, label?: string): Promise<MachineAdded>;
+    /**
+     * Take a saved machine off the list, by its id, and this computer out of the machine: its key
+     * there stops working. Refused, with the reason, while a run is at work there.
+     */
+    removeMachine(id: string): Promise<MachineRemoved>;
     /**
      * What the live screen of a run shows, as the screen's own stream of bytes, until `signal` ends
      * it; nothing when the run has no live screen. OpenAgent asks the computer the run is on, which
@@ -365,6 +373,8 @@ export interface ModuleMachine {
     url: string;
     /** The OpenAgent it runs; absent for a machine that does not answer right now. */
     version?: string;
+    /** The id the machine lists this computer under, among the devices that are in there. */
+    device?: string;
 }
 /** What {@link ModuleHost.machines} answers. */
 export interface ModuleMachines {
@@ -379,6 +389,13 @@ export type MachineAdded = {
     ok: false;
     error: string;
 };
+/** How removing a machine went: done, or refused, with the reason. */
+export type MachineRemoved = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
 /** What the dashboard knows about the module it is serving: every service but the commands and the reads, which it binds to the package. */
 export type ModuleHostBase = Omit<ModuleHost, 'runCommand' | 'act' | 'runComputerCommand' | 'read'>;
 /**
@@ -412,17 +429,21 @@ export { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '.
 export { Popover, PopoverContent, PopoverTrigger } from '../components/ui/popover.js';
 export { RangeSlider } from '../components/ui/slider.js';
 export { Separator } from '../components/ui/separator.js';
-export { PreviewCard } from '@base-ui-components/react/preview-card';
 export { DiffStat } from '../components/DiffStat.js';
 export { ScrollArea } from '../components/ui/scroll-area.js';
 export { Tooltip, TooltipTrigger, TooltipContent } from '../components/ui/tooltip.js';
-export { DropdownMenu, DropdownMenuContent, DropdownMenuCheckboxItem, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuTrigger } from '../components/ui/dropdown-menu.js';
+export { DropdownMenu, DropdownMenuContent, DropdownMenuCheckboxItem, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger } from '../components/ui/dropdown-menu.js';
+export { ContextMenu, ContextMenuTrigger } from '../components/ui/context-menu.js';
+export { PaneTitle, PaneActions } from '../components/PaneHeader.js';
+export { FileIcon } from '../components/FileIcon.js';
 export { Markdown } from '../components/Markdown.js';
 export { StartAgentButton } from '../components/StartAgentButton.js';
 export { LinkActions, type ProjectLinks, type LinkTargets } from '../components/LinkActions.js';
 export { cn } from '../lib/utils.js';
 export { SettingsSection, SettingsRow, SettingsSelectRow, type SettingsOption } from '../components/SettingsRows.js';
 export { QrCode } from '../components/QrCode.js';
+export { AddMachineDialog } from '../components/AddMachineDialog.js';
+export { reachedByLine } from '../../src/client.js';
 export { useCodingAgents, type CodingAgent } from '../lib/models.js';
 export { MAX_SPEND_OFFSET } from '../../src/preference-defaults.js';
 export { formatRelative, formatDateTime, formatDuration, formatAge } from '../lib/format-date.js';

package/dist/module-types/dashboard/rpc/machines.d.ts

@@ -0,0 +1,9 @@
+import type * as impl from '../../src/dashboard-rpc/machines.js';
+export type * from '../../src/dashboard-rpc/machines.js';
+export declare const onMachines: () => Promise<impl.Machine[]>;
+export declare const sendAddMachine: (pasted: string, label?: string | undefined) => Promise<impl.AddMachineResult>;
+export declare const sendRemoveMachine: (id: string) => Promise<impl.RemoveMachineResult>;
+export declare const onMachinesReachable: () => Promise<Record<string, boolean>>;
+export declare const onMachineVersions: () => Promise<impl.MachineVersions>;
+export declare const sendProjectToMachine: (projectId: string, machineId: string) => Promise<impl.ProjectOnMachine>;
+export declare const onProjectOnMachine: (projectId: string, machineId: string) => Promise<impl.ProjectOnMachine>;

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

@@ -12,5 +12,7 @@ export { SeenTracker } from './dashboard/keyed-watcher.js';
 export type { ProjectionRead } from './dashboard/projects.js';
 export { NOTIFICATION_DEFAULTS, MAX_SPEND_OFFSET, notifies, browserNotifyEnabled, notifyCategoryEnabled, type NotifyCategory } from './preference-defaults.js';
 export { parseMachineLink } from './machine-link.js';
+export { reachedByLine } from './reached-by-line.js';
+export { isLoopbackHost } from './loopback-host.js';
 export { bridgeChoiceRequest } from './dashboard/bridge-question.js';
 export { cloudRunState, cloudRunActive, CLOUD_SESSION_WINDOW_MS, type CloudRunState } from './cloud-run-state.js';

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

@@ -1,3 +1,4 @@
+import { type GitRunner } from '@openagt/agent-data';
 import { type LinkedPr, type BranchPrLookup } from './pull-requests.js';
 import type { Cached } from './cache.js';
 import type { AgentMeta } from '../store/index.js';
@@ -60,6 +61,30 @@ export interface AgentHandoff {
     pr?: LinkedPr;
     /** The PR is not known yet, rather than absent (#1028): the lookup is still running. */
     prPending?: boolean;
+    /**
+     * The session kept committing after its PR merged or closed (#1512): the branch holds commits
+     * on top of the PR's head, so the PR is not the answer to that work, which needs a pull request
+     * of its own.
+     */
+    movedPastPr?: boolean;
+    /**
+     * What a pull request for this branch would carry beyond the run's own work: the branch measured
+     * against the project's default branch, for a run started from another branch.
+     *
+     * A run started from a branch of this machine sits on that branch's unlanded commits, and its own
+     * work is measured from where it began ({@link base}) — which is the right count of what the run
+     * did. The pull request, though, goes to the default branch, so that branch's work rides along in
+     * it. Absent when a pull request would carry exactly what the run did, which is every run started
+     * from the branch the project starts agents from.
+     */
+    carries?: {
+        /** The branch a pull request would go to, as the branches provider names it. */
+        base: string;
+        commits: number;
+        files: number;
+        insertions: number;
+        deletions: number;
+    };
     /**
      * The files the session changed and never committed, read from its own checkout (#1173).
      *
@@ -93,6 +118,14 @@ export interface AgentHandoffDeps {
     order?: 'first' | 'latest';
     /** The commit the run's own work begins at ({@link AgentMeta.baseCommit}): what the branch is measured from. */
     from?: string;
+    /** How git is asked whether the branch holds commits on top of its PR's head (default the real one). */
+    git?: GitRunner;
+    /**
+     * When the run ended ({@link AgentMeta.endedAt}), so a pull request it opened on its way out is
+     * not missed: a cached answer read while the run still worked cannot know about one, and the bar
+     * would go on offering to open a request the branch already has. See {@link lookupAgentPr}.
+     */
+    endedAt?: string;
 }
 /**
  * The branch an agent's work is on: what was recorded while the checkout existed (#799/#1277).
@@ -118,6 +151,20 @@ export declare function leftNothing(agent: {
     pr?: unknown;
     landed?: string;
 }, host?: string): boolean;
+/**
+ * Whether a cached pull request answer is from before the run ended, and so cannot have seen what
+ * the run did on its way out.
+ *
+ * A run told to publish its own work opens its pull request as it finishes. The lookup cached while
+ * it was still working says the branch has none, and that answer lives for a minute — long enough
+ * for the bar to offer "Open PR" for a branch that already has one, which is the single mistake
+ * that bar exists to prevent. An answer taken before the run's own end is thrown away rather than
+ * trusted; one taken after it has seen everything the run did.
+ *
+ * Nothing is thrown away for a run still going (no end to be older than), for an answer that was
+ * never read, or for a record whose end is not a date.
+ */
+export declare function answeredBefore(at: number | undefined, endedAt: string | undefined): boolean;
 /** The cached single-PR read {@link resolveAgentPr} asks for the recorded PR's current state. */
 export type CachedBranchPrLookup = (cwd: string, branch?: string) => Promise<Cached<LinkedPr | undefined>>;
 /** What {@link resolveAgentPr} needs to know about an agent: structurally satisfied by {@link AgentMeta}. */
@@ -178,7 +225,7 @@ export declare function readAgentHandoff(cwd: string, branch: string, deps?: Age
  * record kept, and the answer says landed. A branch gone because the run changed nothing is said
  * as that, not as lost work. Undefined for a run with neither a branch nor a landed commit.
  */
-export declare function readRunHandoff(cwd: string, agent: Pick<AgentMeta, 'id' | 'startedAt' | 'branch' | 'baseCommit' | 'landed' | 'status' | 'host' | 'pr'>, deps?: AgentHandoffDeps): Promise<AgentHandoff | undefined>;
+export declare function readRunHandoff(cwd: string, agent: Pick<AgentMeta, 'id' | 'startedAt' | 'endedAt' | 'branch' | 'baseCommit' | 'landed' | 'status' | 'host' | 'pr'>, deps?: AgentHandoffDeps): Promise<AgentHandoff | undefined>;
 /**
  * What a handoff action did. The PR's `number` rides along with its `url` (E6), because the number
  * is the fact worth *recording* — every surface that wants an agent's PR then reads it off the agent

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

@@ -23,6 +23,11 @@ export interface Cached<T> {
     value: T | undefined;
     /** True when no value is known yet and a read is still running. */
     pending: boolean;
+    /**
+     * When this value was read, for a caller that knows of something that happened since and cannot
+     * be in it — a pull request the run opened as it ended, say. Absent while nothing is known yet.
+     */
+    at?: number;
 }
 /** Clock seam, so the tests do not sleep. */
 export type Now = () => number;

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

@@ -1,9 +1,21 @@
 /** What a call says when the machine at the address shows another key than the one it was added with. */
 export declare const NOT_THE_MACHINE = "what answers at this address is not the machine that was added: add the machine again, with a new link";
+/** How this computer says which one it is to a machine's door, with every call: the door lists it once by it. */
+export declare const COMPUTER_HEADER = "x-openagent-computer";
+/** Say which computer this is from here on, with every call to a machine. Set once, when OpenAgent starts. */
+export declare function sayComputer(id: string | undefined): void;
+/** The word OpenAgent was told to say, as the home file keeps it: what its own packages are handed, to say the same. */
+export declare function computerSaid(): string | undefined;
+/**
+ * The word this computer says to one machine's door, made from the word it keeps and that door's
+ * address: each door hears another word, so one that a machine learned says nothing at any other.
+ * A door's own package makes the same word for the line it keeps to that door.
+ */
+export declare function computerWordFor(word: string, door: string): string;
 export interface MachineCall {
     method?: string;
     headers?: Record<string, string>;
     body?: string;
     signal?: AbortSignal;
 }
-export declare function machineFetch(url: string, pin: string | undefined, init?: MachineCall): Promise<Response>;
+export declare function machineFetch(url: string, pin: string | undefined, call?: MachineCall): Promise<Response>;

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

@@ -58,6 +58,9 @@ export declare function remoteFacts(target: MachineAccess): Promise<{
 }>;
 /** The OpenAgent a saved machine runs, as its ping tells it; nothing for a machine that does not answer, or does not say. */
 export declare function remoteVersion(target: MachineAccess): Promise<string | undefined>;
+/** A machine refused a call and said why: the message is the machine's own words, for the person to read. */
+export declare class MachineRefusal extends Error {
+}
 /** What asking to be let in came to: this computer's key there, or why not, in words. */
 export type EnterResult = {
     ok: true;
@@ -71,6 +74,12 @@ export type EnterResult = {
  * is good once: a link used before, or older than a few minutes, is refused.
  */
 export declare function enterRemote(door: string, code: string, name: string, pin?: string): Promise<EnterResult>;
+/**
+ * The id a machine lists this computer under, among the devices that are in there: a door hands
+ * out a key as that id, a dot, and the secret. Never the secret; `undefined` for a key of
+ * another shape, so nothing of one is ever taken for an id.
+ */
+export declare function deviceIdOf(key: string): string | undefined;
 /**
  * Take this computer out of a machine: its key there stops working. Whether the machine did;
  * one that cannot be reached keeps the key until this computer is removed there by hand.
@@ -121,7 +130,8 @@ export interface BringProject {
  * holds this computer's key there, so a read/diff/handoff/push/PR for a relayed agent runs ON the machine: POST
  * {fn, args} to the remote's /_relay/rpc with the key (no Origin), returning the machine's
  * result. Throws on an unreachable machine or a non-2xx so the caller falls back to its own empty/error
- * shape, the same way a failed local read does.
+ * shape, the same way a failed local read does. A refusal the machine gave a reason for is thrown
+ * as a {@link MachineRefusal}, so the reason can be shown in place of that shape's own words.
  */
 export declare function relayRpc(target: RemoteTarget, fn: string, args: unknown[]): Promise<unknown>;
 /**

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

@@ -18,6 +18,11 @@ export type RemoveProjectHandler = (projectId: string, files: boolean) => Remove
  * rather than a file on disk (#426), and the daemon feeds an agent it is relaying from a machine (#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<OpenAgentEvent> | undefined;
+/** A saved machine as a run's row needs it: the name it was given, and its address. */
+export interface SavedMachine {
+    label: string;
+    url: string;
+}
 /** Look up the machine 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 machine instead of resolving a (nonexistent) local checkout. */
@@ -42,10 +47,10 @@ export interface RemoteAgents {
     /** Follow a run that runs on a saved machine, when it is not followed yet: its events then stream here, as for a run this computer sent. */
     follow(projectId: string, agentId: string): Promise<void>;
     /**
-     * The name a saved machine was given, by its computer's own name, as the records of its runs
-     * carry it: asked of the machines first, when one has not said its name yet.
+     * The saved machine, by its computer's own name, as the records of its runs carry it: the name
+     * it was given and its address. Asked of the machines first, when one has not said its name yet.
      */
-    machineNames(): Promise<(host: string) => string | undefined>;
+    machineNames(): Promise<(host: string) => SavedMachine | undefined>;
 }
 /**
  * What every RPC acts through.

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

@@ -71,6 +71,8 @@ export interface OnboardingSuggestion {
 export interface StartAgentOptions {
     /** The model to run on. */
     model?: string;
+    /** How hard that model may think, by the coding agent's own names (`medium`, `high`, …): what the model lists as its efforts. */
+    effort?: 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 at `commit`. A saved pick the project is not offered is held to the furthest the project goes with no pull request. */

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

@@ -39,14 +39,17 @@ export declare function onMachinesReachable(): Promise<Record<string, boolean>>;
 export interface MachineVersions {
     /** This computer's own. */
     version: string;
-    /** Each saved machine, with its version when it answers and says. */
+    /** Each saved machine, with its version when it answers and says, and the id it lists this computer under among its devices. */
     machines: (Machine & {
         version?: string;
+        device?: string;
     })[];
 }
 /**
  * The saved machines with the OpenAgent each runs, beside this computer's own: how a page tells
  * that a machine fell behind this computer. One short call to each, with this computer's key.
+ * The key itself is never told: only the id the machine lists this computer under, which a page
+ * that lists the machine's devices names this computer by.
  */
 export declare function onMachineVersions(): Promise<MachineVersions>;
 /** Whether a saved machine has a project of this computer's: `there` is false while the machine clones it. */

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

@@ -16,6 +16,7 @@ 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';
+import type { SavedMachine } from '../dashboard/rpc-serve.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
@@ -59,6 +60,11 @@ export declare function markCloudWaiting(agent: AgentMeta): AgentMeta;
  * with no recorded host predates the field and passes through untouched.
  */
 export declare function markOtherHost(agent: AgentMeta, thisHost?: string): AgentMeta;
+/**
+ * What a run's row says of the saved machine it runs on: the name the machine was given, and
+ * that it is a person's own computer reached by its line, when it is one.
+ */
+export declare function onMachine(machine: SavedMachine): Pick<AgentMeta, 'remoteLabel' | 'remoteByLine'>;
 /**
  * A run whose record names the computer of a saved machine runs on that machine, whoever started
  * it there, and reads like one this computer sent: by the name the machine was given. The record
@@ -66,7 +72,7 @@ export declare function markOtherHost(agent: AgentMeta, thisHost?: string): Agen
  * own page too, and after this daemon forgot the runs it sent. A run of this computer, and one of
  * a computer that is no saved machine, pass through untouched.
  */
-export declare function markMachine(agent: AgentMeta, machineOf: (host: string) => string | undefined, thisHost?: string): AgentMeta;
+export declare function markMachine(agent: AgentMeta, machineOf: (host: string) => SavedMachine | undefined, 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
@@ -137,7 +143,7 @@ export declare function onDashboard(): Promise<DashboardData>;
  * 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.
+ * Files pane 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. */

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

@@ -9,6 +9,7 @@ export declare function asArrived<T>(call: () => Promise<T>): Promise<T>;
  * knows nothing of the run, a read
  * is answered from what this computer holds of the run, its record when it has one, and
  * anything that would change the run answers `unreachable`: it is never done here in the
- * machine's place.
+ * machine's place. A machine that refused and said why (one that only lets its server watch) is
+ * answered in its own words, where `unreachable` has words of its own to replace.
  */
 export declare function relayOr<T>(agentId: string | undefined, fn: string, args: unknown[], local: () => Promise<T>, unreachable: T): Promise<T>;

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

@@ -96,6 +96,15 @@ export type OpenAgentEvent = {
     kind: 'intent';
     text: string;
 }
+/**
+ * The short name the session was given, emitted once, soon after it opens: a small model's two
+ * to five words for what the person asked, which is what every list of sessions shows instead of
+ * the prompt's first line.
+ */
+ | {
+    kind: 'title';
+    text: string;
+}
 /** The wrapped agent's own progress, forwarded verbatim (never gated on). */
  | {
     kind: 'driver';
@@ -103,9 +112,11 @@ export type OpenAgentEvent = {
 }
 /**
  * A live screen something the agent ran is showing: where it answers, on the loopback of the
- * computer the run is on, live 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`);
+ * computer the run is on, live while it is the newest open screen at that address. `label`
+ * names what it showed then. The same address with `ended` says the screen has gone, and with
+ * `until` that it outlives the run, up to that time: a screen is a browser the person looks at
+ * and clicks in, which the run ending does not take from them. Both of those are rows a reader
+ * shows nothing for. A diary line a command appends itself (agent-driver's `DIARY_ENV`);
  * OpenAgent passes a watcher's calls on to the address (dashboard/screen.ts) and knows nothing
  * of what the screen is.
  */
@@ -114,6 +125,7 @@ export type OpenAgentEvent = {
     url: string;
     label: string;
     ended?: true;
+    until?: string;
 }
 /** An OpenAgent-level log line. */
  | {
@@ -135,18 +147,6 @@ export type OpenAgentEvent = {
     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.
  *