@openagt/dashboard 0.8.0 → 0.9.0

package/dist/widget-types/src/event-stream.d.ts

@@ -1,32 +0,0 @@
-/**
- * A replayable, multi-consumer stream of events: buffer every event, hand out live async
- * iterators, and replay history from an offset (tail=N replay).
- *
- * Absorbed from `@gemstack/ai-autopilot` when that package was deleted (A2). Its element type
- * used to default to the supervisor's event; the only caller here passes `FrameworkEvent`, so
- * the parameter is now required.
- */
-export declare class EventStream<E> {
-    private readonly buffer;
-    private readonly waiters;
-    private closed;
-    /** Append an event. Wire this in as an `onEvent` sink. Ignored once closed. */
-    readonly push: (event: E) => void;
-    /** Alias for {@link push}, reads well at the `onEvent:` call site. */
-    get sink(): (event: E) => void;
-    /** Events buffered so far, from `fromOffset` (default 0) — Flue-style tail replay. */
-    history(fromOffset?: number): E[];
-    /** Number of events buffered. */
-    get length(): number;
-    /** True once {@link close} has run. */
-    get isClosed(): boolean;
-    /** End the stream: live iterators drain their backlog, then finish. Idempotent. */
-    close(): void;
-    /**
-     * A fresh async iterator that replays every buffered event, then yields new
-     * ones as they arrive, and finishes once the stream is closed and drained.
-     * Independent iterators each keep their own cursor, so late consumers still
-     * see the full history.
-     */
-    [Symbol.asyncIterator](): AsyncIterableIterator<E>;
-}

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

