@openagt/dashboard 0.0.0-stage → 0.9.0

package/dist/dashboard/activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../../src/dashboard/activity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACnF,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAKnE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAcvC;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,+BAA+B;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,0FAA0F;IAC1F,IAAI,EAAE,SAAS,GAAG,UAAU,CAAA;IAC5B,2FAA2F;IAC3F,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uGAAuG;IACvG,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC3B,gGAAgG;IAChG,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,EAAE,CAAC,CAAA;CACnD;AAgBD;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CACjC,QAAQ,EAAE,cAAc,EAAE,EAC1B,IAAI,GAAE,YAAiB,GACtB,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAYnC"}

package/dist/dashboard/activity.js

@@ -0,0 +1,56 @@
+import { readAllAgents } from '../store/index.js';
+// The identity + diff live in the leaf `keys.ts` so the dashboard can share them (they are pure);
+// re-exported here so this stays the import site for anything that already reads them from the
+// module that defines `Activity`.
+export { activityKey } from './keys.js';
+// The "New activity" feed (#627): the cross-project stream of run lifecycle transitions that
+// do NOT need the human — an agent started, an agent finished. It is the default-off notification
+// category, the counterpart to the interventions queue (which is the always-on "needs you"
+// half). Same shape and same "only genuinely new" diff as interventions.ts, so the browser
+// hook folds it into a baseline on first look and then notifies once per transition — you hear
+// an agent kick off and an agent land, nothing when the page opens.
+/** How many recent agents per project to consider. Bounds the finished-set — older agents rolled off
+ * long ago and were already baselined, so they never fire. A running agent is always newest (live
+ * meta is prepended), so it is always in range. */
+const RECENT_RUNS = 20;
+/** Map one agent to its current activity item: `started` while running, else `finished`. */
+function activityFor(project, agent) {
+    const kind = agent.status === 'running' ? 'started' : 'finished';
+    return {
+        projectId: project.id,
+        projectName: project.name,
+        agentId: agent.id,
+        kind,
+        ...(agent.intent ? { title: agent.intent } : {}),
+        ...(kind === 'finished' ? { status: agent.status } : {}),
+        ...(agent.updatedAt ? { updatedAt: agent.updatedAt } : {}),
+    };
+}
+/**
+ * Build the cross-project activity feed: for each registered project's most recent agents, one
+ * item per agent reflecting where it is now (`started` while it runs, `finished` once it lands),
+ * newest first. Forgiving — a project whose agents cannot be read simply contributes nothing, and
+ * comes back named as one that was *not* read whole (#1623), since "nothing happened there" and
+ * "I could not look" are the same empty list to everyone but the notification watcher.
+ *
+ * The `started` and `finished` items for one agent carry distinct keys ({@link activityKey}), so a
+ * run that is still going notifies once (started) and again when it lands (finished). An agent that
+ * both starts and finishes between two polls is only ever seen terminal, so it notifies once
+ * (finished) — one quick agent, one line.
+ */
+export async function buildActivity(projects, deps = {}) {
+    const readAgents = deps.readAgents ?? readAllAgents;
+    const items = [];
+    const whole = [];
+    for (const project of projects) {
+        const read = await readAgents(project.path).catch(() => undefined);
+        if (!read)
+            continue;
+        whole.push(project.id);
+        for (const agent of read.slice(0, RECENT_RUNS))
+            items.push(activityFor(project, agent));
+    }
+    items.sort((a, b) => (b.updatedAt ?? '').localeCompare(a.updatedAt ?? ''));
+    return { items, whole };
+}
+//# sourceMappingURL=activity.js.map

package/dist/dashboard/activity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.js","sourceRoot":"","sources":["../../src/dashboard/activity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAoC,MAAM,mBAAmB,CAAA;AAGnF,kGAAkG;AAClG,+FAA+F;AAC/F,kCAAkC;AAClC,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAEvC,6FAA6F;AAC7F,kGAAkG;AAClG,2FAA2F;AAC3F,2FAA2F;AAC3F,+FAA+F;AAC/F,oEAAoE;AAEpE;;mDAEmD;AACnD,MAAM,WAAW,GAAG,EAAE,CAAA;AA4BtB,4FAA4F;AAC5F,SAAS,WAAW,CAAC,OAAuB,EAAE,KAAgB;IAC5D,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAA;IAChE,OAAO;QACL,SAAS,EAAE,OAAO,CAAC,EAAE;QACrB,WAAW,EAAE,OAAO,CAAC,IAAI;QACzB,OAAO,EAAE,KAAK,CAAC,EAAE;QACjB,IAAI;QACJ,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAChD,GAAG,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACxD,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC3D,CAAA;AACH,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,QAA0B,EAC1B,IAAI,GAAiB,EAAE;IAEvB,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,aAAa,CAAA;IACnD,MAAM,KAAK,GAAe,EAAE,CAAA;IAC5B,MAAM,KAAK,GAAa,EAAE,CAAA;IAC1B,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,IAAI,GAAG,MAAM,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAA;QAClE,IAAI,CAAC,IAAI;YAAE,SAAQ;QACnB,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QACtB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,WAAW,CAAC;YAAE,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAA;IACzF,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,CAAA;IAC1E,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAA;AACzB,CAAC"}

