@openagt/dashboard 0.8.0 → 0.10.0

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

@@ -1,28 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-/**
- * The plumbing every one of the daemon's non-RPC HTTP surfaces shares: the browser bridge
- * (`/_bridge`), the web-start queue (`/_web-start`) and the device relay (`/_relay`).
- *
- * All three answer plain-text statuses, JSON payloads, and read capped JSON request bodies, and
- * each carried its own copy — two body readers that differed only in which message they rejected
- * with, and three identical status responders.
- */
-/** Answer with a plain-text status line. */
-export declare function end(res: ServerResponse, status: number, message: string, headers?: Record<string, string>): void;
-/** Answer with a JSON payload. */
-export declare function sendJson(res: ServerResponse, payload: unknown, status?: number): void;
-/**
- * Read a JSON body, refusing anything past the cap rather than buffering it. Rejects with
- * `body too large` on overflow and `body must be JSON` on anything unparseable — the messages the
- * bridge and web-start routes answer 400 with, so a caller learns which of the two it hit.
- */
-export declare function readJsonBody(req: IncomingMessage, maxBytes: number): Promise<unknown>;
-/**
- * The preamble every POST route runs: refuse a non-POST, then read the body. Answers the request
- * itself on either failure and resolves `undefined`, so a caller's whole check is
- * `const body = await readPost(...); if (body === undefined) return`. JSON has no `undefined`, so
- * the sentinel cannot collide with a body that parsed.
- */
-export declare function readPost(req: IncomingMessage, res: ServerResponse, maxBytes: number): Promise<unknown>;
-/** Refuse anything but a GET, answering 405 itself. `false` means the request is already answered. */
-export declare function requireGet(req: IncomingMessage, res: ServerResponse): boolean;

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

@@ -1,66 +0,0 @@
-import { type LiveAgent, type AgentMeta } from '../store/index.js';
-import type { FrameworkEvent } from '../events.js';
-import type { ProjectSummary, ProjectionRead } from './projects.js';
-import { type BranchesFor } from '../store/branches.js';
-import { type PrLister } from './pull-requests.js';
-export { interventionKey } from './keys.js';
-/**
- * One item awaiting the human. Two kinds: an open `pr` to review/merge or close, and an
- * `awaiting` run paused on a choice gate. The card and the browser hook both iterate the flat
- * list, branching on `kind` for the fields that differ.
- */
-export interface Intervention {
-    projectId: string;
-    projectName: string;
-    /**
-     * `pr` = an open PR to review/merge or close; `awaiting` = a run waiting on the question it ended on (#636/#1774);
-     * `unpushed` = a finished agent whose branch has commits that were never pushed (#860).
-     */
-    kind: 'pr' | 'awaiting' | 'unpushed';
-    title: string;
-    /** The PR on the git host (`pr` only): where a click takes the user. */
-    url?: string;
-    /** The PR number (`pr` only). */
-    number?: number;
-    /** The question's id (`awaiting` only) — its stable identity, so it notifies exactly once. */
-    awaitId?: string;
-    /** Which run this is about (`awaiting` #738 / `unpushed`): a project has several agents. */
-    agentId?: string;
-    /** The branch the work is sitting on (`unpushed` only). */
-    branch?: string;
-    /** How many commits are waiting (`unpushed` only). */
-    commits?: number;
-    /** When the PR was opened (`pr`) or the agent last updated (the other two), ISO, for ordering. */
-    createdAt?: string;
-}
-/** Injectable seam so {@link buildInterventions} is unit-testable off disk. */
-export interface InterventionsDeps {
-    prs?: PrLister;
-    /** The reader of the runs that have a checkout (default {@link readLiveMetas}): a waiting run keeps its own; drives the `awaiting` source (#636). */
-    liveAgents?: (cwd: string) => Promise<LiveAgent[]>;
-    /** One run's events, by the project's path and the run's id (default {@link loadAgentEvents}): where a waiting run's question is read. */
-    events?: (cwd: string, agentId: string) => Promise<FrameworkEvent[] | undefined>;
-    /** The finished-agent reader (default {@link listAgents}); drives the `unpushed` source (#860). */
-    agents?: (cwd: string) => Promise<AgentMeta[]>;
-    /** The project's checkouts and branches (default the project's provider, {@link projectBranches}): where a branch's state is read; drives the `unpushed` source (#860). */
-    branches?: BranchesFor;
-    /**
-     * How many of a project's most recent finished agents to inspect for unpushed work. Each one costs
-     * a handful of git reads, and this runs on a poll, so old history is not re-walked every minute:
-     * work that has sat unpushed for dozens of agents is not news, and the agent list stays the record.
-     */
-    handoffLimit?: number;
-}
-/**
- * Build the cross-project interventions queue: every registered project's open PRs, plus any run
- * currently paused on a choice gate (#636), newest first. Forgiving — a project with no remote
- * (or an unreadable one) simply contributes nothing. Hand-opened draft PRs are excluded: they are
- * not yet asking for review. A draft on an agent's branch is not (#1102): an agent publishes a
- * draft when a person should look first, and cloud work adoption opens its PRs as drafts.
- *
- * Which projects were read whole comes back alongside the items (#1623): forgiveness here is what
- * lets one unreachable project keep the queue useful, and it is also what would let that project's
- * whole backlog announce itself as new the moment it came back. The queue's panels ignore this;
- * the notification watcher is the caller that cannot.
- */
-export declare function buildInterventions(projects: ProjectSummary[], deps?: InterventionsDeps): Promise<ProjectionRead<Intervention>>;

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

