@openagt/dashboard 0.9.0 → 0.11.0

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

@@ -0,0 +1,51 @@
+/** A saved machine as the browser sees it: no key. */
+export interface Machine {
+    id: string;
+    label: string;
+    url: string;
+}
+export type AddMachineResult = {
+    ok: true;
+    machine: Machine;
+} | {
+    ok: false;
+    error: string;
+};
+/** The saved machines, newest first. */
+export declare function onMachines(): Promise<Machine[]>;
+/**
+ * Save the machine a pasted link names: the link another OpenAgent gives for a new device. This
+ * computer is let in there with the link's code, once, and keeps the key it is answered. Adding
+ * a machine again, with a new link, replaces its name and the key, and the key it had there
+ * before is taken out.
+ */
+export declare function sendAddMachine(pasted: string, label?: string): Promise<AddMachineResult>;
+export type RemoveMachineResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Take a saved machine off the list, and this computer out of the machine: its key there stops
+ * working. Not while a run is at work there, which is read with that key. Taking the key out is
+ * not waited for: a machine that cannot be reached right now keeps it until this computer is
+ * removed there, among its devices.
+ */
+export declare function sendRemoveMachine(id: string): Promise<RemoveMachineResult>;
+/** Whether each saved machine answers right now, by id: one short call to each, with this computer's key. */
+export declare function onMachinesReachable(): Promise<Record<string, boolean>>;
+/** This computer's OpenAgent, and the one each saved machine runs. */
+export interface MachineVersions {
+    /** This computer's own. */
+    version: string;
+    /** Each saved machine, with its version when it answers and says. */
+    machines: (Machine & {
+        version?: 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.
+ */
+export declare function onMachineVersions(): Promise<MachineVersions>;

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

@@ -38,7 +38,7 @@ export declare function runModuleCommand(projectId: string, pkg: string, args: s
  * Call read `name` of a module's server part in one project: how a module's browser part reads
  * what a command cannot answer fast enough. Refused for an unknown project, a package that is not
  * a module of that project, and a module with no server part. A read whose input names a run this
- * daemon relays to a connected device (`input.agentId`) is read over there, by that device's own
+ * daemon relays to a saved machine (`input.agentId`) is read over there, by that machine's own
  * copy of the module, since the run's checkout is there.
  */
 export declare function readModule(projectId: string, pkg: string, name: string, input: unknown): Promise<ModuleReadResult>;

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

@@ -58,6 +58,8 @@ export interface ProjectLauncher {
     gitHost: boolean;
     /** Whether the project's repository has an `origin` remote; without one nothing can be published, so the publish menu stops at the commit. */
     remote: boolean;
+    /** The address the project's repository was cloned from, the name another machine knows the project by; absent, the project cannot be sent to one. */
+    address?: string;
     /**
      * The two branches an agent can start from here, for the launcher's "start from" chip: `main`,
      * the name of origin's default branch, and `local`, the branch the project's folder is on now.

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

@@ -31,7 +31,7 @@ import type { BridgeAnswer, BridgeContact, BridgeVersion } from '../dashboard/br
  * may have just self-healed a dead agent to `stopped` (#716), and that freshly-archived row can
  * lag `listAgents` by a poll — keeping it regardless leaves the row visible with no flicker.
  *
- * An agent relayed to a connected device (#1067) lives only in the daemon's memory, never on disk, so
+ * An agent relayed to a saved machine (#1067) lives only in the daemon's memory, never on disk, so
  * its in-memory stub is merged in too (#1077): that is what re-opens it after a dashboard reload
  * instead of losing it.
  */
@@ -168,9 +168,8 @@ export declare function onBridgeStatus(): Promise<{
  *
  * Only while the bridge is on, so a daemon with the feature off never hands the secret to a
  * page. Revealing it here is not a new exposure: anyone who can load this dashboard can already
- * start runs on this machine, and on a non-loopback bind their browser is holding the same token
- * as a cookie. What it replaces is the alternative, which was telling people to open
- * `~/.openagent.json` and copy a field out of it.
+ * start runs on this machine. What it replaces is the alternative, which was telling people to
+ * open `~/.openagent.json` and copy a field out of it.
  */
 export declare function onBridgeToken(): Promise<string | null>;
 /**

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

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

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

@@ -0,0 +1,79 @@
+import { type Standing } from '@openagt/init';
+/**
+ * A project's skills, as the dashboard shows and changes them (#2023): the same list with ticks
+ * `npx @openagt/init` shows in a terminal, read and written through that package's own code, so
+ * the two cannot drift apart. A project has a skill when the skill's text is in its folder; the
+ * dashboard writes and deletes those files, and offers the one commit that holds them.
+ */
+/** One skill of the list, as it stands in the project. */
+export interface ProjectSkill {
+    name: string;
+    /** The one line the skill's text says of itself. */
+    description: string;
+    /** How the project's text stands against the one this dashboard carries; `absent` when the project does not hold the skill. */
+    standing: Standing;
+    /** Whether the skill is in the folder but not yet on the branch agents start from: an agent started from it does not have the skill. */
+    waiting: boolean;
+}
+export interface ProjectSkills {
+    /** How many skills the project has, of how many there are: the ones in its folder, and the basic ones every run gets. */
+    has: number;
+    of: number;
+    /** The list's groups; `ticked` says whether a group's skills are ticked in a project that has none yet. */
+    groups: {
+        title: string;
+        ticked: boolean;
+        skills: ProjectSkill[];
+    }[];
+    /** Whether the scheduler starts with the dashboard for this project, on this machine. */
+    scheduler: boolean;
+    /** The branch agents start from, by its name: the remote's default branch, else the branch the folder is on. Absent where there is none. */
+    startBranch?: string;
+    /** How many skill files stand written or deleted in the folder with no commit yet. */
+    uncommitted: number;
+    /** Whether the folder is a git repository: without one there is nothing to commit. */
+    git: boolean;
+    /** Whether the project has a remote: without one a commit on this machine is all agents need. */
+    remote: boolean;
+}
+/** The project's skills; `null` when the project is unknown here. */
+export declare function onProjectSkills(projectId: string): Promise<ProjectSkills | null>;
+/** What a change of skills answered: what was written and deleted, what was left as it is, and the scheduler when the change switched it. */
+export type ChangeSkillsResult = {
+    ok: true;
+    written: string[];
+    removed: string[];
+    left: {
+        path: string;
+        reason: string;
+    }[];
+    scheduler?: 'on' | 'off';
+    schedulerError?: string;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Write and delete skills in a project's folder, and switch its scheduler: what the "Add skills"
+ * screen saves. Only the names of the list are taken; anything else is refused whole. A scheduler
+ * switched on starts at once, by its own line, as it would have at this dashboard's opening.
+ * Nothing is committed here: `sendCommitSkills` is the person's next press.
+ */
+export declare function sendChangeSkills(projectId: string, change: {
+    write?: string[];
+    remove?: string[];
+    scheduler?: boolean;
+}): Promise<ChangeSkillsResult>;
+/**
+ * One commit of skill files that stand uncommitted in the project's folder, on the branch the
+ * folder is on: the files of the skills `only` names, after a change that wrote or deleted them,
+ * else every uncommitted skill file. Never a push.
+ */
+export declare function sendCommitSkills(projectId: string, only?: string[]): Promise<{
+    ok: true;
+    committed: boolean;
+    commit?: string;
+} | {
+    ok: false;
+    error: string;
+}>;

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

@@ -102,11 +102,12 @@ export type OpenAgentEvent = {
     event: DriverEvent;
 }
 /**
- * A live screen something the agent ran is showing: a page on this machine's loopback, shown in
- * the chat where the line is, while it is the newest open screen at that address and the run
+ * 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`);
- * OpenAgent knows nothing of what the page is.
+ * OpenAgent passes a watcher's calls on to the address (dashboard/screen.ts) and knows nothing
+ * of what the screen is.
  */
  | {
     kind: 'screen';

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

@@ -1,11 +1,9 @@
 /**
- * Loopback-address helpers, shared by the daemon (deciding whether a bind gates behind the
- * token, #1051) and the RPC mount (rejecting a rebound `Host`). A leaf module on purpose:
- * `daemon.ts` imports the dashboard, so the mount cannot import these back out of it.
+ * Loopback-address helpers, for the RPC mount (rejecting a cross-origin page and a rebound `Host`).
  */
 /**
- * True when `host` is a loopback address the browser reaches without leaving the machine (#1051).
- * A bind-all (`0.0.0.0`, `::`) or a routable address is not, and gates behind the shared token.
+ * True when `host` is a loopback address the browser reaches without leaving the machine.
+ * A bind-all (`0.0.0.0`, `::`) or a routable address is not.
  *
  * The IPv4 check matches the whole `127.0.0.0/8` range but only as an address: a bare
  * `startsWith('127.')` also accepts a *registrable name* like `127.evil.com`, which is exactly the

package/dist/module-types/src/machine-link.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Read the link another computer's OpenAgent gives for a new device (its Settings, Devices, Add
+ * device): where this computer is let in, and the code that lets it in once. The code rides the
+ * link after the `#`. A server's link carries one thing more after the code and a dot: what the
+ * server's key is known by. Not a web address is `null`, and so is a link with no code.
+ *
+ * A leaf with no Node in it: the dashboard reads a paste with it as the person types, and the
+ * daemon reads it again before it asks to be let in.
+ */
+export interface MachineLink {
+    /** Where the other OpenAgent answers, as an origin (`http://studio.local:4201`). */
+    url: string;
+    /** Where this computer asks to be let in, and later takes itself out: the link without its code. */
+    door: string;
+    /** The code, good once. */
+    code: string;
+    /** What the machine's key is known by, when the link says: a call then goes only to a machine that shows that key. */
+    pin?: string;
+}
+export declare function parseMachineLink(pasted: string): MachineLink | null;

package/dist/module-types/src/openagent-dir.d.ts

@@ -2,9 +2,7 @@
  * The directory, under a project root, that holds OpenAgent's own files.
  *
  * Its own module so every reader and writer of the directory (the hooks file, the project's saved
- * prompts, the activation's `.gitignore`, a run's card, diary and inbox) spells it the same way.
- *
- * Nothing of the product's rides on a branch of its own any more: the agent archives are the
- * `logs` skill's runs, on the shared `agent-data` branch that `@openagt/agent-data` names (#1769).
+ * prompts, a run's card, diary and inbox) spells it the same way. The name itself is
+ * `@openagt/agent-data`'s, which also makes the directory when a folder becomes a project.
  */
-export declare const OPENAGENT_DIR = ".openagent";
+export { OPENAGENT_DIR } from '@openagt/agent-data/names';

package/dist/module-types/src/project-commands.d.ts

@@ -13,6 +13,10 @@ export interface ProjectCommand {
     name: string;
     /** The `description` of the skill's front matter, when it has one. */
     description?: string;
+    /** The branch the skill has yet to reach, by name, when its text is in the folder but not on the branch agents start from: an agent started from that branch does not have the command. */
+    waiting?: string;
+    /** With `waiting`: whether the branch the folder is on has the skill, so an agent started from that branch does have the command. */
+    here?: true;
 }
 /**
  * The project's commands, by name: the skills whose front matter says

package/dist/module-types/src/project-hooks.d.ts

@@ -2,8 +2,8 @@
  * A project's hooks (#1774): the shell lines a project's own `.openagent/hooks.yml` names to
  * run when the dashboard opens and when it closes, the two lines that start a run and continue
  * one, and the line that says whether a run can start here at all. The daemon calls no tool by
- * name: it runs whatever the file says, in the project, with the project's installed tools and
- * then the built-in packages' on the PATH, so a line reaches its tool with nothing fetched from npm. Per
+ * name: it runs whatever the file says, in the project, with the commands of the packages
+ * OpenAgent brings and then the project's installed tools on the PATH, so a line reaches its tool with nothing fetched from npm. Per
  * user, since `.openagent/` is ignored: a hook is this machine's, and a teammate's pull
  * changes nothing.
  *
@@ -49,6 +49,8 @@ export interface RunHooksOptions {
     timeoutMs?: number;
     /** The environment the lines run with; default the daemon's own. */
     env?: NodeJS.ProcessEnv;
+    /** The lines to run, of the ones the file holds; every line when absent. */
+    only?: readonly string[];
 }
 /**
  * Run a project's `open` or `close` lines, in order, each through `sh -c` with the project's
@@ -122,8 +124,9 @@ export declare function runCheckHook(cwd: string, input: {
     driver?: string;
 }, opts?: Omit<RunHooksOptions, 'log'>): Promise<CheckHookResult>;
 /**
- * The environment a line runs with: the PATH led by the project's installed tools, then the
- * built-in packages' own commands, so a tool named in a line is the project's copy when it
- * installed one and the dashboard's otherwise, and never a package fetched by name.
+ * The environment a line runs with: the PATH led by the commands of the packages OpenAgent
+ * brings, then the project's installed tools. So a tool of OpenAgent's named in a line is always
+ * OpenAgent's copy, the one its pages and its data go through too, any other tool is the
+ * project's, and nothing is a package fetched by name.
  */
 export declare function hookEnv(cwd: string, env: NodeJS.ProcessEnv): Promise<NodeJS.ProcessEnv>;

package/dist/module-types/src/project-modules.d.ts

@@ -2,11 +2,12 @@ import { type PackageCommandResult } from '@openagt/agent-data';
 /**
  * A package that adds to the dashboard (#1774): its browser part, named by its
  * `exports["./dashboard"]`, and optionally its server part, named by `exports["./server"]`.
- * OpenAgent names no package: any dependency of the project that exports `./dashboard` is a
- * module, whoever wrote it, and OpenAgent's own built-in modules come the same way.
+ * Any dependency of the project that exports `./dashboard` is a module, whoever wrote it, and the
+ * packages OpenAgent brings itself come the same way, for the projects that have them
+ * (`built-in.ts`).
  */
 export interface ProjectModule {
-    /** The package's name, as the project's package.json lists it. */
+    /** The package's name. */
     package: string;
     /** The package's version, when its package.json says one. */
     version?: string;
@@ -21,8 +22,9 @@ export interface ProjectModule {
 }
 /**
  * The modules a project has: each of its dependencies whose package.json exports `./dashboard` to
- * a file that exists inside the package, plus the modules among OpenAgent's built-in packages (`built-in.ts`). A project that
- * depends on a built-in module's package itself gets its own copy. Sorted by name.
+ * a file that exists inside the package, plus the modules among the packages OpenAgent brings to
+ * this project (`built-in.ts`): a skill's page where the project holds the skill's text. Sorted
+ * by name.
  */
 export declare function readProjectModules(root: string): Promise<ProjectModule[]>;
 /** The one module of this project that `name` names, or undefined. */
@@ -38,7 +40,7 @@ export type ModuleCommandResult = PackageCommandResult;
 /**
  * Run one of a module package's own commands in the project, with the given arguments, and read
  * its standard output as JSON. This is how a module reads its data: the same command an agent runs
- * (`npx logs`), so the module and the agent see the same thing and OpenAgent knows neither.
+ * (`npx @openagt/skill-logs@0.1`), so the module and the agent see the same thing and OpenAgent knows neither.
  *
  * `command` picks one of the package's commands; a package with exactly one needs none. The
  * command runs with Node (a package's commands are Node scripts), in the project root, never

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

@@ -3,8 +3,9 @@ import { type PublishPick } from './publish-levels.js';
  * The multi-project registry (#390): the list of projects the user has
  * installed OpenAgent into, kept as a single JSON file `.bashrc`-style —
  * `$HOME/.openagent.json` — so it is the user's responsibility to re-create
- * per machine. The same file also holds the user's dashboard preferences (#410),
- * so the daemon owns one user file and the UI never needs localStorage.
+ * per machine. The same file also holds the user's dashboard preferences (#410)
+ * and the machines they saved, so the daemon owns one user file and the UI never
+ * needs localStorage.
  */
 /** One registered project. */
 export interface ProjectRecord {
@@ -15,6 +16,25 @@ export interface ProjectRecord {
     /** ISO timestamp the project was added. */
     addedAt: string;
 }
+/**
+ * A saved machine: another computer running OpenAgent that a run can be sent to. Kept in this
+ * file, the person's own, so every browser on this computer shows the same machines and the
+ * key that reaches one never leaves the two machines.
+ */
+export interface MachineRecord {
+    /** The machine's address, which is also what names it: saving the same address again replaces it. */
+    id: string;
+    /** The name the person gave it, or its host when they gave none. */
+    label: string;
+    /** Where its OpenAgent answers, as an origin (`http://studio.local:4201`). */
+    url: string;
+    /** This computer's own key on that machine. Never handed to a browser. */
+    key: string;
+    /** Where this computer was let in there, and where it takes itself out when the machine is removed. */
+    door: string;
+    /** What the machine's key is known by, when its link said: every call goes only to a machine that shows that key. */
+    pin?: string;
+}
 /**
  * The dashboard's Global options (#410), persisted next to the project list so they
  * survive restarts without localStorage — the daemon reads/writes them, the SPA reads
@@ -104,11 +124,16 @@ export interface Registry {
     projects: ProjectRecord[];
     preferences: Preferences;
     /**
-     * The shared daemon token (#1051): generated on the first non-loopback bind and reused after.
-     * A top-level field, deliberately not a {@link Preferences} one, so it is never shipped to the
-     * browser bundle. Absent on a loopback-only machine.
+     * The browser bridge's key (#1237): generated when the bridge is first switched on and reused
+     * after. A top-level field, deliberately not a {@link Preferences} one, so it is never shipped
+     * to the browser bundle. Absent on a machine that never had the bridge on.
      */
-    daemonToken?: string;
+    bridgeToken?: string;
+    /**
+     * The saved machines. Top-level like {@link bridgeToken}, and for the same reason: each one
+     * carries a key, so the list is never part of what the browser is handed.
+     */
+    machines?: MachineRecord[];
 }
 /** A read/write handle for the user preferences, wired into the dashboard's context by the daemon. */
 export interface PreferencesStore {
@@ -122,7 +147,7 @@ export interface PreferencesStore {
 }
 /** The registry file name: a single file under `$XDG_CONFIG_HOME` (dotted under `$HOME`). */
 export declare const REGISTRY_FILE = "openagent.json";
-/** Owner read/write only: the file holds the daemon token (#1051). */
+/** Owner read/write only: the file holds the bridge's key and the saved machines' keys. */
 export declare const REGISTRY_FILE_MODE = 384;
 /**
  * Deterministic, URL-safe id for a project path: the sanitized basename plus a
@@ -151,7 +176,7 @@ export interface RegistryFs {
     rename?(from: string, to: string): Promise<void>;
     /**
      * Narrow a file's permissions. Optional, and best-effort at the call site: this file holds the
-     * daemon token (#1051), so it is written owner-only — but a
+     * bridge's key and the saved machines' keys, so it is written owner-only — but a
      * filesystem that cannot express that (Windows, a FAT volume) must not fail the write.
      */
     chmod?(path: string, mode: number): Promise<void>;
@@ -205,15 +230,33 @@ export declare function writePreferences(preferences: Preferences, fs?: Registry
  */
 export declare function patchPreferences(patch: Preferences, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<Preferences>;
 /**
- * The shared daemon token (#1051): read the persisted one, or generate + persist it now. Called
- * only on a non-loopback bind, so a loopback-only machine never grows one. Serialized with the
- * other mutators so two concurrent binds can't each write a different token. `base64url` of 32
- * random bytes: URL-safe, so it drops straight into a `?token=` without encoding.
+ * The browser bridge's key (#1237): read the persisted one, or generate + persist it now. Called
+ * only with the bridge switched on, so a machine that never had it on never grows one. Serialized
+ * with the other mutators so two concurrent starts can't each write a different key.
+ */
+export declare function ensureBridgeToken(fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<string>;
+/** The persisted bridge key, or `undefined` when none exists. A pure read: it never generates one. */
+export declare function readBridgeToken(fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
+/** The saved machines, newest first. Forgiving like every read of this file: none on a bad file. */
+export declare function listMachines(fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<MachineRecord[]>;
+/**
+ * Save a machine, newest first. One per address: saving an address again replaces its name and
+ * its key, which is how a machine whose key changed is fixed. Answers the stored record, and the
+ * records it took the place of (the one saved at that address before, the oldest past the cap):
+ * each still holds a key the caller takes out of its machine.
  */
-export declare function ensureDaemonToken(fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<string>;
-/** The persisted daemon token (#1051), or `undefined` when none exists. A pure read, so a process
- * that only prints the reachable URL never generates one. */
-export declare function readDaemonToken(fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
+export declare function addMachine(machine: {
+    url: string;
+    key: string;
+    door: string;
+    pin?: string;
+    label?: string;
+}, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<{
+    record: MachineRecord;
+    displaced: MachineRecord[];
+}>;
+/** Take a saved machine off the list, by id. Answers the one that was there. */
+export declare function removeMachine(id: string, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<MachineRecord | undefined>;
 /** A {@link PreferencesStore} bound to the real registry file, wired by the daemon so the
  * dashboard's preferences RPCs read/write the user's home file.
  *

package/dist/module-types/src/repository-address.d.ts

@@ -0,0 +1,22 @@
+import { type GitRunner } from '@openagt/agent-data';
+/**
+ * The one name a project has on every machine: where its repository was cloned from, as
+ * `host/path` (`github.com/me/shop`). A project's id is made from its folder's path, which is
+ * another path on another machine, so a run sent to a machine names its project by this.
+ *
+ * The same repository reads the same whichever way it was cloned: the scheme, a user before the
+ * host, a port, a trailing `.git` or slash are dropped, and letters are lowered, since the git
+ * hosts match names without regard to case. Not an address at all (a path on this disk, a
+ * `file:` address) is none.
+ *
+ * What it does not see through: a host that serves the two ways under two names or two paths
+ * (`ssh.github.com`, Azure DevOps). Such a project reads as two, and the other machine says it
+ * does not have it.
+ */
+export declare function addressOfRemote(remote: string): string | undefined;
+/**
+ * The address of the repository at `cwd`: its `origin` remote, the one every push goes to. A
+ * project with no `origin`, or one that is a folder on this disk, has none and runs on this
+ * machine only.
+ */
+export declare function repositoryAddress(cwd: string, git?: GitRunner): Promise<string | undefined>;

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

@@ -0,0 +1,13 @@
+import type { OpenAgentEvent } from './events.js';
+/**
+ * Which of a run's `screen` lines are live and which are hidden. Live: the newest line at its
+ * address with no `ended` line for it after, and no run `end` after it other than one waiting on
+ * an answer. Every `ended` line is hidden: the screen going is said by its line no longer being
+ * live.
+ */
+export declare function foldScreenRows(events: readonly OpenAgentEvent[]): {
+    live: Set<OpenAgentEvent>;
+    hidden: Set<OpenAgentEvent>;
+};
+/** Where a run's live screen answers: the address of its newest live `screen` line, or nothing. */
+export declare function liveScreen(events: readonly OpenAgentEvent[]): string | undefined;

package/dist/module-types/src/store/agent-store.d.ts

@@ -157,12 +157,12 @@ export interface AgentMeta {
     browserStreamPort?: number;
     /**
      * Where this run executes (#1050/#1053/#610): `actions` for a GitHub Actions run, `web` for a
-     * Claude Code cloud session, `remote` when relayed to a connected device (#1067), absent for a
+     * Claude Code cloud session, `remote` when relayed to a saved machine (#1067), absent for a
      * local run. Persisted so the agent view can tell a burst-mode Actions run from a stalled live
      * feed, show a cloud agent's session link after a reload, and gate the browser pane off (#1053).
      */
     target?: 'local' | 'actions' | 'remote' | 'web';
-    /** The connected device a remote agent (#1067) executes on, for the session list + notice after a reload. */
+    /** The saved machine a remote agent (#1067) executes on, for the session list + notice after a reload. */
     remoteLabel?: string;
     /**
      * The flow this agent started under (#1467): `build` for the scope→build orchestration, `prompt`

package/dist/module-types/src/store/branches.d.ts

@@ -149,7 +149,7 @@ export declare function parseCheckouts(output: unknown): Checkout[];
 /** The states read back from a provider's `show`: the objects with a branch and the three verdicts, lists cleaned; anything else is no state. */
 export declare function parseBranchStates(output: unknown): BranchState[];
 /**
- * The production {@link BranchesReader}: the project's provider, looked up by its package.json,
+ * The production {@link BranchesReader}: the project's provider, looked up among the packages the project has (`built-in.ts`),
  * one source per project kept while the same command provides — so the cache holds across the
  * many reads of one poll, and a project that installs, swaps or drops its provider is read the new
  * way within {@link CACHE_MS}. `changed(root)` forgets that project's reads, so the next read runs

package/dist/module-types/src/store/git-host.d.ts

@@ -101,7 +101,7 @@ export type GitHostReader = GitHostFor & {
 /** The rows read back from a provider's `requests`: the objects with the facts a request needs; anything else is no request. */
 export declare function parseRequests(output: unknown): GitHostRequest[];
 /**
- * The production {@link GitHostReader}: the project's provider, looked up by its package.json, one
+ * The production {@link GitHostReader}: the project's provider, looked up among the packages the project has (`built-in.ts`), one
  * source per project kept while the same command provides, so a project that installs, swaps or
  * drops its git host is read the new way within {@link CACHE_MS}. `changed(root)` forgets the
  * project, so the next ask looks its provider up again.

package/dist/module-types/src/store/queue.d.ts

@@ -32,7 +32,7 @@ export type QueueReader = QueueFor & {
 /** Entries read back from a provider's output: the non-empty strings of an array, trimmed; anything else is no entries. */
 export declare function parseQueueEntries(output: unknown): string[];
 /**
- * The production {@link QueueReader}: the project's provider, looked up by its package.json, one
+ * The production {@link QueueReader}: the project's provider, looked up among the packages the project has (`built-in.ts`), one
  * source per project kept while the same command provides — so the cache holds across the many
  * reads of one poll, and a project that installs, swaps or drops its provider is read the new way
  * within {@link CACHE_MS}. `changed(root)` forgets that project's read, so the next read runs the

package/dist/module-types/src/store/runs.d.ts

@@ -94,7 +94,7 @@ export declare function isRunId(id: string): boolean;
  */
 export declare function parseRunCard(input: unknown): RunCard | undefined;
 /**
- * The production {@link RunsFor}: the project's provider, looked up by its package.json, one
+ * The production {@link RunsFor}: the project's provider, looked up among the packages the project has (`built-in.ts`), one
  * source per project kept while the same command provides — so the cache holds across the many
  * reads of one poll, and a project that installs, swaps or drops its provider is read the new way
  * within {@link CACHE_MS}. `changed(root)` forgets that project's reads, so the next read runs the

package/dist/module-types/src/store/tickets.d.ts

@@ -59,7 +59,7 @@ export type TicketsReader = TicketsFor & {
 /** The rows read back from a provider's output: the objects with the five plain facts, everything else as printed; anything else is no ticket. */
 export declare function parseTickets(output: unknown): Ticket[];
 /**
- * The production {@link TicketsReader}: the project's provider, looked up by its package.json, one
+ * The production {@link TicketsReader}: the project's provider, looked up among the packages the project has (`built-in.ts`), one
  * source per project kept while the same command provides — so the cache holds across the many
  * reads of one poll, and a project that installs, swaps or drops its provider is read the new way
  * within {@link CACHE_MS}. `changed(root)` forgets that project's read, so the next read runs the

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

@@ -0,0 +1 @@
+export declare function openagentVersion(): string;

package/dist/openagent-dir.d.ts

@@ -2,10 +2,8 @@
  * The directory, under a project root, that holds OpenAgent's own files.
  *
  * Its own module so every reader and writer of the directory (the hooks file, the project's saved
- * prompts, the activation's `.gitignore`, a run's card, diary and inbox) spells it the same way.
- *
- * Nothing of the product's rides on a branch of its own any more: the agent archives are the
- * `logs` skill's runs, on the shared `agent-data` branch that `@openagt/agent-data` names (#1769).
+ * prompts, a run's card, diary and inbox) spells it the same way. The name itself is
+ * `@openagt/agent-data`'s, which also makes the directory when a folder becomes a project.
  */
-export declare const OPENAGENT_DIR = ".openagent";
+export { OPENAGENT_DIR } from '@openagt/agent-data/names';
 //# sourceMappingURL=openagent-dir.d.ts.map

package/dist/openagent-dir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openagent-dir.d.ts","sourceRoot":"","sources":["../src/openagent-dir.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,eAAe,CAAA"}
+{"version":3,"file":"openagent-dir.d.ts","sourceRoot":"","sources":["../src/openagent-dir.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA"}

package/dist/openagent-dir.js

@@ -2,10 +2,8 @@
  * The directory, under a project root, that holds OpenAgent's own files.
  *
  * Its own module so every reader and writer of the directory (the hooks file, the project's saved
- * prompts, the activation's `.gitignore`, a run's card, diary and inbox) spells it the same way.
- *
- * Nothing of the product's rides on a branch of its own any more: the agent archives are the
- * `logs` skill's runs, on the shared `agent-data` branch that `@openagt/agent-data` names (#1769).
+ * prompts, a run's card, diary and inbox) spells it the same way. The name itself is
+ * `@openagt/agent-data`'s, which also makes the directory when a folder becomes a project.
  */
-export const OPENAGENT_DIR = '.openagent';
+export { OPENAGENT_DIR } from '@openagt/agent-data/names';
 //# sourceMappingURL=openagent-dir.js.map

package/dist/openagent-dir.js.map

@@ -1 +1 @@
-{"version":3,"file":"openagent-dir.js","sourceRoot":"","sources":["../src/openagent-dir.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,YAAY,CAAA"}
+{"version":3,"file":"openagent-dir.js","sourceRoot":"","sources":["../src/openagent-dir.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA"}