@openagt/dashboard 0.9.0 → 0.11.0

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

@@ -191,6 +191,11 @@ export interface ModulePanel {
      * on it, and hands it the file as `reveal`. Without such a tab, 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.
+     */
+    screen?: true;
     /** The tab's contents. */
     Panel: ComponentType<ModulePanelProps>;
 }
@@ -290,7 +295,47 @@ export interface ModuleHost {
     configureRun(projectId: string, prompt: string): void;
     /** The project's runs the dashboard knows: the ones running, and the recorded ones when the project records them. */
     agents(projectId: string): Promise<ModuleAgent[]>;
+    /**
+     * The other computers a run can be sent to, as saved on this one, each with the OpenAgent it
+     * runs, beside this computer's own: how a page tells that a machine fell behind this computer.
+     */
+    machines(): Promise<ModuleMachines>;
+    /**
+     * Save the machine a link names: the link another OpenAgent gives for a new device, as a person
+     * pastes it under Machines. This computer is let in there with it, once, and keeps its key.
+     */
+    addMachine(link: string, label?: string): Promise<MachineAdded>;
+    /**
+     * 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
+     * may be another machine: the bytes are that computer's, to read as data and never to run.
+     */
+    watchScreen(projectId: string, agentId: string, signal: AbortSignal): Promise<ReadableStream<Uint8Array> | undefined>;
+    /** Send the live screen of a run what the person did on it, as JSON; whether the screen took it. */
+    sendToScreen(projectId: string, agentId: string, input: unknown): Promise<boolean>;
 }
