dorfl 0.0.0 → 0.1.0

package/dist/reap-branches.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The **remote merged-work-branch reaper** — the cross-machine COUNTERPART of the
+ * job-worktree reaper in `gc.ts`. Where `gc.ts` reaps LOCAL job WORKTREES under
+ * `workspacesDir/work/*`, this reaps REMOTE `work/<slug>` BRANCHES that linger on
+ * the arbiter after their propose-mode PR has MERGED.
+ *
+ * The safety lynchpin is the SAME provably-merged predicate the worktree reaper
+ * uses (`gc.ts` `isAncestor`, REUSED here, never a second one): a remote
+ * `work/<slug>` branch is reapable **iff** its tip is
+ * `git merge-base --is-ancestor <tip> <arbiter>/main` — provably on `main`. A
+ * merely-pushed-but-unmerged branch (an in-flight, kept-for-continue recovery
+ * point) is NOT an ancestor of `main`, so the predicate AUTOMATICALLY excludes it
+ * — the never-delete-the-in-flight-branch invariant (ADR §4 deletion-safety)
+ * stays absolute. Deletion of a fully-merged ref needs NO force, so this NEVER
+ * `--force`s.
+ *
+ * It is provider-AGNOSTIC plain git (`git ls-remote` to enumerate, `git push
+ * --delete` to reap), so it works against a local `--bare` arbiter and any
+ * provider — NOT relying on GitHub's repo-level auto-delete setting (which is an
+ * additive convenience for GitHub arbiters only). The arbiter is addressed
+ * THROUGH a local repo (`cwd`) whose `<arbiter>` remote points at it: the same
+ * way `requeue --reset` addresses the arbiter for its sanctioned UN-merged
+ * deletion (the complement of this merged-only sweep).
+ */
+/** Why a remote `work/<slug>` branch was RETAINED (not provably merged). */
+export type RemoteRetainReason = 'not-merged' | 'main-unresolved';
+/** Human-readable text for each remote-branch retain reason (`sweep` reports). */
+export declare const REMOTE_RETAIN_REASON_TEXT: Record<RemoteRetainReason, string>;
+/** A remote `work/<slug>` branch the sweep reaped (provably merged). */
+export interface ReapedBranch {
+    /** The full branch ref (`work/<slug>`). */
+    branch: string;
+    /** The 40-hex tip the branch pointed at when it was deleted. */
+    tip: string;
+}
+/** A remote `work/<slug>` branch the sweep RETAINED, with the reason it kept it. */
+export interface RetainedBranch {
+    branch: string;
+    tip: string;
+    reason: RemoteRetainReason;
+    /** Human-readable reason text (`REMOTE_RETAIN_REASON_TEXT[reason]`). */
+    reasonText: string;
+}
+export interface SweepRemoteBranchesInput {
+    /**
+     * A local repo (a checkout or a hub mirror) whose `<arbiter>` remote points at
+     * the arbiter to sweep. All git runs in here; nothing in the working tree is
+     * touched (only remote refs are read + deleted).
+     */
+    cwd: string;
+    /** The arbiter remote name (default `origin`, as `requeue --arbiter` defaults). */
+    arbiter: string;
+    /** Sink for human-readable progress notes (per reaped / retained branch). */
+    note?: (message: string) => void;
+    /**
+     * Do NOT actually delete — only REPORT what WOULD be reaped vs retained. A
+     * read-only preview (`--dry-run`); the predicate still runs so the report is
+     * exact.
+     */
+    dryRun?: boolean;
+    env?: NodeJS.ProcessEnv;
+}
+export interface SweepRemoteBranchesResult {
+    /** The remote branches reaped this sweep (provably merged). Empty on dry-run. */
+    reaped: ReapedBranch[];
+    /** The remote branches retained, each with a clear reason. */
+    retained: RetainedBranch[];
+    /** On `dryRun`, the branches that WOULD be reaped (not actually deleted). */
+    wouldReap: ReapedBranch[];
+}
+/**
+ * Sweep the arbiter's remote `work/*` branches and DELETE exactly those that are
+ * provably merged into `<arbiter>/main` (`git merge-base --is-ancestor`, REUSING
+ * `gc.ts`'s `isAncestor`), reporting each as deleted-merged / retained-with-
+ * reason. NEVER `--force` (a merged ref needs none); NEVER touches a branch that
+ * is not an ancestor of `main` (the in-flight recovery point the never-delete
+ * invariant protects). Provider-agnostic plain git, so it works on a `--bare`
+ * arbiter.
+ *
+ * The flow:
+ *   1. `git ls-remote --heads <arbiter> 'work/*'` — enumerate remote work
+ *      branches + their tips (one network round-trip; no full fetch).
+ *   2. Fetch `<arbiter>/main` into a local tracking ref so the ancestor check
+ *      resolves the descendant LOCALLY; fetch each candidate tip object too (so
+ *      `merge-base` can read it) — best-effort, into a scratch ref.
+ *   3. For each branch whose tip `--is-ancestor` of the fetched main ⇒ delete via
+ *      `git push <arbiter> --delete <branch>`; else retain with a reason.
+ */
+export declare function sweepRemoteMergedBranches(input: SweepRemoteBranchesInput): SweepRemoteBranchesResult;
+/**
+ * Enumerate the arbiter's remote `work/*` heads + their tips via
+ * `git ls-remote --heads <arbiter> 'work/*'` (one round-trip, no full fetch).
+ * Only `work/<type>-<slug>` branches that {@link parseWorkBranchRef} recognises
+ * are returned (a stray `work/foo` that is not a namespaced work branch is
+ * ignored — the sweep only reaps the branches the protocol creates). Returns []
+ * when the arbiter is unreachable (the safe direction — nothing to reap).
+ */
+export declare function listRemoteWorkBranches(cwd: string, arbiter: string, env: NodeJS.ProcessEnv | undefined): Array<{
+    branch: string;
+    tip: string;
+}>;
+//# sourceMappingURL=reap-branches.d.ts.map

