@openagt/dashboard 0.0.0-stage → 0.8.0

package/dist/module-types/src/store/queue.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The agent queue, as the framework reads it (#1774). The framework keeps no queue and imports no
+ * queue package: a project's queue comes from whichever of its packages declares that it provides
+ * it — `"framework": { "queue": "<command>" }` in the package's own package.json — and the
+ * framework reads it by running that command. Swap the package for another that answers the same
+ * command line and prints the same shape, and nothing here changes. No package declares it: the
+ * project has no queue, and the dashboard shows it none.
+ *
+ * The command line a provider answers, printing one JSON document and exiting 0:
+ *   `<command> --local`   the open entries, in order of work, as an array of strings
+ * `--local` reads the copy on this machine, no network: the framework polls.
+ *
+ * That is the whole contract. Writing the queue is not the framework's: a module the queue package
+ * brings acts on it through its own command (`@openagt/dashboard/module`'s link actions), and the framework
+ * only re-reads.
+ *
+ * The shape, owned here: an entry is one string, the task a future agent is started with, as the
+ * queue's own command prints it. A markdown link at its start names the work and where it points;
+ * how a dashboard reads that is the queue package's module's.
+ */
+/** A project's queue: what a provider answers, read by the framework. */
+export interface QueueSource {
+    /** The open entries, in order of work; `[]` when none can be read. */
+    list(): Promise<string[]>;
+}
+/** The queue of the project at `root`, or `undefined` when none of its packages provides one. */
+export type QueueFor = (root: string) => Promise<QueueSource | undefined>;
+/** A {@link QueueFor} that also forgets what it read of one project, for when a module just wrote there. */
+export type QueueReader = QueueFor & {
+    changed(root: string): void;
+};
+/** Entries read back from a provider's output: the non-empty strings of an array, trimmed; anything else is no entries. */
+export declare function parseQueueEntries(output: unknown): string[];
+/**
+ * The production {@link QueueReader}: the project's provider, looked up by its package.json, one
+ * source per project kept while the same command provides — so the cache holds across the many
+ * reads of one poll, and a project that installs, swaps or drops its provider is read the new way
+ * within {@link CACHE_MS}. `changed(root)` forgets that project's read, so the next read runs the
+ * command again: a module's command just ran there, and may have written.
+ */
+export declare function providedQueue(now?: () => number): QueueReader;
+/** The framework's one reader of the queue, shared by every caller so they share its cache. */
+export declare const projectQueue: QueueReader;
+/** A {@link QueueFor} for a project with no provider: no queue. */
+export declare const noQueue: QueueFor;

package/dist/module-types/src/store/repository.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Creating a project's repository on a host, for a project that lives on this machine only. Like
+ * every provided kind, the framework names no host: the package that declares
+ * `"framework": { "repository": "<command>" }` creates it, and the framework asks by running that
+ * command.
+ *
+ * The command line a provider answers, each printing one JSON document and exiting 0 (a refusal
+ * exits 1 with its reason on stderr):
+ *   `<command> create --check`   the repository the project would become, `{ repository, name }`
+ *                                (`name` is the host's), creating nothing; refused when the
+ *                                project has a remote already or the host cannot be reached
+ *   `<command> create`           create it private, set it as the project's origin and push;
+ *                                `{ repository, url, name }`
+ */
+/** The repository a project would become, and the host it would be on. */
+export interface RepositoryOffer {
+    /** `<account>/<name>`, as the host names it. */
+    repository: string;
+    /** The host's name, for a button: `GitHub`. */
+    name: string;
+}
+export type CreateRepositoryResult = {
+    ok: true;
+    url: string;
+} | {
+    ok: false;
+    error: string;
+};
+/** What the project's repository provider offers to create, or undefined: no provider, a remote already there, or a host that cannot be reached. */
+export declare function repositoryOffer(root: string): Promise<RepositoryOffer | undefined>;
+/** Create the project's repository through its provider; a refusal is the provider's own line. */
+export declare function createRepository(root: string): Promise<CreateRepositoryResult>;

package/dist/module-types/src/store/run-record.d.ts

@@ -0,0 +1,21 @@
+import type { AnyDiaryLine, RunCard } from './runs.js';
+import type { FrameworkEvent } from '../events.js';
+import type { AgentMeta } from './agent-store.js';
+/**
+ * A run's card and diary (`runs.ts`), read as the framework's own shapes (#1769): the card as the
+ * meta every list shows, the diary as the events the run page replays and tails. The card's
+ * eleven plain fields and four kinds of diary line are the shape; whoever ran the agent keeps the
+ * rest of what it knows under one key, `caller`, and writes its other lines as they are. The
+ * framework records no run of its own (#1774), so there is no writing half.
+ */
+/** A card as the framework's meta: `caller` unfolded, the card's own fields winning. */
+export declare function fromRunCard(card: RunCard): AgentMeta;
+/**
+ * One diary line as one framework event: what the agent said, its result, the run's end and its
+ * cost are the shape's four kinds; a line of any other kind is a framework event as written, and
+ * one whose kind is no longer an event (the kinds of runs recorded before The Framework stopped
+ * running agents) reads as nothing. The line's time, `at`, is the event's, whatever the kind.
+ */
+export declare function fromDiaryLine(line: AnyDiaryLine): FrameworkEvent | undefined;
+/** A diary as the run's events, for a reader that replays them. */
+export declare function eventsOf(lines: readonly AnyDiaryLine[]): FrameworkEvent[];

package/dist/module-types/src/store/runs.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Finished runs, as the framework reads them (#1774). The framework keeps no run and imports no
+ * records package: a project's finished runs come from whichever of its packages declares that it
+ * provides them — `"framework": { "runs": "<command>" }` in the package's own package.json — and
+ * the framework reads them by running that command. Swap the package for another that answers
+ * the same command line and prints the same shapes, and nothing here changes. No package declares
+ * it: the project has no finished runs, only the ones still running in a checkout.
+ *
+ * The command line a provider answers, each printing one JSON document and exiting 0:
+ *   `<command> --local --full --limit N`   the runs, newest first, whole cards
+ *   `<command> show <id> --local --full`   one run: the whole card plus `diary`, every line
+ *   `<command> delete <id>`                remove a run
+ *   `<command> patch <id> [--branch <b>] [--pr <n> --pr-url <url>] [--landed <commit> --from <commit>]`   the late facts
+ * `--local` reads the copy on this machine, no network: the framework polls.
+ *
+ * The shapes, owned here: {@link RunCard} and {@link AnyDiaryLine}. A running agent's own card in
+ * its checkout is the same shape, written by the tool that runs it.
+ */
+/** How a run stands: still going, or how it ended. */
+export type RunStatus = 'running' | 'done' | 'stopped' | 'failed' | 'waiting';
+/**
+ * A run's card: what was asked, where the work went, how it ended, what it cost. `caller` is the
+ * bookkeeping of the program that ran the agent (its pid, host, session id, …), one key.
+ */
+export interface RunCard {
+    id: string;
+    startedAt: string;
+    endedAt?: string;
+    status: RunStatus;
+    intent?: string;
+    driver?: string;
+    model?: string;
+    branch?: string;
+    pr?: {
+        number: number;
+        url: string;
+    };
+    ticket?: string;
+    cost?: number;
+    caller?: Record<string, unknown>;
+}
+/** The two late facts a finished run's card may still learn: the branch its work landed on, its pull request. */
+export type RunPatch = Partial<Pick<RunCard, 'branch' | 'pr'>> & {
+    /** The run's work was merged and its branch deleted: its last commit, and the commit its work began at. */
+    landed?: {
+        commit: string;
+        from: string;
+    };
+};
+/** One line of a run's diary: a JSON object with a `kind`. */
+export type AnyDiaryLine = {
+    kind: string;
+} & Record<string, unknown>;
+/** A finished run: its card and its whole diary. */
+export interface FinishedRun {
+    card: RunCard;
+    diary: AnyDiaryLine[];
+}
+/** A project's finished runs: what a provider answers, read by the framework. */
+export interface RunsSource {
+    /**
+     * Every finished run's card, newest first; `[]` when none can be read. `fresh` skips a list read
+     * a moment ago: the caller knows the runs changed since.
+     */
+    list(opts?: {
+        fresh?: boolean;
+    }): Promise<RunCard[]>;
+    /** One run with its diary; `undefined` for no such run, or none readable. */
+    show(id: string): Promise<FinishedRun | undefined>;
+    /** Remove a run, or why it could not be. */
+    remove(id: string): Promise<RunsWrite>;
+    /** Set a run's late facts, or why they could not be. */
+    patch(id: string, patch: RunPatch): Promise<RunsWrite>;
+}
+/** What a change to the runs did: done, or the provider's reason it was not. */
+export type RunsWrite = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/** The finished runs of the project at `root`, or `undefined` when none of its packages provides them. */
+export type RunsFor = (root: string) => Promise<RunsSource | undefined>;
+/** A {@link RunsFor} that also forgets what it read of one project, for when a module just wrote there. */
+export type RunsReader = RunsFor & {
+    changed(root: string): void;
+};
+/** Whether a string can name a run: letters, digits, `-` and `_`, nothing a path can climb out with. */
+export declare function isRunId(id: string): boolean;
+/**
+ * A card read back: the fields of the shape, each kept only when it has the right type, plus
+ * `caller` as it is. `undefined` for anything that is not a card — not an object, or missing an
+ * id, a start or a status. Takes a card's JSON text or an already-parsed value.
+ */
+export declare function parseRunCard(input: unknown): RunCard | undefined;
+/**
+ * The production {@link RunsFor}: the project's provider, looked up by its package.json, one
+ * source per project kept while the same command provides — so the cache holds across the many
+ * reads of one poll, and a project that installs, swaps or drops its provider is read the new way
+ * within {@link CACHE_MS}. `changed(root)` forgets that project's reads, so the next read runs the
+ * command again: a module's command just ran there, and may have written.
+ */
+export declare function providedRuns(now?: () => number): RunsReader;
+/** The framework's one reader of finished runs, shared by every caller so they share its cache. */
+export declare const projectRuns: RunsReader;
+/** A {@link RunsFor} for a project with no provider: no finished runs. */
+export declare const noRuns: RunsFor;

package/dist/module-types/src/store/tickets.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The tickets, as the framework reads them (#1774). The framework keeps no ticket and imports no
+ * tickets package: a project's tickets come from whichever of its packages declares that it
+ * provides them — `"framework": { "tickets": "<command>" }` in the package's own package.json —
+ * and the framework reads them by running that command. Swap the package for another that answers
+ * the same command line and prints the same shape, and nothing here changes. No package declares
+ * it: the project has no tickets, and the dashboard shows it none.
+ *
+ * The command line a provider answers, printing one JSON document and exiting 0:
+ *   `<command> list --local`   every open ticket, as an array of {@link Ticket}
+ * `--local` reads the copy on this machine, no network: the framework polls.
+ *
+ * That is the whole contract. The framework reads tickets for what it composes across skills: the
+ * onboarding step, a queued link's title. Showing them, planning them, claiming and releasing them,
+ * and the Overview's hot-tickets card, are the tickets package's own module, through its own command.
+ *
+ * The shape, owned here: {@link Ticket}, the row a ticket lists as.
+ */
+/** A ticket's row, as a provider prints it. Everything but the five plain facts is optional. */
+export interface Ticket {
+    /** The ticket's file name, its identity: `tickets/<file>` is the path a link to it carries. */
+    file: string;
+    title: string;
+    /** One line of what it is about; empty when the ticket says nothing beyond its title. */
+    summary: string;
+    /** `0`–`10` as written, `10` acting at once; absent when unset, and not checked here. */
+    priority?: string;
+    topics?: string[];
+    /** The issue it tracks in the project's tracker, and the pull request that closes it: a label and where it points. */
+    issue?: {
+        label: string;
+        url: string;
+    };
+    pr?: {
+        label: string;
+        url: string;
+    };
+    /** ISO 8601: the file's date. */
+    date: string;
+    /** Whether a plan sits beside it. */
+    planned: boolean;
+    /** Whether someone holds it, and who: a run's id, or a branch. */
+    locked?: boolean;
+    lockedBy?: string;
+    effort?: number;
+    uncertainty?: number;
+}
+/** A project's tickets: what a provider answers, read by the framework. */
+export interface TicketsSource {
+    /** Every open ticket; `[]` when none can be read. */
+    list(): Promise<Ticket[]>;
+}
+/** The tickets of the project at `root`, or `undefined` when none of its packages provides them. */
+export type TicketsFor = (root: string) => Promise<TicketsSource | undefined>;
+/** A {@link TicketsFor} that also forgets what it read of one project, for when a module just wrote there. */
+export type TicketsReader = TicketsFor & {
+    changed(root: string): void;
+};
+/** The rows read back from a provider's output: the objects with the five plain facts, everything else as printed; anything else is no ticket. */
+export declare function parseTickets(output: unknown): Ticket[];
+/**
+ * The production {@link TicketsReader}: the project's provider, looked up by its package.json, one
+ * source per project kept while the same command provides — so the cache holds across the many
+ * reads of one poll, and a project that installs, swaps or drops its provider is read the new way
+ * within {@link CACHE_MS}. `changed(root)` forgets that project's read, so the next read runs the
+ * command again: a module's command just ran there, and may have written.
+ */
+export declare function providedTickets(now?: () => number): TicketsReader;
+/** The framework's one reader of the tickets, shared by every caller so they share its cache. */
+export declare const projectTickets: TicketsReader;
+/** A {@link TicketsFor} for a project with no provider: no tickets. */
+export declare const noTickets: TicketsFor;

package/dist/module-types/src/subagent-settings.d.ts

@@ -0,0 +1,26 @@
+import { type DriverName } from './driver-names.js';
+/**
+ * The person's subagent settings (#1902), node-free so the daemon and the dashboard bundle share
+ * one copy: the coding agent and model a main agent's subagents run on, by how hard their task is,
+ * and how many of one main agent's subagents run at once. They are the orchestration package's, in
+ * its file at each project's root, written through each project's `subagents` line; the dashboard
+ * reads the file by its name and runs no tool. A level left out runs on the main agent's own coding
+ * agent and model, and a limit left out is the package's own, {@link DEFAULT_AT_ONCE}.
+ */
+/** The file the settings are kept in, at a project's root; this machine's, hidden from git by the package. */
+export declare const SUBAGENT_SETTINGS_FILE = ".orchestration/settings.json";
+/** How many of one main agent's subagents run at once when nobody said: the orchestration package's default. */
+export declare const DEFAULT_AT_ONCE = 4;
+/** A coding agent and, when one is picked, its model; no model is that coding agent's own default. */
+export interface SubagentRunner {
+    driver: DriverName;
+    model?: string;
+}
+export interface SubagentSettings {
+    simple?: SubagentRunner;
+    hard?: SubagentRunner;
+    atOnce?: number;
+}
+export declare const SUBAGENT_LEVELS: readonly ['simple', 'hard'];
+/** The settings in `value`, each field kept only when it has the shape the file promises. */
+export declare function subagentSettingsIn(value: unknown): SubagentSettings;

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

@@ -0,0 +1,3 @@
+import { type FrameworkEvent } from './events.js';
+/** Render a {@link FrameworkEvent} as one human-readable line (terminal surface). */
+export declare function formatFrameworkEvent(event: FrameworkEvent): string;

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

@@ -0,0 +1,89 @@
+import { type AgentStatus, type BranchesFor, type RunsFor } from './store/index.js';
+/** A retained worktree and the agent that left it behind (#752). */
+export interface WorktreeRow {
+    /** The agent id. */
+    agentId: string;
+    /** The branch the agent's work landed on, when its meta recorded one (#799). */
+    branch?: string;
+    /** How the agent that left this checkout ended, or `running` while it is still going. */
+    status?: AgentStatus;
+    /** Size on disk in bytes, absent for a live agent (its tree is still changing) or when unreadable. */
+    sizeBytes?: number;
+    /** True while the agent owning this checkout is still going: it is in use, not retained. */
+    live: boolean;
+}
+/** The outcome of {@link removeProjectWorktree}. */
+export type RemoveResult = {
+    ok: true;
+    /**
+     * Branches that went with the checkout: the branch it was on, when that held nothing of
+     * its own (#1650); the run-id branch the agent branched away from, when everything on
+     * it is in the branch that stays (#1657). Absent when nothing went.
+     */
+    branchesDeleted?: string[];
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * The worktrees a project still has on disk (#752), newest first — the same view the dashboard's
+ * retained-worktrees list is built from, through the same store reads, so the CLI is a second
+ * surface rather than a second behaviour. The checkouts are what the project's branches provider
+ * lists (#1774); a project with no provider has none.
+ *
+ * A live agent's checkout is included and flagged rather than hidden: "what is this directory and
+ * why can I not remove it" is exactly the question the list has to answer.
+ */
+export declare function listProjectWorktrees(cwd: string, opts?: {
+    sizes?: boolean;
+}, branches?: BranchesFor): Promise<WorktreeRow[]>;
+/**
+ * Remove one retained worktree (#752/#737/E5): the one implementation behind every surface that
+ * removes one: the dashboard's Remove button (#982). The run's own tool reclaims a finished run's
+ * checkout by the same rule; this is for the checkouts that rule kept.
+ *
+ * **One rule: only what is committed may go**: the rule is the branches provider's, whose
+ * `remove` takes a clean checkout and leaves its branch on this machine, pushing nothing
+ * (#1774); its refusal is answered in its own words.
+ *
+ * Refuses while the agent is still going — an agent's checkout is where its agent is working, and Stop
+ * is how you end an agent, not pulling the floor out from under it.
+ */
+export declare function removeProjectWorktree(cwd: string, agentId: string, branches?: BranchesFor): Promise<RemoveResult>;
+/** The outcome of {@link deleteProjectAgent}. */
+export type DeleteAgentResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/** Where {@link deleteProjectAgent} reads: the project's providers by default. */
+export interface DeleteAgentOptions {
+    /** Where the project's finished runs are read and removed; the project's runs provider by default. */
+    runs?: RunsFor;
+    /** Where the project's checkouts are read and removed; the project's branches provider by default. */
+    branches?: BranchesFor;
+}
+/**
+ * Delete a session (#1032): take it out of the dashboard, records and all.
+ *
+ * This is the sibling of {@link removeProjectWorktree}, and the difference is the whole point.
+ * Remove-worktree reclaims the checkout on disk and keeps the session — its row, its replayable
+ * log — because the run is recorded on the data branch. Delete removes that record too: the card
+ * (`<id>.json`, what the rail lists) and the diary (`<id>.jsonl`, what replays), so the row is
+ * gone for good. It is the one destructive-of-history action, which is
+ * why the surfaces that call it confirm first. The run is on the data branch, so its deletion is
+ * itself a committed, pushed change.
+ *
+ * What it deliberately leaves is git's, not the dashboard's: the branch `agent-<id>`
+ * (or the name the agent gave it) and its commits. Deleting a branch that may carry merged work
+ * or an open PR is not a thing a
+ * dashboard action should do silently, so the branch stays and delete means "remove from the
+ * dashboard", not "erase every trace".
+ *
+ * Refuses while the agent is still going — Stop is how an agent ends. Any uncommitted work in the
+ * worktree is discarded with it, which is the intent here (the session is being thrown away),
+ * unlike remove-worktree, which refuses a checkout holding uncommitted work: the branches
+ * provider's `remove --discard` (#1774).
+ */
+export declare function deleteProjectAgent(cwd: string, agentId: string, opts?: DeleteAgentOptions): Promise<DeleteAgentResult>;

package/dist/module.css

@@ -0,0 +1,50 @@
+/* The dashboard's theme as Tailwind sees it (#1774): the dark variant, the fonts, and the utilities
+   (`bg-card`, `text-muted-foreground`, …) that read the page's own tokens. The dashboard imports
+   it, and so does a module's stylesheet, so a module's classes read the tokens the page defines in
+   tailwind.css — its colours follow the theme and the theme toggle without a copy of either. */
+
+/* The theme is the `.dark` class LayoutDefault toggles, not the OS preference. Without this,
+   Tailwind v4 compiles `dark:` to `@media (prefers-color-scheme: dark)`, so the `dark:` utilities
+   disagreed with the tokens: picking Dark on a light OS applied the dark tokens but left
+   `dark:text-*-400` unapplied, and picking Light on a dark OS applied them when it should not. */
+@custom-variant dark (&:where(.dark, .dark *));
+
+/* The page is squarer than the old UI, so the radius tightens to ~2px to match. */
+@theme {
+  --radius: 0.125rem;
+  /* The landing page's typeface (#1118), loaded in pages/+Head.tsx. Overriding these two theme
+     keys retargets Tailwind's default body font and every `font-mono` to IBM Plex. */
+  --font-sans: 'IBM Plex Sans', ui-sans-serif, system-ui, sans-serif;
+  --font-mono: 'IBM Plex Mono', ui-monospace, SFMono-Regular, Menlo, monospace;
+}
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-card: var(--card);
+  --color-card-foreground: var(--card-foreground);
+  --color-muted: var(--muted);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-border: var(--border);
+  --color-primary: var(--primary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-accent: var(--accent);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-success: var(--success);
+  --color-warning: var(--warning);
+  --color-danger: var(--danger);
+  --color-info: var(--info);
+
+  /* The shadcn sidebar reads its own `--sidebar-*` family so a sidebar can be themed apart from
+     the page. We keep it in step with the rest of the palette (the rail is the app's own surface,
+     not a contrasting slab): background canvas, accent for the hover/active fill, the shared border
+     and the primary ring. */
+  --color-sidebar: var(--background);
+  --color-sidebar-foreground: var(--foreground);
+  --color-sidebar-primary: var(--primary);
+  --color-sidebar-primary-foreground: var(--primary-foreground);
+  --color-sidebar-accent: var(--accent);
+  --color-sidebar-accent-foreground: var(--accent-foreground);
+  --color-sidebar-border: var(--border);
+  --color-sidebar-ring: var(--primary);
+}

package/dist/node-fs.d.ts

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

package/dist/node-fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-fs.d.ts","sourceRoot":"","sources":["../src/node-fs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,MAAM;IACrB,uCAAuC;IACvC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACnC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACpD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACrD,8EAA8E;IAC9E,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACtC,mFAAmF;IACnF,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC3C,iBAAiB;IACjB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAClC,wEAAwE;IACxE,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IACxC,+FAA+F;IAC/F,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/C,oGAAoG;IACpG,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACjD;AAED,+DAA+D;AAC/D,wBAAgB,MAAM,IAAI,MAAM,CAmD/B"}

package/dist/node-fs.js

@@ -0,0 +1,57 @@
+/** The `node:fs/promises` implementation of {@link NodeFs}. */
+export function nodeFs() {
+    return {
+        async read(path) {
+            const { readFile } = await import('node:fs/promises');
+            return readFile(path, 'utf8');
+        },
+        async write(path, contents) {
+            const { writeFile } = await import('node:fs/promises');
+            await writeFile(path, contents, 'utf8');
+        },
+        async append(path, contents) {
+            const { appendFile } = await import('node:fs/promises');
+            await appendFile(path, contents, 'utf8');
+        },
+        async exists(path) {
+            const { stat } = await import('node:fs/promises');
+            try {
+                return (await stat(path)).isFile();
+            }
+            catch {
+                return false;
+            }
+        },
+        async isDirectory(path) {
+            const { stat } = await import('node:fs/promises');
+            try {
+                return (await stat(path)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        },
+        async mkdir(path) {
+            const { mkdir } = await import('node:fs/promises');
+            await mkdir(path, { recursive: true });
+        },
+        async readdir(path) {
+            const { readdir } = await import('node:fs/promises');
+            try {
+                return await readdir(path);
+            }
+            catch {
+                return [];
+            }
+        },
+        async rename(from, to) {
+            const { rename } = await import('node:fs/promises');
+            await rename(from, to);
+        },
+        async chmod(path, mode) {
+            const { chmod } = await import('node:fs/promises');
+            await chmod(path, mode);
+        },
+    };
+}
+//# sourceMappingURL=node-fs.js.map

package/dist/node-fs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-fs.js","sourceRoot":"","sources":["../src/node-fs.ts"],"names":[],"mappings":"AA+BA,+DAA+D;AAC/D,MAAM,UAAU,MAAM;IACpB,OAAO;QACL,KAAK,CAAC,IAAI,CAAC,IAAI;YACb,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAA;YACrD,OAAO,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QAC/B,CAAC;QACD,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ;YACxB,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAA;YACtD,MAAM,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAA;QACzC,CAAC;QACD,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ;YACzB,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAA;YACvD,MAAM,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAA;QAC1C,CAAC;QACD,KAAK,CAAC,MAAM,CAAC,IAAI;YACf,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAA;YACjD,IAAI,CAAC;gBACH,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,CAAA;YACpC,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,KAAK,CAAA;YACd,CAAC;QACH,CAAC;QACD,KAAK,CAAC,WAAW,CAAC,IAAI;YACpB,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAA;YACjD,IAAI,CAAC;gBACH,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,EAAE,CAAA;YACzC,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,KAAK,CAAA;YACd,CAAC;QACH,CAAC;QACD,KAAK,CAAC,KAAK,CAAC,IAAI;YACd,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAA;YAClD,MAAM,KAAK,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;QACxC,CAAC;QACD,KAAK,CAAC,OAAO,CAAC,IAAI;YAChB,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAA;YACpD,IAAI,CAAC;gBACH,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;YAC5B,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,EAAE,CAAA;YACX,CAAC;QACH,CAAC;QACD,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE;YACnB,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAA;YACnD,MAAM,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;QACxB,CAAC;QACD,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI;YACpB,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAA;YAClD,MAAM,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;QACzB,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/on-before-mergeable-prompt.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The on-before-mergeable prompt (#326), in `prompts/on_before_mergeable_prompt.md` (#551).
+ *
+ * It does not *run* the quality presets, it *queues* them: one agent turn that appends
+ * "Apply <preset filePath> with tf.params.what set to ..." entries to the project's queue
+ * file (`TODO_AGENTS.md`), which a later drain picks up. That is the whole point of
+ * #556 — the previous suite executed maintainability, readability and security-audit as
+ * three child runs on the spot, which does not compose with the queue.
+ *
+ * The markdown is the prompt, verbatim: it is compiled into the package at build time and
+ * used as it is written, so what a reviewer reads in `prompts/` is what an agent is sent.
+ *
+ * Two sections: `## Maintenance` queues the quality presets, and `## Business knowledge`
+ * (#537) asks the agent to fold what it learned back into {@link BUSINESS_KNOWLEDGE_DOCS}.
+ */
+export declare const ON_BEFORE_MERGEABLE_PROMPT_TEMPLATE = "TODO_FILE: the agent queue, `TODO_AGENTS.md` \u2014 add an entry with `queue add \"<entry>\"` from the `queue` skill\n\n## Maintenance\n\nIf the changes introduced by ${{ tf.session_name }} aren't trivial and have refactor potential, add the following to <TODO_FILE>\n- `Apply ${{ tf.presets.maintainability.filePath }} with tf.params.what set to \"changes introduced by ${{ tf.session_name }}\"`\nIf the changes introduced by ${{ tf.session_name }} can potentially lead to security issues, add the following to <TODO_FILE>\n- `Apply ${{ tf.presets.security_audit.filePath }} with tf.params.what set to \"changes introduced by ${{ tf.session_name }}\"`\n\n\n## Business knowledge\n\nIf you didn't already, consider updating the following based on the changes and discussions of ${{ tf.session_name }} (you can create the files if they're missing):\n- `knowledge-base/DECISIONS.md` (decisions taken, and why)\n- `knowledge-base/FACTS.md` (non-obvious facts relevant to the project)\n- `knowledge-base/INSIGHTS.md` (insights relevant to the project)\n\nOnly write what a future agent would need and cannot get from the code itself.";
+/** What the on-before-mergeable prompt's fragments read. */
+export interface OnBeforeMergeableContext {
+    /** The finished agent's session name, read off its branch (#1725). Every line of the prompt names it. */
+    session_name: string;
+    /**
+     * The materialized presets, stem -> `{ filePath }` (#326). The `## Maintenance` entries carry
+     * `tf.presets.<name>.filePath` so the picked-up agent opens the real preset file. Defaulted
+     * from {@link presetContext}, so callers get the standard `.the-framework/presets/*.md` paths.
+     */
+    presets?: Record<string, {
+        filePath: string;
+    }>;
+}
+/** Render the on-before-mergeable prompt for a finished session. */
+export declare function renderOnBeforeMergeablePrompt(tf: OnBeforeMergeableContext): string;
+//# sourceMappingURL=on-before-mergeable-prompt.d.ts.map

package/dist/on-before-mergeable-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-before-mergeable-prompt.d.ts","sourceRoot":"","sources":["../src/on-before-mergeable-prompt.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mCAAmC,8mCAA6B,CAAA;AAE7E,4DAA4D;AAC5D,MAAM,WAAW,wBAAwB;IACvC,yGAAyG;IACzG,YAAY,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC/C;AAED,oEAAoE;AACpE,wBAAgB,6BAA6B,CAAC,EAAE,EAAE,wBAAwB,GAAG,MAAM,CAIlF"}

package/dist/on-before-mergeable-prompt.js

@@ -0,0 +1,26 @@
+import { renderTemplate } from './prompt-template.js';
+import { ON_BEFORE_MERGEABLE_PROMPT } from './prompts.generated.js';
+import { presetContext } from './presets.js';
+/**
+ * The on-before-mergeable prompt (#326), in `prompts/on_before_mergeable_prompt.md` (#551).
+ *
+ * It does not *run* the quality presets, it *queues* them: one agent turn that appends
+ * "Apply <preset filePath> with tf.params.what set to ..." entries to the project's queue
+ * file (`TODO_AGENTS.md`), which a later drain picks up. That is the whole point of
+ * #556 — the previous suite executed maintainability, readability and security-audit as
+ * three child runs on the spot, which does not compose with the queue.
+ *
+ * The markdown is the prompt, verbatim: it is compiled into the package at build time and
+ * used as it is written, so what a reviewer reads in `prompts/` is what an agent is sent.
+ *
+ * Two sections: `## Maintenance` queues the quality presets, and `## Business knowledge`
+ * (#537) asks the agent to fold what it learned back into {@link BUSINESS_KNOWLEDGE_DOCS}.
+ */
+export const ON_BEFORE_MERGEABLE_PROMPT_TEMPLATE = ON_BEFORE_MERGEABLE_PROMPT;
+/** Render the on-before-mergeable prompt for a finished session. */
+export function renderOnBeforeMergeablePrompt(tf) {
+    return renderTemplate(ON_BEFORE_MERGEABLE_PROMPT_TEMPLATE, {
+        tf: { ...tf, presets: tf.presets ?? presetContext() },
+    });
+}
+//# sourceMappingURL=on-before-mergeable-prompt.js.map

package/dist/on-before-mergeable-prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-before-mergeable-prompt.js","sourceRoot":"","sources":["../src/on-before-mergeable-prompt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAA;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAE5C;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,0BAA0B,CAAA;AAc7E,oEAAoE;AACpE,MAAM,UAAU,6BAA6B,CAAC,EAA4B;IACxE,OAAO,cAAc,CAAC,mCAAmC,EAAE;QACzD,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,EAAE,CAAC,OAAO,IAAI,aAAa,EAAE,EAAE;KACtD,CAAC,CAAA;AACJ,CAAC"}

package/dist/open-choices.d.ts

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

package/dist/open-choices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-choices.d.ts","sourceRoot":"","sources":["../src/open-choices.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAKhE;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,GAAG,aAAa,EAAE,CAajF"}