@@ -1,30 +0,0 @@
-import type { Activity } from './activity.js';
-import type { Intervention } from './interventions.js';
-/**
- * The stable identity of a watched item, which the browser notifications dedupe on.
- *
- * A leaf module on purpose: `activity.ts` and `interventions.ts` build their items by reading the
- * store, so they import `node:*` and cannot be reached from the browser bundle. These functions
- * are pure and depend on nothing but the item, so they live here and are re-exported from
- * `client.ts` — which is what lets the dashboard share them instead of keeping a copy that could
- * drift from the item types.
- *
- * The type imports are erased at compile time, so they add no edge to the graph `client.test.ts`
- * walks.
- */
-/**
- * The stable identity of an intervention. A PR is its url (survives title edits and re-sorts);
- * the other two have no url and are keyed on the project plus the thing waiting — the agent and
- * the gate it is parked on, or the agent whose branch is unpushed.
- *
- * The agent is part of the awaiting key because a gate id is only unique within its own agent:
- * every agent's first gate is `await-choices`. Two agents running in one project (#736) and both
- * parked would otherwise share one identity, and the dedupe would announce only one of them.
- */
-export declare function interventionKey(item: Intervention): string;
-/**
- * The stable identity of an activity item: its kind + project + run. The kind is part of the key
- * so an agent's `started` and `finished` are two separate announcements (one when it kicks off, one
- * when it lands), each firing exactly once.
- */
-export declare function activityKey(item: Activity): string;

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

@@ -1,24 +0,0 @@
-import type { Driver, DriverModel } from 'agent-driver';
-import { type DriverName } from '../driver-names.js';
-/** What one coding agent offers: its models, or why it could not say. */
-export type DriverModels = {
-    models: DriverModel[];
-} | {
-    models: [];
-    error: string;
-};
-/** The models of every coding agent a person can pick, by driver. */
-export type ModelsView = Record<DriverName, DriverModels>;
-/** Where the dashboard reads which models each coding agent offers. */
-export interface ModelsSource {
-    read(): Promise<ModelsView>;
-}
-/**
- * Ask each coding agent for its models, once: the first read asks, every later read answers from
- * what it said, for the daemon's life. The list changes only with a new CLI version or a new
- * login, and each question starts a CLI, so a menu opened again never waits on one. An agent that
- * could not say is asked again at the next read, so a CLI installed or logged in since is found.
- */
-export declare function cachedModelsSource(drivers: Record<DriverName, Pick<Driver, 'listModels'>>): ModelsSource;
-/** The daemon's own source: the coding agents on this machine, asked as the person's own login. */
-export declare function defaultModelsSource(): ModelsSource;