package/dist/reap-branches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reap-branches.d.ts","sourceRoot":"","sources":["../src/reap-branches.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAC3B,YAAY,GACZ,iBAAiB,CAAC;AAErB,kFAAkF;AAClF,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAKxE,CAAC;AAEF,wEAAwE;AACxE,MAAM,WAAW,YAAY;IAC5B,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,GAAG,EAAE,MAAM,CAAC;CACZ;AAED,oFAAoF;AACpF,MAAM,WAAW,cAAc;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,kBAAkB,CAAC;IAC3B,wEAAwE;IACxE,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,wBAAwB;IACxC;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,mFAAmF;IACnF,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,yBAAyB;IACzC,iFAAiF;IACjF,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,8DAA8D;IAC9D,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,6EAA6E;IAC7E,SAAS,EAAE,YAAY,EAAE,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,yBAAyB,CACxC,KAAK,EAAE,wBAAwB,GAC7B,yBAAyB,CA6E3B;AAeD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACrC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,GAChC,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAC,CAAC,CA4BtC"}

package/dist/reap-branches.js

@@ -0,0 +1,149 @@
+import { run } from './git.js';
+import { isAncestor } from './gc.js';
+import { parseWorkBranchRef } from './slug-namespace.js';
+/** Human-readable text for each remote-branch retain reason (`sweep` reports). */
+export const REMOTE_RETAIN_REASON_TEXT = {
+    'not-merged': 'not merged (branch tip is not an ancestor of the arbiter main — still in-flight)',
+    'main-unresolved': 'arbiter main could not be resolved, so merge could not be proven (kept — safe direction)',
+};
+/**
+ * Sweep the arbiter's remote `work/*` branches and DELETE exactly those that are
+ * provably merged into `<arbiter>/main` (`git merge-base --is-ancestor`, REUSING
+ * `gc.ts`'s `isAncestor`), reporting each as deleted-merged / retained-with-
+ * reason. NEVER `--force` (a merged ref needs none); NEVER touches a branch that
+ * is not an ancestor of `main` (the in-flight recovery point the never-delete
+ * invariant protects). Provider-agnostic plain git, so it works on a `--bare`
+ * arbiter.
+ *
+ * The flow:
+ *   1. `git ls-remote --heads <arbiter> 'work/*'` — enumerate remote work
+ *      branches + their tips (one network round-trip; no full fetch).
+ *   2. Fetch `<arbiter>/main` into a local tracking ref so the ancestor check
+ *      resolves the descendant LOCALLY; fetch each candidate tip object too (so
+ *      `merge-base` can read it) — best-effort, into a scratch ref.
+ *   3. For each branch whose tip `--is-ancestor` of the fetched main ⇒ delete via
+ *      `git push <arbiter> --delete <branch>`; else retain with a reason.
+ */
+export function sweepRemoteMergedBranches(input) {
+    const note = input.note ?? (() => { });
+    const env = input.env;
+    const dryRun = input.dryRun === true;
+    const reaped = [];
+    const retained = [];
+    const wouldReap = [];
+    const branches = listRemoteWorkBranches(input.cwd, input.arbiter, env);
+    // Resolve the arbiter's main tip LOCALLY (fetch it into a scratch tracking
+    // ref). If it cannot be resolved (unreachable arbiter / no main), we cannot
+    // PROVE any branch merged — retain everything (the safe direction).
+    const mainRef = fetchScratch(input.cwd, input.arbiter, 'main', env);
+    for (const { branch, tip } of branches) {
+        if (mainRef === undefined) {
+            retain(retained, note, branch, tip, 'main-unresolved');
+            continue;
+        }
+        // Make the candidate tip OBJECT readable locally so `merge-base` can use it
+        // (ls-remote gave us the sha, but the object may not be in the local repo).
+        fetchScratch(input.cwd, input.arbiter, branch, env);
+        if (!isAncestor(input.cwd, tip, mainRef, env)) {
+            // NOT an ancestor of main ⇒ still in-flight ⇒ NEVER delete (the invariant).
+            retain(retained, note, branch, tip, 'not-merged');
+            continue;
+        }
+        // Provably merged. Report (dry-run) or delete (the real sweep). Deletion of
+        // a fully-merged ref needs NO force — and we NEVER force here. The deletion
+        // is WRITE-THROUGH: drop the LOCAL tracking ref FIRST, THEN `git push
+        // --delete`. An arbiter-delete failure thus leaves the local store BEHIND
+        // (self-healing on next fetch), never AHEAD (a stale tracking ref that
+        // drives a wrong "continue" — the permanent stale-continue bug today's
+        // arbiter-first ordering creates).
+        if (dryRun) {
+            wouldReap.push({ branch, tip });
+            note(`Would reap ${branch} (merged) on ${input.arbiter}.`);
+            continue;
+        }
+        run('git', ['update-ref', '-d', `refs/remotes/${input.arbiter}/${branch}`], input.cwd, { env });
+        const del = run('git', ['push', input.arbiter, '--delete', branch], input.cwd, { env });
+        if (del.status !== 0) {
+            // A failed delete is NOT a reap; surface it but keep sweeping the rest.
+            // Tolerate "already gone" (a concurrent reap) as a clean delete.
+            const stderr = del.stderr.trim();
+            const alreadyGone = /remote ref does not exist|unable to delete/i.test(stderr);
+            if (alreadyGone) {
+                reaped.push({ branch, tip });
+                note(`Reaped ${branch} (merged; remote ref was already gone).`);
+                continue;
+            }
+            retain(retained, note, branch, tip, 'not-merged');
+            note(`Failed to delete ${branch} on ${input.arbiter} (${stderr || 'unknown error'}); kept.`);
+            continue;
+        }
+        reaped.push({ branch, tip });
+        note(`Reaped ${branch} (merged) on ${input.arbiter}.`);
+    }
+    return { reaped, retained, wouldReap };
+}
+/** Push a retained branch into the result + emit its note. */
+function retain(retained, note, branch, tip, reason) {
+    const reasonText = REMOTE_RETAIN_REASON_TEXT[reason];
+    retained.push({ branch, tip, reason, reasonText });
+    note(`Retained ${branch}: ${reasonText}.`);
+}
+/**
+ * Enumerate the arbiter's remote `work/*` heads + their tips via
+ * `git ls-remote --heads <arbiter> 'work/*'` (one round-trip, no full fetch).
+ * Only `work/<type>-<slug>` branches that {@link parseWorkBranchRef} recognises
+ * are returned (a stray `work/foo` that is not a namespaced work branch is
+ * ignored — the sweep only reaps the branches the protocol creates). Returns []
+ * when the arbiter is unreachable (the safe direction — nothing to reap).
+ */
+export function listRemoteWorkBranches(cwd, arbiter, env) {
+    const res = run('git', ['ls-remote', '--heads', arbiter, 'work/*'], cwd, {
+        env,
+    });
+    if (res.status !== 0) {
+        return [];
+    }
+    const out = [];
+    for (const line of res.stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '') {
+            continue;
+        }
+        // Each line is `<sha>\trefs/heads/<branch>`.
+        const m = /^([0-9a-f]{40})\s+refs\/heads\/(.+)$/.exec(trimmed);
+        if (!m) {
+            continue;
+        }
+        const tip = m[1];
+        const branch = m[2];
+        // Only namespaced work branches (`work/<type>-<slug>`) — the protocol's own
+        // branches. A non-conforming `work/...` head is left untouched.
+        if (parseWorkBranchRef(branch) === undefined) {
+            continue;
+        }
+        out.push({ branch, tip });
+    }
+    return out;
+}
+/**
+ * Fetch a single arbiter head into a SCRATCH remote-tracking ref
+ * (`refs/remotes/<arbiter>/<head>`) EXPLICITLY (a bare arbiter has no fetch
+ * refspec), so the object + ref resolve LOCALLY for the ancestor check. Returns
+ * the local ref name on success, or `undefined` when the head could not be
+ * fetched (unreachable arbiter / missing head) — the caller reads that as
+ * not-provable ⇒ retain (the safe direction). Best-effort; never throws.
+ */
+function fetchScratch(cwd, arbiter, head, env) {
+    const localRef = `refs/remotes/${arbiter}/${head}`;
+    const res = run('git', ['fetch', '--quiet', arbiter, `+refs/heads/${head}:${localRef}`], cwd, { env });
+    if (res.status !== 0) {
+        return undefined;
+    }
+    // Confirm the ref now resolves locally (an empty/odd fetch should read as
+    // unresolved → retain).
+    const verify = run('git', ['rev-parse', '--verify', '--quiet', localRef], cwd, {
+        env,
+    });
+    return verify.status === 0 ? localRef : undefined;
+}
+//# sourceMappingURL=reap-branches.js.map

