dorfl 0.0.0 → 0.1.0

package/dist/close-job.js

@@ -0,0 +1,226 @@
+/**
+ * The CI CLOSE-JOB driver (prd `runner-in-ci`, capability E; task
+ * `install-ci-close-job-workflow`). When work lands on `main`, this resolves which
+ * source issue(s) the landed work closes and closes them — but it OWNS none of the
+ * machinery it relies on. It is the thin JOB that WIRES three UNCHANGED engine
+ * pieces together (the Out-of-Scope fence: do NOT re-build them):
+ *
+ *   - the RESOLUTION — {@link resolveClosingIssue} (`frontmatter.ts`): an artifact
+ *     uses `issue:` XOR `prd:`; a lone task closes its own `issue:` directly, a
+ *     fanned task reaches the number via `task.prd: → work/prds/<prd>.md prd
+ *     issue:`, and `prd:` WINS on a (hand-edited) conflict;
+ *   - the QUERY — {@link isSpecComplete} (`spec-complete.ts`, task
+ *     `prd-complete-query`, done): a spec is COMPLETE iff ≥1 `spec:<slug>` task AND
+ *     all such tasks are in `work/done/`;
+ *   - the CLOSE — {@link IssueProvider.closeIssue} (`issue-provider.ts`, the atomic
+ *     comment+close seam intake already uses): NO direct `gh` in this core; any
+ *     informational comment rides the SAME close call (never the PR seam
+ *     `postPRComment`).
+ *
+ * The closure conditions, per artifact kind:
+ *
+ *   - a **lone task** (`issue:`, no `prd:`) that resides in `work/done/` — its PR
+ *     merged, so its own issue closes (reason `completed`);
+ *   - a **prd** (`issue:`) — closes ONLY when {@link isSpecComplete} says ALL its
+ *     `spec:<slug>` tasks are in `work/done/` (reason `completed`).
+ *
+ * A prd whose query is NOT yet complete is left OPEN (the final fanned task's
+ * merge tick closes it). A lone task still outside `work/done/` is skipped. The
+ * close DEGRADES (never throws) on a missing/unauthenticated provider, exactly
+ * like intake's bounce close — the run reports the real cause and stays exit-0.
+ *
+ * This is the JOB the close-job WORKFLOW (capability E) invokes via
+ * `dorfl close-merged-issues`; the workflow is triggered on a merge to
+ * `main` (`push: {branches: [main]}`). The driver itself is provider-pluggable
+ * (it takes an {@link IssueProvider}) and reads only the `work/` tree.
+ */
+import { readdirSync, readFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { TASK_LIFECYCLE_FOLDERS, SPEC_FOLDERS, workFolderPath, workItemRel, isWorkItemFile, } from './work-layout.js';
+import { parseFrontmatter, resolveClosingIssue } from './frontmatter.js';
+import { isSpecComplete } from './spec-complete.js';
+import { GitHubIssueProvider, } from './issue-provider.js';
+/** The task lifecycle folders a lone-task `issue:` can reside in. */
+const TASK_FOLDERS = TASK_LIFECYCLE_FOLDERS;
+/** The spec folders an `issue:`-bearing spec can reside in. */
+const SPEC_LIFECYCLE_FOLDERS = SPEC_FOLDERS;
+/** List the `.md` filenames in `<repoPath>/work/<folder>/`, sorted; `[]` if absent. */
+function listMarkdown(repoPath, folder) {
+    const dir = workFolderPath(repoPath, folder);
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries.filter((name) => isWorkItemFile(name)).sort();
+}
+/**
+ * Read a prd's `issue:` number by slug, scanning the prd folders. Returns
+ * `undefined` when no prd with that slug carries an `issue:` (a prd with no source
+ * issue, or a typo'd `prd:` hop — degrades to "no issue to close", never crashes).
+ */
+function specIssueNumber(repoPath, specSlug) {
+    for (const folder of SPEC_LIFECYCLE_FOLDERS) {
+        for (const file of listMarkdown(repoPath, folder)) {
+            const fm = parseFrontmatter(readFileSync(join(repoPath, workItemRel(folder, file)), 'utf8'));
+            const slug = fm.slug ?? basename(file, '.md');
+            if (slug === specSlug && fm.issue !== undefined) {
+                return fm.issue;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve the DEDUPLICATED set of closure candidates from the `work/` tree, each
+ * via the UNCHANGED {@link resolveClosingIssue}:
+ *
+ *   - every prd carrying `issue:` (in `work/prds/ready/` or `work/prds/tasked/`) is a
+ *     prd-kind candidate keyed on its own `prd:` query;
+ *   - every LONE task (`issue:` and NO `prd:`) is an `issue`-kind candidate.
+ *
+ * A fanned task carries `prd:` (NOT its own `issue:`), so it reaches the number
+ * through its prd's candidate, never as its own — the issue number lives ONLY on
+ * the prd. Deduplicated by issue number: a prd enumerated once even though many
+ * tasks point at it. Prd candidates are listed before lone-task candidates, each
+ * group slug-sorted, for a deterministic log.
+ */
+function resolveCandidates(repoPath) {
+    const seen = new Set();
+    const specCandidates = [];
+    const taskCandidates = [];
+    // Spec candidates: a spec's `issue:` closes when ITS query is complete.
+    for (const folder of SPEC_LIFECYCLE_FOLDERS) {
+        for (const file of listMarkdown(repoPath, folder)) {
+            const fm = parseFrontmatter(readFileSync(join(repoPath, workItemRel(folder, file)), 'utf8'));
+            const slug = fm.slug ?? basename(file, '.md');
+            const closing = resolveClosingIssue(fm);
+            // A prd's own closing link is its `issue:` (a prd has no `prd:`); on the
+            // hand-edit conflict `prd:` wins via resolveClosingIssue, so only a true
+            // `issue:`-bearing prd becomes a candidate here.
+            if (closing?.via === 'issue' && !seen.has(closing.issue)) {
+                seen.add(closing.issue);
+                specCandidates.push({ issueNumber: closing.issue, via: 'spec', slug });
+            }
+        }
+    }
+    // Lone-task candidates: a task with `issue:` and NO `prd:` closes its OWN
+    // issue directly when it lands in work/done/.
+    for (const folder of TASK_FOLDERS) {
+        for (const file of listMarkdown(repoPath, folder)) {
+            const fm = parseFrontmatter(readFileSync(join(repoPath, workItemRel(folder, file)), 'utf8'));
+            const slug = fm.slug ?? basename(file, '.md');
+            const closing = resolveClosingIssue(fm);
+            // `resolveClosingIssue` returns `via: 'issue'` ONLY when there is no `prd:`
+            // (prd wins on conflict), so a fanned task never lands here — it reaches
+            // its issue through the prd candidate above.
+            if (closing?.via === 'issue' && !seen.has(closing.issue)) {
+                seen.add(closing.issue);
+                taskCandidates.push({ issueNumber: closing.issue, via: 'issue', slug });
+            }
+        }
+    }
+    specCandidates.sort((a, b) => a.slug.localeCompare(b.slug));
+    taskCandidates.sort((a, b) => a.slug.localeCompare(b.slug));
+    return [...specCandidates, ...taskCandidates];
+}
+/** True iff the lone task with this slug resides in `work/done/`. */
+function loneTaskLanded(repoPath, taskSlug) {
+    for (const file of listMarkdown(repoPath, 'done')) {
+        const fm = parseFrontmatter(readFileSync(join(repoPath, workItemRel('done', file)), 'utf8'));
+        const slug = fm.slug ?? basename(file, '.md');
+        if (slug === taskSlug) {
+            return true;
+        }
+    }
+    return false;
+}
+/** The closing comment posted (atomically, on the close call) for each kind. */
+function closeComment(via, slug) {
+    return via === 'spec'
+        ? `Closed by dorfl: every task of spec \`${slug}\` has landed in \`work/done/\`.`
+        : `Closed by dorfl: the task \`${slug}\` has landed in \`work/done/\`.`;
+}
+/**
+ * Run the close-job over a repo's `work/` tree: resolve the closure candidates,
+ * apply the per-kind closure condition (a landed lone task; a prd whose
+ * {@link isSpecComplete} query holds), and close the qualifying issues through the
+ * {@link IssueProvider.closeIssue} seam (reason `completed`, an informational
+ * comment riding the SAME atomic close). REUSES the unchanged resolution + query +
+ * close — it re-implements NONE of them. NEVER throws: a degraded provider close
+ * is reported as `close-failed`, not a crash (the terminal CI tick stays exit-0).
+ */
+export async function runCloseJob(options) {
+    const { repoPath, issueProvider, env } = options;
+    const candidates = [];
+    const closed = [];
+    const completedReason = 'completed';
+    for (const cand of resolveCandidates(repoPath)) {
+        // The closure CONDITION per kind — the only place this job decides; the
+        // computation of "complete" / "landed" is the UNCHANGED engine query.
+        let shouldClose;
+        let notReady;
+        if (cand.via === 'spec') {
+            shouldClose = isSpecComplete({ repoPath, slug: cand.slug }).complete;
+            notReady = 'not-complete';
+        }
+        else {
+            shouldClose = loneTaskLanded(repoPath, cand.slug);
+            notReady = 'not-landed';
+        }
+        if (!shouldClose) {
+            candidates.push({
+                issueNumber: cand.issueNumber,
+                via: cand.via,
+                slug: cand.slug,
+                decision: notReady,
+            });
+            continue;
+        }
+        // CLOSE via the provider seam (NO direct `gh`): comment + reason + close in
+        // ONE atomic call, exactly the seam intake's bounce uses.
+        const result = await issueProvider.closeIssue({
+            cwd: repoPath,
+            issueNumber: cand.issueNumber,
+            comment: closeComment(cand.via, cand.slug),
+            reason: completedReason,
+            env,
+        });
+        if (result.closed) {
+            closed.push(cand.issueNumber);
+            candidates.push({
+                issueNumber: cand.issueNumber,
+                via: cand.via,
+                slug: cand.slug,
+                decision: 'closed',
+            });
+        }
+        else {
+            candidates.push({
+                issueNumber: cand.issueNumber,
+                via: cand.via,
+                slug: cand.slug,
+                decision: 'close-failed',
+                reason: result.reason ?? result.instruction,
+            });
+        }
+    }
+    return { candidates, closed };
+}
+/**
+ * The CLI entry the close-job WORKFLOW invokes (`dorfl
+ * close-merged-issues`): construct the GitHub issue provider and run the
+ * close-job over the checkout's `work/` tree. Provider-pluggable via
+ * {@link runCloseJob}; this wrapper only picks the default (GitHub) adapter.
+ */
+export async function performCloseMergedIssues(options) {
+    const issueProvider = new GitHubIssueProvider({ ghBin: options.ghBin });
+    return runCloseJob({
+        repoPath: options.repoPath,
+        issueProvider,
+        env: options.env,
+    });
+}
+//# sourceMappingURL=close-job.js.map

package/dist/close-job.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-job.js","sourceRoot":"","sources":["../src/close-job.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAC,WAAW,EAAE,YAAY,EAAC,MAAM,SAAS,CAAC;AAClD,OAAO,EAAC,QAAQ,EAAE,IAAI,EAAC,MAAM,WAAW,CAAC;AACzC,OAAO,EACN,sBAAsB,EACtB,YAAY,EAEZ,cAAc,EACd,WAAW,EACX,cAAc,GACd,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAC,gBAAgB,EAAE,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAGN,mBAAmB,GACnB,MAAM,qBAAqB,CAAC;AAE7B,qEAAqE;AACrE,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAE5C,+DAA+D;AAC/D,MAAM,sBAAsB,GAAG,YAAY,CAAC;AAyC5C,uFAAuF;AACvF,SAAS,YAAY,CAAC,QAAgB,EAAE,MAAqB;IAC5D,MAAM,GAAG,GAAG,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC7C,IAAI,OAAiB,CAAC;IACtB,IAAI,CAAC;QACJ,OAAO,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;IAC5B,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,EAAE,CAAC;IACX,CAAC;IACD,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;AAC9D,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CACvB,QAAgB,EAChB,QAAgB;IAEhB,KAAK,MAAM,MAAM,IAAI,sBAAsB,EAAE,CAAC;QAC7C,KAAK,MAAM,IAAI,IAAI,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC;YACnD,MAAM,EAAE,GAAG,gBAAgB,CAC1B,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAC/D,CAAC;YACF,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAC9C,IAAI,IAAI,KAAK,QAAQ,IAAI,EAAE,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;gBACjD,OAAO,EAAE,CAAC,KAAK,CAAC;YACjB,CAAC;QACF,CAAC;IACF,CAAC;IACD,OAAO,SAAS,CAAC;AAClB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAS,iBAAiB,CAAC,QAAgB;IAK1C,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,cAAc,GAAuD,EAAE,CAAC;IAC9E,MAAM,cAAc,GACnB,EAAE,CAAC;IAEJ,wEAAwE;IACxE,KAAK,MAAM,MAAM,IAAI,sBAAsB,EAAE,CAAC;QAC7C,KAAK,MAAM,IAAI,IAAI,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC;YACnD,MAAM,EAAE,GAAG,gBAAgB,CAC1B,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAC/D,CAAC;YACF,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAC9C,MAAM,OAAO,GAAG,mBAAmB,CAAC,EAAE,CAAC,CAAC;YACxC,yEAAyE;YACzE,yEAAyE;YACzE,iDAAiD;YACjD,IAAI,OAAO,EAAE,GAAG,KAAK,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC1D,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBACxB,cAAc,CAAC,IAAI,CAAC,EAAC,WAAW,EAAE,OAAO,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAC,CAAC,CAAC;YACtE,CAAC;QACF,CAAC;IACF,CAAC;IAED,0EAA0E;IAC1E,8CAA8C;IAC9C,KAAK,MAAM,MAAM,IAAI,YAAY,EAAE,CAAC;QACnC,KAAK,MAAM,IAAI,IAAI,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC;YACnD,MAAM,EAAE,GAAG,gBAAgB,CAC1B,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAC/D,CAAC;YACF,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAC9C,MAAM,OAAO,GAAG,mBAAmB,CAAC,EAAE,CAAC,CAAC;YACxC,4EAA4E;YAC5E,yEAAyE;YACzE,6CAA6C;YAC7C,IAAI,OAAO,EAAE,GAAG,KAAK,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC1D,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBACxB,cAAc,CAAC,IAAI,CAAC,EAAC,WAAW,EAAE,OAAO,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAC,CAAC,CAAC;YACvE,CAAC;QACF,CAAC;IACF,CAAC;IAED,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAC5D,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAC5D,OAAO,CAAC,GAAG,cAAc,EAAE,GAAG,cAAc,CAAC,CAAC;AAC/C,CAAC;AAED,qEAAqE;AACrE,SAAS,cAAc,CAAC,QAAgB,EAAE,QAAgB;IACzD,KAAK,MAAM,IAAI,IAAI,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC;QACnD,MAAM,EAAE,GAAG,gBAAgB,CAC1B,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAC/D,CAAC;QACF,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC9C,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC;QACb,CAAC;IACF,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AAED,gFAAgF;AAChF,SAAS,YAAY,CAAC,GAAqB,EAAE,IAAY;IACxD,OAAO,GAAG,KAAK,MAAM;QACpB,CAAC,CAAC,yCAAyC,IAAI,kCAAkC;QACjF,CAAC,CAAC,+BAA+B,IAAI,kCAAkC,CAAC;AAC1E,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAChC,OAAwB;IAExB,MAAM,EAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,EAAC,GAAG,OAAO,CAAC;IAC/C,MAAM,UAAU,GAAqB,EAAE,CAAC;IACxC,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,MAAM,eAAe,GAAqB,WAAW,CAAC;IAEtD,KAAK,MAAM,IAAI,IAAI,iBAAiB,CAAC,QAAQ,CAAC,EAAE,CAAC;QAChD,wEAAwE;QACxE,sEAAsE;QACtE,IAAI,WAAoB,CAAC;QACzB,IAAI,QAAuB,CAAC;QAC5B,IAAI,IAAI,CAAC,GAAG,KAAK,MAAM,EAAE,CAAC;YACzB,WAAW,GAAG,cAAc,CAAC,EAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAC,CAAC,CAAC,QAAQ,CAAC;YACnE,QAAQ,GAAG,cAAc,CAAC;QAC3B,CAAC;aAAM,CAAC;YACP,WAAW,GAAG,cAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YAClD,QAAQ,GAAG,YAAY,CAAC;QACzB,CAAC;QAED,IAAI,CAAC,WAAW,EAAE,CAAC;YAClB,UAAU,CAAC,IAAI,CAAC;gBACf,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,GAAG,EAAE,IAAI,CAAC,GAAG;gBACb,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,QAAQ,EAAE,QAAQ;aAClB,CAAC,CAAC;YACH,SAAS;QACV,CAAC;QAED,4EAA4E;QAC5E,0DAA0D;QAC1D,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,UAAU,CAAC;YAC7C,GAAG,EAAE,QAAQ;YACb,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,OAAO,EAAE,YAAY,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC;YAC1C,MAAM,EAAE,eAAe;YACvB,GAAG;SACH,CAAC,CAAC;QACH,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YACnB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC9B,UAAU,CAAC,IAAI,CAAC;gBACf,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,GAAG,EAAE,IAAI,CAAC,GAAG;gBACb,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,QAAQ,EAAE,QAAQ;aAClB,CAAC,CAAC;QACJ,CAAC;aAAM,CAAC;YACP,UAAU,CAAC,IAAI,CAAC;gBACf,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,GAAG,EAAE,IAAI,CAAC,GAAG;gBACb,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,QAAQ,EAAE,cAAc;gBACxB,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,WAAW;aAC3C,CAAC,CAAC;QACJ,CAAC;IACF,CAAC;IAED,OAAO,EAAC,UAAU,EAAE,MAAM,EAAC,CAAC;AAC7B,CAAC;AAYD;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC7C,OAAwC;IAExC,MAAM,aAAa,GAAG,IAAI,mBAAmB,CAAC,EAAC,KAAK,EAAE,OAAO,CAAC,KAAK,EAAC,CAAC,CAAC;IACtE,OAAO,WAAW,CAAC;QAClB,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,aAAa;QACb,GAAG,EAAE,OAAO,CAAC,GAAG;KAChB,CAAC,CAAC;AACJ,CAAC"}

package/dist/complete.d.ts

@@ -0,0 +1,361 @@
+import type { VerifyConfig } from './verify.js';
+import type { ReviewGate } from './review-gate.js';
+import { synthesiseProposeTitle, composeProposeBody, PR_TITLE_MAX } from './integration-core.js';
+import type { ReviewProvider } from './integrator.js';
+import type { IntegrationMode } from './config.js';
+export { synthesiseProposeTitle, composeProposeBody, PR_TITLE_MAX };
+/**
+ * `dorfl complete [<slug>] [--skip-verify] [--type <t>] [--message <s>]
+ * [--arbiter <remote>]` — the human "finish this" command that runs the same
+ * back-half the autonomous runner runs: gate → mark done → commit → integrate.
+ *
+ * It runs on a `work/<slug>` branch (slug inferred from the branch if omitted).
+ * The build agent leaves its work UNCOMMITTED (it does no git), so `complete`
+ * `git add -A`s the agent's work AND the done-move into ONE atomic commit. This
+ * is the same finish/integration logic `run-once`/`watch` reuse; here it is
+ * human-driven and so allows a `--skip-verify` escape hatch the autonomous
+ * runner never uses (ADR §8).
+ *
+ * The item's SOURCE folder is normally `work/tasks/ready/` (the pool — claim
+ * leaves the body there, task
+ * `cutover-claim-body-stays-and-complete-sources-from-backlog`). A RUNNER-OWNED
+ * RECOVERY of a SPURIOUSLY-stuck item (env-polluted gate, transient flake,
+ * since-fixed cause) sources from the SAME pool location: the per-item-lock
+ * cutover (`cutover-needs-attention-becomes-lock-stuck-recovery-surface`)
+ * retired the `work/needs-attention/` folder — stuck is the lock `state: stuck`
+ * and the body stays in `tasks/ready/` while claimed, so a recovery `complete`
+ * is structurally a normal build. The gate is RE-RUN and authoritative (only a
+ * GREEN re-gate completes; a still-red item stays stuck on the lock).
+ * `--skip-verify` stays the only, human-only, loud override.
+ *
+ * The integration step is split by mode (config `integration`, ADR §6):
+ *   merge   — push the rebased branch to `<arbiter>/main`, then sync the LOCAL
+ *             clone to that new main (the push is authoritative; the local sync
+ *             is the ergonomic finish so the user ends on an up-to-date main).
+ *   propose — push the `work/<slug>` branch (the safety-bearing step) and report
+ *             the next step. Full provider-driven PR/MR creation lands with the
+ *             integration seam; until then `complete` pushes + tells the human.
+ *
+ * In BOTH modes `complete` lands the human back on local `main` by default
+ * ("finish, ready for the next thing") — but the move differs because the work's
+ * location differs: `merge` switches to `main` AND fast-forwards it to the just-
+ * pushed `<arbiter>/main` (the work landed there); `propose` ONLY `git switch
+ * main` (arbiter main has not moved, so there is nothing to ff). `--no-switch`
+ * opts out in either mode (stay on `work/<slug>` to keep iterating).
+ *
+ * After landing on `main`, the LOCAL `work/<slug>` branch is deleted iff its work
+ * is provably on the arbiter (the SAME predicate as worktree deletion, ADR §4,
+ * mode-agnostic): its tip is an ancestor of `<arbiter>/main` (merged) OR
+ * `<arbiter>/work/<slug>` exists with its tip == the local tip (pushed & up-to-
+ * date). Otherwise the branch is KEPT (unmerged / unpushed / a diverged un-pushed
+ * amend = not safe). The REMOTE branch is NEVER deleted (a propose PR is built
+ * from it). `--no-switch` keeps the branch too.
+ *
+ * Before integrating, the work branch is rebased onto the latest `<arbiter>/main`
+ * (ADR §10): a clean rebase continues; a conflicting rebase is `--abort`ed and
+ * surfaced as needs-attention — `complete` NEVER auto-resolves. It NEVER
+ * `--force`es to main.
+ *
+ * Exit codes:
+ *   0  completed (done-move + commit + integrate succeeded)
+ *   1  usage/environment error, or a refusal (gate failed, nothing to commit,
+ *      not on a work branch, rebase conflict needs the human)
+ *
+ * On the two FAILURE paths the human can't paper over — a red gate (without
+ * `--skip-verify`) and a rebase conflict (ADR §10) — `complete` no longer leaves
+ * the item dangling. Instead it routes the item through the shared
+ * `needs-attention` mechanism (ADR §12): record the reason on the per-item lock
+ * entry (`state: stuck`, post-cutover task
+ * `cutover-needs-attention-becomes-lock-stuck-recovery-surface`) so the stuck
+ * item is surfaced by `status` and returnable to `backlog/`. The success and
+ * `--skip-verify` paths are unchanged. The exit code stays 1 (the work did NOT
+ * complete); the outcome still names WHY (gate-failed / rebase-conflict) and
+ * `routedToNeedsAttention` records that the lock amend happened.
+ */
+export type CompleteOutcome = 'completed' | 'already-integrated' | 'prepare-failed' | 'gate-failed' | 'review-blocked' | 'review-unparseable' | 'rebase-conflict' | 'invariant-violation' | 'strand-surfaced' | 'surface-unmoved' | 'refused' | 'usage-error';
+export interface CompleteOptions {
+    /** The slug to complete. If omitted, inferred from a `work/<slug>` branch. */
+    slug?: string;
+    /** The working clone/checkout the work branch lives in. */
+    cwd: string;
+    /** Name of the arbiter git remote. Defaults to `origin`. */
+    arbiter?: string;
+    /** Integration mode: `propose` (default) or `merge`. */
+    integration?: IntegrationMode;
+    /**
+     * **The explicit `--merge` override** for the untrusted-origin build-propose rule
+     * (task `untrusted-origin-forces-build-propose`). `true` iff the operator
+     * EXPLICITLY typed `--merge` on this invocation (vs `merge` resolved from
+     * config). Forwarded to {@link performIntegration}'s `explicitMerge`: an explicit
+     * `--merge` OVERRIDES the untrusted-origin build-propose rule (the operator is
+     * present; CLI always wins). Unset on the autonomous path ⇒ an untrusted-origin
+     * task reliably forces `propose`.
+     */
+    explicitMerge?: boolean;
+    /**
+     * Override the pre-flight DIVERGENCE guard (`--ignore-diverged-main`, mirroring
+     * `--ignore-not-ready`): proceed even when local `main` is ahead of
+     * `<arbiter>/main` (has unpushed commits). MERGE MODE ONLY (only merge mode ff's
+     * local `main`). When overridden and the divergence persists, the now-NON-FATAL
+     * {@link syncLocalMain} reports it honestly (work on the arbiter; local `main`
+     * left to rebase). Loud, never the default.
+     */
+    ignoreDivergedMain?: boolean;
+    /**
+     * Leave the human ON the `work/<slug>` branch (and KEEP it) in either mode,
+     * instead of switching back to `main` + deleting the provably-landed branch.
+     * For "I'll keep iterating on this branch" (e.g. addressing review feedback).
+     */
+    noSwitch?: boolean;
+    /** The declared per-repo ENV-PREP step (string | list), run ONCE before the
+     * first `verify` to make the env ready. Unset ⇒ a no-op (NO default install). */
+    prepare?: VerifyConfig;
+    /** The declared per-repo gate (string | list). Unset ⇒ the default command. */
+    verify?: VerifyConfig;
+    /**
+     * Run the acceptance gate (`prepare` then `verify`) against the REBASED tip
+     * in a CLEAN throwaway worktree (the tree that integrates) when `true` (the
+     * default), rather than the current checkout (the pre-rebase tree) when
+     * `false`. `complete` is a SINGLE-JOB path, so this is the resolved flag
+     * passed UNCONDITIONALLY (no `run`-fleet downgrade). Forwarded verbatim to
+     * {@link performIntegration}.
+     */
+    freshWorktreeGate?: boolean;
+    /**
+     * **The cross-job merge-serialiser CAS-retry cap** (config `mergeRetries`, prd
+     * `land-time-reverify-and-parallel-merge-ceiling` Story 5 / Applied Answer q1
+     * (a)). Threaded verbatim into {@link performIntegration} as `mergeRetries` so
+     * the resolved per-repo value controls how many re-rebase-and-retry attempts
+     * the merge-mode `${branch}:main` push makes before a contender bounces to
+     * needs-attention. Resolved ONCE per `performComplete` call — the same
+     * per-item resolution as `freshWorktreeGate` / `reviewMaxRounds`.
+     */
+    mergeRetries?: number;
+    /** Skip the acceptance gate (human-only escape hatch; never used unattended). */
+    skipVerify?: boolean;
+    /**
+     * **`--allow-backlog`** (prd
+     * `do-allow-backlog-drive-staged-tasks-without-promotion`): TREAT a
+     * `tasks/backlog/`-resident body (staging) as a VALID build source, so a
+     * staged task driven in place done-moves `tasks/backlog/ → tasks/done/`
+     * directly. GATED on the explicit flag: WITHOUT it, a body resting in
+     * `tasks/backlog/` is NOT a sanctioned completion position (a corrupt/wip
+     * strand) and `complete` still REFUSES honestly — only the deliberate drive
+     * promotes from staging. Default off ⇒ today's refusal-on-staging behaviour.
+     * Threaded only by the `do … --allow-backlog` task-build path; no autonomous
+     * caller sets it.
+     */
+    allowBacklog?: boolean;
+    /**
+     * **Gate 2 — the PR/code review gate** (GATES prd `work/prds/tasked/review.md`). When
+     * `true`, after the green `verify` and BEFORE the done-move, run the `review`
+     * SKILL as a FRESH-CONTEXT agent (its own harness launch) and route its verdict:
+     * `approve` → proceed to done-move/commit/integrate; `block` → route to
+     * needs-attention (NEVER merge). `verify` is the non-skippable floor; review is
+     * a JUDGEMENT gate ON TOP (ADR §8), never a replacement. Default OFF.
+     */
+    review?: boolean;
+    /**
+     * The model the REVIEW agent runs on (de-correlation from the builder). Flows
+     * to the review-agent launch through the EXISTING harness seam
+     * (`LaunchInput.model` / `substituteModel`). Unset ⇒ no forced review model.
+     */
+    reviewModel?: string;
+    /**
+     * Bound the revise↔review loop (Gate 2). On exhaustion the gate ERRORS OUT and
+     * forces needs-attention (never silently merges or loops). Defaults to 2.
+     */
+    reviewMaxRounds?: number;
+    /**
+     * The review-gate SEAM (injectable, like `do`'s `dorfl`): a fresh-context
+     * review that returns a parsed `{verdict, findings}`. Tests inject a canned
+     * verdict (no real model); production wires the harness-backed gate
+     * (`harnessReviewGate`). Required when `review` is on (a missing gate with
+     * `review` on is a usage error — the floor must not be silently skipped).
+     */
+    reviewGate?: ReviewGate;
+    /**
+     * `--watch`: tail the Gate-2 REVIEW agent's pi session `.jsonl` live, the SAME
+     * way `do --watch` tails the build agent's (task `watch-review-session`).
+     * Threaded into the `reviewGate` invocation below so the production gate
+     * (`harnessReviewGate`) routes its launch through the shared
+     * `launchWithOptionalWatch` helper. OFF (the default) ⇒ the review path is
+     * byte-for-byte unchanged (sync launch, no tailer). Observability only — it
+     * never changes the verdict/routing.
+     */
+    watch?: boolean;
+    /** Where the tailed review lines are written (defaults to stderr). */
+    watchSink?: (line: string) => void;
+    /**
+     * The HOST-ONLY sessions root the review session FILE is generated under
+     * (resolved `config.sessionsDir`). Threaded to the review-agent launch so its
+     * (distinct `<slug>-review`) session lands under the same root as the build's.
+     */
+    sessionsDir?: string;
+    /** Conventional-commit type for the completion commit. Defaults to `feat`. */
+    type?: string;
+    /** Commit summary. Defaults to the task `title` minus a leading `slug — `. */
+    message?: string;
+    /**
+     * Optional review-request BODY (propose mode) — the PR/MR DESCRIPTION, DISTINCT
+     * from {@link message} (which is the COMMIT summary). Advisory prose that gates
+     * nothing. The autonomous `do` path passes the build agent's final summary
+     * (`LaunchResult.output`); a human `complete --propose` may pass one via a NEW
+     * `--body` flag (NOT `--message`). The runner scaffolds a deterministic header
+     * (a pointer to `work/done/<slug>.md`) above it. Absent ⇒ today's `gh pr create
+     * --fill` empty/commit-derived body (no regression). Ignored in `merge` mode.
+     */
+    body?: string;
+    /** Optional injectable PR opener (e.g. `gh pr create`); used in `propose` mode. */
+    openPr?: (opts: {
+        cwd: string;
+        branch: string;
+        env?: NodeJS.ProcessEnv;
+    }) => void;
+    /**
+     * Optional FULLY-FORMED review provider INSTANCE used VERBATIM (the SAME seam
+     * `run` exposes via `RunOptions.provider`; forwarded to `performIntegration` as
+     * `providerInstance`). Tests/embeddings inject a stubbed `GitHubProvider` (a
+     * custom `gh` path) to drive the full propose pipeline OFFLINE without a real
+     * GitHub arbiter. This is the resolved provider OBJECT — NOT a config override
+     * (there is none; the provider is purely arbiter-derived). Unset ⇒ the core
+     * selects the provider from the arbiter URL as normal.
+     */
+    providerInstance?: ReviewProvider;
+    /**
+     * **The PR-INTENT axis** (config `noPR`, ADR §6). When `true` on the propose
+     * path, push the branch but SKIP the review request (the explicit suppress-PR
+     * intent, re-homing the old `provider: none` use). NOT a provider choice — the
+     * provider is purely arbiter-derived. Threaded verbatim into
+     * {@link performIntegration}. Ignored in `merge` mode and when `openPr` is
+     * injected. Unset/false ⇒ propose opens the PR via the arbiter-derived provider.
+     */
+    noPR?: boolean;
+    /**
+     * Surface a needs-attention bounce ON THE ARBITER (the AUTONOMOUS variant of
+     * the failure path). When set, the two FAILURE routings (`gate-failed` /
+     * `rebase-conflict`) pass this arbiter remote into the ledger write seam's
+     * `applyNeedsAttentionTransition`, which (mode M) cherry-picks the move-only
+     * commit onto the arbiter's `main` — making the stuck state observable to
+     * `scan`/`status`/another machine. This is exactly what `run`'s `runOneItem`
+     * does (it passes `arbiter: job.arbiterRemote`).
+     *
+     * Unset (the default) keeps `complete`'s HUMAN behaviour: route LOCALLY only
+     * (no on-`main` surfacing) — a human is right there, so no cross-machine
+     * surfacing is needed. The unattended `do` worker (the CI command) sets this
+     * so a stuck CI run is NOT invisible.
+     */
+    surfaceArbiter?: string;
+    /** Environment for child git/provider processes (the identity-scoped env). */
+    env?: NodeJS.ProcessEnv;
+    /**
+     * Environment for the REVIEW-AGENT launch (Gate 2) — the AMBIENT env, never the
+     * identity-scoped {@link env} (an agent must not act as the bot). Threaded to
+     * {@link performIntegration}'s `agentEnv`. Unset ⇒ falls back to {@link env}
+     * (byte-for-byte unchanged for non-identity callers, e.g. the human `complete`).
+     */
+    agentEnv?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+    /**
+     * Sink for a pre-formatted block printed VERBATIM (no `>> ` prefix), used for
+     * the visually-distinct propose-mode next-step block so its blank lines and
+     * heading stand out cleanly. Defaults to `note` when not supplied.
+     */
+    noteBlock?: (message: string) => void;
+    /**
+     * Emit ANSI color in the (cosmetic) propose-mode next-step block. Defaults
+     * to the TTY/`NO_COLOR` rule against `process.stdout`; injectable so tests
+     * can simulate a TTY (color) vs. a pipe / `NO_COLOR` (plain) without a real
+     * terminal. Color-only — it changes no gate/done-move/commit/integrate logic.
+     */
+    color?: boolean;
+}
+export interface CompleteResult {
+    exitCode: 0 | 1;
+    outcome: CompleteOutcome;
+    /**
+     * True iff a FAILURE outcome (gate-failed / rebase-conflict) was routed to
+     * `work/needs-attention/` via the shared mechanism (ADR §12), rather than left
+     * dangling. Undefined/false on the success, `--skip-verify`, refused, and
+     * usage-error paths (none of which move the item to needs-attention).
+     */
+    routedToNeedsAttention?: boolean;
+    /** The work branch that was completed, when one was resolved. */
+    branch?: string;
+    /** The completion commit message that was authored, on success. */
+    commitMessage?: string;
+    /** True when the work landed on the arbiter's `main` (merge mode). */
+    mergedToMain?: boolean;
+    /**
+     * Merge mode only: whether the LOCAL `main` was fast-forwarded to the
+     * just-pushed `<arbiter>/main` (the ergonomic courtesy AFTER the authoritative
+     * push). `true` on the normal ff path; `false` when local `main` had DIVERGED
+     * and the ff could not apply — a NON-FATAL skip (the arbiter push already
+     * defined success, so `outcome` stays `completed` / exit 0; the operator is told
+     * to `git rebase` to sync). Undefined outside merge mode / `--no-switch`.
+     */
+    localMainSynced?: boolean;
+    /** The branch HEAD ended on after completing (`main`, or the work branch). */
+    switchedTo?: string;
+    /** True iff the local `work/<slug>` branch was deleted (provably on arbiter). */
+    deletedLocalBranch?: boolean;
+    /**
+     * The review-request URL (e.g. a GitHub PR) opened in `propose` mode, when a
+     * provider opened one and reported it (ADR §6). Absent in merge mode and on
+     * the push-only / degraded path.
+     */
+    prUrl?: string;
+    /** Human-readable summary of the terminal condition. */
+    message: string;
+}
+/**
+ * Resolve the integration mode the human asked for ON THIS invocation from the
+ * mutually-exclusive `--merge` / `--propose` flags. Returns the explicit mode,
+ * or `undefined` when neither flag was given (per-repo > global > default then
+ * decides). Throws when BOTH are given (they are mutually exclusive). This is
+ * the TOP of the complete-time precedence chain (flag > per-repo > global >
+ * default); the autonomous runner uses no flag and so resolves the same
+ * underlying order.
+ */
+export declare function integrationFromFlags(flags: {
+    merge?: boolean;
+    propose?: boolean;
+}): IntegrationMode | undefined;
+/**
+ * Run the complete ritual. Never throws for the expected gate-failed /
+ * rebase-conflict / refused cases — those are returned with exit 1 and a
+ * specific outcome. Usage/environment problems also surface as exit 1.
+ */
+export declare function performComplete(options: CompleteOptions): Promise<CompleteResult>;
+/**
+ * Sync the local `main` to the just-pushed `<arbiter>/main`: switch to main and
+ * fast-forward it. We fetch the arbiter's main (we just pushed our rebased work
+ * there) then `merge --ff-only` so the user lands on an up-to-date local main
+ * without merge noise.
+ *
+ * The ff is a COURTESY, NOT the safety-bearing step — the authoritative push to
+ * `<arbiter>/main` already defined `complete`'s success. So the ff is NON-FATAL:
+ * if local `main` has DIVERGED (unpushed commits the arbiter lacks) the ff cannot
+ * apply; rather than throw (which would make `complete` exit non-zero even though
+ * the merge ALREADY LANDED on the arbiter), we print a clear "rebase to sync"
+ * message and return `false` (the caller records `localMainSynced: false` and
+ * keeps `outcome: completed` / exit 0). Returns `true` on a normal ff.
+ *
+ * Only the diverged / ff-cannot-apply case is softened — the `fetch` and `switch`
+ * stay `gitHard` (a genuinely different failure is NOT masked, per the task).
+ * Exported for direct testing of the softened-vs-fatal boundary in isolation.
+ */
+export declare function syncLocalMain(cwd: string, arbiter: string, env: NodeJS.ProcessEnv | undefined, note: (m: string) => void): Promise<boolean>;
+/**
+ * The provably-safe predicate (ADR §4), mode-agnostic, applied to a LOCAL
+ * `branch` in `cwd`: true iff its tip is an ancestor of `<arbiter>/main` (merged)
+ * OR `<arbiter>/<branch>` exists with its tip == the local tip (pushed &
+ * up-to-date). False when the local branch is absent, or its work is unmerged /
+ * unpushed / a diverged un-pushed amend (remote tip != local tip). A `git fetch`
+ * refreshes the remote-tracking refs; an unreachable arbiter reads as not-
+ * provable → false (the safe direction). Exported for direct testing of the
+ * kept-vs-deleted decision in isolation.
+ */
+export declare function isLocalBranchProvablyOnArbiter(cwd: string, arbiter: string, branch: string, env: NodeJS.ProcessEnv | undefined): Promise<boolean>;
+//# sourceMappingURL=complete.d.ts.map

package/dist/complete.d.ts.map

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