@openagt/dashboard 0.37.0 → 0.39.0

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

@@ -0,0 +1,31 @@
+import { type AgentMeta, type Checkout } from '../store/index.js';
+/**
+ * Who is told at once when this computer's runs of a project change: another computer that waits
+ * for them (machine-runs.ts), and a page that lists them (`/_rpc/changes`). Nothing tells
+ * OpenAgent when a run changes: a run's tool writes its card in the run's checkout. So while
+ * someone listens, the cards are read every second and compared by what a list shows of a run;
+ * the checkouts themselves are listed again less often, since that runs the branches provider,
+ * and at once when a run was just started here ({@link RunsWatch.poke}). Nobody listening,
+ * nothing is read.
+ */
+/** Where a project's runs with a checkout are read: its checkouts, and each one's card. */
+export interface RunsWatchSource {
+    /** `fresh`: a checkout may have just come, and a list read a moment ago does not hold it. */
+    checkouts(cwd: string, fresh: boolean): Promise<readonly Checkout[]>;
+    card(checkout: Checkout): Promise<AgentMeta | undefined>;
+}
+export declare class RunsWatch {
+    private readonly source;
+    private readonly now;
+    private readonly everyMs;
+    private readonly watched;
+    constructor(source: RunsWatchSource, now?: () => number, everyMs?: number);
+    /** Tell `changed` each time the project's runs here change, until the answer is called. */
+    follow(cwd: string, changed: () => void): () => void;
+    /** A run of the project was just started here: its checkouts are listed again at every look for a while, from now. */
+    poke(cwd: string): void;
+    private lookIn;
+    private look;
+}
+/** This computer's own runs, watched for whoever listens. */
+export declare const ownRunsWatch: RunsWatch;

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

