@openagt/dashboard 0.8.0 → 0.10.0

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/dashboard-rpc/skills.d.ts

@@ -0,0 +1,79 @@
+import { type Standing } from '@openagt/init';
+/**
+ * A project's skills, as the dashboard shows and changes them (#2023): the same list with ticks
+ * `npx @openagt/init` shows in a terminal, read and written through that package's own code, so
+ * the two cannot drift apart. A project has a skill when the skill's text is in its folder; the
+ * dashboard writes and deletes those files, and offers the one commit that holds them.
+ */
+/** One skill of the list, as it stands in the project. */
+export interface ProjectSkill {
+    name: string;
+    /** The one line the skill's text says of itself. */
+    description: string;
+    /** How the project's text stands against the one this dashboard carries; `absent` when the project does not hold the skill. */
+    standing: Standing;
+    /** Whether the skill is in the folder but not yet on the branch agents start from: an agent started from it does not have the skill. */
+    waiting: boolean;
+}
+export interface ProjectSkills {
+    /** How many skills the project has, of how many there are: the ones in its folder, and the basic ones every run gets. */
+    has: number;
+    of: number;
+    /** The list's groups; `ticked` says whether a group's skills are ticked in a project that has none yet. */
+    groups: {
+        title: string;
+        ticked: boolean;
+        skills: ProjectSkill[];
+    }[];
+    /** Whether the scheduler starts with the dashboard for this project, on this machine. */
+    scheduler: boolean;
+    /** The branch agents start from, by its name: the remote's default branch, else the branch the folder is on. Absent where there is none. */
+    startBranch?: string;
+    /** How many skill files stand written or deleted in the folder with no commit yet. */
+    uncommitted: number;
+    /** Whether the folder is a git repository: without one there is nothing to commit. */
+    git: boolean;
+    /** Whether the project has a remote: without one a commit on this machine is all agents need. */
+    remote: boolean;
+}
+/** The project's skills; `null` when the project is unknown here. */
+export declare function onProjectSkills(projectId: string): Promise<ProjectSkills | null>;
+/** What a change of skills answered: what was written and deleted, what was left as it is, and the scheduler when the change switched it. */
+export type ChangeSkillsResult = {
+    ok: true;
+    written: string[];
+    removed: string[];
+    left: {
+        path: string;
+        reason: string;
+    }[];
+    scheduler?: 'on' | 'off';
+    schedulerError?: string;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Write and delete skills in a project's folder, and switch its scheduler: what the "Add skills"
+ * screen saves. Only the names of the list are taken; anything else is refused whole. A scheduler
+ * switched on starts at once, by its own line, as it would have at this dashboard's opening.
+ * Nothing is committed here: `sendCommitSkills` is the person's next press.
+ */
+export declare function sendChangeSkills(projectId: string, change: {
+    write?: string[];
+    remove?: string[];
+    scheduler?: boolean;
+}): Promise<ChangeSkillsResult>;
+/**
+ * One commit of skill files that stand uncommitted in the project's folder, on the branch the
+ * folder is on: the files of the skills `only` names, after a change that wrote or deleted them,
+ * else every uncommitted skill file. Never a push.
+ */
+export declare function sendCommitSkills(projectId: string, only?: string[]): Promise<{
+    ok: true;
+    committed: boolean;
+    commit?: string;
+} | {
+    ok: false;
+    error: string;
+}>;

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/openagent-dir.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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, a run's card, diary and inbox) spells it the same way. The name itself is
+ * `@openagt/agent-data`'s, which also makes the directory when a folder becomes a project.
+ */
+export { OPENAGENT_DIR } from '@openagt/agent-data/names';

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.
@@ -13,6 +13,10 @@ export interface ProjectCommand {
     name: string;
     /** The `description` of the skill's front matter, when it has one. */
     description?: string;
+    /** The branch the skill has yet to reach, by name, when its text is in the folder but not on the branch agents start from: an agent started from that branch does not have the command. */
+    waiting?: string;
+    /** With `waiting`: whether the branch the folder is on has the skill, so an agent started from that branch does have the command. */
+    here?: true;
 }
 /**
  * The project's commands, by name: the skills whose front matter says

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
+ * name: it runs whatever the file says, in the project, with the commands of the packages
+ * OpenAgent brings and then the project's installed tools on the PATH, so a line reaches its tool with nothing fetched from npm. Per
+ * 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. */
@@ -49,6 +49,8 @@ export interface RunHooksOptions {
     timeoutMs?: number;
     /** The environment the lines run with; default the daemon's own. */
     env?: NodeJS.ProcessEnv;
+    /** The lines to run, of the ones the file holds; every line when absent. */
+    only?: readonly string[];
 }
 /**
  * Run a project's `open` or `close` lines, in order, each through `sh -c` with the project's
@@ -122,8 +124,9 @@ export declare function runCheckHook(cwd: string, input: {
     driver?: string;
 }, opts?: Omit<RunHooksOptions, 'log'>): Promise<CheckHookResult>;
 /**
- * The environment a line runs with: the PATH led by the project's installed tools, then the
- * built-in packages' own commands, so a tool named in a line is the project's copy when it
- * installed one and the dashboard's otherwise, and never a package fetched by name.
+ * The environment a line runs with: the PATH led by the commands of the packages OpenAgent
+ * brings, then the project's installed tools. So a tool of OpenAgent's named in a line is always
+ * OpenAgent's copy, the one its pages and its data go through too, any other tool is the
+ * project's, and nothing is a package fetched by name.
  */
 export declare function hookEnv(cwd: string, env: NodeJS.ProcessEnv): Promise<NodeJS.ProcessEnv>;

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

@@ -1,12 +1,13 @@
 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"]`.
+ * Any dependency of the project that exports `./dashboard` is a module, whoever wrote it, and the
+ * packages OpenAgent brings itself come the same way, for the projects that have them
+ * (`built-in.ts`).
  */
 export interface ProjectModule {
-    /** The package's name, as the project's package.json lists it. */
+    /** The package's name. */
     package: string;
     /** The package's version, when its package.json says one. */
     version?: string;
@@ -21,8 +22,9 @@ 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
- * depends on a built-in module's package itself gets its own copy. Sorted by name.
+ * a file that exists inside the package, plus the modules among the packages OpenAgent brings to
+ * this project (`built-in.ts`): a skill's page where the project holds the skill's text. Sorted
+ * by name.
  */
 export declare function readProjectModules(root: string): Promise<ProjectModule[]>;
 /** The one module of this project that `name` names, or undefined. */
@@ -38,7 +40,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 @openagt/skill-logs@0.1`), 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

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

@@ -11,8 +11,8 @@ import { type StoreFs } from './store/index.js';
  * The store is a plain JSON array of {@link CustomPreset}, the exact shape the user tier uses, so
  * the dashboard renders both from one type and the same sanitizer guards both files.
  */
-/** The committed file holding a project's shared custom presets, under `.the-framework/`. */
-export declare const PROJECT_PRESETS_FILE = ".the-framework/custom-presets.json";
+/** The committed file holding a project's shared custom presets, under `.openagent/`. */
+export declare const PROJECT_PRESETS_FILE = ".openagent/custom-presets.json";
 /**
  * Read a project's shared custom presets. Forgiving like every other read here: a missing,
  * unreadable or malformed file yields `[]`, never throws, and the same sanitizer that guards
@@ -21,8 +21,8 @@ export declare const PROJECT_PRESETS_FILE = ".the-framework/custom-presets.json"
 export declare function readProjectPresets(cwd: string, fs?: StoreFs): Promise<CustomPreset[]>;
 /**
  * Write a project's shared custom presets, sanitizing first so the committed file is always
- * well-formed. Also ensures `.the-framework/.gitignore` un-ignores the file: the dir's ignore is
- * `*` + `!.gitignore` (nothing else is tracked by default), so without a negation git would
+ * well-formed. Also ensures `.openagent/.gitignore` un-ignores the file: the dir's ignore is
+ * `*` (nothing is tracked by default), so without a negation git would
  * never see the presets and they could not be shared. Removing every preset writes an empty array
  * rather than deleting the file, so the negation stays in place for the next save.
  */

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

@@ -3,7 +3,7 @@ import { type GitRunner } from '@openagt/agent-data';
  * Project-level repo helpers (#380): the activation marker check and a
  * `git ls-files` crawl. Read-only
  * building blocks for the sidebars (#314); activation/install (writing the
- * marker, the install commit) is a separate, deferred concern.
+ * marker) is a separate, deferred concern.
  */
 /** Minimal fs seam so activation is unit-testable without touching disk. */
 export interface ProjectFs {
@@ -11,12 +11,12 @@ export interface ProjectFs {
     exists(path: string): Promise<boolean>;
 }
 /**
- * A repo is "activated"/installed for The Framework when it has the
- * `.the-framework/.gitignore` install writes — the same marker install's own
- * no-op check reads (#1600), so a `.the-framework/` directory something else
+ * A repo is "activated"/installed for OpenAgent when it has the
+ * `.openagent/.gitignore` install writes — the same marker install's own
+ * no-op check reads (#1600), so a `.openagent/` directory something else
  * created can never read as activated while the repo still lacks the ignore
- * file that keeps framework state off its branches. Read-only check; writing
- * the marker + the install commit is a separate, deferred concern.
+ * file that keeps OpenAgent state out of git. Read-only check; writing
+ * the marker is a separate, deferred concern.
  */
 export declare function isActivated(cwd: string, fs?: ProjectFs): Promise<boolean>;
 /**

package/dist/module-types/src/publish-levels.d.ts

@@ -4,8 +4,8 @@
  * The levels are the words a project's start hook is handed as `PUBLISH`, the ones
  * `agent-runner run --publish` takes. The launcher's menu offers them after "Nothing", the pick
  * that hands the hook no level: the run then commits and publishes nothing unless its prompt asks.
- * Until a person picks, a run goes as far as it can without a pull request: its branch pushed, or
- * its work committed where the project has no remote.
+ * Until a person picks, a run commits its work and pushes nothing: what leaves the machine is the
+ * person's to ask for.
  */
 /** The levels a run can be started at, each going further than the one before. */
 export declare const PUBLISH_LEVELS: readonly ['commit', 'branch', 'pr', 'merge'];
@@ -24,8 +24,8 @@ export declare function isPublishPick(value: unknown): value is PublishPick;
  */
 export declare function offeredPublishPicks(gitHost: boolean, remote?: boolean): readonly PublishPick[];
 /**
- * The saved pick as this project can hold it: a pick it is not offered falls back to the furthest
- * it goes with no pull request, which is also the pick in force until a person saves one.
+ * The pick in force in this project. Until a person saves one it is Commit, which pushes nothing.
+ * A saved pick the project is not offered falls back to the furthest it goes with no pull request.
  */
 export declare function publishPickIn(saved: PublishPick | undefined, gitHost: boolean, remote?: boolean): PublishPick;
 /** The level a pick hands the start hook; none for Nothing. */

package/dist/module-types/src/quota-boundary.d.ts

@@ -1,5 +1,5 @@
 /**
- * The quota boundary (#879): how much of the account's week The Framework may
+ * The quota boundary (#879): how much of the account's week OpenAgent may
  * have spent by now.
  *
  * The whole policy is one line — the boundary is the pro-rated share of the week's allowance that
@@ -10,7 +10,7 @@
  * Nothing is left on the floor: the boundary rises on its own and reaches the full allowance
  * exactly as the week resets, so a quiet week still gets spent rather than expiring.
  *
- * The Framework only draws it. Whether work stops at it, or how far past it, is the business of
+ * OpenAgent only draws it. Whether work stops at it, or how far past it, is the business of
  * whatever starts unattended work, which puts its own stop line on the usage bar.
  */
 import type { DriverQuotaWindow } from '@openagt/agent-driver';

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

@@ -1,8 +1,8 @@
 import { type PublishPick } from './publish-levels.js';
 /**
  * The multi-project registry (#390): the list of projects the user has
- * installed The Framework into, kept as a single JSON file `.bashrc`-style —
- * `$HOME/.the-framework.json` — so it is the user's responsibility to re-create
+ * installed OpenAgent into, kept as a single JSON file `.bashrc`-style —
+ * `$HOME/.openagent.json` — so it is the user's responsibility to re-create
  * per machine. The same file also holds the user's dashboard preferences (#410),
  * so the daemon owns one user file and the UI never needs localStorage.
  */
@@ -47,7 +47,7 @@ export interface Preferences {
      * The "needs you" category (#627): notify when an agent is awaiting your answer or a PR is ready
      * to review. A *category* toggle, like {@link notifyNewActivity}, composing with the method
      * toggle {@link notifyBrowser}. **Absent = on**: unlike the other
-     * flat opt-in booleans, human-intervention pings are the baseline The Framework leans on, so an
+     * flat opt-in booleans, human-intervention pings are the baseline OpenAgent leans on, so an
      * unset preference keeps them firing; a user turns them off explicitly.
      */
     notifyHumanIntervention?: boolean;
@@ -72,7 +72,7 @@ export interface Preferences {
      */
     postMergeCleanup?: boolean;
     /** Preferred editor for "Open in editor" (#727): an editor CLI (e.g. `code`, `cursor`, `zed`).
-     * Absent falls back to `$FRAMEWORK_EDITOR`, then `code`. */
+     * Absent falls back to `$OPENAGENT_EDITOR`, then `code`. */
     editor?: string;
     /** Dashboard color theme (#725): `system` (follow the OS, the default), `light`, or `dark`. Absent = system. */
     theme?: 'system' | 'light' | 'dark';
@@ -121,7 +121,7 @@ export interface PreferencesStore {
     patch(patch: Preferences): Promise<Preferences>;
 }
 /** The registry file name: a single file under `$XDG_CONFIG_HOME` (dotted under `$HOME`). */
-export declare const REGISTRY_FILE = "the-framework.json";
+export declare const REGISTRY_FILE = "openagent.json";
 /** Owner read/write only: the file holds the daemon token (#1051). */
 export declare const REGISTRY_FILE_MODE = 384;
 /**
@@ -132,8 +132,8 @@ export declare const REGISTRY_FILE_MODE = 384;
 export declare function projectId(path: string): string;
 /**
  * The registry file path, resolved from `env` (injectable so tests never touch
- * the real home): `$XDG_CONFIG_HOME/the-framework.json` when set, else the
- * dotted `$HOME/.the-framework.json`. A single file, not a directory (#390).
+ * the real home): `$XDG_CONFIG_HOME/openagent.json` when set, else the
+ * dotted `$HOME/.openagent.json`. A single file, not a directory (#390).
  */
 export declare function registryPath(env: NodeJS.ProcessEnv): string;
 /** Minimal fs seam so the registry is unit-testable without touching disk. */
@@ -181,6 +181,12 @@ export declare function listProjects(fs?: RegistryFs, env?: NodeJS.ProcessEnv):
  * otherwise the new record is appended and the file written back (preferences preserved).
  */
 export declare function addProject(path: string, addedAt: string, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<ProjectRecord>;
+/**
+ * Take a project off the list, by id. Answers the record that was removed, or `undefined` when
+ * no project has that id. Only the list changes: nothing in the project's folder is touched, so
+ * a project whose folder is gone is removed like any other.
+ */
+export declare function removeProject(id: string, fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<ProjectRecord | undefined>;
 /** The user's dashboard preferences (#410), or `{}` when none are stored. */
 export declare function readPreferences(fs?: RegistryFs, env?: NodeJS.ProcessEnv): Promise<Preferences>;
 /** Persist the dashboard preferences (#410), sanitized, preserving the project list. */

package/dist/module-types/src/store/agent-checkout.d.ts

@@ -34,7 +34,7 @@ export type AgentDiarySource = {
 };
 /**
  * The diary a run-scoped subscribe should follow (#1472, #1774): the run's own `<id>.jsonl`.
- * While the run has a checkout it is a file there, under the checkout's `.the-framework/`,
+ * While the run has a checkout it is a file there, under the checkout's `.openagent/`,
  * written by the run's tool as the agent works. Once the run is recorded and its checkout
  * reclaimed, it is the finished run's diary, whole, from the project's runs provider. A run that
  * has neither yet was started a moment ago: its tool has not made the checkout, so the diary is