@openagt/dashboard 0.0.0-stage → 0.8.0

package/dist/store/tickets.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 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;
+//# sourceMappingURL=tickets.d.ts.map

package/dist/store/tickets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tickets.d.ts","sourceRoot":"","sources":["../../src/store/tickets.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AAEH,gGAAgG;AAChG,MAAM,WAAW,MAAM;IACrB,+FAA+F;IAC/F,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,yFAAyF;IACzF,OAAO,EAAE,MAAM,CAAA;IACf,yFAAyF;IACzF,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,sHAAsH;IACtH,KAAK,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IACtC,EAAE,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IACnC,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,qCAAqC;IACrC,OAAO,EAAE,OAAO,CAAA;IAChB,kEAAkE;IAClE,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,2EAA2E;AAC3E,MAAM,WAAW,aAAa;IAC5B,qDAAqD;IACrD,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;CAC1B;AAED,oGAAoG;AACpG,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAAA;AAE7E,8GAA8G;AAC9G,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG;IAAE,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAA;AAKxE,kJAAkJ;AAClJ,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,EAAE,CAGtD;AAgCD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,GAAE,MAAM,MAAiB,GAAG,aAAa,CAa3E;AAED,iGAAiG;AACjG,eAAO,MAAM,cAAc,EAAE,aAAiC,CAAA;AAE9D,uEAAuE;AACvE,eAAO,MAAM,SAAS,EAAE,UAAkC,CAAA"}

package/dist/store/tickets.js

@@ -0,0 +1,67 @@
+import { runPackageCommand } from '@openagt/agent-data';
+import { providedCommand } from '../built-in.js';
+/** How long a read is reused: the dashboard polls several reads of every project's tickets every few seconds, and each is a process. */
+const CACHE_MS = 5_000;
+/** 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 function parseTickets(output) {
+    if (!Array.isArray(output))
+        return [];
+    return output.filter(isTicket);
+}
+function isTicket(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const row = value;
+    return typeof row.file === 'string' && row.file !== '' && typeof row.title === 'string' && typeof row.summary === 'string' && typeof row.date === 'string' && typeof row.planned === 'boolean';
+}
+/** The tickets source over one provider command: each list one run of the command, reads cached per {@link CACHE_MS}. */
+function commandTickets(root, command, now) {
+    let listed;
+    return {
+        drop() {
+            listed = undefined;
+        },
+        list() {
+            // Concurrent reads share one process; a read that failed is not kept.
+            if (listed && now() - listed.at < CACHE_MS)
+                return listed.tickets;
+            const read = { at: now(), tickets: Promise.resolve([]) };
+            read.tickets = runPackageCommand(root, command, ['list', '--local']).then(result => {
+                if (!result.ok || !Array.isArray(result.output)) {
+                    if (listed === read)
+                        listed = undefined;
+                    return [];
+                }
+                return parseTickets(result.output);
+            });
+            listed = read;
+            return read.tickets;
+        },
+    };
+}
+/**
+ * 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 function providedTickets(now = Date.now) {
+    const sources = new Map();
+    const reader = async (root) => {
+        let known = sources.get(root);
+        if (!known || now() - known.at >= CACHE_MS) {
+            const command = await providedCommand(root, 'tickets').catch(() => undefined);
+            const same = known?.command && command && known.command.bin === command.bin;
+            known = { at: now(), ...(command ? { command, source: same ? known.source : commandTickets(root, command, now) } : {}) };
+            sources.set(root, known);
+        }
+        return known.source;
+    };
+    return Object.assign(reader, { changed: (root) => sources.get(root)?.source?.drop() });
+}
+/** The framework's one reader of the tickets, shared by every caller so they share its cache. */
+export const projectTickets = providedTickets();
+/** A {@link TicketsFor} for a project with no provider: no tickets. */
+export const noTickets = async () => undefined;
+//# sourceMappingURL=tickets.js.map

