@openagt/dashboard 0.33.1 → 0.35.0

package/dist/module-types/dashboard/lib/settings-crumb.d.ts

@@ -0,0 +1,15 @@
+/** The page inside an entry, as its header shows it. */
+export interface SettingsCrumb {
+    /** What the page is about: "Studio Mac". */
+    title: string;
+    /** Back to the entry itself. */
+    back: () => void;
+}
+/** Set by the Settings dialog around an entry: how its page inside says it is open, and closed. */
+export declare const SettingsCrumbContext: import("react").Context<((crumb: SettingsCrumb | undefined) => void) | null>;
+/**
+ * Show a page inside a Settings entry: the header says its title after the entry's, and its back
+ * arrow calls `back`. Nothing while `crumb` is undefined. Answers whether a header shows it: outside
+ * the Settings dialog none does, and the page draws its own way back.
+ */
+export declare function useSettingsCrumb(crumb: SettingsCrumb | undefined): boolean;

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

@@ -2,5 +2,8 @@
  * Whether an element is narrower than `width` pixels, followed as it is resized: a pane beside the
  * chat is as wide as the person drags it, not as the window is. Pass the element through a state
  * setter used as its `ref`. Wide where the browser cannot measure.
+ *
+ * Measured before the page is drawn, so a pane opened narrow never shows for a frame as a wide one
+ * would (a file tree beside the file, then gone).
  */
 export declare function useNarrow(element: HTMLElement | null, width: number): boolean;

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