package/dist/reap-branches.js.map

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

package/dist/recover-isolated.d.ts

@@ -0,0 +1,72 @@
+import type { IntegrationMode } from './config.js';
+import type { ReviewProvider } from './integrator.js';
+export type RecoverIsolatedOutcome = 'completed' | 'already-integrated' | 'nothing-to-recover' | 'rebase-conflict' | 'usage-error';
+export interface RecoverIsolatedOptions {
+    /** The slug to recover (its retained worktree is located by arbiter-URL + slug). */
+    slug: string;
+    /** The operator's checkout — its arbiter remote names the repo the worktree is off. */
+    cwd: string;
+    /** Name of the arbiter remote in {@link cwd}. Defaults to `origin`. */
+    arbiter?: string;
+    /** The execution working area (config `workspacesDir`); where job worktrees live. */
+    workspacesDir: string;
+    /** Integration mode: `propose` (default) or `merge`. */
+    integration?: IntegrationMode;
+    /** Suppress the PR on the propose path (push the branch, open no review request). */
+    noPR?: boolean;
+    /** Optional fully-formed provider used verbatim (test/embedding seam). */
+    providerInstance?: ReviewProvider;
+    /** Optional injectable PR opener (legacy bridge); used in `propose` mode. */
+    openPr?: (opts: {
+        cwd: string;
+        branch: string;
+        env?: NodeJS.ProcessEnv;
+    }) => void;
+    /** Environment for child git/provider processes (the identity-scoped env). */
+    env?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+}
+export interface RecoverIsolatedResult {
+    exitCode: 0 | 1;
+    outcome: RecoverIsolatedOutcome;
+    /** The work branch that was recovered, when a worktree was located. */
+    branch?: string;
+    /** The retained worktree dir that was recovered from, when located. */
+    worktree?: string;
+    /** The review-request URL opened in propose mode, when a provider opened one. */
+    prUrl?: string;
+    /** Human-readable summary of the terminal condition. */
+    message: string;
+}
+/**
+ * The LOCATE-EXISTING resolver shared by `complete --isolated` and
+ * `resume --isolated`: resolve the arbiter URL from the operator's checkout, then
+ * the slug's retained job-worktree dir via `jobWorktreePath` (arbiter-URL-keyed —
+ * NOT a slug glob). Returns the resolved dir + arbiter URL when the worktree is
+ * PRESENT; an `error` (usage) when the arbiter is unresolvable; or
+ * `{present: false}` when no worktree is retained (the clean nothing-to-recover
+ * case). Pure resolution — no side effects.
+ */
+export declare function locateIsolatedRecovery(params: {
+    slug: string;
+    cwd: string;
+    arbiter: string;
+    workspacesDir: string;
+    env?: NodeJS.ProcessEnv;
+}): {
+    dir: string;
+    arbiterUrl: string;
+    present: true;
+} | {
+    present: false;
+} | {
+    error: string;
+};
+/**
+ * Run the isolated recovery for a stranded, already-committed, already-done-moved
+ * worktree (the `complete --isolated <slug>` surface). Never throws for the
+ * expected cases — they are returned with a specific outcome + exit code.
+ */
+export declare function performRecoverIsolated(options: RecoverIsolatedOptions): Promise<RecoverIsolatedResult>;
+//# sourceMappingURL=recover-isolated.d.ts.map

