@openagt/dashboard 0.8.0 → 0.9.0

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/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,7 +1,7 @@
 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';

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[]>;

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

@@ -1,16 +1,42 @@
 import { type ProjectCommand } from '../project-commands.js';
+import { type BranchReach } from '@openagt/agent-data';
 import { type StartReadiness } from '../project-hooks.js';
 import { type PickDirectoryResult } from '../pick-directory.js';
 import type { ProjectSummary } from '../dashboard/projects.js';
-import type { AddProjectResult, OnboardingSuggestion } from '../dashboard/types.js';
+import type { AddProjectResult, OnboardingSuggestion, RemoveProjectResult } from '../dashboard/types.js';
 export declare function onProjects(): Promise<ProjectSummary[]>;
 /**
  * Add a project from the dashboard (#396/#433): install the repo and register it so it joins the
  * Projects list. Like `sendStart` this needs the daemon (it spawns git + writes the shared
  * registry), so it calls the daemon's own `addProject` closure off the wired dashboard context.
  * Returns the daemon's {@link AddProjectResult}.
+ *
+ * `share` is the person's answer, asked before the add: whether the agents' records may go to the
+ * repository's remote. Nothing is pushed for a project added with `false`.
  */
-export declare function sendAddProject(path: string): Promise<AddProjectResult>;
+export declare function sendAddProject(path: string, share: boolean): Promise<AddProjectResult>;
+/**
+ * Remove a project from the dashboard: it leaves the Projects list. Nothing in its folder is
+ * deleted unless `files` is true: then what OpenAgent left there is removed too, and the answer
+ * says what went and what stayed. Like `sendAddProject` this is the daemon's to do (it runs the project's close hooks and
+ * writes the shared registry), so it calls the daemon's own closure off the wired dashboard context.
+ * Addressed by id and not by path, so a project whose folder is gone can still be removed.
+ */
+export declare function sendRemoveProject(projectId: string, files: boolean): Promise<RemoveProjectResult>;
+/** How far the project's records reach right now, read off its repository; `null` when the project is unknown here. */
+export declare function onRecordsReach(projectId: string): Promise<BranchReach | null>;
+/**
+ * The person's switch: share the project's records with its remote, or keep them on this machine.
+ * Turning it on sends what is there now, so a remote that refuses is said at once, and the switch
+ * goes back to off: the records stay where they were. A project with no remote has nothing to
+ * share with, and is refused.
+ */
+export declare function sendShareRecords(projectId: string, on: boolean): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
 /**
  * Open the OS folder picker on the daemon's machine and wait for the user's choice (#1150). The
  * browser cannot learn an absolute path from any picker of its own, and the daemon — which runs on
@@ -26,7 +52,7 @@ export declare function onOnboarding(): Promise<OnboardingSuggestion>;
 /** What the launcher offers for a project: its commands, and whether a run can be started here at all. */
 export interface ProjectLauncher {
     commands: ProjectCommand[];
-    /** Whether the project's `.the-framework/hooks.yml` has a `start` line; without one Start is off. */
+    /** Whether the project's `.openagent/hooks.yml` has a `start` line; without one Start is off. */
     startHook: boolean;
     /** Whether one of the project's packages provides a git host; without one no pull request can be opened, so the publish menu stops at the branch. */
     gitHost: boolean;

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

@@ -13,7 +13,7 @@ import { type DashboardData } from '../dashboard/dashboard.js';
 import { type GitStatus } from '../dashboard/git-status.js';
 import { type AgentHandoff } from '../dashboard/agent-handoff.js';
 import type { AgentWorktree } from '../dashboard/types.js';
-import type { FrameworkEvent } from '../events.js';
+import type { OpenAgentEvent } from '../events.js';
 import type { BridgeEvent, BridgeHello, BridgeQuestion } from '../dashboard/bridge-endpoints.js';
 import type { BridgeAnswer, BridgeContact, BridgeVersion } from '../dashboard/bridge-store.js';
 /**
@@ -78,7 +78,7 @@ export declare function onRetainedWorktrees(projectId: string): Promise<string[]
  */
 export declare function onAgentWorktree(projectId: string, agentId: string): Promise<AgentWorktree | null>;
 /** One archived agent's event log for replay (or `[]` when the agent or project is gone). */
-export declare function onAgent(projectId: string, agentId: string): Promise<FrameworkEvent[]>;
+export declare function onAgent(projectId: string, agentId: string): Promise<OpenAgentEvent[]>;
 /** What each of the named runs of a project is doing now, by id; a run that is not working has no entry. */
 export declare function onAgentsDoing(projectId: string, agentIds: string[]): Promise<Record<string, string>>;
 /** The surfaced PLAN/TODO docs at the workspace root, in sidebar order (or `[]`). */
@@ -170,7 +170,7 @@ export declare function onBridgeStatus(): Promise<{
  * page. Revealing it here is not a new exposure: anyone who can load this dashboard can already
  * start runs on this machine, and on a non-loopback bind their browser is holding the same token
  * as a cookie. What it replaces is the alternative, which was telling people to open
- * `~/.the-framework.json` and copy a field out of it.
+ * `~/.openagent.json` and copy a field out of it.
  */
 export declare function onBridgeToken(): Promise<string | null>;
 /**

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

@@ -3,7 +3,7 @@
  * 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
+ * used to default to the supervisor's event; the only caller here passes `OpenAgentEvent`, so
  * the parameter is now required.
  */
 export declare class EventStream<E> {

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

@@ -12,7 +12,7 @@ export interface ChoiceOption {
 }
 /**
  * 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
+ * a `choice` {@link OpenAgentEvent}; 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 {
@@ -39,7 +39,7 @@ export interface ChoiceRequest {
 }
 /** 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. */
+/** What a {@link import('./agent.js').RunOpenAgentOptions.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[];
@@ -49,21 +49,21 @@ export interface ChoicePick {
 /** 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):
+ * The single type a run's timeline is read as. OpenAgent 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
+ * daemon stopped running agents** — OpenAgent'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 = {
+export type OpenAgentEvent = {
     at?: string;
 } & (
 /**
@@ -105,8 +105,8 @@ export type FrameworkEvent = {
  * 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.
+ * screen has gone. A diary line a command appends itself (agent-driver's `DIARY_ENV`);
+ * OpenAgent knows nothing of what the page is.
  */
  | {
     kind: 'screen';
@@ -114,7 +114,7 @@ export type FrameworkEvent = {
     label: string;
     ended?: true;
 }
-/** A framework-level log line. */
+/** An OpenAgent-level log line. */
  | {
     kind: 'log';
     message: string;

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

@@ -13,7 +13,7 @@
  * 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 { ChoiceRequest, OpenAgentEvent } from './events.js';
 export type { QuotaBoundary } from './quota-boundary.js';
 export type { CustomPreset, Preferences } from './registry.js';
 export type { PublishPick } from './publish-levels.js';
@@ -23,6 +23,7 @@ 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 { RepositoryOffer, CreateRepositoryResult } from './store/repository.js';
+export type { BranchReach as RecordsReach } from '@openagt/agent-data';
 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';
@@ -37,4 +38,4 @@ export type { ProjectError, ProjectErrorCode } from './project-errors.js';
 export type { ProjectQueue } from './dashboard/queue.js';
 export type { QuotaView } from './dashboard/quota.js';
 export type { Ticket } from './store/tickets.js';
-export type { AgentWorktree, OnboardingSuggestion } from './dashboard/types.js';
+export type { AgentWorktree, CleanupReport, OnboardingSuggestion } from './dashboard/types.js';

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

@@ -1,4 +1,4 @@
-import type { ChoiceRequest, FrameworkEvent } from './events.js';
+import type { ChoiceRequest, OpenAgentEvent } 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
@@ -11,4 +11,4 @@ import type { ChoiceRequest, FrameworkEvent } from './events.js';
  * 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[];
+export declare function pendingChoices(events: readonly OpenAgentEvent[]): ChoiceRequest[];

package/dist/module-types/src/{framework-dir.d.ts → openagent-dir.d.ts}

@@ -1,5 +1,5 @@
 /**
- * The directory, under a project root, that holds The Framework's own files.
+ * The directory, under a project root, that holds OpenAgent'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.
@@ -7,4 +7,4 @@
  * 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 `@openagt/agent-data` names (#1769).
  */
-export declare const THE_FRAMEWORK_DIR = ".the-framework";
+export declare const OPENAGENT_DIR = ".openagent";

package/dist/module-types/src/openagent-gitignore.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The `.openagent/.gitignore` (#313): one file, one content, written at install.
+ *
+ * Everything under `.openagent/` 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 is tracked, this file included: git shows no trace of the directory.
+ */
+/** The `.gitignore` path under `cwd`'s `.openagent/`. */
+export declare function gitignorePath(cwd: string): string;
+/** The whole file: everything under `.openagent/` stays out of git, the file itself too (#1582). */
+export declare function openagentGitignore(): string;

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

@@ -1,6 +1,6 @@
 /**
  * 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
+ * the coding agents read them from. OpenAgent 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.

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

@@ -7,13 +7,15 @@
  * line on the daemon's stdout and nothing else, which is the worst way to handle a state nobody
  * can see.
  *
- * A repository with no origin at all is not an error: a folder that was never shared is a normal
- * project. The sync records it as `localOnly`, a note the dashboard says quietly.
+ * A project whose data stays on this machine is not an error: a folder with no origin, or one the
+ * person does not share, is a normal project. The sync records why as `local`, a note the
+ * dashboard says quietly.
  *
  * 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.
  */
+import type { BranchReach } from '@openagt/agent-data';
 /**
  * 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
@@ -28,6 +30,8 @@ export interface ProjectError {
     /** ISO timestamp of when the error was first recorded; a re-report of the same code keeps it. */
     since: string;
 }
+/** Why a project's data stays on this machine: its repository has no origin, or the person keeps it here. */
+export type StaysLocal = Exclude<BranchReach, 'origin'>;
 /** The daemon's write side: one slot per (project, code). */
 export interface ProjectErrors {
     /**
@@ -40,15 +44,15 @@ export interface ProjectErrors {
     clear(projectPath: string, code: ProjectErrorCode): void;
     /** The project's current errors, oldest first. */
     list(projectPath: string): ProjectError[];
-    /** Whether the project's repository has no remote to sync with, as the last sync found it. */
-    setLocalOnly(projectPath: string, localOnly: boolean): void;
-    /** What the dashboard shows of the project: its errors, and whether it is local only. */
+    /** How far the project's data reaches, as the last sync found it. */
+    setReach(projectPath: string, reach: BranchReach): void;
+    /** What the dashboard shows of the project: its errors, and why its data stays local, if it does. */
     read(projectPath: string): ProjectState;
 }
-/** What the background jobs currently know of a project: what is wrong with it, and whether its repository has no remote. */
+/** What the background jobs currently know of a project: what is wrong with it, and why its data stays on this machine, if it does. */
 export interface ProjectState {
     errors: ProjectError[];
-    localOnly: boolean;
+    local?: StaysLocal;
 }
 /** The dashboard's read side, wired into its context. */
 export type ProjectErrorsReader = ProjectErrors['read'];

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

@@ -1,18 +1,18 @@
 /**
- * A project's hooks (#1774): the shell lines a project's own `.the-framework/hooks.yml` names to
+ * A project's hooks (#1774): the shell lines a project's own `.openagent/hooks.yml` names to
  * run when the dashboard opens and when it closes, the two lines that start a run and continue
  * one, and the line that says whether a run can start here at all. The daemon calls no tool by
  * name: it runs whatever the file says, in the project, with the project's installed tools and
  * then the built-in packages' on the PATH, so a line reaches its tool with nothing fetched from npm. Per
- * user, since `.the-framework/` is ignored: a hook is this machine's, and a teammate's pull
+ * user, since `.openagent/` is ignored: a hook is this machine's, and a teammate's pull
  * changes nothing.
  *
  * Optional, best-effort and bounded: no file means nothing runs, a broken file is a warning, an
  * `open` or `close` line that fails or hangs is logged and the next line still runs, and nothing
  * here ever throws to the daemon.
  */
-/** The hooks file, under the project's ignored `.the-framework/`. */
-export declare const PROJECT_HOOKS_FILE = ".the-framework/hooks.yml";
+/** The hooks file, under the project's ignored `.openagent/`. */
+export declare const PROJECT_HOOKS_FILE = ".openagent/hooks.yml";
 /** How long one line may run before it is killed and logged as timed out. */
 export declare const HOOK_TIMEOUT_MS = 60000;
 /** When a project's hooks run: `open` when the dashboard starts (and when the project is added while it runs), `close` when it stops. */

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

@@ -1,9 +1,9 @@
 import { type PackageCommandResult } from '@openagt/agent-data';
 /**
  * A package that adds to the dashboard (#1774): its browser part, named by its
- * `exports["./dashboard"]`, and optionally its server part, named by `exports["./server"]`. The
- * framework names no package: any dependency of the project that exports `./dashboard` is a
- * module, whoever wrote it, and the framework's own built-in modules come the same way.
+ * `exports["./dashboard"]`, and optionally its server part, named by `exports["./server"]`.
+ * OpenAgent names no package: any dependency of the project that exports `./dashboard` is a
+ * module, whoever wrote it, and OpenAgent's own built-in modules come the same way.
  */
 export interface ProjectModule {
     /** The package's name, as the project's package.json lists it. */
@@ -21,7 +21,7 @@ export interface ProjectModule {
 }
 /**
  * The modules a project has: each of its dependencies whose package.json exports `./dashboard` to
- * a file that exists inside the package, plus the modules among the framework's built-in packages (`built-in.ts`). A project that
+ * a file that exists inside the package, plus the modules among OpenAgent's built-in packages (`built-in.ts`). A project that
  * depends on a built-in module's package itself gets its own copy. Sorted by name.
  */
 export declare function readProjectModules(root: string): Promise<ProjectModule[]>;
@@ -38,7 +38,7 @@ export type ModuleCommandResult = PackageCommandResult;
 /**
  * Run one of a module package's own commands in the project, with the given arguments, and read
  * its standard output as JSON. This is how a module reads its data: the same command an agent runs
- * (`npx logs`), so the module and the agent see the same thing and the framework knows neither.
+ * (`npx logs`), so the module and the agent see the same thing and OpenAgent knows neither.
  *
  * `command` picks one of the package's commands; a package with exactly one needs none. The
  * command runs with Node (a package's commands are Node scripts), in the project root, never