package/dist/widget-types/src/dashboard/open-in-app.d.ts

@@ -1,42 +0,0 @@
-/** Which app to open the project in. */
-export type OpenTarget = 'files' | 'editor';
-/** A known editor: its launcher CLI plus a human label for the picker (#727). */
-export interface EditorInfo {
-    bin: string;
-    label: string;
-}
-/**
- * The editors the picker can offer (#727), probed by their CLI launcher on PATH. Order is the
- * display order. `$FRAMEWORK_EDITOR` and a hand-typed value stay valid beyond this list; this is
- * only what auto-detection looks for.
- */
-export declare const KNOWN_EDITORS: EditorInfo[];
-/** Whether an editor launcher is installed (on PATH). A seam so detection is unit-testable. */
-export type EditorProbe = (bin: string) => Promise<boolean>;
-/** The installed subset of {@link KNOWN_EDITORS}, in display order (#727). */
-export declare function detectEditors(probe?: EditorProbe): Promise<EditorInfo[]>;
-/** The outcome of an open attempt. */
-export type OpenResult = {
-    ok: true;
-} | {
-    ok: false;
-    error: string;
-};
-/** Spawns a command, resolving once it launches (not on exit) and rejecting if it can't start. */
-export type SpawnRunner = (command: string, args: string[]) => Promise<void>;
-/** The OS command that reveals a path in the file manager. */
-export declare function fileManagerCommand(path: string, os?: NodeJS.Platform): {
-    command: string;
-    args: string[];
-};
-/** The command to open a path in an editor: `$FRAMEWORK_EDITOR` when set, else the VS Code CLI. */
-export declare function editorCommand(path: string, editor?: string | undefined): {
-    command: string;
-    args: string[];
-};
-/**
- * Open the project at `cwd` in the file manager or an editor. Failures are values, never throws.
- * `editor` (#727) is the stored preference; when unset {@link editorCommand} falls back to
- * `$FRAMEWORK_EDITOR`, then `code`.
- */
-export declare function openInApp(cwd: string, target: OpenTarget, agent?: SpawnRunner, editor?: string): Promise<OpenResult>;

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

@@ -1,52 +0,0 @@
-import { type AgentMeta, type LiveAgent } from '../store/index.js';
-import type { ChoiceRequest, FrameworkEvent } from '../events.js';
-import { type BridgeQuestion } from './bridge-question.js';
-import type { ProjectSummary } from './projects.js';
-/** One session's open question: the full gate, answerable from wherever it is rendered. */
-export interface OpenQuestion {
-    projectId: string;
-    projectName: string;
-    agentId: string;
-    /** What the agent was asked to do: the card's label. */
-    intent?: string;
-    /** When the agent last spoke, ISO: what the longest-waiting-first order sorts on. */
-    updatedAt?: string;
-    choice: ChoiceRequest;
-    /**
-     * Asked by a Claude web session and carried here by the browser bridge (#1237/#1554): the pick
-     * goes back through `sendBridgeAnswer` on this session, not through the run's resume hook. The option
-     * ids of {@link choice} are the labels, which is what the extension types.
-     */
-    bridge?: {
-        sessionId: string;
-        url: string;
-    };
-}
-/** Injectable seams so {@link buildOpenQuestions} is unit-testable off disk. */
-export interface OpenQuestionsDeps {
-    /** The reader of the runs that have a checkout (default {@link readLiveMetas}): a waiting run keeps its own. */
-    liveAgents?: (cwd: string) => Promise<LiveAgent[]>;
-    /** One run's events, by the project's path and the run's id (default {@link loadAgentEvents}). */
-    events?: (cwd: string, agentId: string) => Promise<FrameworkEvent[] | undefined>;
-    /**
-     * The questions the browser bridge holds, minus those with an answer already on its way
-     * (default: the daemon's bridge store).
-     */
-    bridged?: () => BridgeQuestion[];
-    /**
-     * Every agent of a project, archived included (default {@link readAllAgents}): a web agent is
-     * `done` at its hand-off (#1231) and its checkout may be long gone, so the live reader alone
-     * would never find the run a bridged question belongs to.
-     */
-    agents?: (cwd: string) => Promise<AgentMeta[]>;
-}
-/**
- * Every project's parked questions, longest-waiting first (#1455): an agent that has been blocked
- * on its human the longest is the one to unblock first.
- *
- * Forgiving throughout, like every cross-project rollup: an unreadable project, agent list or
- * event log contributes nothing rather than failing the read. A waiting run whose diary shows no
- * open question (log unreadable) is skipped — offering an answer the daemon would refuse is
- * worse than one card fewer.
- */
-export declare function buildOpenQuestions(projects: ProjectSummary[], deps?: OpenQuestionsDeps): Promise<OpenQuestion[]>;

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

