dorfl 0.0.0 → 0.1.0

package/dist/isolation.js

@@ -0,0 +1,261 @@
+import { git } from './git.js';
+import { createJob } from './workspace.js';
+import { reapJob } from './gc.js';
+import { branchAheadOfArbiter, rebaseContinuedBranchOntoMain, pushContinuedBranchWithStaleLeaseRetry, } from './continue-branch.js';
+import { workBranchRef } from './slug-namespace.js';
+/**
+ * The **job-worktree** strategy — `run`'s EXISTING isolation, extracted behind
+ * the seam UNCHANGED. `prepare` ensures the hub mirror + cuts a per-job worktree
+ * off the freshly-fetched `<hub>/main` (`createJob`); the handle's `teardown`
+ * re-applies the §4 provably-safe deletion predicate (`reapJob`) — reaping the
+ * worktree iff its work is clean AND on the arbiter, retaining it otherwise (the
+ * never-lose-work signal). The arbiter remote inside the worktree is `origin`
+ * (the bare mirror's clone remote), and provider detection keys off the mirror's
+ * resolved arbiter URL — byte-identical to today's `run`.
+ */
+export function jobWorktreeStrategy(options) {
+    return {
+        name: 'job-worktree',
+        prepare({ slug, type, env }) {
+            const job = createJob({
+                fromRepo: options.fromRepo,
+                arbiter: options.arbiter,
+                slug,
+                type: type ?? 'task',
+                workspacesDir: options.workspacesDir,
+                env,
+            });
+            return jobWorktreeHandle(job, env);
+        },
+    };
+}
+/**
+ * Build the uniform handle for a job-worktree `Job` — the EXACT fields `run`'s
+ * pipeline read off `job` today (`dir`/`branch`/`arbiterRemote`/`mirror.url`)
+ * plus the `reapJob` teardown. Exposed so a caller that already created the
+ * `Job` (e.g. `run`'s pipeline, mid-extraction) can wrap it without re-creating.
+ */
+export function jobWorktreeHandle(job, env) {
+    return {
+        dir: job.dir,
+        branch: job.branch,
+        arbiterRemote: job.arbiterRemote,
+        arbiterUrl: job.mirror.url,
+        continued: job.continued,
+        continueRebaseConflict: job.continueRebaseConflict,
+        continuePushFailure: job.continuePushFailure,
+        teardown(opts) {
+            // Auto-reap at end-of-job (ADR §4): re-apply the provably-safe deletion
+            // predicate and remove the worktree ONLY if it holds (clean tree AND the
+            // branch tip reachable on the arbiter). NEVER `--force` here.
+            //
+            // `reachableOnly` (the FAILURE-path opt-in) drops the clean-tree half but
+            // KEEPS reachability: a churn-dirty worktree whose durable branch is on
+            // the arbiter is reaped (it would otherwise linger and poison the next
+            // build's fetch); a worktree whose work is NOT yet on the arbiter is still
+            // retained (never lose work).
+            reapJob({
+                dir: job.dir,
+                branch: job.branch,
+                mirrorPath: job.mirror.path,
+                arbiter: job.arbiterRemote,
+                reachableOnly: opts?.reachableOnly === true,
+                env,
+            });
+        },
+    };
+}
+/**
+ * The **in-place** strategy — the current checkout (a human's clone, or the CI
+ * container) IS the isolation. `prepare` fetches the arbiter and switches the
+ * checkout to `work/<slug>` cut from the freshly-fetched `<arbiter>/main` (the
+ * SAME "every worktree is cut from a fresh main" guarantee, ADR §6), WITHOUT a
+ * hub mirror or external worktree. The handle's `arbiterRemote`/`arbiterUrl` come
+ * from the checkout's own arbiter remote; `teardown` is a NO-OP — the checkout is
+ * left in a defined state on `work/<slug>`, NEVER reaped (it is the human's tree
+ * / the only copy of CI's work).
+ *
+ * NOTE: this strategy assumes the slug is already CLAIMED (the same contract as
+ * the job-worktree strategy, whose caller claims before `prepare`). It does not
+ * itself claim — `do-in-place` composes the claim (and `start`/`complete`) around
+ * the seam. `prepare` here is the thin "put the checkout on a fresh work branch"
+ * step the shared pipeline needs; it is unwired in this task.
+ */
+export function inPlaceStrategy(options) {
+    const arbiter = options.arbiter ?? 'origin';
+    const checkout = options.checkout;
+    return {
+        name: 'in-place',
+        prepare({ slug, type, claimCommit, env }) {
+            const branch = workBranchRef(type ?? 'task', slug);
+            const arbiterUrl = git(['remote', 'get-url', arbiter], checkout, {
+                env,
+            }).trim();
+            git(['fetch', '--quiet', arbiter], checkout, { env });
+            // CONTINUE-detection (shared with the job-worktree path, ADR §14 keystone):
+            // does the arbiter have a `work/<slug>` ref AHEAD of main (a requeue kept
+            // it)? In a normal clone the refs are the remote-tracking
+            // `<arbiter>/work/<slug>` and `<arbiter>/main`.
+            let continued = false;
+            let continueRebaseConflict = false;
+            let continuePushFailure;
+            // ARBITER-AUTHORITATIVE continue-detection: `ls-remote` the arbiter so a
+            // STALE local remote-tracking ref (a plain `git fetch` does NOT prune
+            // unless `fetch.prune` is set) pointing at a branch the arbiter no longer
+            // has cannot resurrect a deleted branch as a "continue".
+            if (branchAheadOfArbiter({
+                cwd: checkout,
+                arbiterRemote: arbiter,
+                branch,
+                branchRef: `${arbiter}/${branch}`,
+                mainRef: `${arbiter}/main`,
+                env,
+            })) {
+                continued = true;
+                // The arbiter `work/<slug>` tip the fetch above brought down, READ BEFORE
+                // the onboard rebase rewrites the local branch — the value the
+                // --force-with-lease push expects the arbiter to still hold. In a normal
+                // clone this lives in the remote-tracking ref `<arbiter>/<branch>` (the
+                // rebase below rewrites only the LOCAL `<branch>`, so the tracking ref keeps
+                // the pre-rebase arbiter sha). Captured here, threaded into the stale-lease
+                // retry below so a requeue-continue that churns the ref after our fetch is
+                // re-leased against the freshly-fetched tip rather than stranding the work.
+                const expectedRemoteTip = git(['rev-parse', `${arbiter}/${branch}`], checkout, { env }).trim();
+                // CONTINUE: land on the kept arbiter tip (force-reset a stale local copy
+                // so we continue the SAME single branch), then REBASE onto fresh main at
+                // onboard-time (ADR §10: rebase, not merge). A CLEAN rebase updates the
+                // already-pushed tip with --force-with-lease on the WORK branch ONLY
+                // (a requeued item is unshared) — NEVER --force, NEVER to main (§11),
+                // SURVIVING a stale-lease ("stale info") rejection by re-fetching +
+                // re-rebasing + retrying (the SAME helper `workspace.ts` uses). A
+                // CONFLICT is aborted (never auto-resolved) + flagged for the caller to
+                // route to needs-attention.
+                git(['switch', '--quiet', '-C', branch, `${arbiter}/${branch}`], checkout, { env });
+                const rebase = rebaseContinuedBranchOntoMain(checkout, `${arbiter}/main`, env);
+                if (rebase.kind === 'conflict') {
+                    continueRebaseConflict = true;
+                }
+                else {
+                    // The helper THROWS on a terminal failure (the stale-lease retry cap, or
+                    // a non-stale-lease rejection / unreachable arbiter). CATCH it and flag
+                    // `continuePushFailure` so the caller routes the item to needs-attention
+                    // — the kept work stays committed + recoverable — rather than crashing
+                    // the run and stranding it silently in-progress (the stale-lease bug).
+                    try {
+                        const pushed = pushContinuedBranchWithStaleLeaseRetry({
+                            cwd: checkout,
+                            branch,
+                            arbiter,
+                            mainRef: `${arbiter}/main`,
+                            expectedRemoteTip,
+                            env,
+                        });
+                        if (pushed.kind === 'conflict') {
+                            continueRebaseConflict = true;
+                        }
+                    }
+                    catch (err) {
+                        continuePushFailure =
+                            err instanceof Error ? err.message : String(err);
+                    }
+                }
+            }
+            else {
+                // FRESH: put the checkout on the namespaced work branch cut from the
+                // EXACT claim commit (the defensive onboarding guard). When a
+                // `claimCommit` is threaded in (the normal `do` build path), assert it is
+                // reachable from the freshly-fetched `<arbiter>/main` and force-RESET the
+                // branch onto it with `-C` — so a stale same-named local branch (e.g. one
+                // `intake` left behind, or a prior re-run) is RE-POINTED at the claim
+                // commit, NEVER silently reused on a pre-claim base (the "nothing to
+                // complete" defect). Mirrors the CONTINUE path's `-C`. A missing /
+                // unreachable claim commit FAILS LOUDLY — never a silent stale-base build.
+                if (claimCommit !== undefined) {
+                    assertClaimCommitReachable(checkout, claimCommit, `${arbiter}/main`, env);
+                    git(['switch', '--quiet', '-C', branch, claimCommit], checkout, {
+                        env,
+                    });
+                }
+                else {
+                    // No claim commit (a bare resume / re-run with no claim in hand): cut
+                    // off the freshly-fetched `<arbiter>/main`; plain-switch a pre-existing
+                    // local branch.
+                    const created = gitSoftSwitch(['switch', '--quiet', '-c', branch, `${arbiter}/main`], checkout, env);
+                    if (!created) {
+                        git(['switch', '--quiet', branch], checkout, { env });
+                    }
+                }
+            }
+            return {
+                dir: checkout,
+                branch,
+                arbiterRemote: arbiter,
+                arbiterUrl,
+                continued,
+                continueRebaseConflict,
+                continuePushFailure,
+                // NO-OP teardown: the checkout is the human's / CI's tree — left on
+                // `work/<slug>` in a defined state, NEVER reaped (ADR §2/§4). The
+                // human's `complete` (or the runner) owns the branch lifecycle.
+                // `reachableOnly` is irrelevant here (nothing is ever reaped in-place).
+                teardown() { },
+            };
+        },
+    };
+}
+/**
+ * Assert the claim commit is reachable from `<arbiter>/main` (an ancestor),
+ * throwing a CLEAR error if not — the LOUD-failure guard the FRESH onboarding
+ * path uses before force-resetting the work branch onto the claim commit. A
+ * not-yet-fetched or rolled-back arbiter main that does NOT reach the claim must
+ * fail fast here, never silently build on a stale base.
+ */
+function assertClaimCommitReachable(checkout, claimCommit, mainRef, env) {
+    const reachable = gitSoftSwitch(['merge-base', '--is-ancestor', claimCommit, mainRef], checkout, env);
+    if (!reachable) {
+        throw new Error(`onboarding '${claimCommit}' failed: the claim commit is not reachable ` +
+            `from ${mainRef} (the claim push did not land, or local ${mainRef} is ` +
+            'stale). Refusing to build on a stale base — re-fetch the arbiter and ' +
+            'retry, or `requeue` the item.');
+    }
+}
+/** Try a git switch; return true on success, false on non-zero (no throw). */
+function gitSoftSwitch(args, cwd, env) {
+    try {
+        git(args, cwd, { env });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Select the isolation strategy by **"is there a checkout"** (ADR §3) — NOT a
+ * hardcoded path:
+ *
+ *   - `checkout` present ⇒ {@link inPlaceStrategy} (the checkout IS the
+ *     isolation; `do <slug>` in a checkout, the in-place human path).
+ *   - `checkout` absent ⇒ {@link jobWorktreeStrategy} (mirror + worktree in the
+ *     agents' area; `do --remote` / `run`).
+ *
+ * Both yield the same uniform handle, so the caller's pipeline is identical
+ * regardless of which strategy was selected.
+ */
+export function selectIsolationStrategy(input) {
+    if (input.checkout !== undefined) {
+        return inPlaceStrategy({
+            checkout: input.checkout,
+            arbiter: input.arbiter,
+        });
+    }
+    if (input.fromRepo === undefined || input.workspacesDir === undefined) {
+        throw new Error('selectIsolationStrategy: the job-worktree strategy (no checkout) ' +
+            'requires both `fromRepo` and `workspacesDir`.');
+    }
+    return jobWorktreeStrategy({
+        fromRepo: input.fromRepo,
+        arbiter: input.arbiter,
+        workspacesDir: input.workspacesDir,
+    });
+}
+//# sourceMappingURL=isolation.js.map

package/dist/isolation.js.map

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

package/dist/issue-provider.d.ts

@@ -0,0 +1,349 @@
+/**
+ * The single provider-native PROCESSING LOCK label (task `intake-processing-lock`,
+ * prd `issue-intake` US #10): a TRANSIENT concurrency mutex — added on start (the
+ * winner only), removed on finish — that serialises two concurrent `intake` runs on
+ * the SAME issue. It is namespaced under the brand (`dorfl:processing`) so it
+ * cannot collide with a user's own labels. It carries NO `work/` state — it is NOT a
+ * label STATE-MACHINE (ADR §12) and NOT a `work/`-file CAS; it is ONE transient lock
+ * label and nothing more.
+ */
+export declare const PROCESSING_LOCK_LABEL: string;
+/**
+ * The **issue seam** (prd `issue-intake`, task `intake-tracer-slice-outcome`):
+ * the provider-pluggable surface `intake <N>` reads an issue + its comment thread
+ * through, and posts a clarifying comment back onto. It is the SIBLING of the
+ * review-request `ReviewProvider` (`integrator.ts` / `github.ts`): both name a
+ * GitHub-backed surface behind a seam, and both keep the CORE free of any `gh`
+ * import — ONLY the adapter shells out (the same discipline `github.ts` documents).
+ *
+ * The READ methods (`getIssue`, `listComments`) + the issue comment
+ * (`postIssueComment`) landed with the keystone task; the LABEL ops
+ * (`addLabel`/`removeLabel`/`getLabels` — the transient `processing` LOCK, task
+ * `intake-processing-lock`) extend it. `closeIssue` (task
+ * `intake-closes-issue-on-bounce`) is the ATOMIC close used on a BOUNCE — a
+ * terminal outcome, so intake closes the issue directly (comment + `not planned`
+ * + close in ONE call). It is ALSO the method CI's future close-job uses for the
+ * task/prd path; only the BOUNCE close is intake's.
+ *
+ * The label ops are a TRANSIENT CONCURRENCY MUTEX carrying NO `work/` state — ONE
+ * lock label, added-on-start / removed-on-finish. They are NOT a label
+ * STATE-MACHINE (ADR §12 forbids modelling `work/` lifecycle in labels) and NOT a
+ * `work/`-file CAS (the contended thing is the ISSUE; the output slug is unknown
+ * pre-run). A provider with no label concept DEGRADES to best-effort (it reports
+ * `supported: false` / `applied: false` and the run proceeds WITHOUT the lock).
+ *
+ * Why `postIssueComment` is a DISTINCT method from `ReviewProvider.postPRComment`
+ * (renamed from `postComment` in this same task): the PR-comment surface is keyed
+ * by the PR **url**; the issue-comment surface is keyed by the issue **number**. In
+ * GitHub the two comment id spaces happen to coincide, but another provider may not
+ * share them — so they are nominally distinct seams with distinct input types
+ * ({@link PostIssueCommentInput} carries `issueNumber`, NOT a `url`).
+ *
+ * Tests STUB `gh` via the injectable `ghBin` (the SAME mechanism the PR-provider
+ * tests use) — no network, no real GitHub.
+ */
+/** A GitHub issue's durable fields the decision prompt reads. */
+export interface Issue {
+    /** The issue number (`#N`). */
+    number: number;
+    /** The issue title. */
+    title: string;
+    /** The issue body (markdown), possibly empty. */
+    body: string;
+    /** The issue author's login (e.g. `octocat`), when the provider reports one. */
+    author?: string;
+    /** `open` / `closed` — the provider's state string, lower-cased. */
+    state?: string;
+}
+/** One comment on the issue thread (oldest-first, as `listComments` returns them). */
+export interface IssueComment {
+    /**
+     * The provider's comment id (`gh issue view --json comments` reports it). Surfaced
+     * for the intake TRIAGE GATE (task `intake-self-awareness-resumption-tracking`):
+     * the triage is id-set membership + list position only — it records which comment
+     * ids intake READ (the marker's `seen=<id>,…`) and detects raced-in / deleted
+     * comments by id arithmetic. ADDITIVE (no existing reader breaks); NO `createdAt`
+     * is added — nothing reads a timestamp (ordering is `listComments`' oldest-first).
+     */
+    id?: string;
+    /** The comment author's login, when reported. */
+    author?: string;
+    /** The comment body (markdown). */
+    body: string;
+}
+export interface GetIssueInput {
+    cwd: string;
+    /** The issue number to read (`intake <N>`). */
+    issueNumber: number;
+    env?: NodeJS.ProcessEnv;
+}
+export interface ListCommentsInput {
+    cwd: string;
+    issueNumber: number;
+    env?: NodeJS.ProcessEnv;
+}
+export interface PostIssueCommentInput {
+    cwd: string;
+    /**
+     * The issue number to comment ON — the issue-comment surface's KEY. This is the
+     * whole reason {@link IssueProvider.postIssueComment} is a sibling of (not a
+     * reuse of) `ReviewProvider.postPRComment`, which is keyed by the PR `url`.
+     */
+    issueNumber: number;
+    /** The comment body (markdown). */
+    body: string;
+    env?: NodeJS.ProcessEnv;
+}
+export interface PostIssueCommentResult {
+    /** True iff a comment was actually posted (a real, authenticated provider). */
+    posted: boolean;
+    /** Human-readable confirmation / fallback (the text on degrade). */
+    instruction: string;
+}
+/**
+ * The close-reason GitHub renders distinct from a "completed" close. `gh issue
+ * close --reason` accepts `completed | not planned | duplicate`; a BOUNCE is
+ * precisely `not planned` (the asks are unrelated and must be re-filed). The
+ * INTERFACE carries it provider-neutrally — a non-GitHub adapter maps or ignores
+ * it (the seam stays provider-pluggable; `reason` is a GitHub-ism on the wire).
+ */
+export type IssueCloseReason = 'completed' | 'not planned' | 'duplicate';
+export interface CloseIssueInput {
+    cwd: string;
+    /** The issue number to close (`gh issue close <N>`). */
+    issueNumber: number;
+    /**
+     * An OPTIONAL closing comment posted IN THE SAME atomic operation as the close
+     * (`gh issue close --comment <body>`). Carrying it on the close call (not a
+     * separate `postIssueComment` then close) removes the comment-posted-but-close-
+     * failed window — the whole point of the atomic close.
+     */
+    comment?: string;
+    /** An OPTIONAL close reason (`gh issue close --reason "not planned"`). */
+    reason?: IssueCloseReason;
+    env?: NodeJS.ProcessEnv;
+}
+export interface CloseIssueResult {
+    /** True iff the issue was actually closed (a real, authenticated provider). */
+    closed: boolean;
+    /**
+     * The REAL underlying failure detail when `closed` is false — the actual `gh`
+     * stderr via {@link ghFailureReason}, NOT a hard-coded "unavailable or
+     * unauthenticated" guess (that misattribution bug was fixed in `mutateLabel`;
+     * do not propagate it). Absent on success.
+     */
+    reason?: string;
+    /** Human-readable confirmation / fallback (the text on degrade). */
+    instruction: string;
+}
+export interface LabelInput {
+    cwd: string;
+    /** The issue number to label / read labels FROM. */
+    issueNumber: number;
+    env?: NodeJS.ProcessEnv;
+}
+export interface AddLabelInput extends LabelInput {
+    /** The single label to add (e.g. the `processing` lock). */
+    label: string;
+}
+export interface RemoveLabelInput extends LabelInput {
+    /** The single label to remove (e.g. the `processing` lock). */
+    label: string;
+}
+/**
+ * The OUTCOME of a label MUTATION (`addLabel` / `removeLabel`). The lock ops are a
+ * CONCURRENCY mutex, so the caller must distinguish THREE genuinely-different
+ * results — collapsing them (the original bug) sent a maintainer hunting an auth
+ * problem that did not exist, and made a real lock-failure proceed lock-less:
+ *
+ * - **`applied`** — the provider made the change on the real surface (the winner
+ *   acquired / released the lock label).
+ * - **`unsupported`** — the provider has NO label concept at all (a non-GitHub
+ *   provider without labels). The lock LEGITIMATELY degrades to best-effort here
+ *   (the spec's provider-pluggability): there is simply nothing to lock on.
+ * - **`failed`** — the provider DOES support labels but the op failed for a REAL
+ *   reason (a missing/unauthenticated `gh`, a permissions error, an unexpected
+ *   `gh` failure). This is NOT a legitimate degrade: the lock is meaningful but
+ *   could not be taken, so the caller must FAIL / back off rather than silently
+ *   proceed lock-less (maintainer decision — see {@link LabelResult.reason}).
+ *
+ * NEVER throws — the seam reports the outcome (the caller decides fail-vs-degrade),
+ * the same never-crash discipline the comment poster / PR provider keep (ADR §6).
+ */
+export type LabelOutcome = 'applied' | 'unsupported' | 'failed';
+export interface LabelResult {
+    /** Which of the three outcomes occurred (the caller routes fail-vs-degrade on this). */
+    outcome: LabelOutcome;
+    /**
+     * True iff the label change was actually applied on the provider surface
+     * (`outcome === 'applied'`). Retained as a convenience for the acquire/release
+     * sites; the THREE-way `outcome` is the load-bearing discriminator.
+     */
+    applied: boolean;
+    /**
+     * The REAL underlying failure detail when `outcome === 'failed'` — the actual
+     * `gh` stderr (e.g. `'dorfl:processing' not found`), NOT a hard-coded
+     * "unavailable or unauthenticated" guess. Surfaced so the cause is diagnosable.
+     * Absent for `applied` / `unsupported`.
+     */
+    reason?: string;
+    /** Human-readable confirmation / degrade-or-failure reason. */
+    instruction: string;
+}
+/**
+ * The result of READING an issue's labels — the lock READ that decides acquire vs
+ * back-off. Like {@link LabelResult} it distinguishes the SAME three outcomes so
+ * the caller never confuses a genuinely-unsupported provider (legitimate degrade)
+ * with a real read FAILURE on a label-supporting provider (must NOT silently
+ * proceed lock-less):
+ *
+ * - **`ok`** — the labels were read (`labels` carries them; possibly empty).
+ * - **`unsupported`** — the provider has NO label concept (legitimate degrade).
+ * - **`failed`** — a label-supporting provider could not be read (e.g. `gh`
+ *   missing/unauthenticated): the lock STATE is unknown, so the caller must FAIL
+ *   rather than guess "no lock held".
+ */
+export type GetLabelsOutcome = 'ok' | 'unsupported' | 'failed';
+export interface GetLabelsResult {
+    /** Which of the three outcomes occurred (the caller routes fail-vs-degrade on this). */
+    outcome: GetLabelsOutcome;
+    /**
+     * False iff the provider has no label surface at all (`outcome === 'unsupported'`)
+     * — retained for back-compat; the three-way `outcome` is load-bearing. A `failed`
+     * read is ALSO `supported: false` historically, but `outcome` separates them.
+     */
+    supported: boolean;
+    /** The labels currently on the issue (empty when none / unsupported / failed). */
+    labels: string[];
+    /**
+     * The REAL underlying failure detail when `outcome === 'failed'` — the actual
+     * `gh` stderr, NOT a hard-coded "unavailable or unauthenticated" guess.
+     */
+    reason?: string;
+    /** Human-readable confirmation / degrade-or-failure reason. */
+    instruction: string;
+}
+/**
+ * The issue seam (provider-pluggable; GitHub via `gh` first). The CORE depends on
+ * THIS interface only; the concrete `gh` shelling-out lives entirely in
+ * {@link GitHubIssueProvider}. A non-GitHub provider can follow the same shape.
+ */
+export interface IssueProvider {
+    /** Stable provider name stamped into diagnostics (`github`, …). */
+    readonly name: string;
+    /** Read the issue (number/title/body/author/state). */
+    getIssue(input: GetIssueInput): Promise<Issue>;
+    /** Read the issue's comment thread, oldest-first. */
+    listComments(input: ListCommentsInput): Promise<IssueComment[]>;
+    /** Post a clarifying comment on the issue (keyed by the issue NUMBER). */
+    postIssueComment(input: PostIssueCommentInput): Promise<PostIssueCommentResult>;
+    /**
+     * Read the issue's current labels — the lock READ that decides acquire vs
+     * back-off. NEVER throws; returns a three-way {@link GetLabelsResult}: `ok`
+     * (labels read), `unsupported` (no label concept → legitimate degrade), or
+     * `failed` (a label-supporting provider could not be read → the caller FAILS
+     * rather than guessing the lock is free).
+     */
+    getLabels(input: LabelInput): Promise<GetLabelsResult>;
+    /**
+     * ADD a single label (acquire the `processing` lock — the winner only). The
+     * RUNNER calls this; the agent stays label-free. NEVER throws — it returns a
+     * three-way {@link LabelResult} (`applied` / `unsupported` / `failed`) so the
+     * caller can FAIL on a real lock-acquire failure (e.g. `gh` unauthenticated)
+     * rather than silently proceed lock-less. On a label-supporting provider where
+     * the lock label does not exist yet (a fresh repo), it CREATES the label first
+     * so the lock works from the first run, then adds it.
+     */
+    addLabel(input: AddLabelInput): Promise<LabelResult>;
+    /**
+     * REMOVE a single label (release the `processing` lock on finish — success OR
+     * handled failure). The RUNNER calls this; the agent stays label-free. NEVER
+     * throws; returns the three-way {@link LabelResult} like {@link addLabel}.
+     */
+    removeLabel(input: RemoveLabelInput): Promise<LabelResult>;
+    /**
+     * CLOSE an issue, OPTIONALLY posting a closing comment and setting a close
+     * reason IN THE SAME atomic operation (`gh issue close <N> [--comment <body>]
+     * [--reason "not planned"]`). Used on a BOUNCE (terminal: comment + `not
+     * planned` + close in ONE call — no post-then-close partial-failure window) and,
+     * later, by CI's task/prd close-job. The RUNNER calls this; the agent stays
+     * seam-free. NEVER throws — a missing/unauthenticated `gh` DEGRADES, surfacing
+     * the REAL `gh` stderr via {@link CloseIssueResult.reason} (NOT a hard-coded
+     * guess), so the terminal outcome is unchanged and the cause stays diagnosable.
+     */
+    closeIssue(input: CloseIssueInput): Promise<CloseIssueResult>;
+}
+export interface GitHubIssueProviderOptions {
+    /**
+     * The `gh` CLI binary (default `gh` on `PATH`). Tests inject a stub script so
+     * the seam is exercised without a real model / network / GitHub — the SAME test
+     * seam the {@link GitHubProvider} (review-request) uses.
+     */
+    ghBin?: string;
+}
+/**
+ * The GitHub issue provider: reads an issue + thread, posts a comment, and (on a
+ * BOUNCE) atomically closes the issue by shelling out to the `gh` CLI (`gh issue
+ * view` / `gh issue comment` / `gh issue close --comment --reason` / `gh issue
+ * edit` for labels). It is the ONLY place in the issue-seam stack that invokes
+ * `gh` — the core never
+ * imports it (the same boundary `github.ts` keeps for the review-request seam).
+ *
+ * The READ methods THROW on a `gh` failure (a missing/unauthenticated `gh`, or an
+ * unknown issue): `intake` cannot decide without the issue, so a read failure is a
+ * hard, surfaced error (unlike the review-request `openRequest`, whose work is
+ * already safely pushed and so degrades). `postIssueComment` is advisory and
+ * DEGRADES (never throws), like the PR-comment poster.
+ */
+export declare class GitHubIssueProvider implements IssueProvider {
+    readonly name = "github";
+    private readonly ghBin;
+    constructor(options?: GitHubIssueProviderOptions);
+    getIssue(input: GetIssueInput): Promise<Issue>;
+    listComments(input: ListCommentsInput): Promise<IssueComment[]>;
+    postIssueComment(input: PostIssueCommentInput): Promise<PostIssueCommentResult>;
+    closeIssue(input: CloseIssueInput): Promise<CloseIssueResult>;
+    getLabels(input: LabelInput): Promise<GetLabelsResult>;
+    addLabel(input: AddLabelInput): Promise<LabelResult>;
+    removeLabel(input: RemoveLabelInput): Promise<LabelResult>;
+    /**
+     * Shared `gh issue edit <N> --add-label|--remove-label <label>` runner for the
+     * label MUTATIONS (the lock acquire/release). NEVER throws — it reports a
+     * three-way {@link LabelResult} so the CALLER decides fail-vs-degrade (the lock
+     * acquire-site FAILS on `failed`; only a genuinely-unsupported provider degrades).
+     *
+     * On `--add-label` against a fresh repo where the lock label does NOT exist yet,
+     * `gh` exits non-zero with `'<label>' not found`. We CREATE the label (`gh label
+     * create`) and RETRY the add, so the lock works from the very first `intake` run
+     * (a fresh repo is lockable without a manual `gh label create`). Label creation
+     * is idempotent-enough for our purpose: a concurrent create loses harmlessly
+     * (the retry add then succeeds against the now-existing label).
+     */
+    private mutateLabel;
+    /**
+     * Create the lock label (`gh label create <label>`) so a fresh repo is lockable
+     * from the first run. Returns a three-way result rather than a bare boolean so the
+     * caller can surface the CREATE's REAL cause (the original bug threw the stderr
+     * away, leaving `mutateLabel` to report the fresh-repo SYMPTOM `'<label>' not
+     * found` even on a permission-denied create):
+     *
+     * - **`{ok: true}`** — the label now exists (created here, or it already existed —
+     *   `gh` reports `already exists`, which we treat as success).
+     * - **`{ok: false}`** (no `reason`) — `gh` is MISSING (binary absent): degrade to
+     *   the caller's existing missing-`gh` handling (the never-hard-fail posture).
+     * - **`{ok: false, reason}`** — the create FAILED for a real reason (e.g. no
+     *   permission): the caller surfaces `reason` (the create's REAL `gh` stderr).
+     *
+     * NEVER throws.
+     */
+    private createLabel;
+    /**
+     * Run `gh <args>` in `cwd`, returning the result, or `undefined` when `gh`
+     * cannot even be spawned (binary missing). Mirrors {@link GitHubProvider}'s
+     * `runGh` (the spawn-error catch keeps a missing `gh` a clean failure).
+     */
+    private runGh;
+    /** Parse a `gh --json` read, THROWING a clear error on any failure. */
+    private parseJson;
+}
+//# sourceMappingURL=issue-provider.d.ts.map

package/dist/issue-provider.d.ts.map

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