@openagt/dashboard 0.8.0 → 0.10.0

package/dist/module-types/src/bridge-browser.d.ts

@@ -16,10 +16,10 @@
  * user has to sign in.
  */
 /** The directory holding the bridge browser's profile and binary, next to the registry file. */
-export declare const BRIDGE_BROWSER_DIR = "the-framework-browser";
+export declare const BRIDGE_BROWSER_DIR = "openagent-browser";
 /**
- * Where the bridge browser lives: `$XDG_CONFIG_HOME/the-framework-browser` when set, else the
- * dotted `$HOME/.the-framework-browser`. Beside the registry, so the same variable that isolates
+ * Where the bridge browser lives: `$XDG_CONFIG_HOME/openagent-browser` when set, else the
+ * dotted `$HOME/.openagent-browser`. Beside the registry, so the same variable that isolates
  * a test's registry isolates its browser, and a machine's real one is never touched from a test.
  * The profile inside it is persistent on purpose: the user signs in once and the sign-in outlives
  * every daemon restart.
@@ -152,7 +152,7 @@ export declare function appBundle(binary: string): string | undefined;
 export declare function bridgeBrowserDeps(): BridgeBrowserDeps;
 /**
  * Make sure nothing else holds the profile: a browser a dead daemon left behind is stopped,
- * gently first. It is the framework's own profile, so whatever holds it is the framework's own
+ * gently first. It is OpenAgent's own profile, so whatever holds it is OpenAgent's own
  * leftover; nothing the user runs shares it.
  */
 export declare function freeProfile(profileDir: string, deps: BridgeBrowserDeps): Promise<boolean>;

package/dist/module-types/src/built-in.d.ts

@@ -1,28 +1,59 @@
+import type { CleanupReport } from './dashboard/types.js';
 import { type ProjectPackage, type ProvidedCommand, type ProvidedCommandLookup } from '@openagt/agent-data';
 /**
- * The packages the framework ships for every project, by name: dependencies of the framework
- * itself, resolved from its own install, so a project installs nothing for them and an empty
- * folder starts an agent and shows it. Each comes through the same contract as a project's own
- * package: a module by its `./dashboard` export, a provider of a kind of data and the writer of
- * its hook lines by its `framework` key. This list is the one place the framework names a
- * package, and a project's own copy of any of them wins.
+ * The packages OpenAgent brings, by name: dependencies of OpenAgent itself, resolved from its
+ * own install, so a project installs nothing for them and an empty folder starts an agent and
+ * shows it. Each comes through the same contract as any package: a module by its `./dashboard`
+ * export, a provider of a kind of data and the writer of its hook lines by its `openagent` key.
+ * These two lists are the one place OpenAgent names a package. One of these names among a
+ * project's own dependencies is not read: OpenAgent's copy, and the rules below for which
+ * project has it, are the only ones.
  */
+/** The packages every project has: an agent cannot start, be shown or be put on a git host without them. */
 export declare const BUILT_IN_PACKAGES: readonly string[];
-/** The built-in packages, resolved from the framework's own install, once; one that is not installed is skipped. */
+/**
+ * The packages a project has once it picked them (#2023). A skill's package is the project's
+ * when the project holds the skill's text where the coding agents read it
+ * (`.claude/skills/<name>/SKILL.md`, `.agents/skills/<name>/SKILL.md`): the rule the launcher
+ * already lists a project's commands by, so deleting the skill's folder takes its page away. A
+ * tool with no skill text (the scheduler) is the project's when one of the project's hook lines
+ * runs it.
+ */
+export declare const PICKED_PACKAGES: readonly string[];
+/** Every name OpenAgent brings itself. */
+export declare const OWN_PACKAGE_NAMES: readonly string[];
+/** Every package OpenAgent brings, resolved from its own install, once; one that is not installed is skipped. */
 export declare function builtInPackages(): Promise<ProjectPackage[]>;
