@openagt/dashboard 0.56.0 → 0.57.0

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

@@ -117,6 +117,32 @@ export interface StartAgentOptions {
      * start is forwarded, so the machine starts an ordinary local run and does not relay onward.
      */
     machine?: string;
+    /**
+     * The repos a session with no project has as context, by their folders on this computer: each is
+     * copied into the session's folder. Refused for a project, which works in its own checkout.
+     */
+    repos?: string[];
+    /**
+     * The account at the git host this session works as, by its login: one of the accounts the
+     * computer the run goes to has there. Absent, the one that computer's runs use. The run's record
+     * keeps it, and a resume goes on as it.
+     */
+    account?: string;
+    /**
+     * The agent the session is on, by its id (`~/.openagent/agents/<id>.json`): its skills and
+     * accounts. Absent, the default agent. The run's record keeps it, and a resume goes on with it.
+     */
+    agent?: string;
+    /** Skills the session gets on top of its agent's, by name: the "Skills" menu's picks for this session. Absent, none. */
+    skillsOn?: string[];
+    /** Skills of its agent's the session does not get, by name. Absent, none. */
+    skillsOff?: string[];
+    /**
+     * Which of the project's own skills stay in the session's checkout: `none`, or their names.
+     * Absent, every one. Refused for a session with no project. The run's record keeps these three,
+     * and a resume goes on with them.
+     */
+    projectSkills?: 'none' | string[];
 }
 /**
  * The outcome of a Start attempt (#345): the id of the run the project's start hook began, or why

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

@@ -0,0 +1,63 @@
+import { type AgentAccounts, type AgentRecord } from '@openagt/agent-data';
+import { type AccountResult } from './accounts.js';
+import { type AgentLoginsOn } from '../dashboard/logins-sync.js';
+export type { AgentAccounts, AgentRecord } from '@openagt/agent-data';
+export type { AgentLoginsOn } from '../dashboard/logins-sync.js';
+/** One skill an agent can be given. */
+export interface AgentSkillChoice {
+    name: string;
+    /** The one line the skill's text says of itself. */
+    description: string;
+}
+export interface AgentsView {
+    /** Every agent, the default first. */
+    agents: AgentRecord[];
+    /** The skills to pick from, in groups: the default agent's first, then the catalogue's. */
+    skills: {
+        title: string;
+        skills: AgentSkillChoice[];
+    }[];
+    /** OpenAgent's GitHub accounts on this computer. */
+    github?: {
+        accounts: string[];
+    };
+    /** The Claude accounts of the Permissions page, by id and name. */
+    claude: {
+        id: string;
+        name: string;
+    }[];
+    /** The Codex accounts, the same way. */
+    codex: {
+        id: string;
+        name: string;
+    }[];
+}
+/** Every agent, and what one can be given. (`onAgents` names the runs' list already.) */
+export declare function onAgentsList(): Promise<AgentsView>;
+/** What the page sends to save an agent: a new one has no id yet. */
+export interface AgentChange {
+    id?: string;
+    name: string;
+    skills: string[];
+    accounts: AgentAccounts;
+    /** Whether its sessions get the project's own skills. */
+    projectSkills: boolean;
+}
+/**
+ * Save an agent: a new one under the id its name gives, an existing one under its own. The name
+ * must give an id, every skill must be one this computer carries, and every account one it knows;
+ * else nothing is written and the reason is said.
+ */
+export declare function sendSaveAgent(change: AgentChange): Promise<({
+    ok: true;
+    id: string;
+} | {
+    ok: false;
+    error: string;
+}) & Partial<AccountResult>>;
+/** How the agents' GitHub accounts stand on each device of the person's. A server copies to no device: none. */
+export declare function onAgentLogins(): Promise<AgentLoginsOn[]>;
+/** Copy the agents' GitHub accounts to every device again, now: the press for one that failed. */
+export declare function sendCopyAgentLogins(): Promise<AccountResult>;
+/** Remove an agent; the default agent stays. */
+export declare function sendRemoveAgent(id: string): Promise<AccountResult>;

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