@@ -1,77 +0,0 @@
-import { type LiveAgent, type AgentMeta, type AgentStatus } from '../store/index.js';
-import type { ProjectSummary } from './projects.js';
-import { type ProjectQueue } from './queue.js';
-/** One project's in-flight run, surfaced in the Overview's "working now" list. */
-export interface ActiveAgent {
-    projectId: string;
-    projectName: string;
-    /** Which run this is (#738): a project can have several in flight, one per worktree. */
-    agentId: string;
-    /** The agent's own checkout, so its git/file status is read from the worktree it edits (#738). */
-    cwd: string;
-    status: AgentStatus;
-    /** What the user asked to build (the agent's `scope` event). */
-    intent?: string;
-    scope?: string;
-    /** ISO timestamp of the agent's last event. */
-    updatedAt?: string;
-    /**
-     * A web run at work on its cloud side (#1668): in its session, or parked on a question the
-     * bridge reported. Its local half is over, so it is not a live agent — it is listed because the
-     * cloud side is the agent, and "no agents working" over a waiting cloud session was a lie.
-     */
-    cloud?: 'in-cloud' | 'waiting';
-    /** The machine whose daemon started it (#1648), only when that is not this one. */
-    host?: string;
-}
-/** One recently active project, most-recent first. */
-export interface RecentProject {
-    projectId: string;
-    projectName: string;
-    lastActivityAt?: string;
-}
-/** The cross-project Overview payload. */
-export interface Overview {
-    /** Projects with a running agent, most-recently-updated first. */
-    active: ActiveAgent[];
-    /** Total open TODO items across every project. */
-    queueOpen: number;
-    /** The most recently active projects (capped). */
-    recent: RecentProject[];
-}
-/** One recent session, tagged with the project it belongs to, for the cross-project rail. */
-export interface RecentAgent {
-    projectId: string;
-    projectName: string;
-    agent: AgentMeta;
-}
-/** Injectable reader so {@link buildRecentAgents} is unit-testable off disk. */
-export interface RecentAgentsDeps {
-    agents?: (cwd: string) => Promise<AgentMeta[]>;
-}
-/**
- * Every project's sessions pooled and sorted newest-first (capped), so the shared sidebar (#shared-
- * shell) can show recents on the home/Overview where no single project is selected. Each row carries
- * the project it belongs to, so selecting it jumps into that project's session. Forgiving — a project
- * whose agents cannot be read simply contributes nothing.
- */
-export declare function buildRecentAgents(projects: ProjectSummary[], deps?: RecentAgentsDeps): Promise<RecentAgent[]>;
-/** Injectable readers so {@link buildOverview} is unit-testable off disk. */
-export interface OverviewDeps {
-    liveAgents?: (cwd: string) => Promise<LiveAgent[]>;
-    queue?: (projects: ProjectSummary[]) => Promise<ProjectQueue[]>;
-    /** Every run of a project, archived included (default {@link readAllAgents}): where the web runs are. */
-    agents?: (cwd: string) => Promise<AgentMeta[]>;
-    /** Whether the bridge holds a question for that cloud session (default: the daemon's bridge store). */
-    waiting?: (sessionId: string) => boolean;
-    now?: () => number;
-    /** This machine's hostname; `node:os` in production. */
-    host?: string;
-}
-/**
- * Build the cross-project Overview: the running agents (every live agent of each project, one per
- * worktree since #736), the total of open queue entries (from {@link collectQueue}), and the most
- * recently active projects (by {@link ProjectSummary.lastActivityAt}). Forgiving — a project
- * with no live run, or none running, simply contributes nothing to `active`.
- */
-export declare function buildOverview(projects: ProjectSummary[], deps?: OverviewDeps): Promise<Overview>;

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