package/dist/store/tickets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tickets.js","sourceRoot":"","sources":["../../src/store/tickets.ts"],"names":[],"mappings":"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"}

package/dist/store/worktree-deps.d.ts

@@ -0,0 +1,30 @@
+/** The filesystem this module needs. Injectable so the scan is testable. */
+export interface LinkFs {
+    /** Entry names in a directory. A missing/unreadable dir yields `[]`. */
+    readdir(path: string): Promise<string[]>;
+    /** True when `path` is a directory (following symlinks). Any error reads as `false`. */
+    isDirectory(path: string): Promise<boolean>;
+    /** True when anything exists at `path`, symlinks included (no link following). */
+    entryExists(path: string): Promise<boolean>;
+    /** Recursive. */
+    mkdir(path: string): Promise<void>;
+    /** Create a directory symlink at `path` pointing to `target`. */
+    symlinkDir(target: string, path: string): Promise<void>;
+}
+/** The `node:fs/promises` implementation of {@link LinkFs}. */
+export declare function nodeLinkFs(): LinkFs;
+/**
+ * Every `node_modules` directory in `repo`, as repo-relative paths, down to
+ * {@link MAX_DEPTH}. Sorted, so the linking order (and any log of it) is stable.
+ */
+export declare function findDependencyDirs(repo: string, fs?: LinkFs): Promise<string[]>;
+/**
+ * Mirror `repo`'s dependency trees into `worktree` at the same relative paths: a real
+ * directory per tree, holding a link per entry (the package manager's private state
+ * left out, see above). Returns the trees mirrored. Best-effort throughout: a worktree
+ * with no deps is a worse run, not a failed one, so a link that cannot be made is
+ * skipped rather than thrown. A tree already present is left alone (the agent may
+ * have installed already).
+ */
+export declare function linkDependencies(repo: string, worktree: string, fs?: LinkFs): Promise<string[]>;
+//# sourceMappingURL=worktree-deps.d.ts.map

package/dist/store/worktree-deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree-deps.d.ts","sourceRoot":"","sources":["../../src/store/worktree-deps.ts"],"names":[],"mappings":"AA0CA,4EAA4E;AAC5E,MAAM,WAAW,MAAM;IACrB,wEAAwE;IACxE,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IACxC,wFAAwF;IACxF,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC3C,kFAAkF;IAClF,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,iEAAiE;IACjE,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACxD;AAED,+DAA+D;AAC/D,wBAAgB,UAAU,IAAI,MAAM,CAyBnC;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAE,MAAqB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAanG;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,GAAE,MAAqB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAkBnH"}

package/dist/store/worktree-deps.js