@@ -23,7 +23,7 @@ export type CopiedView = {
     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. */
+/** What this device keeps from the person's computers, without how full each is: what a computer compares its own with. A device that is no server keeps git hosts' accounts alone. */
 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

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

@@ -0,0 +1,41 @@
+/** A repository at a git host, not looked for on this computer. */
+export interface HostedRepo {
+    /** `<host>/<owner>/<name>`: what a clone is asked for. */
+    address: string;
+    url: string;
+    private: boolean;
+    description?: string;
+    /** Why it is listed: the account it is one of, or the owner the person named. */
+    from: string;
+}
+/** How old the kept lists may be before a read asks the hosts again, behind the answer. */
+export declare const HOSTED_MAX_AGE_MS: number;
+/** How long a first read waits for the hosts before it answers with nothing yet. */
+export declare const HOSTED_FIRST_WAIT_MS = 1500;
+/** What a read answers: the lists as kept, and whether the hosts are being asked now. */
+export interface HostedRead {
+    repos: HostedRepo[];
+    loading: boolean;
+}
+/** What a listing is asked through: the host's package, and OpenAgent's accounts and the person's owners. */
+export declare const hostedWiring: {
+    run: (host: string, args: string[]) => Promise<{
+        ok: true;
+        output: unknown;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    hosts: () => Promise<import("./send-as.js").SendAsHost[]>;
+    owners: () => Promise<string[]>;
+    now: () => number;
+};
+/**
+ * The hosts' repositories as kept. The first read waits {@link HOSTED_FIRST_WAIT_MS} at most, and
+ * then says they are still being read; a read of old lists answers them and asks again behind.
+ */
+export declare function readHosted(): Promise<HostedRead>;
+/** Ask the hosts again now, and answer what they listed: after the person named another owner. */
+export declare function refreshHosted(): Promise<HostedRepo[]>;
+/** Forget the kept lists: for a test. */
+export declare function forgetHosted(): void;

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

@@ -1,7 +1,7 @@
 export { onAgents, onStartedName, onModuleAgents, onAgent, onAgentsDoing, onDocs, onQueue, onOverview, onRecentAgents, onInterventions, onActivity, onDashboard, onGitHostHome, onRepositoryOffer, onGitStatus, onProjectFiles, onRetainedWorktrees, onAgentWorktree, onAgentMainBranch, 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, sendShareRecords, sendPickProjectDirectory, onOnboarding, onCommands, onStartBranches, onStartCheck, onCloneCheck, type ProjectLauncher } from './projects.js';
+export { onProjects, sendAddProject, sendStartedAgain, onCloneTarget, sendAddProjectFromAddress, sendRemoveProject, sendShareRecords, sendPickProjectDirectory, onRepos, sendAddRepoFolder, onOnboarding, onCommands, onStartBranches, onStartCheck, onCloneCheck, type ProjectLauncher } from './projects.js';
 export { onPreferences, savePreferences, patchPreferences, onProjectPresets, saveProjectPresets, onEditors, type SavePreferencesResult, type PatchPreferencesResult, } from './preferences.js';
 export { type EditorInfo } from '../dashboard/open-in-app.js';
 export { onQuota } from './quota.js';
@@ -11,7 +11,8 @@ export { onModules, runModuleCommand, runComputerCommand, runComputerCommandOn,
 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, sendForgetGitHostAccount, sendGitHostLogin, sendGitHostInstall, onAgentState, sendAgentFix, onProjectAccounts, sendProjectAccounts, type GitHostsView, type GitHostRow, type GitHostAccount, type GitHostProvider, type AgentState, type ProjectAccountsView, type ProjectAgentAccounts } from './logins.js';
+export { onAgentsList, sendSaveAgent, sendRemoveAgent, onAgentLogins, sendCopyAgentLogins, type AgentsView, type AgentChange, type AgentSkillChoice, type AgentLoginsOn } from './agents.js';
+export { onGitHosts, sendUseGitHostAccount, sendForgetGitHostAccount, sendGitHostLogin, sendGitHostInstall, onAgentState, sendAgentFix, type GitHostsView, type GitHostRow, type GitHostAccount, type GitHostProvider, type AgentState } from './logins.js';
 export { onPersonalFolder, sendSyncPersonalFolder, sendStopSyncingPersonalFolder, type PersonalFolderView } from './personal-folder.js';
 export { onProjectAgentData, type ProjectAgentData, type KeptData } from './project-agent-data.js';
 export { onServerLogins, sendUseLoginsOn, sendAllowLogins, sendSettleLogin, type ServerLoginsView, type ServerLogins, type LoginThere } from './server-logins.js';

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

@@ -47,7 +47,7 @@ export declare const gitHostPackages: {
         error: string;
     }>;
 };
-/** Runs use `login` at `host` from now on; the terminal's own account stays as it is. */
+/** Runs use `login`, one of OpenAgent's own accounts at `host`, from now on. */
 export declare function sendUseGitHostAccount(host: string, login: string): Promise<AccountResult>;
 /**
  * Take an account off at `host`, on this computer: its tool forgets it, and its token goes on
@@ -91,35 +91,3 @@ export declare function onAgentState(driver?: string): Promise<AgentState>;
  * 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/modules.d.ts

@@ -15,9 +15,10 @@ export interface DashboardModule {
 }
 /**
  * Every module the dashboard loads (#1774), one per package. First the computer's, which are
- * there with no project added. Then every module any registered project brings, with the projects
- * that have it: with no project picked the sidebar and the pages are every project's, and the
- * dashboard narrows them itself to a picked project's. A package several projects install is loaded once, from
+ * there with no project added. Then every module whose pages a registered project shows, with
+ * the projects that show them: with no project picked the sidebar and the pages are every
+ * project's, and the dashboard narrows them itself to a picked project's. A package several
+ * projects install is loaded once, from
  * the first of them in the registry's order; its page then reads each project through that
  * project's own command. A project that cannot be read contributes nothing.
  */

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

@@ -1,4 +1,35 @@
 import { type Person } from '../dashboard/person.js';
 export type { Person } from '../dashboard/person.js';
-/** The person at this dashboard, for the foot of its sidebar (`readPerson`): another person's, for a page their device opened. */
+/** The person at this dashboard, for the foot of its sidebar and Settings › Profile (`readPerson`): another person's, for a page their device opened. */
 export declare function onPerson(): Promise<Person>;
+/** Call the person `name` in OpenAgent, on every computer of theirs: the picture stays as it was. */
+export declare function sendSavePersonName(name: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** Show no picture of the person: their initials instead. */
+export declare function sendRemovePersonPicture(): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/**
+ * Copy the name and picture of GitHub's public profile of `login` into the person's own, once:
+ * read with no login, and never again after this press.
+ */
+export declare function sendSyncPersonFromGitHub(login: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** Forget the person's own name and picture: git's name, or this computer's user, again. */
+export declare function sendForgetPerson(): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;

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

@@ -1,13 +1,30 @@
+import { type SendAsHost } from './send-as.js';
+export type { SendAsHost } from './send-as.js';
 import { type PersonalFolderShown } from '../personal-folder-shown.js';
 export interface PersonalFolderView extends PersonalFolderShown {
     /** Commits made here that have not reached the repository yet. */
     unsent: number;
     /** The projects of this computer that keep their agent data in it, by name. */
     projects: string[];
+    /** The login of OpenAgent's account it is sent as, when it syncs. */
+    account?: string;
+    /** OpenAgent's accounts at each host: what it may be sent as. */
+    hosts: SendAsHost[];
 }
 export declare function onPersonalFolder(): Promise<PersonalFolderView>;
-/** Sync the personal folder with the person's repository: what it has comes in, every record here goes out. */
-export declare function sendSyncPersonalFolder(typed: string): Promise<{
+/**
+ * Sync the personal folder with the person's repository, sent as `login`, one of OpenAgent's
+ * accounts at its host: what it has comes in, every record here goes out. Never as the person's
+ * own login: with no account there, nothing is sent.
+ */
+export declare function sendSyncPersonalFolder(typed: string, login?: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** Send the personal folder as another of OpenAgent's accounts from now on. */
+export declare function sendPersonalFolderAs(login: string): Promise<{
     ok: true;
 } | {
     ok: false;

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

@@ -1,3 +1,4 @@
+import { type SendAsHost } from './send-as.js';
 import { type PersonalFolderShown } from '../personal-folder-shown.js';
 /** One kind of the project's data the skills keep: how many, and the skill that keeps them. */
 export interface KeptData {
@@ -14,6 +15,17 @@ export interface ProjectAgentData {
     /** Whether the project has a remote to keep its data on. */
     canShare: boolean;
     kept: KeptData[];
+    /** The login of OpenAgent's account it is sent as, while shared. */
+    account?: string;
+    /** OpenAgent's accounts at the remote's host: what it may be sent as. None for a remote that asks no login. */
+    accounts?: SendAsHost;
 }
 /** Where the project's agent data is and what is kept; `null` for a project with no folder on this computer. */
 export declare function onProjectAgentData(projectId: string): Promise<ProjectAgentData | null>;
+/** Send the shared project's data as another of OpenAgent's accounts from now on. */
+export declare function sendProjectDataAs(projectId: string, login: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;

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

@@ -1,6 +1,8 @@
 import { type ProjectCommand } from '../project-commands.js';
+import { type HostedRepo } from './hosted-repos.js';
 import { type StartReadiness } from '../project-hooks.js';
 import { type StartFromPick } from '../registry.js';
+import { type FoundRepo } from '../dashboard/repos.js';
 import { type PickDirectoryResult } from '../pick-directory.js';
 import type { ProjectSummary } from '../dashboard/projects.js';
 import type { OwnProject } from '../dashboard/elsewhere.js';
@@ -17,11 +19,9 @@ export declare function onOwnProjects(): Promise<OwnProject[]>;
  * Projects list. Like `sendStart` this needs the daemon (it spawns git + writes the shared
  * registry), so it calls the daemon's own `addProject` closure off the wired dashboard context.
  * Returns the daemon's {@link AddProjectResult}.
- *
- * `share` is the person's answer, asked before the add: whether the agents' records may go to the
- * repository's remote. Nothing is pushed for a project added with `false`.
+ * The agents' records stay on this machine; the project's Agent data page shares them later.
  */
-export declare function sendAddProject(path: string, share: boolean): Promise<AddProjectResult>;
+export declare function sendAddProject(path: string): Promise<AddProjectResult>;
 /**
  * A second `openagent` started while this dashboard listens on its port (#2141): it serves
  * nothing itself, and hands over the folder it was started in, if it is in a repository. The
@@ -47,7 +47,7 @@ export declare function onCloneTarget(address: string): Promise<{
  * folder is then added as {@link sendAddProject} adds one. A folder already there with this
  * repository in it is added as it is. The answer says where the project is.
  */
-export declare function sendAddProjectFromAddress(address: string, share: boolean): Promise<AddProjectResult>;
+export declare function sendAddProjectFromAddress(address: string): Promise<AddProjectResult>;
 /**
  * Remove a project from the dashboard: it leaves the Projects list. Nothing in its folder is
  * deleted unless `files` is true: then what OpenAgent left there is removed too, and the answer
@@ -63,7 +63,7 @@ export declare function sendRemoveProject(projectId: string, files: boolean): Pr
  * where they were; off, back to the personal folder. A project with no remote has nothing to
  * share with, and is refused.
  */
-export declare function sendShareRecords(projectId: string, on: boolean): Promise<{
+export declare function sendShareRecords(projectId: string, on: boolean, login?: string): Promise<{
     ok: true;
 } | {
     ok: false;
@@ -76,6 +76,62 @@ export declare function sendShareRecords(projectId: string, on: boolean): Promis
  * comes back as `path: null`.
  */
 export declare function sendPickProjectDirectory(): Promise<PickDirectoryResult>;
+/** The repos on this computer that are not projects yet, the ones at the git hosts not here, and whether a folder can be added to look in. */
+export interface ReposRead {
+    repos: FoundRepo[];
+    /** The repositories OpenAgent's accounts and the owners the person named have at the hosts, none of them on this computer: picked, one is cloned. */
+    hosted: HostedRepo[];
+    /** The hosts are being asked: the picker asks again shortly. */
+    hostedLoading: boolean;
+    /** This computer can show a folder dialog, so the picker offers "Search another folder…". */
+    canAddFolder: boolean;
+}
+/**
+ * The repos a new session can start in besides the projects (Rom's "a project is a sticky repo"):
+ * every repository the daemon's crawl found on this computer, less those that are projects
+ * already. The kept list, so the picker opens at once; an old one is crawled again behind it.
+ */
+export declare function onRepos(): Promise<ReposRead>;
+/** Settings › Repos: where repos are looked for, on this computer and at the git hosts. */
+export interface RepoSources {
+    /** The folders the person added, looked in beside the home folder. */
+    folders: string[];
+    /** The users and organizations at a git host whose repositories are listed, as `<host>/<name>`. */
+    owners: string[];
+}
+export declare function onRepoSources(): Promise<RepoSources>;
+/** List one more user's or organization's repositories: `vikejs`, `github.com/vikejs` or its page's address. GitHub when no host is named. */
+export declare function sendAddRepoOwner(typed: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** Stop listing an owner's repositories. */
+export declare function sendRemoveRepoOwner(owner: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** Stop looking for repos in a folder the person added. */
+export declare function sendRemoveRepoFolder(folder: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/**
+ * "Search another folder…": the OS folder dialog, and the folder picked joins those the crawl
+ * looks in, which then runs again before the answer. A dismissed dialog adds nothing.
+ */
+export declare function sendAddRepoFolder(): Promise<{
+    ok: true;
+    added: boolean;
+} | {
+    ok: false;
+    error: string;
+}>;
 /**
  * The Onboarding checklist's one server-side fact (#958): the directory this server runs in,
  * so the first step can offer "Add {cwd} as project" without the user typing a path.

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

@@ -167,7 +167,7 @@ export declare function onDocs(projectId: string): Promise<WorkspaceDoc[]>;
 export declare function onQueue(): Promise<ProjectQueue[]>;
 /** The cross-project Overview (#437): what is running now, the queue size, and recent projects. */
 export declare function onOverview(): Promise<Overview>;
-/** Recent sessions pooled across every project (#shared-shell), newest first, for the home rail. */
+/** Recent sessions pooled across every project and the sessions with no project (#shared-shell), newest first, for the home rail. */
 export declare function onRecentAgents(): Promise<RecentAgent[]>;
 /**
  * The cross-project interventions queue (#632, Queue #624): open PRs that need review, newest first,

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

@@ -0,0 +1,41 @@
+import { type GitRunner, type RemoteAccount } from '@openagt/agent-data';
+/** OpenAgent's accounts at one host: what a "Send as" select offers. */
+export interface SendAsHost {
+    host: string;
+    /** The logins GitHub still takes, by name. */
+    logins: string[];
+    /** The one runs use, picked first where none is named yet. */
+    runs?: string;
+}
+/** OpenAgent's accounts at each host a package answers for. */
+export declare function accountsByHost(): Promise<SendAsHost[]>;
+/** What a repository at `host` keeps to be sent as `login`: what its git host's package says of that account, kept a few minutes. */
+export declare function remoteAccount(host: string, login?: string): Promise<{
+    ok: true;
+    account: RemoteAccount;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** The account a repository at a typed address is cloned as: the one runs use at its host; none where OpenAgent has none there. */
+export declare function cloneAccountFor(typed: string): Promise<RemoteAccount | undefined>;
+/** The host the repository at `root` has its origin on; none for no origin, or one in a folder on this disk. */
+export declare function originHost(root: string): Promise<string | undefined>;
+/**
+ * The account a repository's own branches are sent as by a press of the person's (the Skills
+ * page's Send, the clean-up of Claude Code web's branches): the one kept for it at its Share
+ * switch, else the one runs use at its host. Nothing for a remote that is a folder on this disk,
+ * which asks no login.
+ */
+export declare function originAccountOf(root: string): Promise<{
+    ok: true;
+    account?: RemoteAccount;
+} | {
+    ok: false;
+    error: string;
+}>;
+/**
+ * git for the repository at `root`, its talks with origin going as {@link originAccountOf} says:
+ * never as the person's own login. With no account to go as, those talks are refused in words.
+ */
+export declare function originGit(root: string): Promise<GitRunner>;

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

@@ -20,7 +20,6 @@ export interface ProjectSkills {
     /** 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[];
     }[];
     /** 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. */
@@ -40,6 +39,8 @@ export interface ProjectSkills {
     branch?: string;
     /** Whether the branch the folder is on has every waiting skill: an agent started from it has them now. */
     local: boolean;
+    /** Every skill the project holds, by name, as a run's checkout has them: the list's, and the project's own; what the launcher's Skills menu offers per session. */
+    held: string[];
 }
 /** The project's skills; `null` when the project is unknown here. */
 export declare function onProjectSkills(projectId: string): Promise<ProjectSkills | null>;

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

@@ -6,6 +6,13 @@
  */
 export declare const OVERVIEW_SEGMENT = "overview";
 export declare const SETTINGS_SEGMENT = "settings";
+/**
+ * The id the sessions with no project go by where a project's id would be, and their address:
+ * `/session` is the "New agent session" page with no project, `/session/<agentId>` one of those
+ * sessions. A project's id always ends in `-<hash>`, so no project has it, and no project's
+ * address or module's page takes the word.
+ */
+export declare const SESSIONS_ID = "session";
 /**
  * Whether a segment can name a page a module adds (#1774): a lowercase letter, then lowercase
  * letters and digits, and not a word the dashboard keeps. Whichever module claims the segment gets
@@ -13,7 +20,7 @@ export declare const SETTINGS_SEGMENT = "settings";
  * that adds it.
  */
 export declare function isPageSegment(segment: string): boolean;
-/** Each registered project's address, and the project an address or an id names. */
+/** Each registered project's address, and the project an address or an id names; the sessions with no project's too ({@link SESSIONS_ID}). */
 export interface ProjectAddresses {
     /** The project's address: its name, or its id where the name cannot be one. An unknown id is its own address. */
     addressOf(projectId: string): string;

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

@@ -59,7 +59,7 @@ export interface RunHooksOptions {
  * goes there. Never throws.
  */
 export declare function runProjectHooks(cwd: string, kind: HookKind, opts?: RunHooksOptions): Promise<void>;
-/** What a `start` line is given: the prompt, and the coding agent, model, publish level branch to start from and pull request's branch when the person picked them. */
+/** What a `start` line is given: the prompt, and the coding agent, model, publish level, branch to start from, pull request's branch and repos when the person picked them. */
 export interface StartHookInput {
     prompt: string;
     driver?: string;
@@ -72,6 +72,16 @@ export interface StartHookInput {
     base?: string;
     /** The branch the run's pull request goes into; the repository's default branch when absent. */
     prBase?: string;
+    /** The folders of the repos a session with no project has as context: one per line in `REPOS`. */
+    repos?: readonly string[];
+    /** The account at the git host the session works as, by its login: in the environment, as `nameRun` is, so no line has to carry it. */
+    account?: string;
+    /** The agent the session is on, by its id: in the environment the same way. */
+    agent?: string;
+    /** The session's picks of skills, in the environment the same way: names on top of its agent's, names of its agent's left out, and which of the project's own stay (`none`, or names). */
+    skillsOn?: readonly string[];
+    skillsOff?: readonly string[];
+    projectSkills?: 'none' | readonly string[];
     /**
      * Whether the run is given a short name by a small model (the person's setting). `false` reaches
      * the run's own tool through the environment rather than the line, so no project's `hooks.yml`
@@ -112,7 +122,7 @@ export type RunHookResult = {
 };
 /**
  * Run the project's `start` line: the prompt in `PROMPT`, the picks in `DRIVER`, `MODEL`, `EFFORT`,
- * `PUBLISH`, `BASE` and `PR_BASE` when made. The line answers one JSON document on stdout whose `id` names the
+ * `PUBLISH`, `BASE`, `PR_BASE` and `REPOS` (one folder per line) when made. The line answers one JSON document on stdout whose `id` names the
  * run it started, and whose `driver` may name the coding agent that runs it.
  */
 export declare function runStartHook(cwd: string, input: StartHookInput, opts?: Omit<RunHooksOptions, 'log'>): Promise<RunHookResult>;

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

@@ -65,6 +65,12 @@ input?: string): Promise<ModuleCommandResult>;
  * by name.
  */
 export declare function readProjectModules(root: string): Promise<ProjectModule[]>;
+/**
+ * The modules whose pages and cards the project shows: {@link readProjectModules}, less the logs
+ * package's where the project did not pick its skill (`built-in.ts`). The others' commands still
+ * run there.
+ */
+export declare function readProjectPages(root: string): Promise<ProjectModule[]>;
 /** The one module of this project that `name` names, or undefined. */
 export declare function findProjectModule(root: string, name: string): Promise<ProjectModule | undefined>;
 /**

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

@@ -1,9 +1,8 @@
 /**
- * The skills a project can pick on the dashboard's Skills page (#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 its command names): they come with every run, with nothing written in the
- * project.
+ * The skills a project can pick on the dashboard's Skills page (#2023), in its groups. None is
+ * ticked the first time: the person picks what the project needs. The skills every run gets by
+ * default are not here (the branches skill, and the ones its command 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.
@@ -11,8 +10,6 @@
 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. */
@@ -20,8 +17,8 @@ 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.
+ * it takes them out. 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. */

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

@@ -149,6 +149,11 @@ export interface Preferences {
      * listed starts from its main branch**, so the default stores nothing.
      */
     startFrom?: Record<string, StartFromPick>;
+    /**
+     * The agent a run started from the launcher is on, by its id (`~/.openagent/agents/<id>.json`).
+     * The launcher's "Agent" pick writes it. **Absent = the default agent.**
+     */
+    agent?: string;
     /**
      * Where a run started from the launcher goes: a saved machine, by its id. The "Run on" pick
      * writes it, and the page picks it again at its next opening. **Absent = this machine.** A
@@ -240,6 +245,8 @@ export interface Registry {
     name?: string;
     /** The computers the person removed, the newest last (computers-sync.ts). */
     forgotten?: ForgottenMachine[];
+    /** The folders the person added to look for repos in, besides the home folder (dashboard/repos.ts), absolute. */
+    repoFolders?: string[];
 }
 /** A read/write handle for the user preferences, wired into the dashboard's context by the daemon. */
 export interface PreferencesStore {
@@ -320,6 +327,12 @@ export declare function addProject(path: string, addedAt: string, fs?: RegistryF
  * a project whose folder is gone is removed like any other.
  */
 export declare function removeProject(id: string, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<ProjectRecord | undefined>;
+/** The folders the person added to look for repos in (dashboard/repos.ts). Forgiving, like {@link listProjects}. */
+export declare function listRepoFolders(fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<string[]>;
+/** Add a folder to look for repos in, by its absolute path; one already there is not added again. */
+export declare function addRepoFolder(folder: string, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<void>;
+/** Stop looking for repos in a folder the person added; one not there changes nothing. */
+export declare function removeRepoFolder(folder: string, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<void>;
 /** The user's dashboard preferences (#410), or `{}` when none are stored. */
 export declare function readPreferences(fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<Preferences>;
 /** Persist the dashboard preferences (#410), sanitized, preserving the project list. */