@@ -1,235 +0,0 @@
-import type { DriverEvent } from 'agent-driver';
-/** One selectable option in an interactive {@link ChoiceRequest} (#304). */
-export interface ChoiceOption {
-    /** Stable id posted back when this option is picked. */
-    id: string;
-    /** The option shown to the user. */
-    label: string;
-    /** Optional one-line detail under the label (e.g. why an alternative lost). */
-    detail?: string;
-    /** In a multi-select ({@link ChoiceRequest.multi}), whether this option starts checked. Ignored for single-select. */
-    default?: boolean;
-}
-/**
- * An interactive choice the agent pauses on until a pick arrives (#304). Emitted as
- * a `choice` {@link FrameworkEvent}; the dashboard renders it in a panel and posts
- * the pick back. The recommended option is what an agent nobody is watching takes.
- */
-export interface ChoiceRequest {
-    /** Unique id for this pending choice; the pick is posted back against it. */
-    id: string;
-    /** The question shown above the options (e.g. "Approve this plan?"). */
-    title: string;
-    /** The options to choose between (at least one). */
-    options: readonly ChoiceOption[];
-    /**
-     * The option id pre-selected as the default (taken when nobody is watching). Required
-     * for a single-select; omitted for a {@link multi} select, where each option's own
-     * {@link ChoiceOption.default} drives the pre-checked set instead.
-     */
-    recommended?: string;
-    /**
-     * Render as a multi-select checklist (#332): each option is a checkbox pre-checked
-     * per its {@link ChoiceOption.default}, and the pick resolves to the selected
-     * *subset* of ids rather than one. Absent = the single-select gate (#304).
-     */
-    multi?: boolean;
-    /** The markdown file under approval (e.g. `PLAN_<slug>.agent.md`); the doc sidebar renders it. */
-    file?: string;
-}
-/** Who resolved a {@link ChoiceRequest}: a human, or a headless auto-accept. */
-export type ChoiceBy = 'user' | 'auto';
-/** What a {@link import('./agent.js').RunFrameworkOptions.requestChoice} handler resolves with. */
-export interface ChoicePick {
-    /** The picked option id, or (for a {@link ChoiceRequest.multi} select) the selected subset of ids. */
-    picked: string | readonly string[];
-    /** Who picked it. Default `'user'`. */
-    by?: ChoiceBy;
-}
-/** Normalize a {@link ChoicePick} (single id or subset) to a list of picked ids. */
-export declare function pickedIds(picked: string | readonly string[]): string[];
-/**
- * The single type a run's timeline is read as. The framework emits none of these itself (#1774):
- * a run's tool writes the run's diary, and every line of it is read as one of these so the
- * dashboard and the terminal render one timeline whatever wrote it.
- *
- * What a diary yields today is the agent's own progress (`driver`), the session id it reports
- * (`session-update`), the question a turn ended on (`choice`), what it cost (`usage`) and how it
- * ended (`end`). **The rest of this union is a reading vocabulary for runs recorded before the
- * daemon stopped running agents** — the framework's own narration back then. They are kept
- * because that history is still on the data branch and still has to render.
- *
- * Every event read from a diary line that says when it was written carries that time as `at`
- * (ISO 8601), so the timeline shows the same times live, after a reload, and once the run has
- * ended. Lines written before the diary kept times have none, and show none.
- */
-export type FrameworkEvent = {
-    at?: string;
-} & (
-/**
- * Emitted once at start: which agent is wrapped, the workspace, and a link. `model` is the
- * model id the driver was started with (#1438), recorded per leg — a continuation (#762) emits
- * its own `session` event and may run a different model, so readers fold the latest rather
- * than pinning the first. Absent when the agent left the agent on its own default.
- */
-{
-    kind: 'session';
-    driver: string;
-    workspace: string;
-    fake: boolean;
-    sessionLink?: string;
-    model?: string;
-}
-/**
- * Emitted once the wrapped agent reports its real session id (not known at
- * start). Carries the live id and, when a link template was supplied, the
- * resolved URL to jump into that session (#165). Re-emitted if the id changes
- * (each Claude Code prompt is a fresh session), keeping the link current.
- */
- | {
-    kind: 'session-update';
-    sessionId: string;
-    sessionLink?: string;
-}
-/** What this session was asked for, emitted once as it opens (#211). */
- | {
-    kind: 'intent';
-    text: string;
-}
-/** The wrapped agent's own progress, forwarded verbatim (never gated on). */
- | {
-    kind: 'driver';
-    event: DriverEvent;
-}
-/**
- * A live screen something the agent ran is showing: a page on this machine's loopback, shown in
- * the chat where the line is, while it is the newest open screen at that address and the run
- * has not ended. `label` names what it showed then. The same address with `ended` says the
- * screen has gone. A diary line a command appends itself (agent-driver's `DIARY_ENV`); the
- * framework knows nothing of what the page is.
- */
- | {
-    kind: 'screen';
-    url: string;
-    label: string;
-    ended?: true;
-}
-/** A framework-level log line. */
- | {
-    kind: 'log';
-    message: string;
-}
-/**
- * Something went wrong that only the user can fix (#1500), reported by the agent itself
- * through an `error` block rather than left in prose the reader has to notice. The headline
- * is the first line, the detail is the rest.
- *
- * An event, not a status: it says what happened at this point in the run and stays in the log
- * as history — nothing clears it, because nothing can un-happen it. The project-level errors a
- * background job finds between runs are the other half (project-errors.ts): those are
- * conditions that are true *now*, and clear themselves when the condition is gone.
- */
- | {
-    kind: 'error';
-    headline: string;
-    detail?: string;
-}
-/**
- * An ad-hoc markdown view the agent pushed to show the user (#441), e.g. a plan,
- * a summary, or a diff writeup. Non-blocking (unlike a `choice`): the dashboard
- * renders it as a view in the right rail. `id` is stable per title, so re-showing
- * the same view updates it in place rather than stacking a duplicate.
- */
- | {
-    kind: 'view';
-    id: string;
-    title: string;
-    markdown: string;
-}
-/**
- * The pull request this session's work is on (E6), the moment one is opened for it.
- *
- * An event for the same reason `branch` is: only an event reaches the agent's meta,
- * and the meta is what every later surface reads. Before this, each of them re-resolved the PR
- * live from the branch — trying the recorded branch, then the session-name branch, then the
- * run-id branch, and filtering the results by whether the PR predated the session — which is a
- * three-way guess plus a timestamp heuristic standing in for one integer nobody had written down.
- */
- | {
-    kind: 'pull-request';
-    number: number;
-    url: string;
-}
-/**
- * The branch the agent's work is on (#1277), observed off the checkout rather than guessed:
- * emitted at start with the branch the agent actually begins on, and again whenever a later
- * read finds it changed — the agent renames its branch itself, through `branches name`
- * (#1725). Folded to `AgentMeta.branch`, which every surface resolves first — before this event the
- * branch was stamped only at teardown (#799), so any read before that guessed between three
- * naming schemes.
- */
- | {
-    kind: 'branch';
-    branch: string;
-}
-/**
- * The hand-off anchor a cloud run pushed for its session to clone at (#1601): an empty commit
- * unique to this run, so the branch the session actually works on — a `claude/*` name of the
- * cloud's own choosing, never the designated run branch — is recognizable later by plain
- * ancestry. Folded to `AgentMeta.cloudAnchor`, which the daemon's adoption pass matches
- * against origin's `claude/*` heads once the session has pushed its work.
- */
- | {
-    kind: 'cloud-anchor';
-    sha: string;
-}
-/**
- * The work has settled and the agent is parked on the user (#785): it stays open as a
- * conversation (#714), so its process is still alive and it still takes messages, but
- * the agent is not doing anything until you say something.
- *
- * Emitted each time the agent parks, and undone by the next `driver` `start` — so "is it
- * working or waiting for me" is answerable from the event log rather than inferred from
- * a status that only changes when the agent ends.
- */
- | {
-    kind: 'settled';
-}
-/**
- * The price of one turn in USD (#322): the run's record keeps a cost line per turn the
- * coding agent priced, and no token counts, so a turn without a price has no usage event
- * (#540). The dashboard adds them up into its spend readout. Nothing gates on it: an
- * agent already running is never cut short over spending, and the account's quota
- * decides what may *start* instead.
- */
- | {
-    kind: 'usage';
-    costUsd: number;
-}
-/**
- * The agent paused on an interactive choice (#304) and is awaiting a pick. The
- * dashboard renders the options with the recommended default pre-selected and
- * posts the pick back; a headless agent auto-accepts the recommended option.
- */
- | ({
-    kind: 'choice';
-} & ChoiceRequest)
-/** A pending {@link ChoiceRequest} was resolved — the agent continues on `picked` (one id, or the selected subset). */
- | {
-    kind: 'choice-resolved';
-    id: string;
-    picked: string | readonly string[];
-    by: ChoiceBy;
-}
-/**
- * The agent finished. `ok` is false when it threw. `stopped` marks the common,
- * non-error case where the user interrupted it (the dashboard Stop button /
- * Ctrl+C), so a surface can show "stopped" rather than "failed".
- */
- | {
-    kind: 'end';
-    ok: boolean;
-    stopped?: boolean;
-    waiting?: boolean;
-    detail?: string;
-});