+/** A saved machine, as a module sees it: never this computer's key there. */
+export interface ModuleMachine {
+    /** Where the machine answers, as an origin (`https://203.0.113.5`): what it is known by. */
+    id: string;
+    label: string;
+    url: string;
+    /** The OpenAgent it runs; absent for a machine that does not answer right now. */
+    version?: string;
+}
+/** What {@link ModuleHost.machines} answers. */
+export interface ModuleMachines {
+    /** This computer's own OpenAgent. */
+    version: string;
+    machines: ModuleMachine[];
+}
+/** How saving a machine went: done, or stopped, with the reason. */
+export type MachineAdded = {
+    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' | 'read'>;
 /**
@@ -314,6 +359,7 @@ export { Badge } from '../components/ui/badge.js';
 export { Card, CardHeader, CardTitle, CardContent } from '../components/ui/card.js';
 export { Skeleton } from '../components/ui/skeleton.js';
 export { Checkbox } from '../components/ui/checkbox.js';
+export { Switch } from '../components/ui/switch.js';
 export { Input } from '../components/ui/input.js';
 export { Popover, PopoverContent, PopoverTrigger } from '../components/ui/popover.js';
 export { RangeSlider } from '../components/ui/slider.js';

package/dist/module-types/src/built-in.d.ts

@@ -1,37 +1,66 @@
 import type { CleanupReport } from './dashboard/types.js';
 import { type ProjectPackage, type ProvidedCommand, type ProvidedCommandLookup } from '@openagt/agent-data';
 /**
- * The packages OpenAgent ships for every project, by name: dependencies of OpenAgent
- * itself, resolved from its own install, so a project installs nothing for them and an empty
- * folder starts an agent and shows it. Each comes through the same contract as a project's own
- * package: a module by its `./dashboard` export, a provider of a kind of data and the writer of
- * its hook lines by its `openagent` key. This list is the one place OpenAgent names a
- * package, and a project's own copy of any of them wins.
+ * The packages OpenAgent brings, by name: dependencies of OpenAgent itself, resolved from its
+ * own install, so a project installs nothing for them and an empty folder starts an agent and
+ * shows it. Each comes through the same contract as any package: a module by its `./dashboard`
+ * export, a provider of a kind of data and the writer of its hook lines by its `openagent` key.
+ * These two lists are the one place OpenAgent names a package. One of these names among a
+ * project's own dependencies is not read: OpenAgent's copy, and the rules below for which
+ * project has it, are the only ones.
  */
+/** The packages every project has: an agent cannot start, be shown or be put on a git host without them, and the door to this computer and the servers it installed OpenAgent on are no project's to pick. */
 export declare const BUILT_IN_PACKAGES: readonly string[];
-/** The built-in packages, resolved from OpenAgent's own install, once; one that is not installed is skipped. */
+/**
+ * The packages a project has once it picked them (#2023). A skill's package is the project's
+ * when the project holds the skill's text where the coding agents read it
+ * (`.claude/skills/<name>/SKILL.md`, `.agents/skills/<name>/SKILL.md`): the rule the launcher
+ * already lists a project's commands by, so deleting the skill's folder takes its page away. A
+ * tool with no skill text (the scheduler) is the project's when one of the project's hook lines
+ * runs it.
+ */
+export declare const PICKED_PACKAGES: readonly string[];
+/** Every name OpenAgent brings itself. */
+export declare const OWN_PACKAGE_NAMES: readonly string[];
+/** Every package OpenAgent brings, resolved from its own install, once; one that is not installed is skipped. */
 export declare function builtInPackages(): Promise<ProjectPackage[]>;
-/** The directories the built-in packages' commands sit in: what a hook line's PATH gains after the project's own installed tools. */
+/**
+ * The packages OpenAgent brings to the project at `root`: the ones every project has, and
+ * each picked one the project has by its rule (see {@link PICKED_PACKAGES}). Read off the
+ * project's files each time, so a skill written or deleted a moment ago counts at once.
+ */
+export declare function builtInPackagesOf(root: string): Promise<ProjectPackage[]>;
+/** The project's own installed packages, less the names OpenAgent brings itself. */
+export declare function ownPackages(root: string): Promise<ProjectPackage[]>;
+/**
+ * The services of the packages every project has: a package declares
+ * `"openagent": { "service": "<command>" }`, and `<command> serve` runs for as long as OpenAgent
+ * runs (`package-services.ts`). Only those packages: a service is this computer's, and a package
+ * a project picked is that project's.
+ */
+export declare function builtInServices(): Promise<ProvidedCommand[]>;
+/** The directories the commands of OpenAgent's packages sit in: what a hook line's PATH gains after the project's own installed tools. */
 export declare function builtInBinDirs(): Promise<string[]>;
-/** What provides `kind` in the project at `root`: one of the project's own packages, else a built-in one. */
+/** What provides `kind` in the project at `root`: a package the project installed for it, else one OpenAgent brings to this project. */
 export declare function lookupProvided(root: string, kind: string): Promise<ProvidedCommandLookup>;
 /** {@link lookupProvided}'s command, for a caller that only needs to run it. */
 export declare function providedCommand(root: string, kind: string): Promise<ProvidedCommand | undefined>;
-/** Whether `command` comes from a built-in package the project has no copy of: one the project did not choose. */
-export declare function isBuiltIn(root: string, command: ProvidedCommand): Promise<boolean>;
+/** Whether `command` comes from a package OpenAgent brings: one the project did not install. */
+export declare function isBuiltIn(command: ProvidedCommand): boolean;
 /**
  * Have every package that writes hook lines write its own into the project at `root`: a package
  * declares `"openagent": { "hooks": "<command>" }`, and `<command> init`, run in the project,
  * writes its lines into the project's hooks file, keeping every line already there. The project's
- * own packages are asked, then the built-in ones the project has no copy of. Answers one line per
- * package that could not write, in words.
+ * own packages are asked, then the ones OpenAgent brings to it. Answers one line per package
+ * that could not write, in words.
  */
 export declare function writeHookLines(root: string): Promise<string[]>;
 /**
  * Have every package that declares a clean-up remove what it left in the project at `root`: a
  * package declares `"openagent": { "cleanup": "<command>" }`, and `<command> cleanup`, run in the
- * project, answers `{ ok: true, removed, kept }`. The project's own packages are asked, then the
- * built-in ones the project has no copy of, each whatever the one before answered. A package
- * that refuses, fails or answers something else is one line in `failed`, in words.
+ * project, answers `{ ok: true, removed, kept }`. The project's own packages are asked, then
+ * every package OpenAgent brings, also one this project no longer has (what it left stays its
+ * own to remove), each whatever the one before answered. A package that refuses, fails or answers
+ * something else is one line in `failed`, in words.
  */
 export declare function runCleanups(root: string): Promise<CleanupReport>;

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

@@ -1,6 +1,7 @@
 export { DRIVERS, DRIVER_LABELS, isDriverName, driverFromImpl, type DriverName } from './driver-names.js';
 export { PUBLISH_LABELS, isPublishPick, offeredPublishPicks, publishPickIn, type PublishPick } from './publish-levels.js';
 export { formatOpenAgentEvent } from './terminal.js';
+export { foldScreenRows } from './screens.js';
 export { formatBytes } from './format-bytes.js';
 export { errorMessage } from './error-message.js';
 export { pickedIds } from './events.js';
@@ -10,6 +11,6 @@ export { interventionKey, activityKey } from './dashboard/keys.js';
 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 { isLoopbackHost } from './loopback-host.js';
+export { parseMachineLink } from './machine-link.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/bridge-endpoints.d.ts

@@ -5,11 +5,11 @@ export type { BridgeOption, BridgeQuestion } from './bridge-question.js';
  * The browser bridge (#1237): the one endpoint an extension running in the user's own Claude
  * session posts to, so a question a cloud agent is parked on becomes visible in the dashboard.
  *
- * **Why this route carries its own token, unlike every other one.** The #1051 guard in
- * `startDashboard` only exists on a non-loopback bind, and what protects a loopback daemon is
- * the same-origin check on `/_rpc`: a page on another origin is refused outright. This
- * route is the first that is *meant* to be reached from another origin, so neither of those
- * protects it, and it demands `Authorization: Bearer <daemonToken>` unconditionally instead.
+ * **Why this route carries its own token, unlike every other one.** What protects the daemon,
+ * which listens on its own computer only, is the same-origin check on `/_rpc`: a page on another
+ * origin is refused outright. This route is the first that is *meant* to be reached from another
+ * origin, so that check does not protect it, and it demands `Authorization: Bearer <bridgeToken>`
+ * unconditionally instead.
  *
  * **No CORS headers, on purpose.** An extension's service worker holding `host_permissions`
  * fetches without a preflight, so the bridge does not need `Access-Control-Allow-Origin` and

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

@@ -1,7 +1,7 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 /**
  * The plumbing every one of the daemon's non-RPC HTTP surfaces shares: the browser bridge
- * (`/_bridge`), the web-start queue (`/_web-start`) and the device relay (`/_relay`).
+ * (`/_bridge`), the web-start queue (`/_web-start`) and the machine relay (`/_relay`).
  *
  * All three answer plain-text statuses, JSON payloads, and read capped JSON request bodies, and
  * each carried its own copy — two body readers that differed only in which message they rejected

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

@@ -0,0 +1,9 @@
+/** 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";
+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>;

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

@@ -3,50 +3,90 @@ import type { OpenAgentEvent } from '../events.js';
 import type { AgentMeta } from '../store/index.js';
 import type { StartAgentOptions, StartAgentResult } from './types.js';
 /**
- * The server-side half of "run on a connected device" (#1067). The local daemon holds the saved
- * device's token, so it - not the browser - drives the remote daemon: it POSTs the agent to the
+ * The server-side half of "run on a saved machine" (#1067). The local daemon holds this computer's
+ * key on the saved machine, so it - not the browser - drives the remote daemon: it POSTs the agent to the
  * remote's `/_relay/start` and then fetch-streams the remote's `/_relay/events` back into a local
  * {@link EventStream}, which the dashboard reads over its normal same-origin `onEvents` channel. So
- * the browser never talks cross-origin and the token never leaves the two daemons (issue #1067 (b)).
+ * the browser never talks cross-origin and the key never leaves the two daemons (issue #1067 (b)).
  *
- * Authentication is the shared-token cookie (#1051), sent daemon-to-daemon: `Cookie: oa_daemon=<token>` with no
- * `Origin` header. The remote's guard admits a matching cookie without the browser-only `?token=`
- * 302, and its `/_rpc` CSRF check (absent Origin passes) is not even on these raw routes.
+ * Every call but the ping names its project, by its repository's address
+ * (repository-address.ts): a project's folder, and so its id, is another one on each machine.
+ *
+ * The other OpenAgent listens on its own computer only. What answers at a machine's address is
+ * whatever that computer opened to the network, which lets this computer in once, with the code
+ * a machine's link carries ({@link enterRemote}), answers a key of this computer's own, and from
+ * then on passes each call that carries the key (`Authorization: Bearer`, no `Origin`) to its
+ * OpenAgent as that computer's own browser would have made it.
  */
-/** Where a relayed agent executes: the remote daemon's origin and its #1051 token. Memory-only. */
-export interface RemoteTarget {
+/** How a machine is reached: where its OpenAgent answers, this computer's key there, and what the machine's own key is known by when its link said. */
+export interface MachineAccess {
     url: string;
-    token: string;
+    key: string;
+    pin?: string;
+}
+/** Where a relayed agent works: a machine, and the project there, by its repository's address. */
+export interface RemoteTarget extends MachineAccess {
+    project: string;
 }
-/** The body a relay start forwards to the remote's `/_relay/start`. */
+/** What a relay start forwards to the remote's `/_relay/start`, beside the project. */
 export interface RelayStartBody {
     prompt: string;
     options: StartAgentOptions;
 }
 /**
- * Health-check a saved device (#1072): a cookie'd `GET /_relay/ping`, true on any 2xx, false on a
- * non-2xx, an unreachable host, or the timeout. The token stays in memory for the check only, never
- * persisted, same as {@link startRemoteAgent}. This is how the browser's status dots learn reachable
- * from not: it has the tokens, the daemon does the cross-origin request.
+ * What a machine answers a relayed start with: a Start's own outcome, or `noProject` when it has
+ * no project cloned from the address the start named.
+ */
+export type RelayStartResult = StartAgentResult | {
+    ok: false;
+    error: string;
+    noProject: true;
+};
+/**
+ * Health-check a saved machine (#1072): true when it answers this computer's key. This is how
+ * the browser's status dots learn reachable from not.
+ */
+export declare function pingRemote(target: MachineAccess): Promise<boolean>;
+/** 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>;
+/** What asking to be let in came to: this computer's key there, or why not, in words. */
+export type EnterResult = {
+    ok: true;
+    key: string;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Ask a machine to let this computer in, with the code its link carries, under `name`. The code
+ * 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>;
+/**
+ * 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.
  */
-export declare function pingRemote(target: RemoteTarget): Promise<boolean>;
+export declare function leaveRemote(machine: MachineAccess & {
+    door: string;
+}): Promise<boolean>;
 /**
- * Start an agent on the remote daemon and return its {@link StartAgentResult} (with the remote's own run
- * id). A non-2xx or a transport failure surfaces as an `ok: false` result the dashboard shows, the
- * same shape a local refusal has, so the caller does not special-case remote errors.
+ * Start an agent on the remote daemon, in its project cloned from `target.project`, and return
+ * what it answered (with the remote's own run id). A non-2xx or a transport failure surfaces as an
+ * `ok: false` result the dashboard shows, the same shape a local refusal has, so the caller does
+ * not special-case remote errors.
  */
-export declare function startRemoteAgent(target: RemoteTarget, body: RelayStartBody): Promise<StartAgentResult>;
+export declare function startRemoteAgent(target: RemoteTarget, body: RelayStartBody): Promise<RelayStartResult>;
 /**
- * Relay one run-scoped RPC to the device that owns a remote agent (#1067 slice 2). The local daemon
- * holds the device token, so a read/diff/handoff/push/PR for a relayed agent runs ON the device: POST
- * {fn, args} to the remote's /_relay/rpc over the shared-token cookie (#1051) (no Origin), returning the device's
- * result. Throws on an unreachable device or a non-2xx so the caller falls back to its own empty/error
+ * Relay one run-scoped RPC to the machine that owns a remote agent (#1067 slice 2). The local daemon
+ * 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.
  */
 export declare function relayRpc(target: RemoteTarget, fn: string, args: unknown[]): Promise<unknown>;
 /**
  * Fetch-stream a remote agent's newline-delimited events into `onEvent` until the remote closes the
- * body, the agent ends, or `cancel()` is called. A 401 (the token was rotated) ends the stream
+ * body, the agent ends, or `cancel()` is called. A 401 (this computer was removed there) ends the stream
  * cleanly rather than as an error, so the dashboard sees a normal `done`, not a lost connection.
  * Returns a cancel function; calling it aborts the fetch and releases the reader.
  */
@@ -54,11 +94,12 @@ export declare function streamRemoteEvents(target: RemoteTarget, agentId: string
 /**
  * The local daemon's live relayed runs (#1067), keyed by the remote agent id. Registering an agent opens
  * an {@link EventStream} the dashboard reads through `onEvents`, fed by {@link streamRemoteEvents}
- * from the remote. This map is where a saved device's token lives daemon-side: in memory, for the
- * run's lifetime.
+ * from the remote. The target is the saved machine as it was at the Start. A machine is not
+ * removed while a run is at work on it ({@link working}); the runs that ended there before it
+ * was removed read as unreachable, and one added again answers for them with its new key ({@link rekey}).
  *
  * The `targets` map outlives the event pump (#1067 slice 2): a finished remote agent's post-run reads,
- * open-PR and merge still have to reach the device after its event stream has ended, so the device
+ * open-PR and merge still have to reach the machine after its event stream has ended, so the machine
  * target is kept until {@link dispose} clears it, not dropped when the stream closes.
  *
  * The `metas` map (#1077) holds a local {@link AgentMeta} stub per relayed agent so `onAgents` can show a
@@ -73,22 +114,26 @@ export declare class RelayedAgents {
     register(agentId: string, target: RemoteTarget, meta: AgentMeta, projectId: string): void;
     /** The live event stream for a relayed agent, or undefined when this daemon is not relaying it. */
     get(agentId: string | undefined): EventStream<OpenAgentEvent> | undefined;
-    /** The device a relayed agent runs on, kept past the event stream so post-run push/PR still reach it. */
+    /** The machine a relayed agent runs on, kept past the event stream so post-run push/PR still reach it. */
     target(agentId: string | undefined): RemoteTarget | undefined;
+    /** Whether a run this daemon follows is still at work on the machine at `url`: its events still stream. */
+    working(url: string): boolean;
+    /** How the machine at `url` is reached since it was added again, for the runs kept from before: this computer's new key there, and the key the machine is known by. */
+    rekey(url: string, key: string, pin?: string): void;
     /** A project's relayed run stubs (#1077), newest-first, so `onAgents` can surface them in the list. */
     list(projectId: string): AgentMeta[];
     /** Fold each relayed event into the agent's list row via the store's own reducer (#1077), so the
-     *  local stub mirrors the device: the terminal status on `end`, the waiting flag while it is parked
+     *  local stub mirrors the machine: the terminal status on `end`, the waiting flag while it is parked
      *  (#785), the driver once its session starts. Events carry no write time, so this stamps its own. */
     private apply;
     /** Close a relayed agent's event stream (not its target). Idempotent. */
     private endStream;
-    /** Stop every pump, close every stream, and forget every device target + list stub, on daemon shutdown. */
+    /** Stop every pump, close every stream, and forget every machine target + list stub, on daemon shutdown. */
     dispose(): void;
 }
 /**
- * Fold one relayed event into the memory-only row of a run on a device: what the device's own
- * card would say, kept here because that card is on the device. The events are the ones a run's
+ * Fold one relayed event into the memory-only row of a run on a machine: what the machine's own
+ * card would say, kept here because that card is on the machine. The events are the ones a run's
  * diary yields: the agent's session id, its cost, its end.
  */
 export declare function foldRelayedEvent(meta: AgentMeta, event: OpenAgentEvent, at: string): AgentMeta;

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

@@ -7,6 +7,7 @@ import type { BridgeBrowserOwner } from '../bridge-browser.js';
 import type { ProjectErrorsReader } from '../project-errors.js';
 import type { AddProjectResult, RemoveProjectResult, StartAgentOptions, StartAgentResult } from './types.js';
 import type { AgentMeta } from '../store/index.js';
+import type { RemoteTarget } from './remote-run.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). */
@@ -14,19 +15,20 @@ export type AddProjectHandler = (path: string, share: boolean) => AddProjectResu
 /** Wired by the daemon so `sendRemoveProject` can take a project off the list, by its id, and with `files` remove what OpenAgent left in its folder. */
 export type RemoveProjectHandler = (projectId: string, files: boolean) => RemoveProjectResult | Promise<RemoveProjectResult>;
 /** 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).
+ * 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;
-/** Look up the device a relayed agent (#1067) executes on, or undefined for an ordinary local agent. The
+/** 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 device instead of resolving a (nonexistent) local checkout. */
+ *  read/steer/handoff to that machine instead of resolving a (nonexistent) local checkout. */
 export interface RemoteAgents {
-    target(agentId: string | undefined): {
-        url: string;
-        token: string;
-    } | undefined;
+    target(agentId: string | undefined): RemoteTarget | 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[];
+    /** Whether a run relayed from here is still at work on the machine at `url`. */
+    working(url: string): boolean;
+    /** How the machine at `url` is reached since it was added again, for the runs kept from before. */
+    rekey(url: string, key: string, pin?: string): void;
 }
 /**
  * What every RPC acts through.
@@ -40,10 +42,10 @@ export interface DashboardContext {
     startAgent: StartAgentHandler;
     addProject: AddProjectHandler;
     removeProject: RemoveProjectHandler;
-    /** The in-memory event stream for an agent relayed from a connected device (#1067), else undefined. */
+    /** The in-memory event stream for an agent relayed from a saved machine (#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. */
+     *  running on a saved machine and forward the call there. */
     remote: RemoteAgents;
     /** The user-preferences store (#410), over the registry file. */
     preferences: PreferencesStore;
@@ -72,16 +74,12 @@ export declare function isSameOriginRequest(req: IncomingMessage): boolean;
  * 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.
+ * asked for (`evil.com`), not the address it resolved to. The dashboard listens on this
+ * computer's own address only, so the only `Host` a real user's browser can send is a loopback
+ * one — anything else is a rebound name and is rejected. An absent `Host` is rejected too:
+ * HTTP/1.1 requires it, and every browser sends it.
  */
-export declare function isExpectedHost(req: IncomingMessage, boundHost: string | undefined): boolean;
+export declare function isExpectedHost(req: IncomingMessage): boolean;
 /** Where the dashboard's RPCs live. One prefix, so the static handler can decline it by path. */
 export declare const RPC_PREFIX = "/_rpc";
 /**
@@ -90,16 +88,12 @@ export declare const RPC_PREFIX = "/_rpc";
  * `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.
+ * are requests carrying someone else's `Host` (DNS rebinding: the same page must not reach us by
+ * pointing its own name at `127.0.0.1`). 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>;
+export declare function makeRpcMount(context: DashboardContext): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;

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

@@ -0,0 +1,31 @@
+/**
+ * The branch agents start from in the project at `cwd`: origin's default branch as this clone has
+ * it, else the branch the folder is on (a project with no remote starts an agent from its last
+ * local commit). `ref` is what git is asked, `name` what a person reads. None where the folder is
+ * on no branch, or is no repository.
+ */
+export declare function startBranch(cwd: string): Promise<{
+    ref: string;
+    name: string;
+} | undefined>;
+/** A skill that is in the folder and not on the branch agents start from. */
+export interface Waiting {
+    /** The branch it has yet to reach, by name. */
+    branch: string;
+    /** Whether the branch the folder is on has it: an agent started from that branch does. */
+    here: boolean;
+}
+/**
+ * Which of the skills `names`, all in the project's folder, are waiting to reach the branch agents
+ * start from. A skill is said to be waiting only when that is known: an agent's checkout fetches
+ * the remote before it starts, so before a skill is called waiting against a remote branch, this
+ * clone's copy of that branch is fetched too (at most once a minute per project), or a pull
+ * request merged a moment ago would keep its skill waiting here.
+ */
+export declare function waitingSkills(cwd: string, names: readonly string[]): Promise<{
+    start?: {
+        ref: string;
+        name: string;
+    };
+    waiting: Map<string, Waiting>;
+}>;

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

@@ -75,7 +75,7 @@ export interface StartAgentOptions {
     /**
      * 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.
+     * word that is no branch name refuses the Start. Not sent to another machine: its branches are its own.
      */
     base?: string;
     /**
@@ -84,20 +84,12 @@ export interface StartAgentOptions {
      */
     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 `oa_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.
+     * Run this session on a saved machine (#1067), named by its id: the local daemon relays the
+     * start to that machine's daemon, which starts it in its own copy of the project, and streams
+     * its events back into the local agent view. Absent = run on this machine. Stripped before the
+     * start is forwarded, so the machine starts an ordinary local run and does not relay onward.
      */
-    remote?: {
-        url: string;
-        token: string;
-        label?: string;
-    };
+    machine?: 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 = {

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

@@ -22,18 +22,18 @@ export declare function resolveProjectPath(projectId: string): Promise<string |
 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
+ * from a saved machine (#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).
+ * (resolve a local checkout) from one running on a saved machine (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
+ * a call arriving over `/_relay/rpc` is the *machine* side of the relay, and the agent it names is
+ * local to that machine. Forwarding it onward would be a loop, so the honest answer there is that
  * nothing is relayed from here.
  */
 export declare function contextRemote(): RemoteAgents;

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

@@ -65,7 +65,7 @@ export declare function sendRemoveWorktree(projectId: string, agentId: string):
 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
+ * the daemon's wired `startAgent` (which relays to a saved machine 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.
  */

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

@@ -28,7 +28,7 @@ export type LiveFeedEvent = OpenAgentEvent | StreamSync | PartialMessage;
  * 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
+ * from a machine (#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

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

@@ -6,8 +6,9 @@ export { onPreferences, savePreferences, patchPreferences, onProjectPresets, sav
 export { type EditorInfo } from '../dashboard/open-in-app.js';
 export { onQuota } from './quota.js';
 export { onModels } from './models.js';
-export { checkDevices, type DeviceCheck } from './devices.js';
+export { onMachines, sendAddMachine, sendRemoveMachine, onMachinesReachable, onMachineVersions, type Machine, type AddMachineResult, type MachineVersions } from './machines.js';
 export { onModules, runModuleCommand, readModule, type DashboardModule, type ModuleCommandResult, type ModuleReadResult } from './modules.js';
+export { onProjectSkills, sendChangeSkills, sendCommitSkills, type ProjectSkills, type ProjectSkill, type ChangeSkillsResult } from './skills.js';
 import { streamAgentEvents } from './events.js';
 /** One RPC: called with whatever the browser sent, answering with whatever JSON.stringify keeps. */
 export type RpcHandler = (...args: never[]) => unknown;