-/** The directories the built-in packages' commands sit in: what a hook line's PATH gains after the project's own installed tools. */
+/**
+ * The packages OpenAgent brings to the project at `root`: the ones every project has, and
+ * each picked one the project has by its rule (see {@link PICKED_PACKAGES}). Read off the
+ * project's files each time, so a skill written or deleted a moment ago counts at once.
+ */
+export declare function builtInPackagesOf(root: string): Promise<ProjectPackage[]>;
+/** The project's own installed packages, less the names OpenAgent brings itself. */
+export declare function ownPackages(root: string): Promise<ProjectPackage[]>;
+/** The directories the commands of OpenAgent's packages sit in: what a hook line's PATH gains after the project's own installed tools. */
 export declare function builtInBinDirs(): Promise<string[]>;
-/** What provides `kind` in the project at `root`: one of the project's own packages, else a built-in one. */
+/** What provides `kind` in the project at `root`: a package the project installed for it, else one OpenAgent brings to this project. */
 export declare function lookupProvided(root: string, kind: string): Promise<ProvidedCommandLookup>;
 /** {@link lookupProvided}'s command, for a caller that only needs to run it. */
 export declare function providedCommand(root: string, kind: string): Promise<ProvidedCommand | undefined>;
-/** Whether `command` comes from a built-in package the project has no copy of: one the project did not choose. */
-export declare function isBuiltIn(root: string, command: ProvidedCommand): Promise<boolean>;
+/** Whether `command` comes from a package OpenAgent brings: one the project did not install. */
+export declare function isBuiltIn(command: ProvidedCommand): boolean;
 /**
  * Have every package that writes hook lines write its own into the project at `root`: a package
- * declares `"framework": { "hooks": "<command>" }`, and `<command> init`, run in the project,
+ * declares `"openagent": { "hooks": "<command>" }`, and `<command> init`, run in the project,
  * writes its lines into the project's hooks file, keeping every line already there. The project's
- * own packages are asked, then the built-in ones the project has no copy of. Answers one line per
- * package that could not write, in words.
+ * own packages are asked, then the ones OpenAgent brings to it. Answers one line per package
+ * that could not write, in words.
  */
 export declare function writeHookLines(root: string): Promise<string[]>;
+/**
+ * Have every package that declares a clean-up remove what it left in the project at `root`: a
+ * package declares `"openagent": { "cleanup": "<command>" }`, and `<command> cleanup`, run in the
+ * project, answers `{ ok: true, removed, kept }`. The project's own packages are asked, then
+ * every package OpenAgent brings, also one this project no longer has (what it left stays its
+ * own to remove), each whatever the one before answered. A package that refuses, fails or answers
+ * something else is one line in `failed`, in words.
+ */
+export declare function runCleanups(root: string): Promise<CleanupReport>;

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

@@ -1,6 +1,6 @@
 export { DRIVERS, DRIVER_LABELS, isDriverName, driverFromImpl, type DriverName } from './driver-names.js';
 export { PUBLISH_LABELS, isPublishPick, offeredPublishPicks, publishPickIn, type PublishPick } from './publish-levels.js';
-export { formatFrameworkEvent } from './terminal.js';
+export { formatOpenAgentEvent } from './terminal.js';
 export { formatBytes } from './format-bytes.js';
 export { errorMessage } from './error-message.js';
 export { pickedIds } from './events.js';

package/dist/module-types/src/cloud-run-state.d.ts

@@ -9,7 +9,7 @@ export declare const CLOUD_SESSION_WINDOW_MS: number;
  * What the cloud side of a web run is doing.
  *
  * - `waiting`: the browser bridge holds a question the session is parked on
- * - `merged`: the session's work was adopted (#1601) and its pull request merged by the framework
+ * - `merged`: the session's work was adopted (#1601) and its pull request merged by OpenAgent
  * - `in-cloud`: no pull request yet and the run is inside the session window, so it may still be working
  * - `done`: its pull request exists — the work landed, and the PR badge carries its live state — or the
  *   window passed with nothing adopted: the session finished or never pushed

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