package/dist/widget-types/src/framework-dir.d.ts

@@ -1,10 +0,0 @@
-/**
- * The directory, under a project root, that holds The Framework's own files.
- *
- * Its own module so every reader and writer of the directory (the hooks file, the project's saved
- * prompts, the activation's `.gitignore`, a run's card, diary and inbox) spells it the same way.
- *
- * Nothing of the product's rides on a branch of its own any more: the agent archives are the
- * `logs` skill's runs, on the shared `agent-data` branch that `@gemstack/agent-data` names (#1769).
- */
-export declare const THE_FRAMEWORK_DIR = ".the-framework";

package/dist/widget-types/src/framework-gitignore.d.ts

@@ -1,11 +0,0 @@
-/**
- * The `.the-framework/.gitignore` (#313): one file, one content, written at install.
- *
- * Everything under `.the-framework/` is this machine's or transient: a run's live files, the
- * hooks file. The lasting records (the runs, the `logs` skill's) live on the data branch
- * (#1582/#1769), so nothing but this file is tracked: main is 100% code.
- */
-/** The `.gitignore` path under `cwd`'s `.the-framework/`. */
-export declare function gitignorePath(cwd: string): string;
-/** The whole file: everything under `.the-framework/` stays out of git (#1582). */
-export declare function frameworkGitignore(): string;

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