@@ -16,6 +16,8 @@ export interface AccountRow {
     id: string;
     /** Its name as shown: the person's own goes by the agent's name for them until they give it one. */
     name: string;
+    /** A login of the person's own computer, by that computer's name: a server's copy of it. */
+    from?: string;
     /** The person's own login, which the agent keeps: it is never removed. */
     own: boolean;
     /** When an added one was added, ISO 8601. */
@@ -32,11 +34,19 @@ export interface AccountRow {
 /** An account being added: the browser is open on the agent's page, or the login is being kept. */
 export interface AccountAdding {
     name: string;
-    /** The page to sign in at, when the agent gave one: what a person copies into a private window when the browser is signed in to another account. */
+    /** The page to sign in at, when the agent gave one: what a person copies into a private window when the browser is signed in to another account, or opens on their device where this computer has no browser. */
     url?: string;
+    /** No browser here: the code Codex gave, which the person types at {@link url}. */
+    code?: string;
+    /** No browser here: Claude's page shows a code once the person said yes, which they paste back. */
+    paste?: true;
 }
 export interface AccountsView {
     accounts: AccountRow[];
+    /** This computer's own name: what its own login's row says it is on. */
+    computer: string;
+    /** On a server: the computer of the person's whose logins it uses, by its name. */
+    from?: string;
     adding?: AccountAdding;
     /** Why the last add did not go through. */
     failed?: string;
@@ -55,6 +65,10 @@ export declare const accountsWiring: {
     codexFolder: (account: AgentAccount) => string;
     codexWho: (home: string) => Promise<CodexWho>;
     codexUsage: (home: string) => Promise<DriverRateWindow[]>;
+    /** No browser on this computer: a server's. */
+    headless: () => boolean;
+    /** This computer's own name. */
+    computer: () => string;
 };
 /** An agent's accounts in the order runs try them, each with how full it is and whether a limit keeps it out. */
 export declare function onAgentAccounts(agent: AccountsAgent): Promise<AccountsView>;
@@ -70,6 +84,8 @@ export type AccountResult = {
  * in {@link onAgentAccounts}.
  */
 export declare function sendAddAgentAccount(agent: AccountsAgent, name: string): Promise<AccountResult>;
+/** Hand Claude Code the code its page showed the person, on a computer with no browser of its own. */
+export declare function sendAgentAccountCode(agent: AccountsAgent, code: string): Promise<AccountResult>;
 /**
  * Remove an added account. A Claude login is not ended: it is good until its year is over, or until
  * it is taken back on claude.ai. A Codex account's folder, its login in it, goes with it.

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

@@ -0,0 +1,48 @@
+import { type CopiedKind, type CopiedLogin, type GivenLogin, type UsageWindow } from '../dashboard/copied-logins.js';
+import { type AccountResult } from './accounts.js';
+/** What the RPCs reach for, swapped in tests. */
+export declare const copiedWiring: {
+    /** Whether this OpenAgent is a server's: only a server takes logins. */
+    server: () => boolean;
+    /** Where a Codex account's sign-in is kept, a folder each. */
+    codexDir: () => string;
+    /** Run a git host's package command for `host`, with `input` on its standard input. */
+    gitHost: (host: string, args: string[], input?: string) => Promise<{
+        ok: true;
+        output: unknown;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+};
+/** What the server says it keeps, to the computer that asks. */
+export type CopiedView = {
+    ok: true;
+    logins: Omit<CopiedLogin, 'usage'>[];
+} | {
+    ok: false;
+    error: string;
+};
+/** What the server keeps from the person's computers, without how full each is: what a computer compares its own with. */
+export declare function onCopiedLogins(): Promise<CopiedView>;
+/**
+ * Take a login a computer of the person's handed over: it goes where its tool reads it, in place
+ * of what the same account of the same computer had here before. `secret` is the login: a
+ * Claude login, a Codex sign-in as Codex keeps it, a git host's token.
+ */
+export declare function sendCopiedLogin(given: GivenLogin, secret: string): Promise<AccountResult>;
+/** Take a login a computer handed over off this server: it is deleted here, and goes on working wherever else it is. */
+export declare function sendForgetCopiedLogin(which: Pick<CopiedLogin, 'kind' | 'host' | 'source'>): Promise<AccountResult>;
+/**
+ * Keep a login the computer no longer has: the person said to. It is no longer that account of the
+ * computer's, so the computer's next login under the same account takes a place of its own.
+ */
+export declare function sendKeepCopiedLogin(which: Pick<CopiedLogin, 'kind' | 'host' | 'source'>): Promise<AccountResult>;
+/** How full each login is, as the computer read it: shown on this server's page, whose own reading a Claude login made for it cannot make. */
+export declare function sendCopiedUsage(readings: {
+    kind: CopiedKind;
+    host?: string;
+    source: string;
+    windows: UsageWindow[];
+    at: number;
+}[]): Promise<AccountResult>;

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

@@ -1,4 +1,4 @@
-export { onAgents, onAgent, onAgentsDoing, onDocs, onQueue, onOverview, onRecentAgents, onInterventions, onActivity, onDashboard, onGitHostHome, onRepositoryOffer, onGitStatus, onProjectFiles, onRetainedWorktrees, onAgentWorktree, onAgentHandoff, onBridgeQuestion, onBridgeStatus, onBridgeToken, onBridgeEvents, onBridgeAnswer, onBridgeBrowser } from './reads.js';
+export { onAgents, onModuleAgents, onAgent, onAgentsDoing, onDocs, onQueue, onOverview, onRecentAgents, onInterventions, onActivity, onDashboard, onGitHostHome, onRepositoryOffer, onGitStatus, onProjectFiles, onRetainedWorktrees, onAgentWorktree, onAgentHandoff, onBridgeQuestion, onBridgeStatus, onBridgeToken, onBridgeEvents, onBridgeAnswer, onBridgeBrowser } from './reads.js';
 export { sendStop, sendChoice, sendBridgeAnswer, sendBridgeAnswerCancel, sendBridgeBrowser, sendMessage, sendStart, sendOpenInApp, sendRemoveWorktree, sendDeleteAgent, sendOpenPullRequest, sendPush, sendMergeBranch, sendMerge, sendCreateRepository } from './control.js';
 export { streamAgentEvents, type LiveFeedEvent, type PartialMessage, type StreamSync } from './events.js';
 export { onProjects, sendAddProject, sendStartedAgain, onCloneTarget, sendAddProjectFromAddress, sendRemoveProject, onRecordsReach, sendShareRecords, sendPickProjectDirectory, onOnboarding, onCommands, onStartCheck, type ProjectLauncher } from './projects.js';
@@ -6,12 +6,15 @@ 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 { onMachines, sendAddMachine, sendRemoveMachine, onMachinesReachable, onMachineVersions, sendProjectToMachine, onProjectOnMachine, onComputersThrough, sendAddComputerThrough, onMachinePerson, sendRemoveMachineDevice, sendRenameMachine, sendLetMachineIn, sendMachineLineLink, sendMachineCode, sendMachineTold, onMachineLogins, sendMachineLogins, type Machine, type MachineLoginsResult, type AddMachineResult, type MachineVersions, type ProjectOnMachine, type ComputersThrough, type MachinePerson, type MachineCode } from './machines.js';
+export { onMachines, sendAddMachine, sendRemoveMachine, onMachinesReachable, onMachineVersions, sendProjectToMachine, onProjectOnMachine, onMachineStartCheck, onComputersThrough, sendAddComputerThrough, onMachinePerson, sendRemoveMachineDevice, sendRenameMachine, sendLetMachineIn, sendMachineLineLink, sendMachineCode, sendMachineTold, onMachineLogins, sendMachineLogins, type Machine, type MachineLoginsResult, type AddMachineResult, type MachineVersions, type ProjectOnMachine, type ComputersThrough, type MachinePerson, type MachineCode } from './machines.js';
 export { onModules, runModuleCommand, runComputerCommand, runComputerCommandOn, readModule, type DashboardModule, type ModuleCommandResult, type ModuleReadResult } from './modules.js';
 export { onProjectSkills, sendChangeSkills, sendProjectSkills, type ProjectSkills, type ProjectSkill, type ChangeSkillsResult } from './skills.js';
 export { onPerson, type Person } from './person.js';
+export { onGitHostPeople, type HostPerson } from './people.js';
 export { onGitHosts, sendUseGitHostAccount, sendGitHostLogin, sendGitHostInstall, onAgentState, sendAgentFix, onProjectAccounts, sendProjectAccounts, type GitHostsView, type GitHostRow, type GitHostAccount, type GitHostProvider, type AgentState, type ProjectAccountsView, type ProjectAgentAccounts } from './logins.js';
-export { onAgentAccounts, sendAddAgentAccount, sendRemoveAgentAccount, sendUseAgentAccountFirst, sendNameOwnAgentAccount, type AccountsAgent, type AccountRow, type AccountWindow, type AccountAdding, type AccountsView, type AccountResult } from './accounts.js';
+export { onServerLogins, sendUseLoginsOn, sendAllowLogins, sendSettleLogin, type ServerLoginsView, type ServerLogins, type LoginThere } from './server-logins.js';
+export { onCopiedLogins, sendCopiedLogin, sendForgetCopiedLogin, sendKeepCopiedLogin, sendCopiedUsage, type CopiedView } from './copied-logins.js';
+export { onAgentAccounts, sendAddAgentAccount, sendAgentAccountCode, sendRemoveAgentAccount, sendUseAgentAccountFirst, sendNameOwnAgentAccount, type AccountsAgent, type AccountRow, type AccountWindow, type AccountAdding, type AccountsView, type AccountResult } from './accounts.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;

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

@@ -21,6 +21,8 @@ export declare const loginsWiring: {
     /** The project's git host package's command. */
     gitHost: (root: string) => Promise<ProvidedCommand | undefined>;
     run: typeof runPackageCommand;
+    /** Where a git host's package is asked when no project is on its host: the person's home folder. */
+    home: () => string;
     ready: (driver: DriverName) => Promise<DriverReadiness>;
     /** Run a fix's command to its end; rejects with its last lines. */
     fix: (command: string) => Promise<void>;
@@ -31,6 +33,20 @@ export declare const loginsWiring: {
  * the last answer when there is one for the same projects, the hosts being read again behind it.
  */
 export declare function onGitHosts(): Promise<GitHostsView>;
+/**
+ * A git host's package command for `host`, run where the host was last found, with `input` on its
+ * standard input. An object, not a function: what the RPC table is built of are this module's
+ * functions, and this is no call a page makes.
+ */
+export declare const gitHostPackages: {
+    run(host: string, args: string[], input?: string): Promise<{
+        ok: true;
+        output: unknown;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+};
 /** Runs use `login` at `host` from now on; the terminal's own account stays as it is. */
 export declare function sendUseGitHostAccount(host: string, login: string): Promise<AccountResult>;
 /** Log another account in at `host`, in the browser: the code the person types, and where. */
@@ -53,6 +69,8 @@ export interface AgentState {
     problem?: string;
     /** What a press does about it, when the agent's package declared a command for it. */
     fix?: DriverFix;
+    /** The agent's own login is out, and runs use an added account: the own login is no account to show. */
+    ownLoggedOut?: true;
     /** A press's fix going on. */
     fixing?: DriverFix['kind'];
     /** Why the last press's fix failed. */

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

@@ -1,4 +1,6 @@
+import { type Health } from '../health.js';
 import { type MachineLogins } from '../dashboard/machine-logins.js';
+import { type StartReadiness } from '../project-hooks.js';
 /** A saved machine as the browser sees it: no key. */
 export interface Machine {
     id: string;
@@ -151,12 +153,16 @@ export interface MachineVersions {
     version: string;
     /** This computer's own name, as another machine lists it. */
     name: string;
+    /** How this computer stands: its memory, disk and load. */
+    health?: Health;
     /**
-     * Each saved machine, with its version when it answers and says, the id it lists this computer
-     * under among its devices, and the ids it is listed under at the doors of the machines it saved.
+     * Each saved machine, with its version and how it stands when it answers and says, the id it
+     * lists this computer under among its devices, and the ids it is listed under at the doors of
+     * the machines it saved.
      */
     machines: (Machine & {
         version?: string;
+        health?: Health;
         device?: string;
         listed?: string[];
     })[];
@@ -201,3 +207,10 @@ export type ProjectOnMachine = {
 export declare function sendProjectToMachine(projectId: string, machineId: string): Promise<ProjectOnMachine>;
 /** Whether a saved machine has the project by now, or why it will not: asked while the machine clones it. */
 export declare function onProjectOnMachine(projectId: string, machineId: string): Promise<ProjectOnMachine>;
+/**
+ * What would stop a run sent to a saved machine, as the machine says from its own copy of the
+ * project: its coding agent there, installed and logged in. `null` when there is nothing to say:
+ * a machine that does not answer, does not have the project yet (it clones it at the first run),
+ * or has no check.
+ */
+export declare function onMachineStartCheck(projectId: string, machineId: string, driver?: string): Promise<StartReadiness | null>;

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

@@ -6,7 +6,7 @@ export type { ModuleReadResult } from '../dashboard/module-host.js';
 export interface DashboardModule {
     /** The package that brings it. */
     package: string;
-    /** The URL of its browser module, served from the first project that has it, or from OpenAgent's own copy for one of the computer's. */
+    /** The URL of its browser module, served from the first project that has it, or from OpenAgent's own copy for one of the computer's, with its file's version: a browser keeps it for good. */
     url: string;
     /** The registered projects whose packages include it, in the registry's order; none for one of the computer's, whose commands run in no project. */
     projects: string[];
@@ -26,15 +26,15 @@ export declare function onModules(): Promise<DashboardModule[]>;
  * Run one of a module package's commands in one project and answer its JSON output: how a module
  * reads (and changes) its own data. Refused for an unknown project and for a package that is not a
  * module of that project, so a page can run only its own package's commands, never an arbitrary
- * program. Once the command has run, OpenAgent forgets what it had read of that project's
- * provided data (its queue, its runs): the command may have written it, and the next read sees
- * that at once instead of a cached copy.
+ * program.
  *
- * `acts` says the command is a module's action on the project (a link action), not a page's read:
- * OpenAgent then also converges the project's data branch with origin, as its clock does
- * every minute, before forgetting — in a project that shares its records a package's command
- * writes as a remote writer, straight to origin, and this machine's copy would otherwise show the
- * write only at the next sync.
+ * `acts` says the command is a module's action on the project (a claim released, an entry added),
+ * not a page's read. Only then does OpenAgent converge the project's data branch with origin, as
+ * its clock does every minute, and forget what it had read of the data that package provides (the
+ * queue package's queue): in a project that shares its records a package's command writes as a
+ * remote writer, straight to origin, and the next read shows the change at once instead of at the
+ * next sync. A read writes nothing, so what was read stays: the Members card reading the logs
+ * package's people leaves the runs that package provides read.
  */
 export declare function runModuleCommand(projectId: string, pkg: string, args: string[], command?: string, acts?: boolean): Promise<ModuleCommandResult>;
 /**

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

@@ -0,0 +1,15 @@
+import { type GitHostFor, type GitHostPerson } from '../store/git-host.js';
+/** A person of a project, as its git host knows them: their email, login and picture. */
+export type HostPerson = GitHostPerson & {
+    email: string;
+};
+/**
+ * The git host's accounts behind these emails of a project's (`people` of its git host): what a
+ * card shows as each person's picture. What it said of an email is kept a day, a miss too, so a
+ * card that asks every minute asks the host once a day per person. No git host: nobody.
+ */
+export declare function onGitHostPeople(projectId: string, emails: string[], deps?: {
+    gitHost?: GitHostFor;
+    now?: () => number;
+    resolve?: (projectId: string) => Promise<string | undefined>;
+}): Promise<HostPerson[]>;

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

@@ -1,3 +1,4 @@
+import { type ModuleAgent, type ModuleAgentsWanted } from '../dashboard/module-agents.js';
 import type { BridgeBrowserStatus } from '../bridge-browser.js';
 import { type AgentDoing, type AgentMeta, type BranchesFor } from '../store/index.js';
 import { type GitHostHome } from '../store/git-host.js';
@@ -17,6 +18,7 @@ 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';
+import { type OwnRuns } from '../dashboard/machine-runs.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
@@ -37,6 +39,31 @@ import type { SavedMachine } from '../dashboard/rpc-serve.js';
  * instead of losing it.
  */
 export declare function onAgents(projectId: string): Promise<AgentMeta[]>;
+/**
+ * A project's runs as a module sees them ({@link ModuleAgent}), only the ones it asks for: a card
+ * shows a few of the hundreds a project keeps, and each run in the few fields a module reads, so
+ * what a phone downloads for it is that much smaller. The same runs as {@link onAgents}.
+ */
+export declare function onModuleAgents(projectId: string, wanted?: ModuleAgentsWanted): Promise<ModuleAgent[]>;
+/**
+ * A project's runs as its records and checkouts say them, each as recorded: the ones this
+ * computer runs, and every other computer's whose record came through the project's shared records.
+ * A run of this computer's that has no record yet is its project's git user's, as its record will be.
+ */
+export declare function recordedRuns(cwd: string): Promise<AgentMeta[]>;
+/**
+ * A project's runs as the dashboard lists them: its records, with what each saved machine says of
+ * its own runs right now taking over theirs (machine-runs.ts). Not marked yet for the dashboard.
+ */
+export declare function projectRuns(cwd: string): Promise<AgentMeta[]>;
+/**
+ * This computer's own runs of a project, for another computer that lists them (machine-runs.ts):
+ * the ones that changed since `since`, the answer it had last, as they stand right now. Only this
+ * computer's: what another computer's records say is that computer's to answer. With `wait` (ms,
+ * up to {@link RUNS_WAIT_MS}) and no change a list shows since `since`, the answer waits for the
+ * first such change, or says what changed otherwise once the wait is up.
+ */
+export declare function onOwnRuns(projectId: string, since?: unknown, wait?: unknown): Promise<OwnRuns>;
 /**
  * What a run's row marks beside its name, for both lists of runs, a project's and all projects'
  * together: how its pull request stands, and the work it left on this machine.
@@ -100,7 +127,8 @@ export declare function markSaving(agent: AgentMeta, thisHost?: string, alive?:
  * A run as its record may say it. A record is a file anyone with the project can write, and its
  * tool's own words are read into the row as they are, so the words only this daemon gives a row
  * are taken off it first: that it runs on a saved machine and which, that it is another
- * computer's, that it is being saved. A computer's name that is no name is none.
+ * computer's, that it is being saved, when its computer was last seen. A computer's name that is
+ * no name is none.
  */
 export declare function asRecorded(agent: AgentMeta): AgentMeta;
 /**

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

@@ -0,0 +1,7 @@
+/** One thing the page is told: the runs of the project changed. */
+export interface RunsChanged {
+    kind: 'runs';
+    projectId: string;
+}
+/** Tell `send` each time the runs of a project on the list change, until the answer is called. */
+export declare function followRunsChanged(send: (change: RunsChanged) => void): () => void;

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

@@ -0,0 +1,21 @@
+import { type ServerLogins } from '../dashboard/logins-sync.js';
+import type { CopiedKind } from '../dashboard/copied-logins.js';
+import type { AccountResult } from './accounts.js';
+export type { ServerLogins, LoginThere } from '../dashboard/logins-sync.js';
+export interface ServerLoginsView {
+    /** This computer's own name: what a server says its logins are from. */
+    computer: string;
+    servers: ServerLogins[];
+}
+/** Each saved server of the person's, and how this computer's logins stand there. */
+export declare function onServerLogins(): Promise<ServerLoginsView>;
+/** A server uses this computer's logins from now on: what can go there goes now. */
+export declare function sendUseLoginsOn(machineId: string): Promise<AccountResult>;
+/** The press: a login of the server's own for each account that waits for one, made in this computer's browser. */
+export declare function sendAllowLogins(machineId: string): Promise<AccountResult>;
+/** A login the server has of this computer's that this computer no longer has: kept there, or taken off. */
+export declare function sendSettleLogin(machineId: string, which: {
+    kind: CopiedKind;
+    host?: string;
+    source: string;
+}, keep: boolean): Promise<AccountResult>;

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

@@ -0,0 +1,19 @@
+/** A computer's memory, disk and load, as it says them. */
+export interface Health {
+    /** Memory, in bytes: all of it, and how much is in use, the cache a system gives back on demand not counted. */
+    memory: {
+        total: number;
+        used: number;
+    };
+    /** The disk of its user's home, in bytes: all of it, and how much is in use. */
+    disk?: {
+        total: number;
+        used: number;
+    };
+    /** How busy its processors are, in percent of all of them: the time they were not idle since the reading before. */
+    load?: number;
+}
+/** This computer's health, read at most every {@link KEPT_MS}. */
+export declare function computerHealth(now?: number): Promise<Health>;
+/** What another computer said of its health, kept only as well-formed: whole, finite, used no more than all. */
+export declare function readHealth(said: unknown): Health | undefined;

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

@@ -38,3 +38,4 @@ export type { ProjectQueue } from './dashboard/queue.js';
 export type { QuotaView } from './dashboard/quota.js';
 export type { Ticket } from './store/tickets.js';
 export type { AgentWorktree, CleanupReport, OnboardingSuggestion } from './dashboard/types.js';
+export type { CardPlace, CardWidth, OverviewLayouts } from './overview-layout.js';

package/dist/module-types/src/overview-layout.d.ts

@@ -0,0 +1,37 @@
+/** How wide a card stands, as a share of the Overview's column. */
+export declare const CARD_WIDTHS: readonly ['1/4', '1/3', '1/2', '2/3', '3/4', '1'];
+export type CardWidth = (typeof CARD_WIDTHS)[number];
+/** One card's place in a layout: its id, and what was picked for it. */
+export interface CardPlace {
+    id: string;
+    /** Picked to be hidden. */
+    hidden?: true;
+    /** Picked to stand at this width; its own default when unsaid. */
+    width?: CardWidth;
+}
+/** The layouts, by project id, and {@link ALL_PROJECTS} for the Overview of every project. */
+export type OverviewLayouts = Record<string, CardPlace[]>;
+/** The key of the layout of the Overview of every project. */
+export declare const ALL_PROJECTS = "*";
+/** What a card says of itself to be laid out: its id, and the widths it stands at. */
+export interface LayoutCard {
+    id: string;
+    /** Its width until one is picked. */
+    width: CardWidth;
+    /** The narrowest it fits: a narrower pick is not offered, and a saved one is not kept. */
+    minWidth: CardWidth;
+}
+/** The widths a card fits, narrowest first. */
+export declare function widthsFor(card: Pick<LayoutCard, 'minWidth'>): CardWidth[];
+/**
+ * The cards in their order, each with its width and whether it is hidden, by the layout of `key`
+ * (else the all-projects one, else none): the cards it names first, in its order, then the rest in
+ * their own. A name no card has any more is passed over.
+ */
+export declare function arrangeCards<C extends LayoutCard>(cards: readonly C[], layouts: OverviewLayouts | undefined, key: string): {
+    card: C;
+    width: CardWidth;
+    hidden: boolean;
+}[];
+/** Keep only well-formed layouts: string keys, each a list of places with a card id; a malformed place is dropped, not thrown. */
+export declare function sanitizeOverviewLayouts(value: unknown): OverviewLayouts;

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

@@ -120,12 +120,22 @@ export declare function runResumeHook(cwd: string, input: ResumeHookInput, opts?
 export interface StartReadiness {
     problems: string[];
     warnings: string[];
-    /** What a press does about the problem: install the coding agent's CLI, or log it in. The command run is the agent's package's, asked again at the press. */
+    /**
+     * What a press does about a problem: install the coding agent's CLI, or log it in. The command run
+     * is the agent's package's, asked again at the press; `problem` is the line of `problems` it answers.
+     */
     fix?: {
         kind: 'install' | 'log-in';
         command: string;
+        problem: string;
     };
 }
+/**
+ * A check's answer read as one, or nothing when it is not: a `check` line's, or a machine's that
+ * ran its own. Problems and warnings are lists of lines; a fix answers one of the problems said,
+ * or it is no fix to offer.
+ */
+export declare function readinessOf(said: unknown): StartReadiness | undefined;
 /** How a `check` line went; `noHook` when the project's file names no such line. */
 export type CheckHookResult = ({
     ok: true;

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

@@ -1,3 +1,4 @@
+import { type OverviewLayouts } from './overview-layout.js';
 import { type PublishPick } from './publish-levels.js';
 /**
  * The multi-project registry (#390): the list of projects the user has
@@ -48,11 +49,15 @@ export interface MachineRecord {
     owner?: string;
     /** The person was told, once, that their logins are copied to that other person's computer. */
     told?: true;
+    /** A server of the person's own that uses this computer's logins: they said so once (`logins-sync.ts`). */
+    logins?: true;
     /**
      * The ids the machine is listed under at the doors of the machines it saved, as it last said:
      * kept, so it is known to be in at this computer's door too while it does not answer.
      */
     listed?: string[];
+    /** When the machine last answered for its runs, ISO, kept to the minute: what its runs say while it does not answer. */
+    seenAt?: string;
 }
 /** A GitHub account's name: letters, digits and single dashes, at most 39. */
 export declare function isAccount(value: unknown): value is string;
@@ -167,6 +172,8 @@ export interface Preferences {
      * Appearance clears it.
      */
     onboardingDismissed?: boolean;
+    /** How the Overview lays out its cards, per project and for all projects ({@link OverviewLayouts}); absent = each card in its own order and width. */
+    overviewLayouts?: OverviewLayouts;
 }
 /** The persisted registry file shape (#410): the project list plus the user preferences. */
 export interface Registry {
@@ -336,8 +343,15 @@ export declare function noteListed(machine: {
     id: string;
     key: string;
 }, listed: string[], fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<void>;
+/** Keep when a saved machine last answered, once a minute at most: the file is not written at each answer. */
+export declare function noteSeen(machine: {
+    id: string;
+    key: string;
+}, at: string, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<void>;
 /** Write down that the person was told their logins are copied to a saved machine of another person's. Answers whether it is saved. */
 export declare function tellMachine(id: string, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<boolean>;
+/** Say whether a saved server uses this computer's logins. Answers whether it is saved. */
+export declare function useLoginsOn(id: string, on: boolean, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<boolean>;
 /** Give a saved machine the name the person picked. Answers the machine as saved; nothing when it is not saved, or the name is empty. */
 export declare function renameMachine(id: string, label: string, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<MachineRecord | undefined>;
 /** Take a saved machine off the list, by id. Answers the one that was there. */

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

@@ -8,7 +8,11 @@ import { type AnyDiaryLine, type RunsFor } from './runs.js';
  * provider answers (`runs.ts`), when one of its packages provides them. The dashboard is a
  * projection of those files and that answer.
  */
-export type AgentStatus = 'running' | 'done' | 'stopped' | 'failed' | 'waiting';
+/**
+ * How a run stands. `unknown` is never recorded: it is how a run of another computer reads while
+ * that computer does not answer, whatever its record last said, so it is never taken for working.
+ */
+export type AgentStatus = 'running' | 'done' | 'stopped' | 'failed' | 'waiting' | 'unknown';
 /**
  * A queryable snapshot of the agent, derived entirely from the event log. Lets the
  * dashboard render a header (and a future agent list) without parsing every line.
@@ -33,6 +37,11 @@ export interface AgentMeta {
     pid?: number;
     /** The host the owning {@link pid} lives on, so a pid probe only trusts a match (#716). */
     host?: string;
+    /**
+     * Whose run it is, by the email its record is kept under: the git user of the computer that
+     * ran it. A run of this computer's that has no record yet is its project's git user's.
+     */
+    person?: string;
     /** What this session was asked for (from the `intent` event). */
     intent?: string;
     /** The session's short name, as a list shows it: two to five words a small model gave it. */
@@ -197,6 +206,11 @@ export interface AgentMeta {
     remoteLabel?: string;
     /** That saved machine is a person's own computer, reached by the line it keeps open here (reached-by-line.ts): the run is drawn with a computer, not a server. */
     remoteByLine?: true;
+    /**
+     * While the run's status is `unknown`: when its computer last answered this one, ISO, when it
+     * did since this computer knows it. Not stored: annotated on the way to the dashboard.
+     */
+    seenAt?: string;
     /**
      * The flow this agent started under (#1467): `build` for the scope→build orchestration, `prompt`
      * for the direct-prompt path (research and transparent runs record `prompt` too). Persisted so a

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

@@ -166,7 +166,7 @@ export interface BranchesSource {
 export type BranchesFor = (root: string) => Promise<BranchesSource | undefined>;
 /** A {@link BranchesFor} that also forgets what it read of one project, for when a module or a run just wrote there. */
 export type BranchesReader = BranchesFor & {
-    changed(root: string): void;
+    changed(root: string, pkg?: string): void;
 };
 /** The rows read back from a provider's `list`: the objects with an id and a path, everything else as printed; anything else is no checkout. */
 export declare function parseCheckouts(output: unknown): Checkout[];
@@ -180,7 +180,7 @@ export declare function parseBranchesAhead(output: unknown): BranchAhead[];
  * 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 command again: a run just started there, or a module's command just ran, and a checkout may
- * have come or gone.
+ * have come or gone. `changed(root, pkg)` forgets them only when that package is the one providing.
  */
 export declare function providedBranches(now?: () => number): BranchesReader;
 /** OpenAgent's one reader of the checkouts, shared by every caller so they share its cache. */

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

@@ -18,6 +18,8 @@
  *   `<command> merge <number>`                          land the pull request: armed to merge on green, or merged at once
  *   `<command> home`                                    the project's page on the git host, and the git host's name
  *   `<command> me`                                      who is signed in there: {@link GitHostPerson}
+ *   `<command> people <email>...`                       the accounts behind the project's commit emails: an array of
+ *                                                       {@link GitHostPerson} each with its `email`, one per email the host knows
  * The branch `open` is asked for must already be on the remote: pushing is the branches
  * provider's step, and OpenAgent runs it first.
  *
@@ -101,12 +103,16 @@ export interface GitHostSource {
     home(): Promise<GitHostHome | undefined>;
     /** Who is signed in at the git host; `undefined` when nobody is, or the provider cannot tell. */
     me(): Promise<GitHostPerson | undefined>;
+    /** The accounts behind these commit emails, each with its email; an email the host knows no account for is left out. */
+    people(emails: readonly string[]): Promise<(GitHostPerson & {
+        email: string;
+    })[]>;
 }
 /** The git host of the project at `root`, or `undefined` when none of its packages provides one. */
 export type GitHostFor = (root: string) => Promise<GitHostSource | undefined>;
 /** A {@link GitHostFor} that also forgets what it knows of one project. */
 export type GitHostReader = GitHostFor & {
-    changed(root: string): void;
+    changed(root: string, pkg?: string): void;
 };
 /** 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[];
@@ -114,7 +120,7 @@ export declare function parseRequests(output: unknown): GitHostRequest[];
  * 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.
+ * project, so the next ask looks its provider up again; `changed(root, pkg)` only when that package is the one providing.
  */
 export declare function providedGitHost(now?: () => number): GitHostReader;
 /** OpenAgent's one reader of the git host, shared by every caller. */

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

@@ -1,10 +1,11 @@
 /**
  * A package's command just ran in the project at `root` (a module's, through the dashboard), and
- * may have written what one of OpenAgent's provided readers caches: every provided reader
- * forgets that project, so its next read runs the provider again. OpenAgent never knows which
- * command writes what; forgetting is cheap and re-reading is what it does anyway.
+ * may have written what one of OpenAgent's provided readers caches. Given the package, only what
+ * that package provides is forgotten: a card reading the queue leaves the runs read, so the next
+ * read of the runs is not made again for nothing. With no package, every provided reader forgets
+ * that project. Its next read runs the provider again; forgetting is cheap.
  */
-export declare function providedDataChanged(root: string): void;
+export declare function providedDataChanged(root: string, pkg?: string): void;
 /** The kinds of OpenAgent's data a project's package may provide, one reader each (`git-host` is `git-host.ts`). */
 export declare const PROVIDED_KINDS: readonly ['tickets', 'queue', 'runs', 'branches', 'git-host', 'repository'];
 /**