package/dist/recover-isolated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recover-isolated.d.ts","sourceRoot":"","sources":["../src/recover-isolated.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,iBAAiB,CAAC;AA8BpD,MAAM,MAAM,sBAAsB,GAC/B,WAAW,GACX,oBAAoB,GACpB,oBAAoB,GACpB,iBAAiB,GACjB,aAAa,CAAC;AAEjB,MAAM,WAAW,sBAAsB;IACtC,oFAAoF;IACpF,IAAI,EAAE,MAAM,CAAC;IACb,uFAAuF;IACvF,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qFAAqF;IACrF,aAAa,EAAE,MAAM,CAAC;IACtB,wDAAwD;IACxD,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,qFAAqF;IACrF,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,0EAA0E;IAC1E,gBAAgB,CAAC,EAAE,cAAc,CAAC;IAClC,6EAA6E;IAC7E,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE;QACf,GAAG,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;KACxB,KAAK,IAAI,CAAC;IACX,8EAA8E;IAC9E,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,8CAA8C;IAC9C,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC;IAChB,OAAO,EAAE,sBAAsB,CAAC;IAChC,uEAAuE;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB,GACE;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAC,GAChD;IAAC,OAAO,EAAE,KAAK,CAAA;CAAC,GAChB;IACA,KAAK,EAAE,MAAM,CAAC;CACb,CAmBH;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC3C,OAAO,EAAE,sBAAsB,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CA2GhC"}