@@ -1,42 +0,0 @@
-/**
- * The types the dashboard reads the daemon's answers as.
- *
- * Not a library API: nothing imports this package by name, and the browser gets its *values* from
- * `client.ts` (the node-free entry) and its data over `POST /_rpc/<name>`. What is left here is the
- * vocabulary of those answers — one import site for a browser file that would otherwise reach into
- * two dozen modules to name what an RPC returns.
- *
- * Type-only on purpose. A value re-exported here would pull the module that defines it into the
- * browser bundle, which is the failure `client.ts` exists to prevent; `export type` erases at build.
- *
- * Every name below is imported by a file under `dashboard/`. That is the whole rule: this file
- * ends where its consumers end, so a name nothing renders cannot quietly live on in it.
- */
-export type { AgentError, SessionInfo } from './agent-view.js';
-export type { ChoiceRequest, FrameworkEvent } from './events.js';
-export type { QuotaBoundaryStatus } from './quota-boundary.js';
-export type { CustomPreset, Preferences } from './registry.js';
-export type { DriverQuotaWindow } from 'agent-driver';
-export type { AgentMeta, AgentStatus } from './store/agent-store.js';
-export type { Activity } from './dashboard/activity.js';
-export type { AgentHandoff } from './dashboard/agent-handoff.js';
-export type { GitHostHome } from './store/git-host.js';
-export type { BridgeEvent } from './dashboard/bridge-endpoints.js';
-export type { BridgeOption, BridgeQuestion } from './dashboard/bridge-question.js';
-export type { BridgeAnswer } from './dashboard/bridge-store.js';
-export type { DashboardData } from './dashboard/dashboard.js';
-export type { WorkspaceDoc } from './dashboard/docs.js';
-export type { FileChange, FileDiff } from './dashboard/file-diff.js';
-export type { FileContent } from './dashboard/file-read.js';
-export type { AgentTree, FileMark } from './dashboard/agent-tree.js';
-export type { GitStatus } from './dashboard/git-status.js';
-export type { Intervention } from './dashboard/interventions.js';
-export type { OpenQuestion } from './dashboard/open-questions.js';
-export type { ActiveAgent, Overview, RecentAgent } from './dashboard/overview.js';
-export type { ProjectSummary, ProjectionRead } from './dashboard/projects.js';
-export type { ProjectError, ProjectErrorCode } from './project-errors.js';
-export type { ProjectQueue } from './dashboard/queue.js';
-export type { ProjectScheduler, SchedulerCommand, SchedulerDecision, SchedulerState, SchedulerTick } from './dashboard/scheduler-state.js';
-export type { QuotaView } from './dashboard/quota.js';
-export type { Ticket } from './store/tickets.js';
-export type { AgentWorktree, OnboardingSuggestion } from './dashboard/types.js';

package/dist/widget-types/src/jsonl-tail.d.ts

@@ -1,54 +0,0 @@
-/**
- * Tails an append-only JSONL log, calling `onLine` for each complete line as it
- * is written. Reads only the bytes appended since the last {@link pull},
- * buffering a torn trailing line until its newline arrives. A file that shrinks
- * (a fresh agent truncated the log) resets to the start so the new content is
- * picked up. The generic base behind the daemon's event tail and the agent's
- * control tail (#344) — one tailer, two directions.
- */
-export declare class JsonlTailer<T> {
-    private path;
-    private readonly onLine;
-    private offset;
-    private partial;
-    private lastMtimeMs;
-    private adoptMtime;
-    constructor(path: string, onLine: (value: T) => void);
-    /**
-     * Point the tailer at the log's new home, keeping the read offset. For a log that is
-     * *relocated with its content intact* — a run's diary is copied verbatim onto the data branch
-     * when the run ends and its checkout is reclaimed — the bytes already consumed are a prefix of
-     * the new file, so the next {@link pull} delivers exactly the lines the move would otherwise
-     * have swallowed, without replaying what was already delivered.
-     *
-     * The first pull after a retarget adopts the new home's mtime instead of running the
-     * same-length-rewrite check: the copy is younger than the original by construction, and a
-     * fully-consumed log would otherwise read as "rewritten to the same length" and replay
-     * every line it already delivered.
-     */
-    retarget(path: string): void;
-    /** Read and dispatch any lines appended since the previous call. */
-    pull(): Promise<void>;
-}
-/** Options for {@link followFile}. */
-export interface FollowFileOptions {
-    /** How often the backstop poll runs. */
-    pollMs: number;
-    /**
-     * Let the process exit with the tail still running (steering must never hold it open).
-     * Covers both handles this opens — the poll timer *and* the `fs.watch` — since either one
-     * on its own is enough to keep the event loop alive.
-     */
-    unref?: boolean;
-}
-/**
- * Drive a {@link JsonlTailer} as the file grows: an `fs.watch` on `dir` for latency, plus a
- * poll backstop because `fs.watch` is unreliable across platforms. Pulls are serialized (a
- * pull already in flight swallows the next trigger) and stop for good once the returned
- * function is called. Shared by the agent's control tail and the dashboard's event tail, which
- * hand-rolled this separately and drifted apart.
- *
- * Nothing here may throw at the process: a failed pull and a watcher error are both survivable,
- * and the poll alone is a complete tail (#996).
- */
-export declare function followFile(dir: string, pull: () => Promise<void>, opts: FollowFileOptions): () => void;

