agentplane 0.3.9 → 0.3.11

package/dist/commands/pr/check.js

@@ -6,10 +6,16 @@ import { fileExists } from "../../cli/fs-utils.js";
 import { createCliEmitter, workflowModeMessage } from "../../cli/output.js";
 import { CliError } from "../../shared/errors.js";
 import { parsePrMeta } from "../shared/pr-meta.js";
-import { gitListTaskBranches, parseTaskIdFromBranch } from "../shared/git-worktree.js";
+import { findWorktreeForBranch, gitListTaskBranches, parseTaskIdFromBranch, } from "../shared/git-worktree.js";
+import { gitRevParse } from "../shared/git-ops.js";
 import { loadBackendTask, loadCommandContext, } from "../shared/task-backend.js";
-import { readPrArtifact, resolvePrPaths } from "./internal/pr-paths.js";
-import { validateReviewContents } from "./internal/review-template.js";
+import { readPrArtifactFromBranch, resolvePrPaths } from "./internal/pr-paths.js";
+import { validateGithubPrBodyContents, validateReviewContents, } from "./internal/review-template.js";
+import { assessPrArtifactFreshness } from "./internal/freshness.js";
+function isUnknownRevisionError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return /unknown revision or path not in the working tree/i.test(message);
+}
 async function resolveArtifactBranch(opts) {
     const prefix = opts.ctx.config.branch.task_prefix;
     const branches = await gitListTaskBranches(opts.resolved.gitRoot, prefix);
@@ -25,26 +31,101 @@ async function resolveArtifactBranch(opts) {
     }
     return null;
 }