@@ -1,89 +0,0 @@
-import { type ProjectRecord } from '../registry.js';
-import { type AgentMeta } from '../store/index.js';
-import type { ProjectError } from '../project-errors.js';
-/**
- * The multi-project read side (#392): projects the daemon serves come from the registry (#390),
- * and every read resolves a project id to that project's path before running the per-cwd reader
- * underneath. One daemon serves them all, running as many agents per project as their own
- * concurrency allows (#736), each in its own checkout.
- */
-/** One project's summary for the Projects sidebar (#314). */
-export interface ProjectSummary {
-    /** Registry id (stable, URL-safe). */
-    id: string;
-    /** Absolute repo path. */
-    path: string;
-    /** Display name (the path's basename). */
-    name: string;
-    /** True when the repo still has its `.the-framework/` marker. */
-    activated: boolean;
-    /** ISO timestamp of the project's newest activity: its most recent session. */
-    lastActivityAt?: string;
-    /**
-     * What the daemon's background jobs currently find wrong with the project (#1500), oldest
-     * first — absent when nothing is. Not part of the summary itself: the dashboard's project
-     * list attaches it from the daemon's error state.
-     */
-    errors?: ProjectError[];
-}
-/**
- * A projection over the registered projects, together with the projects it could actually see.
- *
- * A project whose sources cannot be read contributes no items — which is exactly what a project
- * with nothing waiting contributes. `whole` is what tells the two apart (#1623). Only a caller
- * that keeps a baseline of what it has already announced needs the distinction; the panels that
- * simply render the list read `items` and ignore it.
- */
-export interface ProjectionRead<T> {
-    /** What was found. Possibly only part of it, when some project could not be read. */
-    items: T[];
-    /** The ids of the projects every source answered for, so their share of `items` is all of it. */
-    whole: string[];
-}
-/** Injectable readers so {@link summarizeProject} is unit-testable off disk. */
-export interface SummarizeDeps {
-    isActivated?: (path: string) => Promise<boolean>;
-    /** The project's runs (live + archived), newest-first. Defaults to {@link readAllAgents}. */
-    readAgents?: (path: string) => Promise<AgentMeta[]>;
-}
-/** A project's runs, live prepended to the archived history. Forgiving: a failed read is `[]`. */
-/**
- * Derive a {@link ProjectSummary} from a registry record: its display name, whether
- * it is still activated, and its last activity. Forgiving: a failed read reads as an
- * inactive project with no activity, never a throw.
- *
- * Activity is the sessions themselves (B3). It used to be the newest of those and the latest
- * `LOGS.md` entry — a committed markdown re-narration of the same sessions, which could only ever
- * be older than the agent it described.
- */
-export declare function summarizeProject(record: ProjectRecord, deps?: SummarizeDeps): Promise<ProjectSummary>;
-/**
- * Reads the registry to serve the multi-project endpoints. The dashboard server
- * holds one of these; the daemon uses the default (the real registry), tests pass
- * a fake so the server is exercised without touching the user's registry.
- */
-export interface ProjectsProvider {
-    /** Every registered project, summarized, for the projects read. */
-    list(): Promise<ProjectSummary[]>;
-    /** The absolute path for a registry id, or `undefined` when unknown. */
-    resolvePath(id: string): Promise<string | undefined>;
-}
-/** Injectable readers so {@link defaultProjectsProvider} is unit-testable off the user's registry. */
-export interface ProviderDeps {
-    /** The registry's records. Defaults to {@link listProjects}, forgiving. */
-    listRecords?: () => Promise<ProjectRecord[]>;
-    /** Whether a project's directory is on disk. Defaults to a directory stat. */
-    isDirectory?: (path: string) => Promise<boolean>;
-    /** Defaults to {@link summarizeProject}. */
-    summarize?: (record: ProjectRecord) => Promise<ProjectSummary>;
-}
-/**
- * A {@link ProjectsProvider} backed by the global registry (#390).
- *
- * Only projects whose directory is still on disk are served (#1140): a repo the user renamed or
- * deleted used to stay in the sidebar as a grey "not activated" entry with no files (#1142),
- * indistinguishable from a repo that merely lost its marker, and with nothing to click to make it
- * go away. The registry itself is left alone — the record is skipped, not pruned — so a directory
- * that comes back (renamed back, a volume remounted) is a project again on the next read.
- */
-export declare function defaultProjectsProvider(deps?: ProviderDeps): ProjectsProvider;

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