@@ -0,0 +1,115 @@
+import { join, relative } from 'node:path';
+import { FRAMEWORK_DIR } from './agent-store.js';
+/**
+ * Give a fresh worktree a dependency tree (#736). `node_modules` is gitignored, so
+ * `git worktree add` hands the agent an empty one and every command in it fails.
+ *
+ * Three ways to fix that: copy the tree (correct, but gigabytes per agent), install
+ * into each worktree (correct, but real latency on every start), or link the
+ * parent checkout's trees in (instant, no extra disk, one store shared by N runs).
+ * We link — but each *entry* of a dependency directory, into a real directory of
+ * the worktree's own, never the directory itself (#1262). A directory link made the
+ * parent's tree the worktree's modules directory in the package manager's eyes:
+ * an agent that changed a dependency and ran `pnpm install` had pnpm resolve
+ * through the link and rewrite — or, under `CI=true`, purge outright — the parent
+ * checkout's real `node_modules`, and every later agent died at boot. With a real
+ * directory holding links, an install in the worktree writes into the worktree.
+ *
+ * The package manager's own state (`.pnpm`, `.modules.yaml`, and the like — every
+ * dot-entry but `.bin`) is deliberately not linked: it is what tells the package
+ * manager "this tree is mine, installed here", and the worktree's is not. The
+ * packages still resolve without it — a package entry in a pnpm tree is a relative
+ * link into `.pnpm`, and a link to that link resolves where the target lives, in
+ * the parent checkout. `.bin` is linked because an agent runs the project's tools.
+ */
+/** The dependency directory mirrored into a worktree. */
+const NODE_MODULES = 'node_modules';
+/** How deep below the repo root a `node_modules` is looked for (root = 0). Covers a
+ *  pnpm/npm workspace's `packages/<pkg>/node_modules` without walking the world. */
+const MAX_DEPTH = 2;
+/** Directory names never descended into while scanning for dependency trees. */
+const SKIP = new Set([NODE_MODULES, '.git', FRAMEWORK_DIR, 'dist', 'build', 'coverage']);
+/** The one dot-entry of a dependency directory that is linked: the project's executables. */
+const BIN = '.bin';
+/** The package manager's private state in a dependency directory: never linked (see above). */
+const isPrivate = (name) => name.startsWith('.') && name !== BIN;
+/** The `node:fs/promises` implementation of {@link LinkFs}. */
+export function nodeLinkFs() {
+    return {
+        async readdir(path) {
+            const { readdir } = await import('node:fs/promises');
+            return readdir(path).catch(() => []);
+        },
+        async isDirectory(path) {
+            const { stat } = await import('node:fs/promises');
+            return stat(path).then(s => s.isDirectory(), () => false);
+        },
+        async entryExists(path) {
+            const { lstat } = await import('node:fs/promises');
+            return lstat(path).then(() => true, () => false);
+        },
+        async mkdir(path) {
+            const { mkdir } = await import('node:fs/promises');
+            await mkdir(path, { recursive: true });
+        },
+        async symlinkDir(target, path) {
+            const { symlink } = await import('node:fs/promises');
+            // 'junction' is the only directory-link type Windows grants without elevation;
+            // it is ignored on POSIX.
+            await symlink(target, path, process.platform === 'win32' ? 'junction' : 'dir');
+        },
+    };
+}
+/**
+ * Every `node_modules` directory in `repo`, as repo-relative paths, down to
+ * {@link MAX_DEPTH}. Sorted, so the linking order (and any log of it) is stable.
+ */
+export async function findDependencyDirs(repo, fs = nodeLinkFs()) {
+    const found = [];
+    const walk = async (dir, depth) => {
+        if (await fs.isDirectory(join(dir, NODE_MODULES)))
+            found.push(relative(repo, join(dir, NODE_MODULES)));
+        if (depth >= MAX_DEPTH)
+            return;
+        for (const name of await fs.readdir(dir)) {
+            if (name.startsWith('.') || SKIP.has(name))
+                continue;
+            const child = join(dir, name);
+            if (await fs.isDirectory(child))
+                await walk(child, depth + 1);
+        }
+    };
+    await walk(repo, 0);
+    return found.sort();
+}
+/**
+ * Mirror `repo`'s dependency trees into `worktree` at the same relative paths: a real
+ * directory per tree, holding a link per entry (the package manager's private state
+ * left out, see above). Returns the trees mirrored. Best-effort throughout: a worktree
+ * with no deps is a worse run, not a failed one, so a link that cannot be made is
+ * skipped rather than thrown. A tree already present is left alone (the agent may
+ * have installed already).
+ */
+export async function linkDependencies(repo, worktree, fs = nodeLinkFs()) {
+    const linked = [];
+    for (const rel of await findDependencyDirs(repo, fs)) {
+        const source = join(repo, rel);
+        const dir = join(worktree, rel);
+        try {
+            if (await fs.entryExists(dir))
+                continue;
+            await fs.mkdir(dir);
+            for (const name of await fs.readdir(source)) {
+                if (isPrivate(name))
+                    continue;
+                await fs.symlinkDir(join(source, name), join(dir, name)).catch(() => { });
+            }
+            linked.push(rel);
+        }
+        catch {
+            // Raced, or a filesystem that refuses the directory: the agent still starts.
+        }
+    }
+    return linked;
+}
+//# sourceMappingURL=worktree-deps.js.map