package/dist/widget-types/src/loopback-host.d.ts

@@ -1,19 +0,0 @@
-/**
- * Loopback-address helpers, shared by the daemon (deciding whether a bind gates behind the
- * token, #1051) and the RPC mount (rejecting a rebound `Host`). A leaf module on purpose:
- * `daemon.ts` imports the dashboard, so the mount cannot import these back out of it.
- */
-/**
- * True when `host` is a loopback address the browser reaches without leaving the machine (#1051).
- * A bind-all (`0.0.0.0`, `::`) or a routable address is not, and gates behind the shared token.
- *
- * The IPv4 check matches the whole `127.0.0.0/8` range but only as an address: a bare
- * `startsWith('127.')` also accepts a *registrable name* like `127.evil.com`, which is exactly the
- * rebound `Host` the DNS-rebinding guard exists to reject (it can resolve to `127.0.0.1`).
- */
-export declare function isLoopbackHost(host: string): boolean;
-/**
- * The hostname a `Host` header names, with the port dropped. Keeps the bracketed IPv6 form
- * (`[::1]:4200` → `[::1]`), which splitting on the first colon would mangle.
- */
-export declare function hostnameFromHostHeader(header: string): string;

package/dist/widget-types/src/node-fs.d.ts

@@ -1,32 +0,0 @@
-/**
- * The one `node:fs/promises` adapter. Every `node*Fs()` factory in the package
- * returns this under its own narrow type: the store may append, the registry may
- * not, and those interfaces stay separate because they are the consumers'
- * contracts. Only the implementation was worth sharing, and it was written out
- * four times before this.
- *
- * Every import is dynamic, which is the whole point of the convention: a module
- * that reads files keeps a `node:fs` edge out of its static import graph, so it
- * can be reached from browser-safe code as long as the read itself never runs
- * there. `client.test.ts` enforces the graph half.
- */
-export interface NodeFs {
-    /** Rejects when the file is absent. */
-    read(path: string): Promise<string>;
-    write(path: string, contents: string): Promise<void>;
-    append(path: string, contents: string): Promise<void>;
-    /** True when `path` exists AND is a file. Any stat error reads as `false`. */
-    exists(path: string): Promise<boolean>;
-    /** True when `path` exists AND is a directory. Any stat error reads as `false`. */
-    isDirectory(path: string): Promise<boolean>;
-    /** Recursive. */
-    mkdir(path: string): Promise<void>;
-    /** List a directory's entries (names only). Missing dir yields `[]`. */
-    readdir(path: string): Promise<string[]>;
-    /** Replace `to` with `from`. Atomic within one filesystem, which is the point of having it. */
-    rename(from: string, to: string): Promise<void>;
-    /** Set a file's permission bits. Rejects when the path is absent, or the fs cannot express them. */
-    chmod(path: string, mode: number): Promise<void>;
-}
-/** The `node:fs/promises` implementation of {@link NodeFs}. */
-export declare function nodeFs(): NodeFs;