@@ -1,126 +0,0 @@
-import { type GitHostFor, type GitHostRequest } from '../store/git-host.js';
-import { type Cached } from './cache.js';
-/**
- * The pull requests the dashboard reads (#1820), in one place, all through the project's git host
- * provider (`../store/git-host.ts`): a branch's request, a branch's whole request history, and the
- * project's open requests. Reads only: opening and landing are `agent-handoff.ts`'s, through the
- * same provider. The framework runs no git host tool; a project with no git host package has no pull
- * requests, and every read here answers "none" for it.
- *
- * The shapes are the framework's own ({@link LinkedPr}, {@link OpenPr}), copied out of what the
- * provider answers rather than passed through, so a field a provider adds cannot leak into what
- * callers store.
- */
-/** The PR opened for a branch, when there is one. */
-export interface LinkedPr {
-    number: number;
-    url: string;
-    /** OPEN / MERGED / CLOSED, as the git host reports it; UNKNOWN for a recorded request no live read confirmed. */
-    state: string;
-    title: string;
-    /** ISO creation time, when the read included it: what tells one agent's PR from a predecessor's. */
-    createdAt?: string;
-    /**
-     * The head commit the PR covers, when the read included it (#1512): what tells "the branch's
-     * PR already landed everything" from "the session kept working after its PR merged".
-     */
-    headRefOid?: string;
-    /** The commit a merged PR landed as on the base branch, when the git host said. */
-    mergeCommit?: string;
-}
-/** An open PR on the interventions queue (#632). */
-export interface OpenPr {
-    number: number;
-    title: string;
-    url: string;
-    /**
-     * Draft PRs are generally left off the queue: a draft is not asking for review.
-     *
-     * The exception is a draft the framework opened for itself (#1102), which {@link headRefName}
-     * is what tells apart.
-     */
-    isDraft: boolean;
-    /** The branch the PR is from, so a session's own PR can be recognised as ours (#1102). */
-    headRefName?: string;
-    createdAt?: string;
-}
-/**
- * A best-effort PR lookup, for a named branch or for the checkout's current branch. One type for
- * both: the named-branch form is the general one, and "the current branch" is just omitting it.
- */
-export type PrLookup = (cwd: string, branch?: string) => Promise<LinkedPr | undefined>;
-/**
- * The branch-addressed form, for a caller that always names one (#799): a finished session's
- * worktree may be gone, so "the current branch" would silently be the project's, not the
- * session's. Narrower than {@link PrLookup} on purpose, so that invariant is in the type.
- */
-export type BranchPrLookup = (cwd: string, branch: string) => Promise<LinkedPr | undefined>;
-/** Lists a checkout's open PRs; rejects when the git host could not answer. */
-export type PrLister = (cwd: string) => Promise<OpenPr[]>;
-/** A provider's request as the framework keeps it: the state upper-cased, the head as the request's commit. */
-export declare function linkedPrOf(request: GitHostRequest): LinkedPr;
-/** A provider's open request as the interventions queue keeps it. */
-export declare function openPrOf(request: GitHostRequest): OpenPr;
-/**
- * Every PR a branch name has ever had, newest first (#1251).
- *
- * The newest request for a head *in any state* is what a single view would answer, so a session
- * whose prompt pins its branch name (`the-framework/triage-quick`) inherits a predecessor's
- * merged PR as its own. The list form keeps the whole history so {@link pickAgentPr} can decide
- * which entry, if any, belongs to the agent asking. Resolves `[]` when the project has no git host or
- * the git host could not answer — indistinguishable from "no PRs", which is what every caller would do
- * with a failure anyway.
- */
-export declare function prsForBranch(cwd: string, branch: string, gitHost?: GitHostFor): Promise<LinkedPr[]>;
-/**
- * {@link prsForBranch} for a caller about to *open* a PR (#1601): a listing the git host could not
- * answer throws instead of reading as "no PRs", because "none" and "could not tell" must not look
- * alike there — the difference is a second draft PR on a branch that already has one. A project
- * with no git host has none, truthfully.
- */
-export declare function prsForBranchOrThrow(cwd: string, branch: string, gitHost?: GitHostFor): Promise<LinkedPr[]>;
-/** The newest PR of `branch`, in any state, or undefined when it has none or the git host cannot tell. */
-export declare function prView(cwd: string, branch: string, gitHost?: GitHostFor): Promise<LinkedPr | undefined>;
-/**
- * The cached form of {@link prView} (#1028), and what the dashboard's panels use.
- *
- * A PR lookup costs a process where the git reads beside it cost ten milliseconds, and the answer
- * changes about as often as someone opens a PR. Cached per checkout and branch, shared between
- * the worktree bar and the handoff summary, and refreshed behind whoever asks. `pending` says the
- * answer is not known yet rather than that there is no PR — the difference matters to a caller
- * deciding whether to offer "Open PR". A read with no branch to ask about answers nothing at once.
- */
-export declare function cachedPrView(cwd: string, branch?: string): Promise<Cached<LinkedPr | undefined>>;
-/** Forget a branch's PR, after an action that changes whether it has one. */
-export declare function forgetPr(cwd: string, branch?: string): void;
-/** The cached form of {@link prsForBranch}, shared through the same read-through cache (#1028). */
-export declare function cachedPrsForBranch(cwd: string, branch: string): Promise<Cached<LinkedPr[]>>;
-/** Forget a branch's PR history, after an action that changes it (opening one). */
-export declare function forgetBranchPrs(cwd: string, branch: string): void;
-/**
- * The PR that belongs to an agent, out of every PR its branch name has had (#1251/#1255).
- *
- * An OPEN PR always counts: a git host allows one open PR per head branch, so whatever is open on the
- * run's branch is where its pushed commits land. A closed one counts only when it was created
- * after the agent started (`since`, the agent's `startedAt`) — the oldest such entry, which is the one
- * this agent's handoff opened. Anything older is a previous agent's PR wearing the same branch name,
- * which is exactly what showed a merged two-day-old PR as a fresh session's own. Without `since`
- * only an open PR is trusted.
- *
- * `order` exists for the one caller asking a different question (#1512). `'first'` answers
- * identity — which PR did *this agent* open, so a later agent's must not be the answer. `'latest'`
- * answers the handoff decision — which PR last saw the branch, so "did the session keep working
- * past it" is readable off that PR's `headRefOid`; there the oldest entry would call work that a
- * second PR already landed unlanded.
- */
-export declare function pickAgentPr(prs: LinkedPr[], since?: string, order?: 'first' | 'latest'): LinkedPr | undefined;
-/**
- * A project's open PRs, through its git host. Unlike the other reads here it *rejects* when the git host
- * could not answer — no remote, not logged in, the git host unreachable — instead of resolving `[]`.
- *
- * "No PRs are open" and "I could not look" are different answers, and its caller keeps a baseline
- * of what it has already announced (#1623): taking the second for the first makes the next
- * successful read announce every already-open PR as new. The caller decides what a failure costs;
- * it cannot decide what it never hears about. A project with no git host package has none open.
- */
-export declare function openPrs(cwd: string, gitHost?: GitHostFor): Promise<OpenPr[]>;

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

