@openagt/dashboard 0.0.0-stage → 0.8.0

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

@@ -0,0 +1,99 @@
+import type { LinkedPr } from './pull-requests.js';
+/** The outcome of removing a retained worktree (#737). */
+export type RemoveWorktreeResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/** The outcome of deleting a session — its records and worktree (#1032). */
+export type DeleteAgentResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/** The outcome of an add-project attempt (#396): registered, or was already, or why not. */
+export type AddProjectResult = {
+    ok: true;
+    alreadyActivated: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * What the Onboarding checklist (#958) needs and no other read carries: the server's own
+ * working directory, offered as the one-click first project.
+ *
+ * Both fields are null where adding projects is not wired (the relay), so a public host
+ * never discloses its filesystem layout.
+ */
+export interface OnboardingSuggestion {
+    /** The server's working directory, or null when it cannot be offered. */
+    cwd: string | null;
+    /** The project id for {@link cwd} when it is already registered, else null. */
+    cwdProjectId: string | null;
+}
+/**
+ * What a Start carries besides its prompt (#1774): the person's picks, handed to the project's
+ * `start` hook line as `DRIVER` and `MODEL`. Absent leaves each to the tool the line names.
+ */
+export interface StartAgentOptions {
+    /** The model to run on. */
+    model?: string;
+    /** Which coding agent the run is on: `claude-code` or `codex`. */
+    driver?: string;
+    /**
+     * The follow-up's prompt: once the run ends done with a pull request, a fresh agent works its
+     * branch from it before the request merges. The launcher's "Post-merge cleanup" box.
+     */
+    then?: string;
+    /**
+     * Run this session on a connected device (#1067): the local daemon relays the start to the remote
+     * daemon at `url` (authenticating with `token` as the `fw_daemon` cookie) and streams its events
+     * back into the local agent view. The device `label` rides along (memory-only, like `url`/`token`) so
+     * the local session list + notice can show which device the agent is on after a reload (#1077).
+     * Memory-only relay config the dashboard sets at submit time from a saved device. NEVER persisted to
+     * Preferences or the registry: a device token is a per-browser secret. Absent = run locally.
+     * Stripped before the start is forwarded, so the remote starts an ordinary local run and does not
+     * relay onward.
+     */
+    remote?: {
+        url: string;
+        token: string;
+        label?: string;
+    };
+}
+/** The outcome of a Start attempt (#345): the id of the run the project's start hook began, or why there is none. */
+export type StartAgentResult = {
+    ok: true;
+    agentId: string;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Where a session is working (#798): its checkout, its branch, and what it is holding. Read by
+ * the dashboard so a session's action bar can say which worktree it has, rather than leaving the
+ * user to infer it from an agent id.
+ *
+ * Only what is true of the run: once its checkout is gone there is no tree to be clean or dirty,
+ * so {@link checkout} is absent and the branch is the one the run recorded.
+ */
+export interface AgentWorktree {
+    /** The run's own checkout while it exists. */
+    checkout?: {
+        /** Absolute path of the checkout. */
+        path: string;
+        /** Uncommitted changes present in it. */
+        dirty: boolean;
+        /** Size on disk, bytes. Only read once nothing is writing to it, and best-effort even then. */
+        sizeBytes?: number;
+    };
+    /** The branch the run's work is on: its checkout's while it has one, else the one it recorded. */
+    branch?: string;
+    /** The PR opened for this run's branch (#809), when there is one. */
+    pr?: LinkedPr;
+    /** The PR is not known yet, rather than absent (#1028): the lookup is still running. */
+    prPending?: boolean;
+}

package/dist/widget-types/src/dashboard/widget-serve.d.ts

@@ -0,0 +1,14 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type ProjectsProvider } from './projects.js';
+import { type ProjectWidget } from '../project-widgets.js';
+/** Where widget files are served: `/_widgets/<project id>/<package>/<file>`, each segment encoded. */
+export declare const WIDGETS_PREFIX = "/_widgets";
+/** The URL a widget's module is served at from one project. */
+export declare function widgetUrl(projectId: string, widget: Pick<ProjectWidget, 'package' | 'entry'>): string;
+/**
+ * Serve one widget file (#1774): the project must be registered, the package must be a widget of
+ * that project, and the file must sit inside the widget module's own directory. Anything else is a
+ * 404, never a fallback: a widget URL is asked for by the dashboard's loader, not typed by a person.
+ * Served as `no-cache`, since a widget is rebuilt in place under the same name.
+ */
+export declare function serveWidgetFile(req: IncomingMessage, res: ServerResponse, pathname: string, projects?: ProjectsProvider): Promise<void>;

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

@@ -0,0 +1,53 @@
+import { type ProjectsProvider } from '../dashboard/projects.js';
+import type { DashboardContext, EventsSource, RemoteAgents } from '../dashboard/rpc-serve.js';
+import type { PreferencesStore } from '../registry.js';
+import type { QuotaSource } from '../dashboard/quota.js';
+import type { ModelsSource } from '../dashboard/models.js';
+import type { ProjectErrorsReader } from '../project-errors.js';
+import type { BridgeBrowserOwner } from '../bridge-browser.js';
+/** Wire the dashboard's capabilities. The daemon calls this once at start-up; a test calls it per case. */
+export declare function setDashboardContext(context: DashboardContext): void;
+/** The projects every RPC resolves a project id against: the global registry. */
+export declare function contextProjects(): ProjectsProvider;
+/** The workspace path for a project id, or undefined when no project has that id. */
+export declare function resolveProjectPath(projectId: string): Promise<string | undefined>;
+/**
+ * The checkout a call should act on: a live agent's own worktree when `agentId` names one (#738/#749),
+ * else the project root. Since #736 an agent reads and writes inside its worktree — its event log,
+ * its control log, its working tree — so anything addressed at a *run* has to resolve here, not
+ * at the project path, or it reads an empty log and steers an agent that is not listening. The
+ * resolution itself (and its #766 first-seconds subtlety) lives in the store's
+ * {@link resolveAgentCheckout}, shared with the daemon; this adds only the project-id lookup.
+ */
+export declare function resolveAgentPath(projectId: string, agentId?: string): Promise<string | undefined>;
+/**
+ * The in-memory {@link EventsSource} (#426). It answers only for a run this daemon is relaying
+ * from a connected device (#1067) — such a run has no diary on this machine, since it works in a
+ * checkout over there — and returns undefined for an ordinary local run, whose diary `onEvents`
+ * tails off disk.
+ */
+export declare function contextEventsSource(): EventsSource;
+/**
+ * The relayed-agent lookup (#1067 slice 2). A run-scoped RPC uses it to tell an ordinary local agent
+ * (resolve a local checkout) from one running on a connected device (forward the call there).
+ *
+ * The one accessor with a default rather than a throw, because "unwired" has a real meaning here:
+ * a call arriving over `/_relay/rpc` is the *device* side of the relay, and the agent it names is
+ * local to that device. Forwarding it onward would be a loop, so the honest answer there is that
+ * nothing is relayed from here.
+ */
+export declare function contextRemote(): RemoteAgents;
+/** The user-preferences store (#410), over the registry file. */
+export declare function contextPreferences(): PreferencesStore;
+/** The quota source behind the usage panel (#533). */
+export declare function contextQuota(): QuotaSource;
+/** Which models each coding agent offers. */
+export declare function contextModels(): ModelsSource;
+/** What a project currently suffers from (#1500), as the daemon's background jobs last recorded it. */
+export declare function contextProjectErrors(): ProjectErrorsReader;
+/** The daemon's own bridge browser (#1332). */
+export declare function contextBridgeBrowser(): BridgeBrowserOwner;
+/** The daemon's own `startAgent`, so a start from the dashboard is the same start the CLI makes. */
+export declare function contextStartAgent(): DashboardContext['startAgent'];
+/** Install + register a repo (#433), which only the daemon can do. */
+export declare function contextAddProject(): DashboardContext['addProject'];

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

@@ -0,0 +1,108 @@
+import { type SteerResult } from '../dashboard/run-inbox.js';
+export type { SteerResult };
+import { type OpenTarget, type OpenResult } from '../dashboard/open-in-app.js';
+import type { BridgeBrowserAction } from '../bridge-browser.js';
+import { type HandoffResult } from '../dashboard/agent-handoff.js';
+import type { DeleteAgentResult, RemoveWorktreeResult, StartAgentOptions, StartAgentResult } from '../dashboard/types.js';
+/**
+ * The key every action on one run locks under (`agent-locks.ts`): a Remove, a Delete and an Open
+ * PR on the same run each run their own git; serialized, whichever runs second finds the state
+ * the first one left and acts on that. The project and the run's id, not the checkout's path:
+ * the path is the branches provider's to know, and an Open PR on a run whose checkout is gone
+ * still locks the run.
+ */
+export declare function agentLockKey(cwd: string, agentId: string): string;
+/**
+ * Stop a live agent (the Stop button): SIGINT to the process the run's own card names, when it is
+ * this machine's and alive. The card is the file the dashboard shows the run from, and its pid is
+ * whoever runs the agent; the framework names no tool. Nothing else: a run without a live pid
+ * here has nothing to stop.
+ */
+export declare function sendStop(projectId: string, agentId?: string): Promise<void>;
+/**
+ * Answer the question a run stopped on (#304, #1774). `pick` is one option id, or the chosen
+ * subset of a multi-select; the answer handed to the run is the chosen labels, read off the
+ * question as the run's own diary holds it, so only what the agent offered can be answered.
+ */
+export declare function sendChoice(projectId: string, id: string, pick: string | string[], agentId?: string): Promise<SteerResult>;
+/**
+ * Queue the user's pick for the question a Claude web session is parked on (#1237).
+ *
+ * Not a line for a run like {@link sendChoice}: a cloud agent has no run here to hand it to, so
+ * the pick goes to the bridge store, where the browser extension collects it, types
+ * it into the session's composer and submits. Only labels of the currently parked question are
+ * accepted — one, or a multi-select's subset — and the daemon composes the text typed from them,
+ * so this can never put arbitrary text in front of another product's agent. Local only, no
+ * relay: the bridge lives on the daemon the extension talks to.
+ */
+export declare function sendBridgeAnswer(sessionId: string, labels: string[]): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+/** Withdraw a queued bridge answer (#1237). A no-op once the extension has delivered it. */
+export declare function sendBridgeAnswerCancel(sessionId: string): Promise<void>;
+/**
+ * Say something to a run (#714, #1774): the person's own words, the next prompt of the same
+ * conversation. A run that is working takes them when its turn ends; an ended run is resumed
+ * with them. Empty messages are dropped.
+ */
+export declare function sendMessage(projectId: string, text: string, agentId?: string): Promise<SteerResult>;
+/**
+ * Remove a retained worktree (#737). An agent that failed or was stopped keeps its checkout so you
+ * can inspect it; this is the explicit cleanup for one, since nothing removes them on a timer.
+ *
+ * The checks and the removal are {@link removeProjectWorktree}'s, shared with the CLI's removal
+ * path (#982) so the surfaces cannot drift again; this adds only the agent lock around them.
+ */
+export declare function sendRemoveWorktree(projectId: string, agentId: string): Promise<RemoveWorktreeResult>;
+/**
+ * Delete a session (#1032): remove it from the dashboard, records and all — the sibling of
+ * {@link sendRemoveWorktree}, and the one destructive-of-history action, so its surface confirms
+ * first. The checks, the worktree removal and what it leaves behind (the branch and its
+ * commits) are all {@link deleteProjectAgent}'s; this adds only the agent lock around them.
+ */
+export declare function sendDeleteAgent(projectId: string, agentId: string): Promise<DeleteAgentResult>;
+/**
+ * Start a run in the project (#405, #1774): the project's own `start` hook line, reached through
+ * the daemon's wired `startAgent` (which relays to a connected device when the options name
+ * one). Answers the id of the run the hook began, or why there is none: a project without the
+ * line cannot start a run from here.
+ */
+export declare function sendStart(projectId: string, prompt: string, options?: StartAgentOptions): Promise<StartAgentResult>;
+/**
+ * Open a project in the OS file manager or an editor (#490). Localhost-only: the daemon
+ * spawns a local command against the project's own registered path. A public host has no
+ * local path to resolve, so it returns an error rather than spawning anything.
+ *
+ * With a `agentId` it opens that session's own checkout instead (#798) — the whole point of
+ * opening it is to look at what the agent is doing, which is not in the project's tree.
+ */
+export declare function sendOpenInApp(projectId: string, target: OpenTarget, agentId?: string): Promise<OpenResult>;
+/**
+ * Open a PR for a finished session's branch (#799): the project's branches provider pushes it
+ * first if the remote lacks it (#1774).
+ *
+ * The title and body come from what the agent already recorded: the branch the agent named its
+ * work with and the intent the user asked for. Nothing new is invented and nothing extra is asked
+ * of the user, which is the point of "offer the next step rather than describe it".
+ */
+export declare function sendOpenPullRequest(projectId: string, agentId: string): Promise<HandoffResult>;
+/**
+ * The user's Push action (#1820): push a finished run's branch, the last step where the project has
+ * no git host package. Under the agent lock, as Open PR is, so the push cannot race a Remove.
+ */
+export declare function sendPush(projectId: string, agentId: string): Promise<HandoffResult>;
+/**
+ * The user's Merge action (#1391): merge a finished run's open pull request, directly. A run
+ * that is still working has no Merge: its agent publishes its own work, and the button comes
+ * with the ended view.
+ */
+export declare function sendMerge(projectId: string, agentId: string): Promise<HandoffResult>;
+/**
+ * Ask the daemon's bridge browser to show its window (for the one-time sign-in), hide it again,
+ * or restart (#1332). Anything else is refused; a browser that is not running ignores show/hide.
+ */
+export declare function sendBridgeBrowser(action: BridgeBrowserAction): Promise<{
+    ok: boolean;
+    error?: string;
+}>;

package/dist/widget-types/src/dashboard-rpc/devices.d.ts

@@ -0,0 +1,8 @@
+/** One device to health-check: its profile id plus the origin and token to reach it with. */
+export interface DeviceCheck {
+    id: string;
+    url: string;
+    token: string;
+}
+/** Ping each saved device and map its id to whether it answered (#1072). Bad entries are dropped. */
+export declare function checkDevices(devices: DeviceCheck[]): Promise<Record<string, boolean>>;

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

@@ -0,0 +1,53 @@
+/**
+ * Tail a JSONL log: read what is already in it, then follow appends. Each complete line is
+ * parsed and handed to `onEvent`; malformed lines are skipped. Returns a stop function that
+ * removes the watcher and the poll.
+ *
+ * The reading is {@link JsonlTailer} and the following is {@link followFile}. This used to be
+ * its own copy of both, which is how it ended up missing the tailer's same-length-rewrite
+ * detection (#567).
+ *
+ * `onReplayed` is told once the first pull — the replay of everything already logged — has
+ * been delivered (#1383). That boundary is what lets a reconnecting client buffer the replay
+ * and swap its feed atomically instead of blanking while history re-streams. The follower
+ * only starts after it, so no appended line can slip in ahead of the marker. Best-effort on
+ * a failed first read: the marker still fires (the poll retries the read), because a client
+ * waiting on it forever would freeze its feed.
+ *
+ * Kept transport-agnostic (a plain `onEvent` callback, not a stream) so the file
+ * side can be driven on its own; `events.ts` wires it to the SSE endpoint.
+ */
+export declare function tailEvents<T = unknown>(path: string, onEvent: (event: T) => void, onReplayed?: () => void): () => void;
+/** Where a relocating tail reads now: a file it follows, a finished run's lines, whole, or nowhere yet (`pending`: ask again shortly). */
+export type TailTarget<T> = {
+    file: string;
+} | {
+    finished: T[];
+} | {
+    pending: true;
+};
+/**
+ * Tail a run's diary across its relocations: the same read-then-follow as {@link tailEvents},
+ * but where the diary is is asked again whenever the tailed file is not there.
+ *
+ * A run's diary does not sit still. While the run works it is a file in the run's checkout; when
+ * the run ends its tool records it and reclaims the checkout, and from then on the diary is the
+ * finished run's, read whole from the project's runs provider. A fixed-path tail whose file was
+ * retired went silent *without the final lines* whenever the last `fs.watch` signal was lost —
+ * the 1s poll then found the file gone and had nothing to read, so the feed never learned the run
+ * ended. This tail treats a missing file as the question it is: it asks `resolve` where the diary
+ * is now (`resolveAgentDiary` answers the finished run once the checkout is gone, #1472). A new
+ * file retargets the same tailer and follows it. A finished run's lines are the same lines the
+ * file had, in the same order, so the ones past the count already delivered are sent and the tail
+ * ends: a finished diary does not grow. The same file, or no answer, means the diary has not
+ * moved, and the tail keeps waiting where it is. A diary that is nowhere yet (`pending`: the run
+ * was started a moment ago and its tool has not made the checkout) is asked for again on the
+ * same cadence until it has a home, and only then followed; the replay boundary is reported at
+ * once, since there is nothing to replay. Asking even when the file was never seen matters for a
+ * short run (#1774): started, ended and reclaimed between two polls, its diary was only ever
+ * visible as a finished run.
+ *
+ * `onReplayed` keeps {@link tailEvents}' once-per-subscription contract: a relocation is not a
+ * new replay boundary, so it never fires twice.
+ */
+export declare function tailAgentEvents<T = unknown>(resolve: () => Promise<TailTarget<T> | undefined>, onEvent: (event: T) => void, onReplayed?: () => void): () => void;

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

@@ -0,0 +1,29 @@
+import type { FrameworkEvent } from '../events.js';
+/**
+ * The end-of-replay marker (#1383). A subscribe replays the whole log before following live,
+ * and without a boundary a reconnecting client cannot tell "replay still streaming" from "the
+ * log is genuinely this short" — so it blanked a populated feed and refilled it line by line.
+ * Sent once per subscription, after the on-disk replay is delivered. Wire-only: it is not a
+ * {@link FrameworkEvent}, is never written to any journal, and the client swallows it.
+ */
+export type StreamSync = {
+    kind: 'stream-sync';
+};
+/** What `onEvents` streams: the agent's events, plus the wire-only end-of-replay marker. */
+export type LiveFeedEvent = FrameworkEvent | StreamSync;
+/**
+ * Follow one agent's events: `send` is called per event until the returned stop function runs.
+ * Returns undefined when there is nothing to stream (an unknown project), which the mount ends as
+ * a clean close — mirroring the read model's empty results rather than throwing at the client.
+ *
+ * The `agentId` names the run whose diary is followed; without one there is nothing to stream.
+ *
+ * Two sources, chosen by what is wired. An in-memory stream wins: an agent the daemon is relaying
+ * from a device (#1067). Otherwise the on-disk log. The daemon's source answers only for relayed
+ * runs, so an ordinary local agent falls through to tailing the log.
+ *
+ * Only the on-disk tail sends the {@link StreamSync} marker: the in-memory sources have no replay
+ * boundary to report, so a reconnecting client falls back to a grace deadline before swapping its
+ * feed (see use-live-events in the dashboard).
+ */
+export declare function streamAgentEvents(projectId: string, agentId: string | undefined, send: (value: LiveFeedEvent) => void, onDone?: () => void): Promise<(() => void) | undefined>;

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

@@ -0,0 +1,28 @@
+export { onAgents, onAgent, onDocs, onQueue, onOverview, onRecentAgents, onInterventions, onOpenQuestions, onActivity, onDashboard, onGitHostHome, onGitStatus, onProjectFiles, onProjectFileStatus, onAgentTree, onFileDiff, onAgentChanges, onFileContent, 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, sendMerge } from './control.js';
+export { streamAgentEvents, type LiveFeedEvent, type StreamSync } from './events.js';
+export { onProjects, sendAddProject, sendPickProjectDirectory, onOnboarding, onCommands, onStartCheck, sendScheduleSwitch, 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';
+export { onModels } from './models.js';
+export { checkDevices, type DeviceCheck } from './devices.js';
+export { onWidgets, runWidgetCommand, type DashboardWidget, type WidgetCommandResult } from './widgets.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;
+/**
+ * Every RPC the mount will answer, by name.
+ *
+ * Built from the modules' own exports rather than listed by hand, so a function that is exported
+ * and simply never registered — the failure that shipped per-project preferences broken (#866),
+ * a 400 and nothing else — cannot happen: the name IS the export name.
+ *
+ * Null-prototype, because the name is a path segment off an unauthenticated request and this table
+ * is indexed by it directly. With `Object.prototype` behind it, `POST /_rpc/constructor` found
+ * `Object` and answered 200 with whatever it was handed, and `__proto__` / `toString` / `valueOf`
+ * were reachable too — 500s rather than the 404 a name that is not an RPC has to get.
+ */
+export declare const RPC_HANDLERS: Record<string, RpcHandler>;
+/** The live event stream, which is a subscription rather than a call — see `rpc-serve.ts`. */
+export declare const RPC_EVENT_STREAM: typeof streamAgentEvents;

package/dist/widget-types/src/dashboard-rpc/models.d.ts

@@ -0,0 +1,3 @@
+import type { ModelsView } from '../dashboard/models.js';
+/** Which models each coding agent offers, or why one could not say. */
+export declare function onModels(): Promise<ModelsView>;

package/dist/widget-types/src/dashboard-rpc/preferences.d.ts

@@ -0,0 +1,40 @@
+import { type EditorInfo } from '../dashboard/open-in-app.js';
+import type { CustomPreset, Preferences } from '../registry.js';
+/** The outcome of a {@link savePreferences} write. */
+export type SavePreferencesResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/** The user's stored dashboard preferences, or `{}` when the read fails. */
+export declare function onPreferences(): Promise<Preferences>;
+/** Persist the dashboard preferences (sanitized in the store). */
+export declare function savePreferences(preferences: Preferences): Promise<SavePreferencesResult>;
+/** The outcome of a patch write (#1148): the stored result, so the caller can adopt it. */
+export type PatchPreferencesResult<T> = {
+    ok: true;
+    preferences: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Merge the keys the caller changed into the stored preferences (#1148), and hand back what is
+ * now stored. The write half of the fix for a stale tab reverting settings it never touched:
+ * {@link savePreferences} replaces the whole block, so a client's snapshot overwrote whatever
+ * anyone else had changed since it loaded. Returning the merged result also lets the caller
+ * adopt the truth it just wrote against, so a tab converges instead of staying stale.
+ */
+export declare function patchPreferences(patch: Preferences): Promise<PatchPreferencesResult<Preferences>>;
+/**
+ * A project's shared custom presets (#1025), committed into its `.the-framework/` so they travel
+ * with the repo — the team-shared counterpart to the user-tier {@link onPreferences} presets. Read
+ * from the project's own checkout, so this resolves the project id to its workspace path rather than
+ * touching the home registry. `[]` for an unknown project.
+ */
+export declare function onProjectPresets(projectId: string): Promise<CustomPreset[]>;
+/** Persist a project's shared custom presets into its `.the-framework/` (#1025). */
+export declare function saveProjectPresets(projectId: string, presets: CustomPreset[]): Promise<SavePreferencesResult>;
+/** The editors installed on this server (#727), for the "Preferred editor" picker. */
+export declare function onEditors(): Promise<EditorInfo[]>;

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

@@ -0,0 +1,54 @@
+import { type ProjectCommand } from '../project-commands.js';
+import { type StartReadiness } from '../project-hooks.js';
+import { type PickDirectoryResult } from '../pick-directory.js';
+import type { ProjectSummary } from '../dashboard/projects.js';
+import type { AddProjectResult, OnboardingSuggestion } from '../dashboard/types.js';
+export declare function onProjects(): Promise<ProjectSummary[]>;
+/**
+ * Add a project from the dashboard (#396/#433): install the repo and register it so it joins the
+ * 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}.
+ */
+export declare function sendAddProject(path: string): Promise<AddProjectResult>;
+/**
+ * Open the OS folder picker on the daemon's machine and wait for the user's choice (#1150). The
+ * browser cannot learn an absolute path from any picker of its own, and the daemon — which runs on
+ * the machine the user is sitting at — can, so the dialog is the daemon's. A dismissed dialog
+ * comes back as `path: null`.
+ */
+export declare function sendPickProjectDirectory(): Promise<PickDirectoryResult>;
+/**
+ * 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.
+ */
+export declare function onOnboarding(): Promise<OnboardingSuggestion>;
+/** What the launcher offers for a project: its commands, and whether a run can be started here at all. */
+export interface ProjectLauncher {
+    commands: ProjectCommand[];
+    /** Whether the project's `.the-framework/hooks.yml` has a `start` line; without one Start is off. */
+    startHook: boolean;
+}
+/**
+ * The project's commands (#1774), read off its skills folders, and whether it has a start hook.
+ * `null` when the project is unknown here.
+ */
+export declare function onCommands(projectId: string): Promise<ProjectLauncher | null>;
+/**
+ * What would stop a run in this project before it spends a checkout, said in the launcher before
+ * the Start: the project's `check` hook, given the coding agent picked. A missing CLI or a
+ * logged-out one is a problem the run itself would refuse on; a warning is said and blocks nothing.
+ * A check line that fails is said as a warning: it is a broken check, not a reason to stop.
+ * `null` for an unknown project or one without a check hook: nothing to say.
+ */
+export declare function onStartCheck(projectId: string, driver?: string): Promise<StartReadiness | null>;
+/**
+ * Switch one scheduled command on or off on this machine: the project's `switch` hook line. The
+ * daemon names no tool; the scheduler card reads the switch back from the scheduler's state.
+ */
+export declare function sendScheduleSwitch(projectId: string, command: string, on: boolean): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/widget-types/src/dashboard-rpc/quota.d.ts

@@ -0,0 +1,26 @@
+import type { QuotaView } from '../dashboard/quota.js';
+import { runOffsetHook } from '../project-hooks.js';
+import type { ProjectSummary } from '../dashboard/projects.js';
+/** Where the account's quota stands against its boundary. */
+export declare function onQuota(): Promise<QuotaView>;
+/**
+ * Set how far past the quota boundary unattended work may go (#960): every registered project's
+ * `offset` hook line, with the points in `POINTS`. The daemon names no tool: the line is the
+ * project's, and what it writes is what the panel reads back.
+ */
+export declare function sendSpendOffset(points: number): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/**
+ * The write behind {@link sendSpendOffset}, over the projects given. A project without the line is
+ * skipped; none having it, or a line that fails, is the answer's error, each failing project named.
+ */
+export declare function setSpendOffset(projects: readonly ProjectSummary[], points: number, run?: typeof runOffsetHook): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;