package/dist/recover-isolated.js

@@ -0,0 +1,188 @@
+import { existsSync } from 'node:fs';
+import { performIntegration } from './integration-core.js';
+import { resolveArbiterUrlFromCheckout } from './do.js';
+import { jobWorktreePath } from './workspace.js';
+import { mirrorPath } from './repo-mirror.js';
+import { reapJob } from './gc.js';
+import { workBranchRef } from './slug-namespace.js';
+import { run } from './git.js';
+/**
+ * **`complete --isolated <slug>` — FINISH an already-committed, already-done-moved
+ * STRANDED isolated worktree** (prd `ledger-integrity` story 6, the
+ * `finish-already-committed-branch` task). The LOCATE-EXISTING inverse of
+ * `do --isolated` (which CREATES a worktree): it resolves the slug's RETAINED job
+ * worktree via the existing arbiter-URL-keyed naming
+ * (`jobWorktreePath`/`encodeWorkId` — NOT a slug glob, since two repos can share a
+ * slug), then runs the recover-already-committed integration path
+ * (`performIntegration({committedRecovery: true})`) from it: rebase the kept
+ * commit onto `<arbiter>/main` → integrate, SKIPPING the (already-done) gate /
+ * done-move / commit.
+ *
+ * IDEMPOTENT / HONEST: when NO worktree is retained for the slug, this is a clean
+ * "nothing to recover / already integrated" no-op (exit 0, no crash, no fresh
+ * worktree) — after a successful recovery the worktree is reaped, so a re-run
+ * correctly finds nothing. The integration core's own UNSPOOFABLE detection
+ * (`already-integrated`) covers the case where the worktree still exists but its
+ * tip is already on the arbiter (never a double-integrate).
+ *
+ * `resume --isolated <slug>` shares the SAME locate-existing resolver (see
+ * {@link locateIsolatedRecovery}) to re-engage the retained worktree WITHOUT
+ * claiming — it just reports the worktree path for the operator to cd into.
+ */
+const DEFAULT_ARBITER = 'origin';
+/** The arbiter remote name valid INSIDE a job worktree (cut from the bare hub mirror). */
+const WORKTREE_ARBITER_REMOTE = 'origin';
+/**
+ * The LOCATE-EXISTING resolver shared by `complete --isolated` and
+ * `resume --isolated`: resolve the arbiter URL from the operator's checkout, then
+ * the slug's retained job-worktree dir via `jobWorktreePath` (arbiter-URL-keyed —
+ * NOT a slug glob). Returns the resolved dir + arbiter URL when the worktree is
+ * PRESENT; an `error` (usage) when the arbiter is unresolvable; or
+ * `{present: false}` when no worktree is retained (the clean nothing-to-recover
+ * case). Pure resolution — no side effects.
+ */
+export function locateIsolatedRecovery(params) {
+    const arbiterUrl = resolveArbiterUrlFromCheckout(params.cwd, params.arbiter, params.env);
+    if (arbiterUrl === undefined) {
+        return {
+            error: `--isolated finishes a worktree off this repo's arbiter (inferred from ` +
+                `cwd), but no '${params.arbiter}' remote was found here (is this a git ` +
+                `repo? does the '${params.arbiter}' remote exist?).`,
+        };
+    }
+    const dir = jobWorktreePath(params.workspacesDir, arbiterUrl, params.slug);
+    if (!existsSync(dir)) {
+        return { present: false };
+    }
+    return { dir, arbiterUrl, present: true };
+}
+/**
+ * Run the isolated recovery for a stranded, already-committed, already-done-moved
+ * worktree (the `complete --isolated <slug>` surface). Never throws for the
+ * expected cases — they are returned with a specific outcome + exit code.
+ */
+export async function performRecoverIsolated(options) {
+    const note = options.note ?? (() => { });
+    const env = options.env;
+    const arbiter = options.arbiter ?? DEFAULT_ARBITER;
+    const located = locateIsolatedRecovery({
+        slug: options.slug,
+        cwd: options.cwd,
+        arbiter,
+        workspacesDir: options.workspacesDir,
+        env,
+    });
+    if ('error' in located) {
+        return { exitCode: 1, outcome: 'usage-error', message: located.error };
+    }
+    if (!located.present) {
+        // No retained worktree — honest no-op: nothing to recover (already
+        // integrated + reaped, or never stranded). No crash, NO fresh worktree.
+        const message = `Nothing to recover for '${options.slug}': no retained isolated worktree ` +
+            'found (already integrated and reaped, or never stranded).';
+        note(message);
+        return { exitCode: 0, outcome: 'nothing-to-recover', message };
+    }
+    const dir = located.dir;
+    const branch = workBranchRef('task', options.slug);
+    // The strand left the worktree ON its `work/<slug>` branch; make sure we are on
+    // it (it carries the kept committed work + the done-move). Best-effort: if HEAD
+    // is already there this is a no-op; a missing branch surfaces as a usage error
+    // from the integration core's HEAD-resolution.
+    gitSoft(['switch', '--quiet', branch], dir, env);
+    note(`Recovering '${options.slug}' from the retained worktree ${dir}…`);
+    const core = await performIntegration({
+        cwd: dir,
+        // Inside a job worktree the arbiter remote is `origin` (the mirror's clone
+        // remote), NOT the operator's checkout arbiter name.
+        arbiter: WORKTREE_ARBITER_REMOTE,
+        slug: options.slug,
+        branch,
+        source: 'in-progress',
+        recovering: false,
+        committedRecovery: true,
+        mode: options.integration ?? 'propose',
+        noPR: options.noPR,
+        providerInstance: options.providerInstance,
+        openPr: options.openPr,
+        env,
+        note,
+    });
+    if (core.outcome === 'already-integrated') {
+        // The kept tip is already on the arbiter — a clean no-op. Reap the now-redundant
+        // worktree (its branch is provably on the arbiter), so a re-run finds nothing.
+        reapIfSafe(options.workspacesDir, located.arbiterUrl, branch, dir, env);
+        return {
+            exitCode: 0,
+            outcome: 'already-integrated',
+            branch,
+            worktree: dir,
+            message: core.reason ?? `'${options.slug}' is already integrated.`,
+        };
+    }
+    if (core.outcome === 'rebase-conflict') {
+        // A genuine code conflict — the kept commit stays intact on the branch
+        // (recoverable); the operator resolves it and re-runs. Worktree RETAINED.
+        return {
+            exitCode: 1,
+            outcome: 'rebase-conflict',
+            branch,
+            worktree: dir,
+            message: core.reason ?? `recovering '${options.slug}' hit a rebase conflict.`,
+        };
+    }
+    if (core.outcome === 'completed') {
+        // Integrated from the kept commit. The work is now on the arbiter, so the
+        // worktree is provably redundant — reap it (the same §4 predicate the build
+        // teardown uses; never lose work — reachability still gates).
+        reapIfSafe(options.workspacesDir, located.arbiterUrl, branch, dir, env);
+        const prUrl = core.integration?.url;
+        const message = prUrl
+            ? `Recovered '${options.slug}': integrated the kept commit (${prUrl}).`
+            : `Recovered '${options.slug}': integrated the kept commit from ${branch}.`;
+        note(message);
+        return {
+            exitCode: 0,
+            outcome: 'completed',
+            branch,
+            worktree: dir,
+            prUrl,
+            message,
+        };
+    }
+    // Any other core outcome (defensive — committed-recovery only returns the three
+    // above): surface it as a usage error rather than mis-reporting success.
+    return {
+        exitCode: 1,
+        outcome: 'usage-error',
+        branch,
+        worktree: dir,
+        message: core.reason ??
+            `recovering '${options.slug}' returned an unexpected outcome ` +
+                `'${core.outcome}'.`,
+    };
+}
+/**
+ * Reap the recovered worktree iff its branch is provably on the arbiter (the §4
+ * predicate, reachable-only so incidental churn does not retain a worktree whose
+ * branch is already safe). Best-effort: never throws on this success path.
+ */
+function reapIfSafe(workspacesDir, arbiterUrl, branch, dir, env) {
+    try {
+        reapJob({
+            dir,
+            branch,
+            mirrorPath: mirrorPath(workspacesDir, arbiterUrl),
+            reachableOnly: true,
+            env,
+        });
+    }
+    catch {
+        // best-effort — the work is already on the arbiter; a reap failure is cosmetic.
+    }
+}
+/** Run git, returning the raw result (no throw) — for soft checks. */
+function gitSoft(args, cwd, env) {
+    return run('git', args, cwd, { env });
+}
+//# sourceMappingURL=recover-isolated.js.map

package/dist/recover-isolated.js.map

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