package/dist/widget-types/src/open-choices.d.ts

@@ -1,14 +0,0 @@
-import type { ChoiceRequest, FrameworkEvent } from './events.js';
-/**
- * Every question a run still waits on, in the order asked, read off the run's events. One rule
- * for every surface that offers an answer (the run page, the open-questions list, the write
- * that delivers the answer), so none offers what another would refuse.
- *
- * A `choice` event opens a question; asked again under the same id, the later one replaces it.
- * It closes when the agent goes on (any later event of the agent's own: the answer, or the
- * person's text, began a new turn), when a `choice-resolved` names it, and when the run ends
- * for good. An end that says `waiting` closes nothing: the run ended ON the question, its
- * checkout kept, and the answer resumes it. A run that died holding a question ends otherwise,
- * and its question goes with it (#1359): nobody would read the pick.
- */
-export declare function pendingChoices(events: readonly FrameworkEvent[]): ChoiceRequest[];

package/dist/widget-types/src/pick-directory.d.ts

@@ -1,29 +0,0 @@
-/**
- * The system folder picker behind the dashboard's "Add project" (#1150): the daemon opens the
- * OS's own choose-a-folder dialog and hands the picked absolute path back, because a browser page
- * cannot learn the absolute path of anything the user picks in it.
- */
-/** The outcome of asking the OS for a folder: a path, a dismissed dialog (`path: null`), or why the dialog could not be asked. */
-export type PickDirectoryResult = {
-    ok: true;
-    path: string | null;
-} | {
-    ok: false;
-    error: string;
-};
-/** What a dialog command left behind when it exited. */
-export type DialogRun = {
-    code: number;
-    stdout: string;
-    stderr: string;
-};
-/** Injectable seam so tests never open a real dialog. */
-export type DialogRunner = (command: string, args: string[]) => Promise<DialogRun>;
-/**
- * Open the OS folder picker and wait for the user's choice.
- *
- * Dismissing the dialog is a normal outcome (`path: null`), not an error. A Linux daemon with no
- * desktop session to draw on, a Linux machine with neither dialog helper installed, and a platform
- * with no dialog wired up each answer with that reason instead of trying.
- */
-export declare function pickDirectory(platform?: NodeJS.Platform, run?: DialogRunner, env?: NodeJS.ProcessEnv): Promise<PickDirectoryResult>;

package/dist/widget-types/src/preference-defaults.d.ts

@@ -1,53 +0,0 @@
-import type { Preferences } from './registry.js';
-/**
- * What an unset preference means, and the bounds the controls that write them share.
- *
- * A leaf module (no `node:*`) so `client.ts` can export it and the dashboard reads the same values
- * the daemon acts on.
- *
- * No cycle: `registry.ts` re-exports the bounds from here, and the `Preferences` import going the
- * other way is type-only, so it erases.
- */
-/**
- * Notifications have two axes (B5): `notifyBrowser` says whether they reach you in the browser at
- * all, and `notifyHumanIntervention` / `notifyNewActivity` say *what* they are about. A category
- * delivers only while the browser switch is on too.
- */
-/** What a notification is about. */
-export type NotifyCategory = 'humanIntervention' | 'newActivity';
-/**
- * What each switch means when nobody has said.
- *
- * The polarities are not uniform, and that is the point of writing them down once: browser
- * delivery and the "needs you" category fire unless you turn them off, while plain activity is
- * opt-in.
- */
-export declare const NOTIFICATION_DEFAULTS: {
-    readonly browser: true;
-    readonly categories: {
-        readonly humanIntervention: true;
-        readonly newActivity: false;
-    };
-};
-/** Whether browser delivery is switched on, with its default applied. */
-export declare function browserNotifyEnabled(preferences: Preferences): boolean;
-/** Whether a category is switched on, with its default applied. */
-export declare function notifyCategoryEnabled(preferences: Preferences, category: NotifyCategory): boolean;
-/** Whether a category delivers: both browser delivery and the category have to be on. */
-export declare function notifies(preferences: Preferences, category: NotifyCategory): boolean;
-/**
- * How far either way the automatic-consumption slider reaches, in percentage points (#960).
- *
- * Here because the browser clamps to it, in the usage panel's slider and in Settings, and the
- * daemon's quota source falls back to the default below: one number both sides import.
- */
-export declare const MAX_SPEND_OFFSET = 50;
-/**
- * Where the slider sits before anyone has touched it, in percentage points (#960 Edit): half a
- * day's worth of the week's allowance, ahead of the boundary.
- *
- * Landing exactly on the boundary reads as generous on paper but stops unattended work the moment
- * the account is precisely on pace, which is normal jitter rather than overspending. A half-day
- * cushion gives it room to breathe without meaningfully loosening the spend-boundary policy (#879).
- */
-export declare const DEFAULT_SPEND_OFFSET: number;