package/dist/dashboard/agent-handoff.d.ts

@@ -0,0 +1,244 @@
+import { type LinkedPr, type BranchPrLookup } from './pull-requests.js';
+import type { Cached } from './cache.js';
+import type { AgentMeta } from '../store/index.js';
+import { type BranchesFor } from '../store/branches.js';
+import { type GitHostFor } from '../store/git-host.js';
+import { type RunsFor } from '../store/runs.js';
+/** One commit a session put on its branch. */
+export interface HandoffCommit {
+    sha: string;
+    /** Short sha, for display. */
+    short: string;
+    subject: string;
+}
+/** One file the session changed, against the branch point. */
+export interface HandoffFile {
+    path: string;
+    insertions: number;
+    deletions: number;
+    /** True for a binary file, where line counts are meaningless. */
+    binary: boolean;
+}
+/** What a finished session produced and what can still be done with it. */
+export interface AgentHandoff {
+    /** The branch the work is on. */
+    branch: string;
+    /** The name the agent gave its work, as the branches provider answers it; absent while the run has not named it. */
+    name?: string;
+    /** The branch still exists in the repo (a deleted or never-created one does not). */
+    exists: boolean;
+    /** The branch is gone because the run changed nothing ({@link leftNothing}), not because work went. */
+    unchanged?: boolean;
+    /**
+     * The run's work was landed: merged into its main agent's branch by that agent, or into the
+     * project's default branch by the person, on this machine. The run's own branch went with that,
+     * and what is read here is what it held, by the last commit its record kept.
+     */
+    landed?: boolean;
+    /** What the branch is measured against: the repo's default branch, or the commit the run's own work begins at (a run started from another branch, or one already merged), when one was found. */
+    base?: string;
+    commits: HandoffCommit[];
+    files: HandoffFile[];
+    insertions: number;
+    deletions: number;
+    /**
+     * The session produced nothing to hand off: the branch exists but carries no commit the base
+     * does not already have — or nothing beyond OpenAgent's own bookkeeping (#1291), which is
+     * committed for provenance, never as publishable work. Said out loud, rather than shown as an
+     * empty branch.
+     */
+    empty: boolean;
+    /** The repo has a remote to push to at all. */
+    hasRemote: boolean;
+    /** The branch is on the remote and the remote is at the same commit. */
+    pushed: boolean;
+    /** The branch is already merged into the base. */
+    merged: boolean;
+    /** The project has a git host package (#1820): a pull request is a next step at all. Without one, the last step is the push. */
+    gitHost: boolean;
+    /** The PR opened for this branch, when there is one. */
+    pr?: LinkedPr;
+    /** The PR is not known yet, rather than absent (#1028): the lookup is still running. */
+    prPending?: boolean;
+    /**
+     * The files the session changed and never committed, read from its own checkout (#1173).
+     *
+     * The agent is told to commit its work, but one that ended without doing so holds its whole
+     * output in an uncommitted tree, and nothing commits it on the agent's behalf (#1638). That work
+     * is not on the branch yet, so it is
+     * not in {@link commits} and it does not make {@link empty} false. Paths rather than a count,
+     * because a no-diff branch must *name* what is waiting instead of offering an Open PR that
+     * the git host can only refuse. Absent when no checkout is on the branch any more — "no checkout"
+     * and "a checkout, tree clean" are different answers.
+     */
+    pendingFiles?: string[];
+}
+/** Injectable seams so the reader is unit-testable off disk and off the provider. */
+export interface AgentHandoffDeps {
+    pr?: BranchPrLookup;
+    /** The project's checkouts and branches (default the project's provider, {@link projectBranches}). */
+    branches?: BranchesFor;
+    /** The project's git host (default the project's provider, {@link projectGitHost}). */
+    gitHost?: GitHostFor;
+    /**
+     * When the agent started (ISO), so the PR lookup can tell the agent's own PR from an earlier agent's
+     * on the same branch name (#1251). Without it, only an open PR is trusted.
+     */
+    since?: string;
+    /**
+     * Which of the run's own PRs answers, when it has more than one (#1512). Identity questions want
+     * the first; a handoff decision comparing the branch tip against a PR's head wants the last one
+     * that saw the branch, or work a later PR already landed reads as unlanded. See {@link pickAgentPr}.
+     */
+    order?: 'first' | 'latest';
+    /** The commit the run's own work begins at ({@link AgentMeta.baseCommit}): what the branch is measured from. */
+    from?: string;
+}
+/**
+ * The branch an agent's work is on: what was recorded while the checkout existed (#799/#1277).
+ * The agent renames its branch itself (#1725), so anything but the record is a guess, and a run
+ * whose record carries no branch has none to hand off.
+ */
+export declare function agentBranchFor(agent: {
+    id: string;
+    branch?: string;
+}): string | undefined;
+/**
+ * Whether a run whose branch is gone changed nothing (#1850): it ended `done`, `failed` or
+ * `stopped` on this machine, has no pull request, and was not landed by a main agent (a landed
+ * run's branch went because its work moved on, not for holding nothing). Such a run's own tool recorded the branch's
+ * last name as it ended, a Stop included, and then reclaimed the checkout, and the branches rule
+ * deletes a branch with the checkout only when it holds nothing. A run whose process died is marked
+ * `stopped` by the sweep only when it left no checkout, so it had nowhere to keep a change. A run
+ * another machine ran leaves no such proof here, and one `waiting` keeps its checkout.
+ */
+export declare function leftNothing(agent: {
+    status?: string;
+    host?: string;
+    pr?: unknown;
+    landed?: string;
+}, host?: string): boolean;
+/** The cached single-PR read {@link resolveAgentPr} asks for the recorded PR's current state. */
+export type CachedBranchPrLookup = (cwd: string, branch?: string) => Promise<Cached<LinkedPr | undefined>>;
+/** What {@link resolveAgentPr} needs to know about an agent: structurally satisfied by {@link AgentMeta}. */
+export interface PrAgent {
+    id: string;
+    branch?: string;
+    /** The pull request the agent recorded when one was opened for it (E6). */
+    pr?: {
+        number: number;
+        url: string;
+    };
+}
+/**
+ * The pull request that belongs to an agent: the one it recorded (E6), read live for its state.
+ *
+ * The number is a fact about the agent, so the agent writes it down — at the moment its handoff opens
+ * the PR, or when the dashboard's button does after the process is gone. Every surface then reads
+ * the same integer instead of re-deriving it.
+ *
+ * What that replaced: a three-way branch-name ladder (the recorded branch, then a branch built from
+ * the session name, then the run-id branch, because a hands-off web agent's checkout is gone and its
+ * session name may be a reused pin) plus a timestamp heuristic on top of it, so that a predecessor's PR on
+ * a shared branch name was not mistaken for this agent's. Three sources and a guess, standing in for
+ * one integer nobody had written down — the same lesson the `branch` event (#1277) already learned.
+ *
+ * The *state* is still read live, because it changes without this agent doing anything: a PR merges,
+ * a human closes it. That read rides the PR-lookup cache (#1028), and `pending` while it is warming means the
+ * caller can ask again rather than render "no PR".
+ */
+export declare function resolveAgentPr(cwd: string, agent: PrAgent, prs?: CachedBranchPrLookup): Promise<Cached<LinkedPr | undefined>>;
+/**
+ * Merge a finished session's open PR (#1391): the Merge action, pressed by a human saying "it's
+ * good, land it". The landing itself is the git host provider's (`merge <number>`): armed to merge on
+ * green, merged at once where it is already green, or watched by the provider where the
+ * repository allows no auto-merge; a draft is marked ready on the way. Refuses when the agent has
+ * no PR or it is no longer open — "already merged" is an answer, not an action.
+ */
+export declare function mergeAgentPr(cwd: string, agent: PrAgent, deps?: {
+    gitHost?: GitHostFor;
+    prs?: CachedBranchPrLookup;
+}): Promise<HandoffResult>;
+/**
+ * Read what a finished session left behind, for `branch`: the branch's git facts from the
+ * project's branches provider, and the run's own pull request from OpenAgent's lookup.
+ *
+ * Returns undefined only when the project has no branches provider, or the provider did not
+ * answer for the branch. A branch that no longer exists still returns a handoff (with
+ * `exists: false`), because "that branch is gone" is itself the answer the dashboard needs to
+ * show — and its PR is a remote question, still answerable (#1255).
+ */
+export declare function readAgentHandoff(cwd: string, branch: string, deps?: AgentHandoffDeps): Promise<AgentHandoff | undefined>;
+/**
+ * What a finished run left behind, off its record: {@link readAgentHandoff} for the branch the
+ * record names, measured from the commit the run's own work begins at when the record names one
+ * (a run started from another branch holds, beyond the default branch, that branch's work too).
+ *
+ * A run its main agent landed has no branch left: what it held is read by the last commit its
+ * record kept, and the answer says landed. A branch gone because the run changed nothing is said
+ * as that, not as lost work. Undefined for a run with neither a branch nor a landed commit.
+ */
+export declare function readRunHandoff(cwd: string, agent: Pick<AgentMeta, 'id' | 'startedAt' | 'branch' | 'baseCommit' | 'landed' | 'status' | 'host' | 'pr'>, deps?: AgentHandoffDeps): Promise<AgentHandoff | undefined>;
+/**
+ * What a handoff action did. The PR's `number` rides along with its `url` (E6), because the number
+ * is the fact worth *recording* — every surface that wants an agent's PR then reads it off the agent
+ * rather than re-deriving it later.
+ */
+export type HandoffResult = {
+    ok: true;
+    url?: string;
+    number?: number;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Push a finished session's branch (#1820): the last step where the project has no git host, or the
+ * step a person wants on its own. The branches provider pushes it under its clean rule; a branch
+ * only the remote has is already there. Refuses a session that recorded no branch.
+ */
+export declare function pushAgentBranch(cwd: string, agent: Pick<AgentMeta, 'id' | 'branch'>, deps?: {
+    branches?: BranchesFor;
+}): Promise<HandoffResult>;
+/**
+ * Merge a finished session's branch into the project's default branch, on this machine: how the
+ * work reaches the project's own folder where there is no remote to push to. The branches provider
+ * merges and deletes the branch; the session's record then keeps the branch's last commit and the
+ * commit its work began at, so what it changed is still read once the branch is gone.
+ */
+export declare function mergeAgentBranch(cwd: string, agent: Pick<AgentMeta, 'id' | 'branch'>, deps?: {
+    branches?: BranchesFor;
+    runs?: RunsFor;
+}): Promise<HandoffResult>;
+/**
+ * Open a draft PR for a branch that exists only on the remote (#1601): a cloud session's own
+ * `claude/*` branch was pushed from a VM this machine never sees, so there is nothing to push
+ * here — the provider publishes the branch as the remote has it. Draft because a PR
+ * OpenAgent opens by itself must not put a review request in anyone's inbox, and the
+ * interventions queue keeps listing a session's draft.
+ */
+export declare function openRemoteBranchPullRequest(cwd: string, agent: HandoffAgent, branch: string, deps?: {
+    branches?: BranchesFor;
+    gitHost?: GitHostFor;
+}): Promise<HandoffResult>;
+/**
+ * Open a PR for a finished session, deciding from what the agent recorded which cases should not
+ * open one. Reads the branch's handoff first: a branch that no longer exists, or a session that
+ * changed nothing, is a clear error rather than an empty PR, and a branch that already has a PR
+ * returns that one. Title is its branch, else the id; body is the intent, plus which session did it. This is the handoff decision the
+ * dashboard's open-PR button offers; the RPC layer only resolves which run it is about, and the
+ * two providers do the pushing and the opening.
+ */
+export declare function openAgentPullRequest(cwd: string, agent: AgentMeta, options?: {
+    draft?: boolean;
+    branches?: BranchesFor;
+    gitHost?: GitHostFor;
+    pr?: BranchPrLookup;
+}): Promise<HandoffResult>;
+/**
+ * The little a handoff needs to know about the agent it is for: which branch, and what to say on
+ * the PR. Narrower than {@link AgentMeta} so a caller cannot quietly start depending on the rest
+ * of the agent's state.
+ */
+export type HandoffAgent = Pick<AgentMeta, 'id' | 'branch' | 'intent'> & Partial<Pick<AgentMeta, 'startedAt'>>;
+//# sourceMappingURL=agent-handoff.d.ts.map

package/dist/dashboard/agent-handoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-handoff.d.ts","sourceRoot":"","sources":["../../src/dashboard/agent-handoff.ts"],"names":[],"mappings":"AACA,OAAO,EAA4E,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACjJ,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAClD,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACxE,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtE,OAAO,EAAe,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAwB5D,8CAA8C;AAC9C,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAA;IACX,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,8DAA8D;AAC9D,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,iEAAiE;IACjE,MAAM,EAAE,OAAO,CAAA;CAChB;AAED,2EAA2E;AAC3E,MAAM,WAAW,YAAY;IAC3B,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,oHAAoH;IACpH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,qFAAqF;IACrF,MAAM,EAAE,OAAO,CAAA;IACf,uGAAuG;IACvG,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,iMAAiM;IACjM,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,aAAa,EAAE,CAAA;IACxB,KAAK,EAAE,WAAW,EAAE,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB;;;;;OAKG;IACH,KAAK,EAAE,OAAO,CAAA;IACd,+CAA+C;IAC/C,SAAS,EAAE,OAAO,CAAA;IAClB,wEAAwE;IACxE,MAAM,EAAE,OAAO,CAAA;IACf,kDAAkD;IAClD,MAAM,EAAE,OAAO,CAAA;IACf,gIAAgI;IAChI,OAAO,EAAE,OAAO,CAAA;IAChB,wDAAwD;IACxD,EAAE,CAAC,EAAE,QAAQ,CAAA;IACb,wFAAwF;IACxF,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;;;;;;;;;OAUG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;CACxB;AAED,qFAAqF;AACrF,MAAM,WAAW,gBAAgB;IAC/B,EAAE,CAAC,EAAE,cAAc,CAAA;IACnB,sGAAsG;IACtG,QAAQ,CAAC,EAAE,WAAW,CAAA;IACtB,uFAAuF;IACvF,OAAO,CAAC,EAAE,UAAU,CAAA;IACpB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAA;IAC1B,gHAAgH;IAChH,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAEzF;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,IAAI,GAAE,MAAmB,GAAG,OAAO,CAExI;AAYD,iGAAiG;AACjG,MAAM,MAAM,oBAAoB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC,CAAA;AAE1G,6GAA6G;AAC7G,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,2EAA2E;IAC3E,EAAE,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CACrC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,EACd,GAAG,GAAE,oBAAmC,GACvC,OAAO,CAAC,MAAM,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC,CAUvC;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,EACd,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,UAAU,CAAC;IAAC,GAAG,CAAC,EAAE,oBAAoB,CAAA;CAAO,GAC9D,OAAO,CAAC,aAAa,CAAC,CAcxB;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,gBAAqB,GAC1B,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAgCnC;AAED;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,WAAW,GAAG,QAAQ,GAAG,YAAY,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,IAAI,CAAC,EAC1G,IAAI,GAAE,gBAAqB,GAC1B,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CASnC;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAuBtG;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,QAAQ,CAAC,EAAE,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,WAAW,CAAA;CAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAOzJ;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,QAAQ,CAAC,EAAE,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,WAAW,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAa1K;AAED;;;;;;GAMG;AACH,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE,MAAM,EACd,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,WAAW,CAAC;IAAC,OAAO,CAAC,EAAE,UAAU,CAAA;CAAO,GAC1D,OAAO,CAAC,aAAa,CAAC,CAExB;AAcD;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,SAAS,EAChB,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,WAAW,CAAC;IAAC,OAAO,CAAC,EAAE,UAAU,CAAC;IAAC,EAAE,CAAC,EAAE,cAAc,CAAA;CAAO,GACnG,OAAO,CAAC,aAAa,CAAC,CAsBxB;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,QAAQ,GAAG,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC,CAAA"}

package/dist/dashboard/agent-handoff.js

@@ -0,0 +1,310 @@
+import { hostname } from 'node:os';
+import { cachedPrView, cachedPrsForBranch, forgetBranchPrs, forgetPr, pickAgentPr } from './pull-requests.js';
+import { projectBranches } from '../store/branches.js';
+import { projectGitHost } from '../store/git-host.js';
+import { projectRuns } from '../store/runs.js';
+/**
+ * The branch an agent's work is on: what was recorded while the checkout existed (#799/#1277).
+ * The agent renames its branch itself (#1725), so anything but the record is a guess, and a run
+ * whose record carries no branch has none to hand off.
+ */
+export function agentBranchFor(agent) {
+    return agent.branch;
+}
+/**
+ * Whether a run whose branch is gone changed nothing (#1850): it ended `done`, `failed` or
+ * `stopped` on this machine, has no pull request, and was not landed by a main agent (a landed
+ * run's branch went because its work moved on, not for holding nothing). Such a run's own tool recorded the branch's
+ * last name as it ended, a Stop included, and then reclaimed the checkout, and the branches rule
+ * deletes a branch with the checkout only when it holds nothing. A run whose process died is marked
+ * `stopped` by the sweep only when it left no checkout, so it had nowhere to keep a change. A run
+ * another machine ran leaves no such proof here, and one `waiting` keeps its checkout.
+ */
+export function leftNothing(agent, host = hostname()) {
+    return !agent.pr && agent.landed === undefined && (agent.status === 'done' || agent.status === 'failed' || agent.status === 'stopped') && agent.host === host;
+}
+/**
+ * The branch's PR as it applies to *this* run: the injected seam when the caller gave one, else
+ * the cached history filtered through {@link pickAgentPr} with the agent's start time (#1251).
+ */
+async function lookupAgentPr(cwd, branch, deps) {
+    if (deps.pr)
+        return { value: await deps.pr(cwd, branch).catch(() => undefined), pending: false };
+    const prs = await cachedPrsForBranch(cwd, branch).catch(() => ({ value: undefined, pending: false }));
+    return { value: prs.value ? pickAgentPr(prs.value, deps.since, deps.order) : undefined, pending: prs.pending };
+}
+/**
+ * The pull request that belongs to an agent: the one it recorded (E6), read live for its state.
+ *
+ * The number is a fact about the agent, so the agent writes it down — at the moment its handoff opens
+ * the PR, or when the dashboard's button does after the process is gone. Every surface then reads
+ * the same integer instead of re-deriving it.
+ *
+ * What that replaced: a three-way branch-name ladder (the recorded branch, then a branch built from
+ * the session name, then the run-id branch, because a hands-off web agent's checkout is gone and its
+ * session name may be a reused pin) plus a timestamp heuristic on top of it, so that a predecessor's PR on
+ * a shared branch name was not mistaken for this agent's. Three sources and a guess, standing in for
+ * one integer nobody had written down — the same lesson the `branch` event (#1277) already learned.
+ *
+ * The *state* is still read live, because it changes without this agent doing anything: a PR merges,
+ * a human closes it. That read rides the PR-lookup cache (#1028), and `pending` while it is warming means the
+ * caller can ask again rather than render "no PR".
+ */
+export async function resolveAgentPr(cwd, agent, prs = cachedPrView) {
+    if (!agent.pr)
+        return { value: undefined, pending: false };
+    const branch = agentBranchFor(agent);
+    const read = await prs(cwd, branch).catch(() => ({ value: undefined, pending: false }));
+    // The live read is about the recorded PR's *state*; a different number on the branch is some
+    // other PR and never this agent's answer.
+    if (read.value && read.value.number === agent.pr.number)
+        return { value: read.value, pending: false };
+    // Nothing live to say, so the recorded fact stands on its own: an agent whose PR is on a branch this
+    // machine cannot see still has a PR, and its number and URL are what the surfaces need.
+    return { value: { ...agent.pr, state: read.pending ? 'OPEN' : 'UNKNOWN', title: '' }, pending: read.pending };
+}
+/**
+ * Merge a finished session's open PR (#1391): the Merge action, pressed by a human saying "it's
+ * good, land it". The landing itself is the git host provider's (`merge <number>`): armed to merge on
+ * green, merged at once where it is already green, or watched by the provider where the
+ * repository allows no auto-merge; a draft is marked ready on the way. Refuses when the agent has
+ * no PR or it is no longer open — "already merged" is an answer, not an action.
+ */
+export async function mergeAgentPr(cwd, agent, deps = {}) {
+    const pr = (await resolveAgentPr(cwd, agent, deps.prs)).value;
+    if (!pr)
+        return { ok: false, error: 'this session has no pull request to merge' };
+    if (pr.state !== 'OPEN')
+        return { ok: false, error: `this session's PR is already ${pr.state.toLowerCase()}` };
+    const gitHost = await (deps.gitHost ?? projectGitHost)(cwd).catch(() => undefined);
+    if (!gitHost)
+        return { ok: false, error: 'this project has no git host package to merge with' };
+    const merged = await gitHost.merge(pr.number);
+    if (!merged.ok)
+        return { ok: false, error: merged.error };
+    // The PR's cached state just changed, so the branch's cached read must go or the bar keeps
+    // offering a merge for a PR that landed (#1028).
+    const branch = agentBranchFor(agent);
+    forgetPr(cwd, branch);
+    if (branch !== undefined)
+        forgetBranchPrs(cwd, branch);
+    return { ok: true, url: pr.url, number: pr.number };
+}
+/**
+ * Read what a finished session left behind, for `branch`: the branch's git facts from the
+ * project's branches provider, and the run's own pull request from OpenAgent's lookup.
+ *
+ * Returns undefined only when the project has no branches provider, or the provider did not
+ * answer for the branch. A branch that no longer exists still returns a handoff (with
+ * `exists: false`), because "that branch is gone" is itself the answer the dashboard needs to
+ * show — and its PR is a remote question, still answerable (#1255).
+ */
+export async function readAgentHandoff(cwd, branch, deps = {}) {
+    const branches = await (deps.branches ?? projectBranches)(cwd).catch(() => undefined);
+    if (!branches)
+        return undefined;
+    const [state] = await branches.show([branch], deps.from);
+    if (!state)
+        return undefined;
+    const gitHost = await (deps.gitHost ?? projectGitHost)(cwd).catch(() => undefined);
+    // Read through the cache and allowed to arrive late (#1028): the branch's facts are local
+    // git, and none of them should wait on the git host.
+    const pr = await lookupAgentPr(cwd, branch, deps);
+    const commits = state.commits.map(commit => ({ sha: commit.sha, short: commit.sha.slice(0, 7), subject: commit.subject }));
+    const files = state.files.map(file => ({ path: file.path, insertions: file.insertions, deletions: file.deletions, binary: file.binary }));
+    return {
+        branch,
+        ...(state.name ? { name: state.name } : {}),
+        exists: state.exists,
+        ...(state.base ? { base: state.base } : {}),
+        commits,
+        files,
+        insertions: files.reduce((sum, f) => sum + f.insertions, 0),
+        deletions: files.reduce((sum, f) => sum + f.deletions, 0),
+        // A session that changed nothing is a real outcome, not an error: it gets said, not shown as
+        // an empty branch with buttons that would push nothing. The files decide as well as the
+        // commits: commits that net to no change leave nothing to hand off.
+        empty: commits.length === 0 || files.length === 0,
+        hasRemote: state.hasRemote,
+        pushed: state.pushed,
+        merged: state.merged,
+        gitHost: gitHost !== undefined,
+        ...(pr.value ? { pr: pr.value } : {}),
+        ...(pr.pending ? { prPending: true } : {}),
+        ...(state.pendingFiles ? { pendingFiles: state.pendingFiles } : {}),
+    };
+}
+/**
+ * What a finished run left behind, off its record: {@link readAgentHandoff} for the branch the
+ * record names, measured from the commit the run's own work begins at when the record names one
+ * (a run started from another branch holds, beyond the default branch, that branch's work too).
+ *
+ * A run its main agent landed has no branch left: what it held is read by the last commit its
+ * record kept, and the answer says landed. A branch gone because the run changed nothing is said
+ * as that, not as lost work. Undefined for a run with neither a branch nor a landed commit.
+ */
+export async function readRunHandoff(cwd, agent, deps = {}) {
+    const at = agentBranchFor(agent) ?? agent.landed;
+    if (at === undefined)
+        return undefined;
+    // A commit has no pull request to look up: only a branch is asked of the git host.
+    const noPr = agentBranchFor(agent) === undefined ? { pr: async () => undefined } : {};
+    const handoff = await readAgentHandoff(cwd, at, { since: agent.startedAt, ...(agent.baseCommit !== undefined ? { from: agent.baseCommit } : {}), ...deps, ...noPr });
+    if (!handoff)
+        return undefined;
+    if (agent.landed !== undefined)
+        return { ...handoff, landed: true };
+    return !handoff.exists && leftNothing(agent) ? { ...handoff, unchanged: true } : handoff;
+}
+/**
+ * Open a PR for a branch: the two providers composed (#1820). The branches provider pushes the
+ * branch (`push --branch`), then the git host provider opens its request (`open --branch`); the
+ * request's base is the git host's. A branch that already has an open request is answered as it is.
+ * The branch has a PR now, so the cached "no PR" must go or the bar would keep offering to open
+ * one for the next minute (#1028) — both caches: the single-PR view and the history.
+ */
+async function publishBranch(cwd, branch, draft, branches, gitHost) {
+    const source = await branches(cwd).catch(() => undefined);
+    if (!source)
+        return { ok: false, error: 'this project has no branches provider to push with' };
+    const gitHostSource = await gitHost(cwd).catch(() => undefined);
+    if (!gitHostSource)
+        return { ok: false, error: 'this project has no git host package to open a pull request with' };
+    const pushed = await source.push(branch);
+    if (!pushed.ok)
+        return { ok: false, error: pushed.error };
+    const opened = await gitHostSource.open(branch, { title: draft.title, body: draft.body, ...(draft.draft ? { draft: true } : {}) });
+    if (!opened.ok)
+        return { ok: false, error: opened.error };
+    forgetPr(cwd, branch);
+    forgetBranchPrs(cwd, branch);
+    return { ok: true, url: opened.request.url, number: opened.request.number };
+}
+/**
+ * Push a finished session's branch (#1820): the last step where the project has no git host, or the
+ * step a person wants on its own. The branches provider pushes it under its clean rule; a branch
+ * only the remote has is already there. Refuses a session that recorded no branch.
+ */
+export async function pushAgentBranch(cwd, agent, deps = {}) {
+    const branch = agentBranchFor(agent);
+    if (branch === undefined)
+        return { ok: false, error: 'this session recorded no branch to push' };
+    const source = await (deps.branches ?? projectBranches)(cwd).catch(() => undefined);
+    if (!source)
+        return { ok: false, error: 'this project has no branches provider to push with' };
+    const pushed = await source.push(branch);
+    return pushed.ok ? { ok: true } : { ok: false, error: pushed.error };
+}
+/**
+ * Merge a finished session's branch into the project's default branch, on this machine: how the
+ * work reaches the project's own folder where there is no remote to push to. The branches provider
+ * merges and deletes the branch; the session's record then keeps the branch's last commit and the
+ * commit its work began at, so what it changed is still read once the branch is gone.
+ */
+export async function mergeAgentBranch(cwd, agent, deps = {}) {
+    const branch = agentBranchFor(agent);
+    if (branch === undefined)
+        return { ok: false, error: 'this session recorded no branch to merge' };
+    const source = await (deps.branches ?? projectBranches)(cwd).catch(() => undefined);
+    if (!source)
+        return { ok: false, error: 'this project has no branches provider to merge with' };
+    const merged = await source.merge(branch);
+    if (!merged.ok)
+        return { ok: false, error: merged.error };
+    if (!merged.deleted)
+        return { ok: true };
+    const runs = await (deps.runs ?? projectRuns)(cwd).catch(() => undefined);
+    const recorded = await runs?.patch(agent.id, { landed: { commit: merged.commit, from: merged.from } });
+    // The merge is in whatever the record says; a record that could not be written is said, since the page reads the record.
+    if (recorded && !recorded.ok)
+        return { ok: false, error: `merged into ${merged.into}, but the record was not updated: ${recorded.error}` };
+    return { ok: true };
+}
+/**
+ * Open a draft PR for a branch that exists only on the remote (#1601): a cloud session's own
+ * `claude/*` branch was pushed from a VM this machine never sees, so there is nothing to push
+ * here — the provider publishes the branch as the remote has it. Draft because a PR
+ * OpenAgent opens by itself must not put a review request in anyone's inbox, and the
+ * interventions queue keeps listing a session's draft.
+ */
+export async function openRemoteBranchPullRequest(cwd, agent, branch, deps = {}) {
+    return publishBranch(cwd, branch, { title: agentPrTitle(agent), body: agentPrBody(agent), draft: true }, deps.branches ?? projectBranches, deps.gitHost ?? projectGitHost);
+}
+/**
+ * Whether the session kept committing after its PR merged or closed (#1512): the PR carries a
+ * head, the branch has a tip, and they disagree. False for an open PR (pushed commits still land
+ * on it), for a headless read (an older cache or injected lookup — never risk a duplicate PR on
+ * a guess), and for a gone branch (no tip to compare; the PR stays the best answer, #1255).
+ */
+function movedPastPr(state) {
+    if (!state.pr || state.pr.state === 'OPEN')
+        return false;
+    const tip = state.commits[0]?.sha;
+    return Boolean(state.pr.headRefOid && tip && state.pr.headRefOid !== tip);
+}
+/**
+ * Open a PR for a finished session, deciding from what the agent recorded which cases should not
+ * open one. Reads the branch's handoff first: a branch that no longer exists, or a session that
+ * changed nothing, is a clear error rather than an empty PR, and a branch that already has a PR
+ * returns that one. Title is its branch, else the id; body is the intent, plus which session did it. This is the handoff decision the
+ * dashboard's open-PR button offers; the RPC layer only resolves which run it is about, and the
+ * two providers do the pushing and the opening.
+ */
+export async function openAgentPullRequest(cwd, agent, options = {}) {
+    // A subagent's work goes to its main agent's branch, and that one opens the pull request.
+    if (agent.parent !== undefined)
+        return { ok: false, error: 'this run is a subagent: its main agent lands its work and opens the pull request' };
+    const branch = agentBranchFor(agent);
+    if (branch === undefined)
+        return { ok: false, error: 'this session recorded no branch to open a PR from' };
+    const branches = options.branches ?? projectBranches;
+    const gitHost = options.gitHost ?? projectGitHost;
+    // `latest` order (#1512), because the `movedPastPr` decision below compares the branch tip
+    // against a PR's head: against the *first* PR, work a second one already landed reads as
+    // unlanded and this opens a third for it.
+    const handoff = await readAgentHandoff(cwd, branch, { since: agent.startedAt, order: 'latest', branches, gitHost, ...(options.pr ? { pr: options.pr } : {}), ...(agent.baseCommit !== undefined ? { from: agent.baseCommit } : {}) }).catch(() => undefined);
+    // The agent's PR first, even when its branch is gone locally: a hands-off web agent's branch only
+    // ever existed on the remote, and its PR is the answer the button exists to give (#1255).
+    // Unless the session demonstrably kept committing after that PR merged or closed (#1512) —
+    // then the old PR is not the answer, the new work needs its own.
+    if (handoff?.pr && !movedPastPr(handoff))
+        return { ok: true, url: handoff.pr.url, number: handoff.pr.number };
+    if (handoff && !handoff.exists)
+        return { ok: false, error: `branch ${branch} no longer exists` };
+    // Refuse rather than open an empty PR: a session that changed nothing has nothing to hand off.
+    if (handoff?.empty)
+        return { ok: false, error: 'this session produced no commits to open a PR for' };
+    // Its commits are still counted once the default branch has them, from where its work began: nothing is left to open one for.
+    if (handoff?.merged)
+        return { ok: false, error: 'this session’s work is already merged' };
+    return publishBranch(cwd, branch, { title: agentPrTitle(agent, handoff?.name), body: agentPrBody(agent), ...(options.draft ? { draft: true } : {}) }, branches, gitHost);
+}
+/**
+ * The PR title for a session (#1102).
+ *
+ * Two rungs, each a name for the work the session did: the branch the agent named its work with
+ * (#1725), else the session id — which says little, but says it honestly. An agent that publishes
+ * its own work titles its own PR; this is only the title of one a person opens for it.
+ *
+ * The prompt the session was given is not among them. It used to be, cut to 72 characters, and a
+ * squash merge made that permanent: `main` ended up carrying instructions truncated mid-sentence
+ * as commit subjects, which describe neither what changed nor even a whole thought (#1618).
+ */
+function agentPrTitle(agent, name) {
+    // The name the branches provider answers for the branch comes before the branch itself:
+    // OpenAgent draws the name it is given and never cuts the package's prefix off a branch.
+    return name ?? agent.branch ?? `Session ${agent.id}`;
+}
+/**
+ * The PR body: what was asked for, which is all OpenAgent knows on its own, and which session
+ * did it.
+ */
+function agentPrBody(agent) {
+    const lines = [];
+    const opening = agent.intent?.trim();
+    if (opening)
+        lines.push(opening, '');
+    lines.push(`Opened from OpenAgent session \`${agent.id}\`.`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=agent-handoff.js.map