@@ -43,7 +43,7 @@ export interface AgentHandoff {
     deletions: number;
     /**
      * The session produced nothing to hand off: the branch exists but carries no commit the base
-     * does not already have — or nothing beyond the framework's own bookkeeping (#1291), which is
+     * does not already have — or nothing beyond OpenAgent's own bookkeeping (#1291), which is
      * committed for provenance, never as publishable work. Said out loud, rather than shown as an
      * empty branch.
      */
@@ -161,7 +161,7 @@ export declare function mergeAgentPr(cwd: string, agent: PrAgent, deps?: {
 }): Promise<HandoffResult>;
 /**
  * Read what a finished session left behind, for `branch`: the branch's git facts from the
- * project's branches provider, and the run's own pull request from the framework's lookup.
+ * project's branches provider, and the run's own pull request from OpenAgent's lookup.
  *
  * Returns undefined only when the project has no branches provider, or the provider did not
  * answer for the branch. A branch that no longer exists still returns a handoff (with
@@ -213,8 +213,8 @@ export declare function mergeAgentBranch(cwd: string, agent: Pick<AgentMeta, 'id
 /**
  * Open a draft PR for a branch that exists only on the remote (#1601): a cloud session's own
  * `claude/*` branch was pushed from a VM this machine never sees, so there is nothing to push
- * here — the provider publishes the branch as the remote has it. Draft because a PR the
- * framework opens by itself must not put a review request in anyone's inbox, and the
+ * here — the provider publishes the branch as the remote has it. Draft because a PR
+ * OpenAgent opens by itself must not put a review request in anyone's inbox, and the
  * interventions queue keeps listing a session's draft.
  */
 export declare function openRemoteBranchPullRequest(cwd: string, agent: HandoffAgent, branch: string, deps?: {

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

@@ -26,12 +26,12 @@ export declare const BRIDGE_PREFIX = "/_bridge";
  * The extension version this daemon speaks (#1519). The extension states its own version on
  * every call, in this header, and a daemon expecting another refuses outright: a version-skewed
  * extension does not fail loudly, it half-works — missed messages, silently ignored fields —
- * which reads as a framework bug and burns a debugging session. The extension's manifest must
+ * which reads as an OpenAgent bug and burns a debugging session. The extension's manifest must
  * carry the same number; a test keeps the two in lockstep.
  */
-export declare const EXPECTED_EXTENSION_VERSION = "0.12.0";
+export declare const EXPECTED_EXTENSION_VERSION = "0.13.0";
 /** The header the extension states its version in. Lowercase, as node presents all headers. */
-export declare const EXTENSION_VERSION_HEADER = "x-tf-extension-version";
+export declare const EXTENSION_VERSION_HEADER = "x-oa-extension-version";
 /**
  * One thing a cloud session did, as scraped from its page (#1237).
  *

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

@@ -4,7 +4,7 @@
  *
  * These are written per session as `PLAN_<SESSION>.agent.md` (the plan for now) and
  * `TODO_<SESSION>.agent.md` (the backlog), where SESSION is a git-branch slug — by
- * The Framework's own system prompt back when it ran the agent (#323/#326), and by
+ * OpenAgent's own system prompt back when it ran the agent (#323/#326), and by
  * whatever a project's own skills tell an agent to write now. The flat fallback is `PLAN.md`
  * at the root; the `TODO` category has no flat file: the agent queue is not a document of the
  * checkout but a project package's data, and the dashboard shows it on that package's own page

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

@@ -16,7 +16,7 @@ export interface GitStatusDeps {
     /**
      * The agent's start, when the status is read for an agent's checkout (#1255). The default lookup
      * answers the newest PR for the branch *in any state* — so an agent on a reused pinned branch
-     * (`the-framework/triage-quick`) wears a predecessor's merged PR as its own badge.
+     * (`openagent/triage-quick`) wears a predecessor's merged PR as its own badge.
      * With `since` set the PR is picked from the branch's whole history by {@link pickAgentPr}
      * instead: an open PR, or a closed one no older than the agent itself.
      */

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

@@ -1,5 +1,5 @@
 import { type LiveAgent, type AgentMeta } from '../store/index.js';
-import type { FrameworkEvent } from '../events.js';
+import type { OpenAgentEvent } from '../events.js';
 import type { ProjectSummary, ProjectionRead } from './projects.js';
 import { type BranchesFor } from '../store/branches.js';
 import { type PrLister } from './pull-requests.js';
@@ -39,7 +39,7 @@ export interface InterventionsDeps {
     /** 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>;
+    events?: (cwd: string, agentId: string) => Promise<OpenAgentEvent[] | 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). */

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

@@ -7,7 +7,7 @@ export interface EditorInfo {
 }
 /**
  * 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
+ * display order. `$OPENAGENT_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[];
@@ -29,7 +29,7 @@ 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. */
+/** The command to open a path in an editor: `$OPENAGENT_EDITOR` when set, else the VS Code CLI. */
 export declare function editorCommand(path: string, editor?: string | undefined): {
     command: string;
     args: string[];
@@ -37,6 +37,6 @@ export declare function editorCommand(path: string, editor?: string | undefined)
 /**
  * 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`.
+ * `$OPENAGENT_EDITOR`, then `code`.
  */
 export declare function openInApp(cwd: string, target: OpenTarget, agent?: SpawnRunner, editor?: string): Promise<OpenResult>;

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

@@ -1,5 +1,5 @@
 import { type AgentMeta, type LiveAgent } from '../store/index.js';
-import type { ChoiceRequest, FrameworkEvent } from '../events.js';
+import type { ChoiceRequest, OpenAgentEvent } from '../events.js';
 import { type BridgeQuestion } from './bridge-question.js';
 import type { ProjectSummary } from './projects.js';
 /** One session's open question, as the hub lists it: who waits, on what, since when. */
@@ -19,7 +19,7 @@ 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>;
+    events?: (cwd: string, agentId: string) => Promise<OpenAgentEvent[] | undefined>;
     /**
      * The questions the browser bridge holds, minus those with an answer already on its way
      * (default: the daemon's bridge store).

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

@@ -1,6 +1,6 @@
 import { type ProjectRecord } from '../registry.js';
 import { type AgentMeta } from '../store/index.js';
-import type { ProjectError } from '../project-errors.js';
+import type { ProjectError, StaysLocal } from '../project-errors.js';
 import { type GitHostFor } from '../store/git-host.js';
 /**
  * The multi-project read side (#392): projects the daemon serves come from the registry (#390),
@@ -16,7 +16,7 @@ export interface ProjectSummary {
     path: string;
     /** Display name (the path's basename). */
     name: string;
-    /** True when the repo still has its `.the-framework/` marker. */
+    /** True when the repo still has its `.openagent/` marker. */
     activated: boolean;
     /** Whether one of the project's packages provides a git host; without one no pull request can be opened there. */
     gitHost: boolean;
@@ -29,10 +29,11 @@ export interface ProjectSummary {
      */
     errors?: ProjectError[];
     /**
-     * The project's repository has no remote, as the daemon's last data sync found it: nothing is
-     * wrong, it lives on this machine only. Absent otherwise; attached like `errors`.
+     * Why the project's data stays on this machine, as the daemon's last data sync found it: its
+     * repository has no remote, or the person keeps the agents' records here. Nothing is wrong.
+     * Absent for a project that shares them; attached like `errors`.
      */
-    localOnly?: true;
+    local?: StaysLocal;
 }
 /**
  * A projection over the registered projects, together with the projects it could actually see.

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

@@ -4,10 +4,10 @@ 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
+ * same provider. OpenAgent 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
+ * The shapes are OpenAgent'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.
  */
@@ -36,7 +36,7 @@ export interface OpenPr {
     /**
      * 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}
+     * The exception is a draft OpenAgent opened for itself (#1102), which {@link headRefName}
      * is what tells apart.
      */
     isDraft: boolean;
@@ -57,7 +57,7 @@ export type PrLookup = (cwd: string, branch?: string) => Promise<LinkedPr | unde
 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. */
+/** A provider's request as OpenAgent 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;
@@ -65,7 +65,7 @@ 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
+ * whose prompt pins its branch name (`openagent/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

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

@@ -1,5 +1,5 @@
 import { EventStream } from '../event-stream.js';
-import type { FrameworkEvent } from '../events.js';
+import type { OpenAgentEvent } from '../events.js';
 import type { AgentMeta } from '../store/index.js';
 import type { StartAgentOptions, StartAgentResult } from './types.js';
 /**
@@ -9,7 +9,7 @@ import type { StartAgentOptions, StartAgentResult } from './types.js';
  * {@link EventStream}, which the dashboard reads over its normal same-origin `onEvents` channel. So
  * the browser never talks cross-origin and the token never leaves the two daemons (issue #1067 (b)).
  *
- * Authentication is the shared-token cookie (#1051), sent daemon-to-daemon: `Cookie: fw_daemon=<token>` with no
+ * Authentication is the shared-token cookie (#1051), sent daemon-to-daemon: `Cookie: oa_daemon=<token>` with no
  * `Origin` header. The remote's guard admits a matching cookie without the browser-only `?token=`
  * 302, and its `/_rpc` CSRF check (absent Origin passes) is not even on these raw routes.
  */
@@ -50,7 +50,7 @@ export declare function relayRpc(target: RemoteTarget, fn: string, args: unknown
  * cleanly rather than as an error, so the dashboard sees a normal `done`, not a lost connection.
  * Returns a cancel function; calling it aborts the fetch and releases the reader.
  */
-export declare function streamRemoteEvents(target: RemoteTarget, agentId: string, onEvent: (event: FrameworkEvent) => void, onEnd?: () => void): () => void;
+export declare function streamRemoteEvents(target: RemoteTarget, agentId: string, onEvent: (event: OpenAgentEvent) => void, onEnd?: () => void): () => void;
 /**
  * The local daemon's live relayed runs (#1067), keyed by the remote agent id. Registering an agent opens
  * an {@link EventStream} the dashboard reads through `onEvents`, fed by {@link streamRemoteEvents}
@@ -72,7 +72,7 @@ export declare class RelayedAgents {
     /** Open a local stream for a remote agent and start pumping the remote's events into it. */
     register(agentId: string, target: RemoteTarget, meta: AgentMeta, projectId: string): void;
     /** The live event stream for a relayed agent, or undefined when this daemon is not relaying it. */
-    get(agentId: string | undefined): EventStream<FrameworkEvent> | undefined;
+    get(agentId: string | undefined): EventStream<OpenAgentEvent> | undefined;
     /** The device a relayed agent runs on, kept past the event stream so post-run push/PR still reach it. */
     target(agentId: string | undefined): RemoteTarget | undefined;
     /** A project's relayed run stubs (#1077), newest-first, so `onAgents` can surface them in the list. */
@@ -91,4 +91,4 @@ export declare class RelayedAgents {
  * card would say, kept here because that card is on the device. The events are the ones a run's
  * diary yields: the agent's session id, its cost, its end.
  */
-export declare function foldRelayedEvent(meta: AgentMeta, event: FrameworkEvent, at: string): AgentMeta;
+export declare function foldRelayedEvent(meta: AgentMeta, event: OpenAgentEvent, at: string): AgentMeta;

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

@@ -1,20 +1,22 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { FrameworkEvent } from '../events.js';
+import type { OpenAgentEvent } from '../events.js';
 import type { PreferencesStore } from '../registry.js';
 import type { QuotaSource } from './quota.js';
 import type { ModelsSource } from './models.js';
 import type { BridgeBrowserOwner } from '../bridge-browser.js';
 import type { ProjectErrorsReader } from '../project-errors.js';
-import type { AddProjectResult, StartAgentOptions, StartAgentResult } from './types.js';
+import type { AddProjectResult, RemoveProjectResult, StartAgentOptions, StartAgentResult } from './types.js';
 import type { AgentMeta } from '../store/index.js';
 /** Wired by the daemon so `sendStart` can reach the daemon's own `startAgent` closure. */
 export type StartAgentHandler = (prompt: string, options: StartAgentOptions, projectId?: string) => StartAgentResult | Promise<StartAgentResult>;
 /** Wired by the daemon so `sendAddProject` can install + register a repo (#433). */
-export type AddProjectHandler = (path: string) => AddProjectResult | Promise<AddProjectResult>;
+export type AddProjectHandler = (path: string, share: boolean) => AddProjectResult | Promise<AddProjectResult>;
+/** Wired by the daemon so `sendRemoveProject` can take a project off the list, by its id, and with `files` remove what OpenAgent left in its folder. */
+export type RemoveProjectHandler = (projectId: string, files: boolean) => RemoveProjectResult | Promise<RemoveProjectResult>;
 /** Resolve an agent to its live event stream: the relay feeds `onEvents` from its own in-memory stream
  * rather than a file on disk (#426), and the daemon feeds an agent it is relaying from a device (#1067).
  * Returns undefined when there is no in-memory stream, so `onEvents` falls back to tailing the log. */
-export type EventsSource = (projectId: string, agentId?: string) => AsyncIterable<FrameworkEvent> | undefined;
+export type EventsSource = (projectId: string, agentId?: string) => AsyncIterable<OpenAgentEvent> | undefined;
 /** Look up the device a relayed agent (#1067) executes on, or undefined for an ordinary local agent. The
  *  daemon wires this from its live relayed-agent map; a run-scoped RPC uses it to forward a remote agent's
  *  read/steer/handoff to that device instead of resolving a (nonexistent) local checkout. */
@@ -37,6 +39,7 @@ export interface RemoteAgents {
 export interface DashboardContext {
     startAgent: StartAgentHandler;
     addProject: AddProjectHandler;
+    removeProject: RemoveProjectHandler;
     /** The in-memory event stream for an agent relayed from a connected device (#1067), else undefined. */
     eventsSource: EventsSource;
     /** The relayed-agent lookup (#1067 slice 2), so a run-scoped RPC can tell a local agent from one

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

@@ -3,10 +3,10 @@ import { type InboxLine } from '@openagt/agent-driver';
  * What a person says to a run (#1774): their own words, or their answer to the question the run
  * stopped on. The daemon runs no agent, so the line reaches the run through what the run's tool
  * reads: the inbox file in the run's checkout while the run works, the project's `resume` hook
- * line once it has ended. The framework names no tool in either.
+ * line once it has ended. OpenAgent names no tool in either.
  */
 /**
- * The inbox of a run, in its checkout's `.the-framework/`: the file agent-driver's session reads
+ * The inbox of a run, in its checkout's `.openagent/`: the file agent-driver's session reads
  * when a turn ends, one JSON line per message or answer. The run's tool hands the session the
  * same path.
  */

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

@@ -0,0 +1,31 @@
+/**
+ * The branch agents start from in the project at `cwd`: origin's default branch as this clone has
+ * it, else the branch the folder is on (a project with no remote starts an agent from its last
+ * local commit). `ref` is what git is asked, `name` what a person reads. None where the folder is
+ * on no branch, or is no repository.
+ */
+export declare function startBranch(cwd: string): Promise<{
+    ref: string;
+    name: string;
+} | undefined>;
+/** A skill that is in the folder and not on the branch agents start from. */
+export interface Waiting {
+    /** The branch it has yet to reach, by name. */
+    branch: string;
+    /** Whether the branch the folder is on has it: an agent started from that branch does. */
+    here: boolean;
+}
+/**
+ * Which of the skills `names`, all in the project's folder, are waiting to reach the branch agents
+ * start from. A skill is said to be waiting only when that is known: an agent's checkout fetches
+ * the remote before it starts, so before a skill is called waiting against a remote branch, this
+ * clone's copy of that branch is fetched too (at most once a minute per project), or a pull
+ * request merged a moment ago would keep its skill waiting here.
+ */
+export declare function waitingSkills(cwd: string, names: readonly string[]): Promise<{
+    start?: {
+        ref: string;
+        name: string;
+    };
+    waiting: Map<string, Waiting>;
+}>;

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

@@ -14,10 +14,36 @@ export type DeleteAgentResult = {
     ok: false;
     error: string;
 };
-/** The outcome of an add-project attempt (#396): registered, or was already, or why not. */
+/**
+ * The outcome of an add-project attempt (#396): registered, or was already, or why not.
+ * `noRemote` says the person asked to share the agents' records and the repository has no remote
+ * to share with: they are kept on this machine.
+ */
 export type AddProjectResult = {
     ok: true;
     alreadyActivated: boolean;
+    noRemote?: true;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * What removing OpenAgent's files from a project's folder did: what went, what stayed with the
+ * reason, and what could not be done, each line in words for a person. Paths are from the
+ * project's root.
+ */
+export interface CleanupReport {
+    removed: string[];
+    kept: {
+        path: string;
+        reason: string;
+    }[];
+    failed: string[];
+}
+/** The outcome of removing a project from the list: gone from it, with what the clean-up did when one was asked for, or why not. */
+export type RemoveProjectResult = {
+    ok: true;
+    cleanup?: CleanupReport;
 } | {
     ok: false;
     error: string;
@@ -44,7 +70,7 @@ export interface StartAgentOptions {
     model?: string;
     /** Which coding agent the run is on: `claude-code` or `codex`. */
     driver?: string;
-    /** The person's saved pick of how far the run takes its work when the agent finishes. Absent, none is saved: the daemon starts the run as far as the project goes with no pull request. A pick the project is not offered is held to that too. */
+    /** The person's saved pick of how far the run takes its work when the agent finishes. Absent, none is saved: the daemon starts the run at `commit`. A saved pick the project is not offered is held to the furthest the project goes with no pull request. */
     publish?: PublishPick;
     /**
      * The branch the agent's own branch starts from, as this machine has it, commits that are not
@@ -59,7 +85,7 @@ export interface StartAgentOptions {
     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
+     * daemon at `url` (authenticating with `token` as the `oa_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

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

@@ -51,3 +51,5 @@ export declare function contextBridgeBrowser(): BridgeBrowserOwner;
 export declare function contextStartAgent(): DashboardContext['startAgent'];
 /** Install + register a repo (#433), which only the daemon can do. */
 export declare function contextAddProject(): DashboardContext['addProject'];
+/** Take a project off the list, which only the daemon can do: it runs the project's close hooks first. */
+export declare function contextRemoveProject(): DashboardContext['removeProject'];

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

@@ -16,7 +16,7 @@ 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
+ * whoever runs the agent; OpenAgent 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>;

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

@@ -1,10 +1,10 @@
-import type { FrameworkEvent } from '../events.js';
+import type { OpenAgentEvent } 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.
+ * {@link OpenAgentEvent}, is never written to any journal, and the client swallows it.
  */
 export type StreamSync = {
     kind: 'stream-sync';
@@ -19,7 +19,7 @@ export type PartialMessage = {
     text: string;
 };
 /** What `onEvents` streams: the agent's events, plus the wire-only end-of-replay marker and partial message. */
-export type LiveFeedEvent = FrameworkEvent | StreamSync | PartialMessage;
+export type LiveFeedEvent = OpenAgentEvent | StreamSync | PartialMessage;
 /**
  * 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

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

@@ -1,13 +1,14 @@
 export { onAgents, onAgent, onAgentsDoing, onDocs, onQueue, onOverview, onRecentAgents, onInterventions, onOpenQuestions, onActivity, onDashboard, onGitHostHome, onRepositoryOffer, onGitStatus, onProjectFiles, 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, sendMergeBranch, sendMerge, sendCreateRepository } from './control.js';
 export { streamAgentEvents, type LiveFeedEvent, type PartialMessage, type StreamSync } from './events.js';
-export { onProjects, sendAddProject, sendPickProjectDirectory, onOnboarding, onCommands, onStartCheck, type ProjectLauncher } from './projects.js';
+export { onProjects, sendAddProject, sendRemoveProject, onRecordsReach, sendShareRecords, sendPickProjectDirectory, onOnboarding, onCommands, onStartCheck, 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 { onModules, runModuleCommand, readModule, type DashboardModule, type ModuleCommandResult, type ModuleReadResult } from './modules.js';
+export { onProjectSkills, sendChangeSkills, sendCommitSkills, type ProjectSkills, type ProjectSkill, type ChangeSkillsResult } from './skills.js';
 import { streamAgentEvents } from './events.js';
 /** One RPC: called with whatever the browser sent, answering with whatever JSON.stringify keeps. */
 export type RpcHandler = (...args: never[]) => unknown;

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

@@ -12,8 +12,9 @@ export interface DashboardModule {
     projects: string[];
 }
 /**
- * Every module any registered project brings (#1774), one per package: the sidebar and the pages
- * are cross-project, like the Overview. A package several projects install is loaded once, from
+ * Every module any registered project brings (#1774), one per package, with the projects
+ * that have it: with no project picked the sidebar and the pages are every project's, and the
+ * dashboard narrows them itself to a picked project's. A package several projects install is loaded once, from
  * the first of them in the registry's order; its page then reads each project through that
  * project's own command. A project that cannot be read contributes nothing.
  */
@@ -22,14 +23,15 @@ export declare function onModules(): Promise<DashboardModule[]>;
  * Run one of a module package's commands in one project and answer its JSON output: how a module
  * reads (and changes) its own data. Refused for an unknown project and for a package that is not a
  * module of that project, so a page can run only its own package's commands, never an arbitrary
- * program. Once the command has run, the framework forgets what it had read of that project's
+ * program. Once the command has run, OpenAgent forgets what it had read of that project's
  * provided data (its queue, its runs): the command may have written it, and the next read sees
  * that at once instead of a cached copy.
  *
  * `acts` says the command is a module's action on the project (a link action), not a page's read:
- * the framework then also converges the project's data branch with origin, as its clock does
- * every minute, before forgetting — a package's command writes as a remote writer, straight to
- * origin, and this machine's copy would otherwise show the write only at the next sync.
+ * OpenAgent then also converges the project's data branch with origin, as its clock does
+ * every minute, before forgetting — in a project that shares its records a package's command
+ * writes as a remote writer, straight to origin, and this machine's copy would otherwise show the
+ * write only at the next sync.
  */
 export declare function runModuleCommand(projectId: string, pkg: string, args: string[], command?: string, acts?: boolean): Promise<ModuleCommandResult>;
 /**

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

@@ -28,13 +28,13 @@ export type PatchPreferencesResult<T> = {
  */
 export declare function patchPreferences(patch: Preferences): Promise<PatchPreferencesResult<Preferences>>;
 /**
- * A project's shared custom presets (#1025), committed into its `.the-framework/` so they travel
+ * A project's shared custom presets (#1025), committed into its `.openagent/` 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). */
+/** Persist a project's shared custom presets into its `.openagent/` (#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[]>;