-async function readPrArtifactWithOptionalBranch(opts) {
-    const localPath = path.join(opts.prDir, opts.fileName);
-    if (await fileExists(localPath)) {
-        return await readFile(localPath, "utf8");
+async function readLocalPrArtifactText(prDir, fileName) {
+    const localPath = path.join(prDir, fileName);
+    if (!(await fileExists(localPath)))
+        return null;
+    return await readFile(localPath, "utf8");
+}
+function validateSnapshotContents(opts) {
+    const errors = [];
+    let meta = null;
+    if (opts.texts.metaText) {
+        try {
+            meta = parsePrMeta(opts.texts.metaText, opts.taskId);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            errors.push(message);
+        }
     }
-    if (opts.branchCache.value === undefined) {
-        opts.branchCache.value = await resolveArtifactBranch({
-            ctx: opts.ctx,
-            resolved: opts.resolved,
-            taskId: opts.taskId,
-        });
+    else {
+        errors.push(`Missing PR directory: ${opts.relPrDir}`, `Missing ${opts.relMetaPath}`);
     }
-    if (!opts.branchCache.value)
-        return null;
-    return await readPrArtifact({
-        resolved: opts.resolved,
-        prDir: opts.prDir,
-        fileName: opts.fileName,
-        branch: opts.branchCache.value,
+    if (opts.texts.diffstatText === null)
+        errors.push(`Missing ${opts.relDiffstatPath}`);
+    if (opts.texts.verifyLogText === null)
+        errors.push(`Missing ${opts.relVerifyLogPath}`);
+    if (opts.texts.reviewText) {
+        validateReviewContents(opts.texts.reviewText, errors);
+    }
+    else {
+        errors.push(`Missing ${opts.relReviewPath}`);
+    }
+    if (!opts.texts.githubTitleText?.trim()) {
+        errors.push(`Missing ${opts.relGithubTitlePath}`);
+    }
+    if (opts.texts.githubBodyText) {
+        validateGithubPrBodyContents(opts.texts.githubBodyText, errors);
+    }
+    else {
+        errors.push(`Missing ${opts.relGithubBodyPath}`);
+    }
+    return { meta, errors };
+}
+async function evaluateSnapshotFreshness(opts) {
+    if (!opts.snapshot.meta || !opts.branchHeadSha)
+        return;
+    const freshness = await assessPrArtifactFreshness({
+        gitRoot: opts.gitRoot,
+        workflowDir: opts.workflowDir,
+        taskId: opts.taskId,
+        branchHeadSha: opts.branchHeadSha,
+        metaHeadSha: opts.snapshot.meta.head_sha ?? null,
+        metaLastVerifiedSha: opts.snapshot.meta.last_verified_sha ?? null,
+        metaVerifyStatus: opts.snapshot.meta.verify?.status ?? null,
+        taskVerificationState: opts.taskVerificationState,
+        verifyLogText: opts.snapshot.texts.verifyLogText,
+        requiresVerify: opts.requiresVerify,
     });
+    opts.snapshot.freshnessEvaluated = true;
+    opts.snapshot.freshnessReviewFresh = freshness.reviewFresh;
+    opts.snapshot.freshnessVerifySatisfied = freshness.verifySatisfied;
+    opts.snapshot.freshnessVerifyFresh = freshness.verifyFresh;
+    opts.snapshot.freshnessVerifyLogSha = freshness.verifyLogSha;
+}
+function finalizeSnapshotErrors(opts) {
+    const errors = [...opts.snapshot.errors];
+    const meta = opts.snapshot.meta;
+    if (!meta)
+        return errors;
+    if (opts.branchHeadSha && opts.snapshot.freshnessEvaluated) {
+        if (!opts.snapshot.freshnessReviewFresh) {
+            errors.push(`PR artifacts stale: head_sha=${meta.head_sha ?? "<missing>"} current_head=${opts.branchHeadSha}`);
+        }
+        if (opts.requiresVerify && !opts.snapshot.freshnessVerifySatisfied) {
+            if (meta.verify?.status !== "pass") {
+                errors.push("Verify requirements not satisfied (meta.verify.status != pass)");
+            }
+            if ((!meta.last_verified_sha || !meta.last_verified_at) &&
+                !opts.snapshot.freshnessVerifyLogSha) {
+                errors.push("Verify metadata missing (last_verified_sha/last_verified_at)");
+            }
+        }
+        if (opts.requiresVerify && meta.last_verified_sha && !opts.snapshot.freshnessVerifyFresh) {
+            errors.push(`Verify state stale: last_verified_sha=${meta.last_verified_sha} current_head=${opts.branchHeadSha}`);
+        }
+        return errors;
+    }
+    if (opts.requiresVerify) {
+        if (meta.verify?.status !== "pass") {
+            errors.push("Verify requirements not satisfied (meta.verify.status != pass)");
+        }
+        if (!meta.last_verified_sha || !meta.last_verified_at) {
+            errors.push("Verify metadata missing (last_verified_sha/last_verified_at)");
+        }
+    }
+    return errors;
 }
 export async function cmdPrCheck(opts) {
     try {
@@ -57,7 +138,7 @@ export async function cmdPrCheck(opts) {
             rootOverride: opts.rootOverride,
             taskId: opts.taskId,
         });
-        const { resolved, config, prDir, metaPath, diffstatPath, verifyLogPath, reviewPath } = await resolvePrPaths({ ...opts, ctx });
+        const { resolved, config, prDir, metaPath, diffstatPath, verifyLogPath, reviewPath, githubTitlePath, githubBodyPath, } = await resolvePrPaths({ ...opts, ctx });
         if (config.workflow_mode !== "branch_pr") {
             throw new CliError({
                 exitCode: exitCodeForError("E_USAGE"),
@@ -71,72 +152,165 @@ export async function cmdPrCheck(opts) {
         const relDiffstatPath = path.relative(resolved.gitRoot, diffstatPath);
         const relVerifyLogPath = path.relative(resolved.gitRoot, verifyLogPath);
         const relReviewPath = path.relative(resolved.gitRoot, reviewPath);
+        const relGithubTitlePath = path.relative(resolved.gitRoot, githubTitlePath);
+        const relGithubBodyPath = path.relative(resolved.gitRoot, githubBodyPath);
         const branchCache = {};
-        let meta = null;
-        const metaText = await readPrArtifactWithOptionalBranch({
-            ctx,
-            resolved,
-            prDir,
-            fileName: "meta.json",
+        const requiresVerify = Boolean(task.verify && task.verify.length > 0);
+        const localTexts = {
+            metaText: await readLocalPrArtifactText(prDir, "meta.json"),
+            diffstatText: await readLocalPrArtifactText(prDir, "diffstat.txt"),
+            verifyLogText: await readLocalPrArtifactText(prDir, "verify.log"),
+            reviewText: await readLocalPrArtifactText(prDir, "review.md"),
+            githubTitleText: await readLocalPrArtifactText(prDir, "github-title.txt"),
+            githubBodyText: await readLocalPrArtifactText(prDir, "github-body.md"),
+        };
+        const localParsed = validateSnapshotContents({
+            texts: localTexts,
+            relPrDir,
+            relMetaPath,
+            relDiffstatPath,
+            relVerifyLogPath,
+            relReviewPath,
+            relGithubTitlePath,
+            relGithubBodyPath,
             taskId: task.id,
-            branchCache,
         });
-        if (metaText) {
+        const localSnapshot = {
+            source: "local",
+            texts: localTexts,
+            meta: localParsed.meta,
+            errors: localParsed.errors,
+            freshnessEvaluated: false,
+            freshnessReviewFresh: false,
+            freshnessVerifySatisfied: false,
+            freshnessVerifyFresh: false,
+            freshnessVerifyLogSha: null,
+        };
+        const localBranch = localSnapshot.meta?.branch?.trim() ?? "";
+        if (localBranch) {
+            branchCache.value = localBranch;
+        }
+        else if (branchCache.value === undefined) {
+            branchCache.value = await resolveArtifactBranch({
+                ctx,
+                resolved,
+                taskId: task.id,
+            });
+        }
+        const branchForFreshness = branchCache.value ?? null;
+        let branchHeadSha = null;
+        if (branchForFreshness) {
             try {
-                meta = parsePrMeta(metaText, task.id);
+                branchHeadSha = await gitRevParse(resolved.gitRoot, [branchForFreshness]);
             }
             catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                errors.push(message);
+                if (!isUnknownRevisionError(err))
+                    throw err;
             }
         }
-        else {
-            errors.push(`Missing PR directory: ${relPrDir}`, `Missing ${relMetaPath}`);
-        }
-        const diffstatText = await readPrArtifactWithOptionalBranch({
-            ctx,
-            resolved,
-            prDir,
-            fileName: "diffstat.txt",
-            taskId: task.id,
-            branchCache,
-        });
-        if (diffstatText === null) {
-            errors.push(`Missing ${relDiffstatPath}`);
-        }
-        const verifyLogText = await readPrArtifactWithOptionalBranch({
-            ctx,
-            resolved,
-            prDir,
-            fileName: "verify.log",
+        await evaluateSnapshotFreshness({
+            snapshot: localSnapshot,
+            gitRoot: resolved.gitRoot,
+            workflowDir: config.paths.workflow_dir,
             taskId: task.id,
-            branchCache,
+            branchHeadSha,
+            taskVerificationState: task.verification?.state ?? null,
+            requiresVerify,
         });
-        if (verifyLogText === null) {
-            errors.push(`Missing ${relVerifyLogPath}`);
-        }
-        const reviewText = await readPrArtifactWithOptionalBranch({
-            ctx,
-            resolved,
-            prDir,
-            fileName: "review.md",
-            taskId: task.id,
-            branchCache,
-        });
-        if (reviewText) {
-            validateReviewContents(reviewText, errors);
-        }
-        else {
-            errors.push(`Missing ${relReviewPath}`);
-        }
-        if (task.verify && task.verify.length > 0) {
-            if (meta?.verify?.status !== "pass") {
-                errors.push("Verify requirements not satisfied (meta.verify.status != pass)");
-            }
-            if (!meta?.last_verified_sha || !meta.last_verified_at) {
-                errors.push("Verify metadata missing (last_verified_sha/last_verified_at)");
+        let selectedSnapshot = localSnapshot;
+        if (branchForFreshness &&
+            branchHeadSha &&
+            (!localSnapshot.meta ||
+                !localSnapshot.freshnessReviewFresh ||
+                (requiresVerify && !localSnapshot.freshnessVerifySatisfied))) {
+            const worktreePath = await findWorktreeForBranch(resolved.gitRoot, branchForFreshness);
+            const branchTexts = {
+                metaText: await readPrArtifactFromBranch({
+                    resolved,
+                    prDir,
+                    fileName: "meta.json",
+                    branch: branchForFreshness,
+                    worktreePath,
+                }),
+                diffstatText: await readPrArtifactFromBranch({
+                    resolved,
+                    prDir,
+                    fileName: "diffstat.txt",
+                    branch: branchForFreshness,
+                    worktreePath,
+                }),
+                verifyLogText: await readPrArtifactFromBranch({
+                    resolved,
+                    prDir,
+                    fileName: "verify.log",
+                    branch: branchForFreshness,
+                    worktreePath,
+                }),
+                reviewText: await readPrArtifactFromBranch({
+                    resolved,
+                    prDir,
+                    fileName: "review.md",
+                    branch: branchForFreshness,
+                    worktreePath,
+                }),
+                githubTitleText: await readPrArtifactFromBranch({
+                    resolved,
+                    prDir,
+                    fileName: "github-title.txt",
+                    branch: branchForFreshness,
+                    worktreePath,
+                }),
+                githubBodyText: await readPrArtifactFromBranch({
+                    resolved,
+                    prDir,
+                    fileName: "github-body.md",
+                    branch: branchForFreshness,
+                    worktreePath,
+                }),
+            };
+            const branchParsed = validateSnapshotContents({
+                texts: branchTexts,
+                relPrDir,
+                relMetaPath,
+                relDiffstatPath,
+                relVerifyLogPath,
+                relReviewPath,
+                relGithubTitlePath,
+                relGithubBodyPath,
+                taskId: task.id,
+            });
+            const branchSnapshot = {
+                source: "branch",
+                texts: branchTexts,
+                meta: branchParsed.meta,
+                errors: branchParsed.errors,
+                freshnessEvaluated: false,
+                freshnessReviewFresh: false,
+                freshnessVerifySatisfied: false,
+                freshnessVerifyFresh: false,
+                freshnessVerifyLogSha: null,
+            };
+            await evaluateSnapshotFreshness({
+                snapshot: branchSnapshot,
+                gitRoot: resolved.gitRoot,
+                workflowDir: config.paths.workflow_dir,
+                taskId: task.id,
+                branchHeadSha,
+                taskVerificationState: task.verification?.state ?? null,
+                requiresVerify,
+            });
+            if (branchSnapshot.errors.length === 0 &&
+                branchSnapshot.meta &&
+                branchSnapshot.freshnessReviewFresh &&
+                (!requiresVerify || branchSnapshot.freshnessVerifySatisfied)) {
+                selectedSnapshot = branchSnapshot;
             }
         }
+        errors.push(...finalizeSnapshotErrors({
+            snapshot: selectedSnapshot,
+            branchHeadSha,
+            requiresVerify,
+        }));
         if (errors.length > 0) {
             throw new CliError({
                 exitCode: exitCodeForError("E_VALIDATION"),

package/dist/commands/pr/close-superseded.d.ts

@@ -0,0 +1,9 @@
+import { type CommandContext } from "../shared/task-backend.js";
+export declare function cmdPrCloseSuperseded(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string;
+    taskId: string;
+    deleteRemoteBranch: boolean;
+}): Promise<number>;
+//# sourceMappingURL=close-superseded.d.ts.map

package/dist/commands/pr/close-superseded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-superseded.d.ts","sourceRoot":"","sources":["../../../src/commands/pr/close-superseded.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,2BAA2B,CAAC;AAiCnC,wBAAsB,oBAAoB,CAAC,IAAI,EAAE;IAC/C,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,OAAO,CAAC;CAC7B,GAAG,OAAO,CAAC,MAAM,CAAC,CAsHlB"}

package/dist/commands/pr/close-superseded.js

@@ -0,0 +1,129 @@
+import { readFile } from "node:fs/promises";
+import { mapCoreError } from "../../cli/error-map.js";
+import { exitCodeForError } from "../../cli/exit-codes.js";
+import { createCliEmitter, infoMessage, workflowModeMessage } from "../../cli/output.js";
+import { fileExists } from "../../cli/fs-utils.js";
+import { CliError } from "../../shared/errors.js";
+import { loadBackendTask, loadCommandContext, } from "../shared/task-backend.js";
+import { parsePrMetaForwardCompatible } from "../shared/pr-meta.js";
+import { cmdPrClose } from "./close.js";
+import { isGhNotFound, resolveDefaultGithubRepo, runGhApiJson, runGhApiNoOutput, } from "./internal/gh-api.js";
+import { resolvePrPaths } from "./internal/pr-paths.js";
+async function deleteRemoteBranch(opts) {
+    const endpoint = `repos/${opts.repo}/git/refs/heads/${encodeURIComponent(opts.branch)}`;
+    try {
+        await runGhApiNoOutput(opts.cwd, [endpoint, "-X", "DELETE"]);
+        return "deleted";
+    }
+    catch (err) {
+        if (isGhNotFound(err))
+            return "already-absent";
+        throw err;
+    }
+}
+export async function cmdPrCloseSuperseded(opts) {
+    try {
+        const output = createCliEmitter();
+        const ctx = opts.ctx ??
+            (await loadCommandContext({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null }));
+        const { task } = await loadBackendTask({
+            ctx,
+            cwd: opts.cwd,
+            rootOverride: opts.rootOverride,
+            taskId: opts.taskId,
+        });
+        if (String(task.status ?? "")
+            .trim()
+            .toUpperCase() !== "DONE") {
+            throw new CliError({
+                exitCode: exitCodeForError("E_VALIDATION"),
+                code: "E_VALIDATION",
+                message: `Task ${opts.taskId} must be DONE before closing superseded PRs.`,
+            });
+        }
+        const { config, metaPath, resolved } = await resolvePrPaths({ ...opts, ctx });
+        if (config.workflow_mode !== "branch_pr") {
+            throw new CliError({
+                exitCode: exitCodeForError("E_USAGE"),
+                code: "E_USAGE",
+                message: workflowModeMessage(config.workflow_mode, "branch_pr"),
+            });
+        }
+        if (!(await fileExists(metaPath))) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_VALIDATION"),
+                code: "E_VALIDATION",
+                message: `Missing PR metadata: ${metaPath}`,
+            });
+        }
+        const meta = parsePrMetaForwardCompatible(await readFile(metaPath, "utf8"), opts.taskId);
+        const branch = meta.branch?.trim() ?? "";
+        if (!branch) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_VALIDATION"),
+                code: "E_VALIDATION",
+                message: `Missing PR branch for ${opts.taskId}`,
+            });
+        }
+        const repo = await resolveDefaultGithubRepo(resolved.gitRoot);
+        const owner = repo.split("/", 1)[0]?.trim() ?? "";
+        if (!owner) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_VALIDATION"),
+                code: "E_VALIDATION",
+                message: "Could not derive GitHub owner from remote origin.",
+            });
+        }
+        const openPrs = await runGhApiJson(resolved.gitRoot, [
+            `repos/${repo}/pulls?head=${encodeURIComponent(`${owner}:${branch}`)}&state=open&per_page=100`,
+        ]);
+        if (openPrs.length === 0) {
+            const remoteBranchAction = opts.deleteRemoteBranch
+                ? await deleteRemoteBranch({ cwd: resolved.gitRoot, repo, branch })
+                : "skipped";
+            output.report([
+                { label: "task", value: opts.taskId },
+                { label: "branch", value: branch },
+                { label: "state", value: "skipped" },
+                { label: "reason", value: "no open task PR found" },
+                { label: "remote_branch_action", value: remoteBranchAction },
+            ], { header: infoMessage(`pr close-superseded ${opts.taskId}`) });
+            return 0;
+        }
+        if (openPrs.length > 1) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_VALIDATION"),
+                code: "E_VALIDATION",
+                message: `Multiple open PRs match task ${opts.taskId} branch ${branch}: ${openPrs
+                    .map((pr) => pr.number)
+                    .filter((value) => typeof value === "number" && Number.isInteger(value) && value > 0)
+                    .map((value) => `#${value}`)
+                    .join(", ")}`,
+            });
+        }
+        const prNumber = Number(openPrs[0]?.number ?? 0);
+        if (!Number.isInteger(prNumber) || prNumber <= 0) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_VALIDATION"),
+                code: "E_VALIDATION",
+                message: `Could not determine open PR number for task ${opts.taskId}.`,
+            });
+        }
+        return await cmdPrClose({
+            ctx,
+            cwd: opts.cwd,
+            rootOverride: opts.rootOverride,
+            prNumber,
+            comment: `Superseded by protected-main closure of task ${opts.taskId}.`,
+            deleteRemoteBranch: opts.deleteRemoteBranch,
+        });
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        throw mapCoreError(err, {
+            command: "pr close-superseded",
+            root: opts.rootOverride ?? null,
+        });
+    }
+}

package/dist/commands/pr/close.d.ts

@@ -0,0 +1,11 @@
+import { type CommandContext } from "../shared/task-backend.js";
+export declare function cmdPrClose(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string;
+    prNumber: number;
+    repo?: string;
+    comment?: string;
+    deleteRemoteBranch: boolean;
+}): Promise<number>;
+//# sourceMappingURL=close.d.ts.map

package/dist/commands/pr/close.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"close.d.ts","sourceRoot":"","sources":["../../../src/commands/pr/close.ts"],"names":[],"mappings":"AAIA,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AA+CpF,wBAAsB,UAAU,CAAC,IAAI,EAAE;IACrC,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,OAAO,CAAC;CAC7B,GAAG,OAAO,CAAC,MAAM,CAAC,CAuGlB"}

package/dist/commands/pr/close.js

@@ -0,0 +1,116 @@
+import { mapCoreError } from "../../cli/error-map.js";
+import { exitCodeForError } from "../../cli/exit-codes.js";
+import { createCliEmitter, successMessage } from "../../cli/output.js";
+import { CliError } from "../../shared/errors.js";
+import { loadCommandContext } from "../shared/task-backend.js";
+import { isGhNotFound, resolveDefaultGithubRepo, runGhApiJson, runGhApiNoOutput, } from "./internal/gh-api.js";
+function ensureNonEmptyFlag(name, value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new CliError({
+            exitCode: exitCodeForError("E_USAGE"),
+            code: "E_USAGE",
+            message: `Invalid value for --${name}.`,
+        });
+    }
+    return trimmed;
+}
+export async function cmdPrClose(opts) {
+    try {
+        if (!Number.isInteger(opts.prNumber) || opts.prNumber <= 0) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_USAGE"),
+                code: "E_USAGE",
+                message: "Invalid PR number.",
+            });
+        }
+        const output = createCliEmitter();
+        const ctx = opts.ctx ??
+            (await loadCommandContext({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null }));
+        const commandCwd = ctx.resolvedProject.gitRoot;
+        const repo = opts.repo
+            ? ensureNonEmptyFlag("repo", opts.repo)
+            : await resolveDefaultGithubRepo(commandCwd);
+        const comment = opts.comment?.trim() ? ensureNonEmptyFlag("comment", opts.comment) : null;
+        const pr = await runGhApiJson(commandCwd, [
+            `repos/${repo}/pulls/${opts.prNumber}`,
+        ]);
+        if (!pr.number) {
+            throw new CliError({
+                exitCode: exitCodeForError("E_VALIDATION"),
+                code: "E_VALIDATION",
+                message: `GitHub pull request #${opts.prNumber} was not found in ${repo}.`,
+            });
+        }
+        if (comment) {
+            await runGhApiNoOutput(commandCwd, [
+                `repos/${repo}/issues/${opts.prNumber}/comments`,
+                "-X",
+                "POST",
+                "-f",
+                `body=${comment}`,
+            ]);
+        }
+        const closed = await runGhApiJson(commandCwd, [
+            `repos/${repo}/pulls/${opts.prNumber}`,
+            "-X",
+            "PATCH",
+            "-f",
+            "state=closed",
+        ]);
+        const headRepo = closed.head?.repo?.full_name?.trim() ?? pr.head?.repo?.full_name?.trim() ?? null;
+        const headRef = closed.head?.ref?.trim() ?? pr.head?.ref?.trim() ?? null;
+        let remoteBranchAction = "skipped";
+        if (opts.deleteRemoteBranch) {
+            if (!headRef) {
+                remoteBranchAction = "skipped-missing-head";
+            }
+            else if (headRepo && headRepo !== repo) {
+                remoteBranchAction = "skipped-fork";
+            }
+            else {
+                try {
+                    await runGhApiNoOutput(commandCwd, [
+                        `repos/${repo}/git/refs/heads/${encodeURIComponent(headRef)}`,
+                        "-X",
+                        "DELETE",
+                    ]);
+                    remoteBranchAction = "deleted";
+                }
+                catch (err) {
+                    if (isGhNotFound(err)) {
+                        remoteBranchAction = "already-absent";
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+        }
+        const result = {
+            repo,
+            prNumber: opts.prNumber,
+            url: closed.html_url?.trim() ?? pr.html_url?.trim() ?? null,
+            state: closed.state?.trim() ?? pr.state?.trim() ?? "closed",
+            comment: comment ? "added" : "skipped",
+            remoteBranch: headRef,
+            remoteBranchAction,
+        };
+        output.report([
+            { label: "repo", value: result.repo },
+            { label: "state", value: result.state },
+            { label: "url", value: result.url ?? "unknown" },
+            { label: "comment", value: result.comment },
+            { label: "remote_branch", value: result.remoteBranch ?? "unknown" },
+            { label: "remote_branch_action", value: result.remoteBranchAction },
+        ], {
+            header: successMessage("pr close", `#${result.prNumber}`),
+        });
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        throw mapCoreError(err, { command: "pr close", root: opts.rootOverride ?? null });
+    }
+}

package/dist/commands/pr/index.d.ts

@@ -2,5 +2,7 @@ export { cmdPrOpen } from "./open.js";
 export { cmdPrUpdate } from "./update.js";
 export { cmdPrCheck } from "./check.js";
 export { cmdPrNote } from "./note.js";
+export { cmdPrClose } from "./close.js";
+export { cmdPrCloseSuperseded } from "./close-superseded.js";
 export { cmdIntegrate } from "./integrate.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/pr/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/pr/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/pr/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/commands/pr/index.js

@@ -2,4 +2,6 @@ export { cmdPrOpen } from "./open.js";
 export { cmdPrUpdate } from "./update.js";
 export { cmdPrCheck } from "./check.js";
 export { cmdPrNote } from "./note.js";
+export { cmdPrClose } from "./close.js";
+export { cmdPrCloseSuperseded } from "./close-superseded.js";
 export { cmdIntegrate } from "./integrate.js";