package/dist/widget-types/src/project-commands.d.ts

@@ -1,23 +0,0 @@
-/**
- * A project's commands (#1774): the skills written to be run by a person, read off the folders
- * the coding agents read them from. The framework ships no prompt text; what a project can be
- * asked to do is what its own command skills say. A skill that teaches the agent how to do
- * something (the tickets, the queue) is not a command: typed alone it starts an agent with
- * nothing to do, so the launcher does not list it.
- */
-/** Where coding agents read a project's skills: Claude Code's folder, and the shared one Codex reads. */
-export declare const SKILLS_DIRS: readonly ['.claude/skills', '.agents/skills'];
-/** One skill as the launcher shows it. */
-export interface ProjectCommand {
-    /** What is typed after the slash: the skill's folder name. */
-    name: string;
-    /** The `description` of the skill's front matter, when it has one. */
-    description?: string;
-}
-/**
- * The project's commands, by name: the skills whose front matter says
- * `disable-model-invocation: true`, written to be run by a person or a runner and never picked
- * up by the agent on its own. A skill in both folders is listed once. A folder without a
- * readable `SKILL.md` is skipped, and a project with no skills folder has no commands.
- */
-export declare function readProjectCommands(cwd: string): Promise<ProjectCommand[]>;

package/dist/widget-types/src/project-errors.d.ts

@@ -1,43 +0,0 @@
-/**
- * The daemon's per-project error state (#1500): a background job that finds a project in a state
- * the user has to fix — and can only fix if told — records it here, and clears it the moment the
- * state is good again. The dashboard renders what is recorded; nothing else reads it.
- *
- * The first emitter is the data-branch sync (#1599): a push origin rejects, or a repo with no
- * origin at all, used to be a console line on the daemon's stdout and nothing else, which is the
- * worst way to handle a state nobody can see.
- *
- * In memory on purpose. Every emitter re-evaluates on its own cadence — the sync every minute —
- * so a restarted daemon re-learns each error within a tick, and there is no stale record to
- * outlive the condition that raised it.
- */
-/**
- * What went wrong, by kind: the dashboard picks its wording from this, the message carries the
- * detail. `data-sync`: the data branch cannot converge with the remote. `provider`: which package
- * provides a kind of the project's data is unsettled (#1820): several declare it and the project's
- * package.json names none, or names one that does not.
- */
-export type ProjectErrorCode = 'data-sync' | 'provider';
-export interface ProjectError {
-    code: ProjectErrorCode;
-    /** The detail — what the failing command said, in the words the user would see running it by hand. */
-    message: string;
-    /** ISO timestamp of when the error was first recorded; a re-report of the same code keeps it. */
-    since: string;
-}
-/** The daemon's write side: one slot per (project, code). */
-export interface ProjectErrors {
-    /**
-     * Record the error. A second report of the same code on the same project refreshes the message
-     * and keeps `since`, so a banner says how long this has been going on rather than resetting
-     * every minute.
-     */
-    set(projectPath: string, code: ProjectErrorCode, message: string): void;
-    /** The condition is gone; a clear of something never set is a no-op. */
-    clear(projectPath: string, code: ProjectErrorCode): void;
-    /** The project's current errors, oldest first. */
-    list(projectPath: string): ProjectError[];
-}
-/** The dashboard's read side, wired into its context: what the project currently suffers from. */
-export type ProjectErrorsReader = ProjectErrors['list'];
-export declare function projectErrorStore(now?: () => Date): ProjectErrors;