@@ -1,16 +0,0 @@
-import type { ProjectSummary } from './projects.js';
-import { type QueueFor } from '../store/queue.js';
-/** One project's queue, as the dashboard reads it. */
-export interface ProjectQueue {
-    projectId: string;
-    projectName: string;
-    /** The open entries, in order of work: each the task a future agent is started with. */
-    entries: string[];
-}
-/**
- * The queue of every project that has one, most entries first: a project one of whose packages
- * provides the queue is listed even with nothing queued (the card shows the projects it can speak
- * for), and a project with no provider is left out (it has no queue, so nothing is said about it).
- * `queueFor` is injectable so this is unit-testable off disk and processes.
- */
-export declare function collectQueue(projects: ProjectSummary[], queueFor?: QueueFor): Promise<ProjectQueue[]>;

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

@@ -1,59 +0,0 @@
-import { QuotaPoller } from '../quota-poller.js';
-import { type QuotaBoundaryStatus } from '../quota-boundary.js';
-import type { DriverQuotaUnavailableReason, DriverQuotaWindow } from 'agent-driver';
-/**
- * Everything the dashboard needs to draw the usage panel (#533): the account's
- * own windows, and where they stand against the quota boundary (#879).
- */
-export interface QuotaView {
-    /**
-     * The account's quota windows as the agent reported them (session, week, and
-     * a week per model). Empty when we have no reading at all — check
-     * {@link unavailable} before reading that as "nothing used".
-     */
-    windows: DriverQuotaWindow[];
-    /** When the reading was taken, epoch ms. Absent when there has never been one. */
-    readAt?: number;
-    /**
-     * Why there is no reading, when there isn't one. Present alongside stale
-     * `windows` too: the last good reading is kept through a blip, and this says
-     * the newest attempt failed, so the UI can mark it stale rather than blank it.
-     */
-    unavailable?: DriverQuotaUnavailableReason;
-    /**
-     * Where the account stands against its boundary (#879). Absent when there is no
-     * reading, or when the week's reset could not be placed — which is "we don't
-     * know", not "nothing is allowed".
-     */
-    boundary?: QuotaBoundaryStatus;
-}
-/** Where a dashboard reads the quota from. */
-export interface QuotaSource {
-    read(): Promise<QuotaView>;
-    /** Stop any polling behind it. */
-    stop(): void;
-}
-/**
- * A {@link QuotaSource} backed by a live poller.
- *
- * The boundary is measured per read rather than captured: it moves with the clock, so a cached
- * one would be stale the moment the week's day rolls over. A read costs no reading of the
- * account: the poller's last good windows are measured again.
- *
- * The panel's boundary names no model on purpose: the bar is about the account (#879/#1619).
- */
-export declare function pollerQuotaSource(poller: QuotaPoller, now?: () => number, 
-/** The slider's position, read per call so moving it shows without a restart (#960). */
-limitOffset?: () => number | Promise<number>): QuotaSource;
-/**
- * The daemon's own quota source: it polls for the whole life of the dashboard,
- * not just during an agent, because the panel has to show where the account stands
- * even when nothing is running.
- *
- * Separate from the reading an agent takes for itself: that one dies with the agent, and
- * nothing stops a running agent over quota anyway. This one exists to draw the bar and the line
- * unattended work stops at. That line is the schedulers' own spend offset, which `spendOffset`
- * reads off their state files (#960): the scheduler is what obeys it, so the bar draws what it
- * obeys. None named, or none readable, is the default cushion, which is the schedulers' default too.
- */
-export declare function defaultQuotaSource(spendOffset: () => Promise<number | undefined>): QuotaSource;