package/dist/store/worktree-deps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree-deps.js","sourceRoot":"","sources":["../../src/store/worktree-deps.ts"],"names":[],"mappings":"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"}

package/dist/store/worktree.d.ts

@@ -0,0 +1,194 @@
+import { type GitRunner } from '../project.js';
+/**
+ * Git-worktree lifecycle for concurrent agents (#453/#735): give each agent its own
+ * checkout so N runs on one repo never fight over the working tree. Pure plumbing
+ * over the existing {@link GitRunner} seam; no daemon wiring, no concurrency, no
+ * dashboard changes (those are the sibling #453 slices). This module only knows
+ * how to add, list, remove, and prune worktrees.
+ */
+/** The path an agent's worktree gets (#1580): `<repo>/.the-framework/branches/<run branch name>`. */
+export declare function worktreePath(repo: string, agentId: string): string;
+export { AGENT_BRANCH_PREFIX, LEGACY_AGENT_BRANCH_PREFIX, agentBranchName, legacyAgentBranchName, } from '../branch-names.js';
+/** One entry parsed from `git worktree list --porcelain`. */
+export interface WorktreeInfo {
+    /** Absolute worktree path (the main checkout included). */
+    path: string;
+    /** The checked-out commit. */
+    head: string;
+    /** The checked-out branch (short name), or absent when detached. */
+    branch?: string;
+}
+/** Inputs to {@link addWorktree}. The caller owns branch naming (#736). */
+export interface AddWorktreeOptions {
+    agentId: string;
+    /** The branch to create for the agent. */
+    branch: string;
+    /** Base ref to branch from; defaults to the repo's current HEAD. */
+    base?: string;
+}
+/** The worktree {@link addWorktree} created. */
+export interface AddedWorktree {
+    path: string;
+    branch: string;
+}
+/**
+ * Create a worktree for an agent on a fresh branch: `git worktree add -b <branch>
+ * <path> [base]`. Git makes the leaf dir (and any missing parents) itself. The
+ * `agentId` is validated as path-safe first so a caller can never traverse out of
+ * `.the-framework/branches/`. Rejects on any git failure (a caller that wants a
+ * run needs its checkout, so failure must surface, not be swallowed).
+ */
+export declare function addWorktree(repo: string, opts: AddWorktreeOptions, agent?: GitRunner): Promise<AddedWorktree>;
+/**
+ * Check an *existing* branch out into an agent's worktree (#762): `git worktree add <path> <branch>`,
+ * no `-b`. Continuing an agent puts it back on the branch its work is already on, rather than
+ * branching again from HEAD and stranding what it did last time.
+ *
+ * A branch that is gone is recreated from HEAD (#1650): the only branch the framework deletes is
+ * one that held nothing past a commit the remote already had, so HEAD is where its work was.
+ * Anything else git refuses — the branch checked out elsewhere, say — still rejects, like
+ * {@link addWorktree}: a continued agent needs its checkout.
+ */
+export declare function attachWorktree(repo: string, opts: {
+    agentId: string;
+    branch: string;
+}, agent?: GitRunner): Promise<AddedWorktree>;
+/**
+ * Every worktree registered for the repo (the main checkout included). Forgiving:
+ * a non-repo / git failure yields `[]` so a reconcile scan never throws.
+ */
+export declare function listWorktrees(repo: string, agent?: GitRunner): Promise<WorktreeInfo[]>;
+/**
+ * Parse `git worktree list --porcelain`: blank-line-separated records, each with
+ * a `worktree <path>` line, a `HEAD <sha>` line, and either `branch refs/heads/...`
+ * or `detached`. Extra attributes (bare/locked/prunable) are ignored. Exported so
+ * the parsing is unit-testable without a real repo.
+ */
+export declare function parseWorktreeList(porcelain: string): WorktreeInfo[];
+/**
+ * Commit whatever the agent left behind, on the agent's own branch (#786).
+ *
+ * An agent that edits and stops without committing is behaving as instructed: the
+ * system prompt has it commit *pre-existing* changes before it starts, never its own
+ * work at the end. Removing that checkout would destroy the diff (the work was never
+ * staged, so it is not recoverable from git afterwards), so teardown commits it first
+ * and the branch outlives the worktree.
+ *
+ * Returns whether the checkout is safe to remove: true when it was already clean or
+ * the work is now committed, false when the commit failed (no git identity, a hook
+ * refusing it). False means keep the checkout, which is the safe direction.
+ *
+ * Retries before giving up (#1376): the daemon's conversation committer works in the same
+ * checkout and is busiest exactly when this runs (session end), so a first attempt can lose
+ * an `index.lock` race. That transient loss is how a session's real work got judged
+ * "committed nothing" by the handoff while the teardown's identical commit, seconds later,
+ * succeeded. A short wait outlasts the committer's hold; a persistent failure (identity,
+ * hooks) still comes back false.
+ */
+export declare function commitPendingWork(path: string, agent?: GitRunner, retry?: {
+    attempts?: number;
+    delayMs?: number;
+}): Promise<boolean>;
+/**
+ * Remove an agent's worktree. Tolerant of an already-gone / never-registered path so
+ * teardown stays idempotent (the agent child is detached; the daemon only holds its pid).
+ *
+ * Plain removal first: it refuses a checkout git considers unclean, which after
+ * {@link commitPendingWork} means a state we did not anticipate. Falling back to
+ * `--force` keeps teardown working (an ignored build artifact must not strand a
+ * worktree forever), but it says so, because forcing past unknown state is exactly
+ * how uncommitted work got deleted in the first place.
+ */
+export declare function removeWorktree(repo: string, path: string, agent?: GitRunner): Promise<void>;
+/**
+ * Delete a branch that holds nothing (#1650). `-D`, because "merged" in git's eyes is the wrong
+ * test: the caller proved the tip is a commit the remote already has, which is the stronger fact.
+ * Forgiving: the checkout is already gone by the time this runs, and a branch that would not
+ * delete is a leftover name, not lost work.
+ */
+export declare function deleteBranch(repo: string, branch: string, agent?: GitRunner): Promise<void>;
+/**
+ * Whether `path` is the root of a git worktree — the main checkout's or a linked one (#1654).
+ *
+ * Git answers for any directory *inside* a repository, so a `branches/<run>` directory that is
+ * no longer a worktree (a checkout removed by hand, a marker written after teardown) makes every
+ * git command run in it act on the enclosing repo: the user's own checkout, on the user's own
+ * branch. The one question that tells the two apart is whether git's top level is this very
+ * directory. False on any failure, and the caller leaves the directory alone.
+ */
+export declare function isWorktreeRoot(path: string, agent?: GitRunner): Promise<boolean>;
+/**
+ * The branch checked out at `path` when `path` is a worktree root (#1654), else `undefined` —
+ * the read every consumer of a `branches/<run>` directory wants, so none of them can take the
+ * enclosing repo's branch for the run's.
+ */
+export declare function worktreeBranch(path: string, agent?: GitRunner): Promise<string | undefined>;
+/**
+ * The branch checked out at `path`, or `undefined` when detached / not a repo.
+ * Forgiving, like {@link listWorktrees}: callers use it to decide, not to fail.
+ */
+export declare function currentBranch(path: string, agent?: GitRunner): Promise<string | undefined>;
+/**
+ * Rename an agent's branch once the agent names the session (#736): the worktree is
+ * created on `tf-agent-<agentId>` before a name exists, and this puts the
+ * readable `tf-<sessionName>` on it.
+ *
+ * Only renames when `path` is still on `from`. The #326 system prompt currently
+ * tells the agent to create and check out its own `tf-<name>` branch,
+ * and until that step is dropped there (the prompt ships verbatim from the issue,
+ * so it is not ours to edit) the agent may already have moved off `from` — in
+ * which case it named the branch itself and there is nothing to rename. Returns
+ * whether it renamed, and never throws: an agent must not die over a branch name.
+ */
+export declare function renameAgentBranch(path: string, from: string, to: string, agent?: GitRunner): Promise<boolean>;
+/**
+ * `git worktree prune`: drop administrative entries for worktree dirs a crash left
+ * behind. Never removes a live worktree, so it is always safe. Forgiving.
+ */
+export declare function pruneWorktrees(repo: string, agent?: GitRunner): Promise<void>;
+/** Runs `du`, resolving its stdout. Injectable so the size read can be tested without a real tree. */
+export type SizeRunner = (path: string) => Promise<string>;
+/** A {@link SizeRunner} over `du -sk`: one process, and it does not follow the symlinked deps (#736). */
+export declare function nodeSizeRunner(): SizeRunner;
+/**
+ * A worktree's size on disk in bytes, or undefined when it cannot be read (#798). Best-effort by
+ * design: this only ever labels a "remove this" button, so a missing number costs nothing while a
+ * throw or a hang would cost the panel it sits in. `du` is absent on Windows, which reads as
+ * unknown like any other failure.
+ */
+export declare function worktreeSize(path: string, agent?: SizeRunner): Promise<number | undefined>;
+/**
+ * Whether a branch is on the remote, with the local tip already there (E5).
+ *
+ * The one predicate the whole retention story is built on: nothing local is ever the last copy of
+ * work, so anything the remote has may be deleted and anything it does not have stays. It replaced
+ * three interacting rules — a clean finish removes the checkout, a failure keeps it, a merged
+ * branch reclaims it later — each of which asked *what state did this session end in* rather than
+ * *is this recoverable*.
+ *
+ * `git rev-parse` of the remote-tracking ref, then a merge-base check: the ref existing is not
+ * enough, because a branch pushed and then committed to again has a tip the remote has never seen.
+ * Reads only local refs (no fetch), so it is cheap enough to ask on every teardown — the remote ref
+ * is written by the push this is checking for, which is what makes that sound.
+ *
+ * Anything unreadable answers `false`. A repo with no remote configured therefore keeps every
+ * checkout, which is the honest outcome: there is nowhere for the work to be recoverable from.
+ */
+export declare function branchPushed(repo: string, branch: string, agent?: GitRunner): Promise<boolean>;
+/**
+ * Whether the checkout has nothing uncommitted — the read half of {@link commitPendingWork}, for
+ * a decision that must not commit on the way to its answer: removing a publish-nothing session's
+ * checkout requires a clean tree, and grabbing someone's half-typed edits as a commit to find
+ * that out would be the intrusion the question exists to avoid. Throws when git cannot answer,
+ * so the caller keeps the checkout rather than guessing.
+ */
+export declare function worktreeClean(path: string, agent?: GitRunner): Promise<boolean>;
+/**
+ * Whether the repo has any remote configured at all. What the sweep asks once per project: with
+ * no remote, {@link branchPushed} is false for every checkout and the push cannot land, so the
+ * whole per-checkout probe-and-push cycle is doomed before it starts — and that answer cannot
+ * change between two rows of the same sweep. Anything unreadable answers `false`, like
+ * {@link branchPushed}: keeping a checkout is the safe direction.
+ */
+export declare function repoHasRemote(repo: string, agent?: GitRunner): Promise<boolean>;
+//# sourceMappingURL=worktree.d.ts.map

package/dist/store/worktree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../src/store/worktree.ts"],"names":[],"mappings":"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"}