@@ -212,11 +212,12 @@ export interface ModulePanelProps {
     activity?: number;
     /**
      * On a pane that lists what a run changed (`changes`): the changed file a click in the chat
-     * asked to see, by its path in the run's checkout. `at` tells one ask from the next for the
-     * same file. Absent until a file is asked for.
+     * asked to see, by its path in the run's checkout; no path when the click asked for all of
+     * them, from the first. `at` tells one ask from the next for the same file. Absent until a
+     * file is asked for.
      */
     reveal?: {
-        path: string;
+        path?: string;
         at: number;
     };
     context: ModuleContext;
@@ -230,10 +231,8 @@ export interface ModulePanelProps {
 export interface ModulePanel {
     /** Which pane this is among the module's own, for its key and for remembering that it is open. */
     id: string;
-    /** The pane's name: on its card, and what its icon is called. */
+    /** The pane's name: on its card, and what its icon is called and its tooltip says. */
     label: string;
-    /** The icon's tooltip: one sentence on what the pane shows. */
-    help: string;
     /** The pane's icon in the top bar, drawn at the size its `className` gives. */
     icon: ComponentType<{
         className?: string;
@@ -374,7 +373,7 @@ export interface ModuleHost {
     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.
+     * pastes it under Devices. This computer is let in there with it, once, and keeps its key.
      */
     addMachine(link: string, label?: string): Promise<MachineAdded>;
     /**
@@ -382,6 +381,13 @@ export interface ModuleHost {
      * there stops working. Refused, with the reason, while a run is at work there.
      */
     removeMachine(id: string): Promise<MachineRemoved>;
+    /** Give a saved machine the name the person picked. */
+    renameMachine(id: string, label: string): Promise<MachineAdded>;
+    /**
+     * Have a saved machine save this computer, with the link this computer's door gave for a new
+     * device: that machine then starts runs here too. Not for a computer reached through a server.
+     */
+    letMachineIn(machineId: string, link: string): Promise<MachineAdded>;
     /**
      * The computers that keep a line open to a saved server: computers at home a run can be sent to
      * through the server, and whether each is saved here already. None for a machine that is no server.
@@ -418,11 +424,18 @@ export interface ModuleMachine {
     device?: string;
     /** Whose computer it is, by their GitHub account, when it is another person's shared with everyone on a server. */
     owner?: string;
+    /**
+     * The ids the machine is listed under at the doors of the machines it saved, as it says: one of
+     * them among this computer's own door's devices is that machine, in there too.
+     */
+    listed?: string[];
 }
 /** What {@link ModuleHost.machines} answers. */
 export interface ModuleMachines {
     /** This computer's own OpenAgent. */
     version: string;
+    /** This computer's own name, as another machine lists it: "Suleimans-MacBook-Pro". */
+    name?: string;
     machines: ModuleMachine[];
 }
 /** How saving a machine went: done, or stopped, with the reason. */
@@ -513,6 +526,7 @@ export { StartAgentButton } from '../components/StartAgentButton.js';
 export { LinkActions, type ProjectLinks, type LinkTargets } from '../components/LinkActions.js';
 export { cn } from '../lib/utils.js';
 export { SettingsSection, SettingsRow, SettingsSelectRow, type SettingsOption } from '../components/SettingsRows.js';
+export { useSettingsCrumb, type SettingsCrumb } from '../lib/settings-crumb.js';
 export { QrCode } from '../components/QrCode.js';
 export { AddMachineDialog } from '../components/AddMachineDialog.js';
 export { InviteDialog, type InviteCode, type InviteAnswer, type InvitePersons } from '../components/InviteDialog.js';
@@ -523,6 +537,7 @@ export { MAX_SPEND_OFFSET } from '../../src/preference-defaults.js';
 export { formatRelative, formatDateTime, formatDuration, formatAge } from '../lib/format-date.js';
 export { usePolled, useLoaded, forgetRemembered } from '../lib/use-async.js';
 export { useNarrow } from '../lib/use-narrow.js';
+export { Waiting } from '../components/Waiting.js';
 export { useHighlighted, Pieces, type Piece } from '../lib/highlight.js';
 export { useAction } from '../lib/use-action.js';
 export { useSchedule, type Schedule } from '../lib/use-schedule.js';

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

@@ -11,6 +11,13 @@ export declare const onComputersThrough: (machineId: string) => Promise<impl.Com
 export declare const sendAddComputerThrough: (machineId: string, computerId: string) => Promise<impl.AddMachineResult>;
 export declare const onMachinePerson: (machineId: string) => Promise<impl.MachinePerson>;
 export declare const sendRemoveMachineDevice: (machineId: string, deviceId: string) => Promise<impl.MachinePerson>;
+export declare const sendRenameMachine: (id: string, label: string) => Promise<impl.AddMachineResult>;
+export declare const sendLetMachineIn: (machineId: string, link: string) => Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
 export declare const sendMachineTold: (machineId: string) => Promise<{
     ok: boolean;
 }>;

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

@@ -0,0 +1,37 @@
+/** An account the git host's tool knows, as its package said it. */
+export interface GitHostAccount {
+    login: string;
+    /** The terminal's: the one the tool uses when not told which. */
+    terminal: boolean;
+    /** The one OpenAgent's runs use. */
+    runs: boolean;
+    /** Whether the tool could use it when asked. */
+    ok: boolean;
+}
+/** What a git host's package answers of it. */
+export interface GitHostProvider {
+    name: string;
+    /** The host's word for a pull request. */
+    requestWord: string;
+    /** Its logo, an SVG. */
+    logo?: string;
+    /** The tool it works through, by its command's name. */
+    tool: string;
+    installed: boolean;
+    /** The command a press installs the tool with, shown under the button. */
+    install: string;
+    accounts: GitHostAccount[];
+    /** A login waiting for the browser's yes: the code the person types, and where. */
+    loggingIn?: {
+        code: string;
+        url: string;
+    };
+    /** The install a press started is going on. */
+    installing?: boolean;
+    /** Why the last install failed, while the tool is still not here. */
+    installFailed?: string;
+}
+/** The host of a git remote's address: `git@host:path`, `ssh://user@host/path`, `https://host/path`. None for a local path. */
+export declare function remoteHost(remote: string): string | undefined;
+/** A package's `accounts` answer, read: none for an answer that is not one. */
+export declare function readProvider(output: unknown): GitHostProvider | undefined;

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

@@ -7,7 +7,7 @@
  *
  * What a computer says of a login there is only whose it is, where it came from and a mark of it:
  * the start of its SHA-256, by which the copier tells whether the copy is still its own login.
- * The login itself is never said. The marks are the servers package's (`own.ts`), made the same way.
+ * The login itself is never said. The marks are the devices package's (`servers/own.ts`), made the same way.
  */
 /** One login there, as that computer says it. */
 export interface LoginThere {
@@ -40,7 +40,7 @@ export declare function markOf(login: string): string;
 /** What another computer said of the logins there, as far as it reads as such: it is another computer's data. */
 export declare function readLogins(value: unknown): MachineLogins;
 /**
- * The servers package's `own` answer of a person's own OpenAgent, as that computer says it: each
+ * The devices package's `server own` answer of a person's own OpenAgent, as that computer says it: each
  * login that is there, a copy when it names the server it came from.
  */
 export declare function loginsOfOwn(said: unknown): MachineLogins;

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

@@ -14,7 +14,7 @@ export interface Person {
     avatar?: string;
 }
 /**
- * Who a call came from, when the door in front of OpenAgent says (remote-access): the GitHub
+ * Who a call came from, when the door in front of OpenAgent says (the devices package): the GitHub
  * account of the person whose device made it. Said only on a computer several persons use.
  */
 export declare const PERSON_HEADER = "x-openagent-person";

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

@@ -49,13 +49,14 @@ export type RelayStartResult = StartAgentResult | {
  */
 export declare function pingRemote(target: MachineAccess): Promise<boolean>;
 /**
- * What a saved machine says of itself in its ping: the OpenAgent it runs, and the computer's own
- * name, which the records of its runs carry. Nothing for a machine that does not answer, or
- * does not say.
+ * What a saved machine says of itself in its ping: the OpenAgent it runs, the computer's own
+ * name, which the records of its runs carry, and the ids it is listed under at the doors of the
+ * machines it saved. Nothing for a machine that does not answer, or does not say.
  */
 export declare function remoteFacts(target: MachineAccess): Promise<{
     version?: string;
     host?: string;
+    listed?: string[];
 }>;
 /** 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>;
@@ -93,7 +94,7 @@ export declare function leaveRemote(machine: MachineAccess & {
  * computer at home that nothing on a network reaches is asked at this address, through the
  * server, with this computer's key at the server. To this computer it is one more machine.
  */
-export declare const THROUGH_PATH = "/_remote-access/via/";
+export declare const THROUGH_PATH = "/_devices/via/";
 /** A computer that keeps a line open to a server, as the server's door lists it. */
 export interface ComputerOnServer {
     id: string;
@@ -246,6 +247,17 @@ export declare function remoteComputerCommand(machine: MachineAccess, pkg: strin
     ok: false;
     error: string;
 }>;
+/**
+ * Have a saved machine save this computer, by a link this computer's door gave for a new device:
+ * that machine then sends its runs here too. Asked of the machine's own OpenAgent, as its page
+ * would add a machine; what it answers is its own words.
+ */
+export declare function remoteAddMachine(machine: MachineAccess, link: string, label: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
 /** The logins this computer's person has on a machine of another person's, as that machine says (machine-logins.ts). */
 export declare function remoteLogins(machine: MachineAccess): Promise<{
     ok: true;

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

@@ -0,0 +1,81 @@
+import { type AgentAccount, type DriverRateWindow } from '@openagt/agent-driver';
+import { type Mint } from '@openagt/agent-driver-claude';
+import { type CodexLogin, type CodexLoginOptions, type CodexWho } from '@openagt/agent-driver-codex';
+/** The agents with accounts: Claude Code's and Codex's. */
+export type AccountsAgent = 'claude' | 'codex';
+/** One of an account's usage windows, by how long it lasts. */
+export interface AccountWindow {
+    /** `5 h`, `week`, `month`. */
+    label: string;
+    /** How much of it is gone, 0-100. */
+    percent: number;
+}
+/** One account as the page shows it. */
+export interface AccountRow {
+    /** The account as the file names it: what the page sends back to act on it. */
+    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;
+    /** The person's own login, which the agent keeps: it is never removed. */
+    own: boolean;
+    /** When an added one was added, ISO 8601. */
+    added?: string;
+    /** How full it is, shortest window first; none when nothing said it yet. */
+    windows: AccountWindow[];
+    /** When those were said, epoch ms, when not now: an added Claude account is known from its last run. */
+    asOf?: number;
+    /** Until when a limit keeps it out, epoch ms. */
+    limitedUntil?: number;
+    /** `in-use`: the first one a run takes now; `next`: the one after it; `limited`: a limit keeps it out. */
+    state?: 'in-use' | 'next' | 'limited';
+}
+/** 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. */
+    url?: string;
+}
+export interface AccountsView {
+    accounts: AccountRow[];
+    adding?: AccountAdding;
+    /** Why the last add did not go through. */
+    failed?: string;
+    /** The daemon's clock, so "free in 2 h" is counted from the same now. */
+    now: number;
+}
+/** What the RPCs reach for, swapped in tests: the logins, where each agent keeps who the person is, how full a Codex account is. */
+export declare const accountsWiring: {
+    mint: Mint;
+    claudeJson: () => string;
+    path: (agent: AccountsAgent) => string;
+    now: () => number;
+    loginCodex: (opts: CodexLoginOptions) => Promise<CodexLogin>;
+    codexDir: () => string;
+    codexOwnHome: () => string;
+    codexFolder: (account: AgentAccount) => string;
+    codexWho: (home: string) => Promise<CodexWho>;
+    codexUsage: (home: string) => Promise<DriverRateWindow[]>;
+};
+/** 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>;
+export type AccountResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Add an account: this computer's browser opens on the agent's page, the person signs in there to
+ * the account being added, and its login is kept under `name`. Answers at once; the page follows it
+ * in {@link onAgentAccounts}.
+ */
+export declare function sendAddAgentAccount(agent: AccountsAgent, name: 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.
+ */
+export declare function sendRemoveAgentAccount(agent: AccountsAgent, name: string): Promise<AccountResult>;
+/** Runs try `name` first from now on. */
+export declare function sendUseAgentAccountFirst(agent: AccountsAgent, name: string): Promise<AccountResult>;
+/** The person's own login under the name they give it. */
+export declare function sendNameOwnAgentAccount(agent: AccountsAgent, name: string): Promise<AccountResult>;

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

@@ -6,10 +6,12 @@ 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, sendMachineLineLink, sendMachineTold, onMachineLogins, sendMachineLogins, type Machine, type MachineLoginsResult, type AddMachineResult, type MachineVersions, type ProjectOnMachine, type ComputersThrough, type MachinePerson } from './machines.js';
+export { onMachines, sendAddMachine, sendRemoveMachine, onMachinesReachable, onMachineVersions, sendProjectToMachine, onProjectOnMachine, onComputersThrough, sendAddComputerThrough, onMachinePerson, sendRemoveMachineDevice, sendRenameMachine, sendLetMachineIn, sendMachineLineLink, sendMachineTold, onMachineLogins, sendMachineLogins, type Machine, type MachineLoginsResult, type AddMachineResult, type MachineVersions, type ProjectOnMachine, type ComputersThrough, type MachinePerson } 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 { 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';
 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

@@ -0,0 +1,97 @@
+import { runPackageCommand, type ProvidedCommand } from '@openagt/agent-data';
+import type { DriverFix, DriverReadiness } from '@openagt/agent-driver';
+import { type DriverName } from '../driver-names.js';
+import { type AccountResult } from './accounts.js';
+import { type GitHostProvider } from '../dashboard/git-hosts.js';
+export type { GitHostAccount, GitHostProvider } from '../dashboard/git-hosts.js';
+/** One host the projects' remotes are on: which projects, and its package's answer, or none when no package answers for it. */
+export interface GitHostRow {
+    host: string;
+    /** The projects whose remote is there, by name. */
+    projects: string[];
+    provider?: GitHostProvider;
+}
+export interface GitHostsView {
+    hosts: GitHostRow[];
+}
+/** What the RPCs reach for, swapped in tests. */
+export declare const loginsWiring: {
+    /** The origin remote's address of the project at `root`. */
+    origin: (root: string) => Promise<string | undefined>;
+    /** The project's git host package's command. */
+    gitHost: (root: string) => Promise<ProvidedCommand | undefined>;
+    run: typeof runPackageCommand;
+    ready: (driver: DriverName) => Promise<DriverReadiness>;
+    /** Run a fix's command to its end; rejects with its last lines. */
+    fix: (command: string) => Promise<void>;
+    driver: () => Promise<DriverName>;
+};
+/** The hosts the projects' remotes are on, in the projects' order, each with its package's answer. A project with no remote is on none. */
+export declare function onGitHosts(): Promise<GitHostsView>;
+/** 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. */
+export declare function sendGitHostLogin(host: string): Promise<{
+    ok: true;
+    code: string;
+    url: string;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** Install the tool `host`'s package works through, with the command it declared; the card follows it. */
+export declare function sendGitHostInstall(host: string): Promise<AccountResult>;
+/** How the coding agent's CLI is on this computer, and what a press does about what is missing. */
+export interface AgentState {
+    driver: DriverName;
+    /** Installed and logged in, or it could not say otherwise. */
+    ready: boolean;
+    /** What is in the way, in words. */
+    problem?: string;
+    /** What a press does about it, when the agent's package declared a command for it. */
+    fix?: DriverFix;
+    /** A press's fix going on. */
+    fixing?: DriverFix['kind'];
+    /** Why the last press's fix failed. */
+    failed?: string;
+}
+/** The coding agent picked in Settings, or `driver`: installed, logged in, and what a press fixes. */
+export declare function onAgentState(driver?: string): Promise<AgentState>;
+/**
+ * Fix what is in the way of `driver`: the command its package declared for it, run here, the
+ * install to its end, the login until the browser said yes. Answers at once; the page follows it
+ * in {@link onAgentState}.
+ */
+export declare function sendAgentFix(driver: string): Promise<AccountResult>;
+/** A project's own accounts, beside the computer's: shown for a kind the computer has two or more of, or that the project names already. */
+export interface ProjectAccountsView {
+    gitHost?: {
+        host: string;
+        name: string;
+        /** The host's word for a pull request. */
+        requestWord: string;
+        accounts: string[];
+        /** The computer's runs' account. */
+        computer?: string;
+        /** The project's own, when it names one. */
+        project?: string;
+    };
+    claude?: ProjectAgentAccounts;
+    codex?: ProjectAgentAccounts;
+}
+/** One agent's accounts a project may pick from, and its own few. */
+export interface ProjectAgentAccounts {
+    accounts: {
+        id: string;
+        name: string;
+    }[];
+    /** The project's own few, by id, when it names some. */
+    project?: string[];
+}
+export declare function onProjectAccounts(projectId: string): Promise<ProjectAccountsView | null>;
+/** Change a project's own accounts: a value sets one, `null` goes back to the computer's. Kept on this computer, never in the repository. */
+export declare function sendProjectAccounts(projectId: string, change: {
+    gitHost?: string | null;
+    claude?: string[] | null;
+    codex?: string[] | null;
+}): Promise<AccountResult>;

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

@@ -129,19 +129,41 @@ export declare function onMachinesReachable(): Promise<Record<string, boolean>>;
 export interface MachineVersions {
     /** This computer's own. */
     version: string;
-    /** Each saved machine, with its version when it answers and says, and the id it lists this computer under among its devices. */
+    /** This computer's own name, as another machine lists it. */
+    name: string;
+    /**
+     * 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.
+     */
     machines: (Machine & {
         version?: string;
         device?: string;
+        listed?: string[];
     })[];
 }
 /**
  * The saved machines with the OpenAgent each runs, beside this computer's own: how a page tells
  * that a machine fell behind this computer. One short call to each, with this computer's key.
  * The key itself is never told: only the id the machine lists this computer under, which a page
- * that lists the machine's devices names this computer by.
+ * that lists the machine's devices names this computer by. A machine also says the ids it is
+ * listed under at the doors it saved: one of them in this computer's own door is that machine,
+ * in there too, so a page lists the computer once. A machine that does not answer is known by
+ * what it said last.
  */
 export declare function onMachineVersions(): Promise<MachineVersions>;
+/** Give a saved machine the name the person picked. */
+export declare function sendRenameMachine(id: string, label: string): Promise<AddMachineResult>;
+/**
+ * Have a saved machine save this computer, with a link this computer's door gave for a new
+ * device: from then on it starts runs here too. Not for a computer reached through a server,
+ * whose runs come here through that server.
+ */
+export declare function sendLetMachineIn(machineId: string, link: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
 /** Whether a saved machine has a project of this computer's: `there` is false while the machine clones it. */
 export type ProjectOnMachine = {
     ok: true;

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

@@ -1,10 +1,9 @@
-import { type Standing } from '@openagt/init';
+import { type Standing } from '../project-skills/project.js';
 import { type SendSkillsResult } from '../dashboard/send-skills.js';
 export type { SendSkillsResult } from '../dashboard/send-skills.js';
 /**
- * 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
+ * A project's skills, as the dashboard shows and changes them (#2023): the list with ticks of the
+ * skills a project picks beyond the defaults. A project has a skill when the skill's text is in its folder; the
  * dashboard writes and deletes those files, and sends them where agents start from.
  */
 /** One skill of the list, as it stands in the project. */

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

@@ -120,6 +120,11 @@ 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. */
+    fix?: {
+        kind: 'install' | 'log-in';
+        command: string;
+    };
 }
 /** How a `check` line went; `noHook` when the project's file names no such line. */
 export type CheckHookResult = ({

package/dist/module-types/src/project-skills/apply.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Writing and deleting a project's skills (#2023). A skill is one tracked file,
+ * `.agents/skills/<name>/SKILL.md`, where Codex reads it, and one tracked link,
+ * `.claude/skills/<name>`, pointing at that folder, where Claude Code reads it: the way the
+ * OpenAgent repository itself holds its skills. Nothing else is written: no `package.json`, no
+ * install, so a Node project, a PHP project and an empty folder get exactly the same.
+ */
+/** What one write or delete touched, as paths from the project's root: what a commit of it holds. */
+export interface Touched {
+    paths: string[];
+    /** A place that was left as it is, and why: something there that OpenAgent did not write. */
+    left: {
+        path: string;
+        reason: string;
+    }[];
+}
+/** Write (or write again) the text of skill `name` and its link. */
+export declare function writeSkill(root: string, name: string): Promise<Touched>;
+/** Delete the text of skill `name` and its link. A folder that holds more than the text keeps the rest. */
+export declare function removeSkill(root: string, name: string): Promise<Touched>;
+/** What switching the scheduler answered. */
+export type SchedulerOutcome = {
+    ok: true;
+    changed: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Switch the scheduler on or off for this project on this machine: its two lines in the project's
+ * hooks file, which is outside git. Switching it off also stops one that is running, since nothing
+ * else would. Switching it on in a folder with no `.openagent/` makes the folder a project first,
+ * exactly as a dashboard's "Add project" does, since the hooks file lives there.
+ */
+export declare function setScheduler(root: string, on: boolean): Promise<SchedulerOutcome>;

package/dist/module-types/src/project-skills/branch.d.ts

@@ -0,0 +1,29 @@
+import { type GitRunner } from '@openagt/agent-data';
+import { type CommitOutcome } from './commit.js';
+/**
+ * A project's skills as git has them (#2023): which are on a branch, and which stand written or
+ * deleted in the folder with no commit yet. An agent's checkout starts from a branch, so a skill
+ * written into the folder reaches agents only once it is on that branch; until then a dashboard
+ * says it is waiting, and offers the commit.
+ */
+/** Which skills are on a branch: asked by name. */
+export interface OnBranch {
+    has(name: string): boolean;
+}
+/**
+ * The skills on `ref`, in either folder: a text there, or a link named as the skill (where it
+ * leads is the project's own business). Read with one listing of the two folders. Where the
+ * listing fails, or a skills folder is itself a link to somewhere the listing does not show, the
+ * answer is that every skill is there: a skill is said to be waiting only when that is known.
+ */
+export declare function skillsOn(root: string, ref: string, git?: GitRunner): Promise<OnBranch>;
+/** The paths git may hold for `names`, from the project's root: each text, each link, and a text in a folder of Claude Code's own where there is no link. */
+export declare function skillPaths(root: string, names: readonly string[]): Promise<string[]>;
+/** The skills whose files stand written, changed or deleted in the folder with no commit yet, in the list's order. */
+export declare function uncommittedSkills(root: string, git?: GitRunner): Promise<string[]>;
+/**
+ * One commit of skill files that stand uncommitted, and nothing else. With `names`, the files of
+ * those skills alone: what a dashboard commits after a change. Without, every uncommitted file of
+ * the list's skills. Never a push.
+ */
+export declare function commitSkills(root: string, names?: readonly string[], git?: GitRunner): Promise<CommitOutcome>;

package/dist/module-types/src/project-skills/catalogue.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The skills a project can pick in the dashboard's Skills list (#2023), in its groups, with what
+ * is ticked the first time. Every group is ticked except the skills that are useless until something of
+ * their own is set up. The skills every run gets by default are not here (the branches skill,
+ * and the ones `@openagt/start` names): they come with every run, with nothing written in the
+ * project.
+ *
+ * Each skill's text is its own package's `SKILL.md`, read from this package's install, so the
+ * dashboard carries the texts of the versions it was published with.
+ */
+export interface SkillGroup {
+    title: string;
+    skills: readonly string[];
+    /** Whether the group's skills are ticked in a project that has none of them yet. */
+    ticked: boolean;
+}
+export declare const GROUPS: readonly SkillGroup[];
+/** Every skill of the list, in its order. */
+export declare const SKILL_NAMES: readonly string[];
+/**
+ * The scheduler's skill: written, it also gets the two lines that start the scheduler while the
+ * dashboard is open, in the project's hooks file, which is this machine's and outside git; deleted,
+ * it takes them out. Ticked by default: every automation starts switched off, so the scheduler
+ * starts no agent until a person says so.
+ */
+export declare const SCHEDULER = "scheduler";
+/** One skill as the dashboard carries it. */
+export interface CarriedSkill {
+    name: string;
+    /** The package the text is from, and its version: what a written text is stamped with. */
+    package: string;
+    version: string;
+    /** The whole `SKILL.md`. */
+    text: string;
+    /** The `description` of its front matter, in one line. */
+    description: string;
+}
+/** Every skill of the list with its text, read once from this package's own install. */
+export declare function carriedSkills(): Promise<Map<string, CarriedSkill>>;

package/dist/module-types/src/project-skills/change.d.ts

@@ -0,0 +1,29 @@
+/** One change to a project's skills, from the dashboard's Skills list or its Update button. */
+export interface Change {
+    /** Skills to write: a new one, or one written again over what is there. */
+    write?: readonly string[];
+    /** Skills to delete. */
+    remove?: readonly string[];
+}
+export interface Changed {
+    written: string[];
+    removed: string[];
+    /** Every tracked path the change wrote or deleted, from the project's root: what its commit holds. */
+    paths: string[];
+    /** What was left as it is, and why. */
+    left: {
+        path: string;
+        reason: string;
+    }[];
+    /** The scheduler after the change, when the change wrote or deleted its skill; `error` when it could not be switched. */
+    scheduler?: {
+        on: boolean;
+        changed: boolean;
+    } | {
+        on: boolean;
+        error: string;
+    };
+}
+/** Whether `name` is a skill of the list. */
+export declare function isKnown(name: string): boolean;
+export declare function applyChange(root: string, change: Change): Promise<Changed>;