agentplane 0.3.13 → 0.3.14

package/dist/commands/pr/internal/sync.js

@@ -1,337 +1,78 @@
-import { mkdir, readFile, rm } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
 import path from "node:path";
-import { extractTaskSuffix, resolveBaseBranch } from "@agentplaneorg/core";
+import { resolveBaseBranch } from "@agentplaneorg/core";
 import { mapBackendError } from "../../../cli/error-map.js";
 import { exitCodeForError } from "../../../cli/exit-codes.js";
 import { fileExists } from "../../../cli/fs-utils.js";
 import { workflowModeMessage } from "../../../cli/output.js";
 import { CliError } from "../../../shared/errors.js";
-import { writeJsonStableIfChanged, writeTextIfChanged } from "../../../shared/write-if-changed.js";
-import { execFileAsync, gitEnv } from "../../shared/git.js";
-import { gitDiffStat } from "../../shared/git-diff.js";
-import { gitBranchUpstream, gitCurrentBranch } from "../../shared/git-ops.js";
-import { parseTaskIdFromBranch } from "../../shared/git-worktree.js";
-import { isTransientGhTransportError, normalizeGhTransportError, withGhTransportRetry, } from "../../shared/gh-transport.js";
 import { INCIDENTS_POLICY_PATH } from "../../incidents/shared.js";
-import { buildObservedGithubPrMeta, buildOpenedPrMeta, buildUpdatedPrMeta, resolvePrArtifactHeadSha, parsePrMeta, } from "../../shared/pr-meta.js";
+import { resolvePrArtifactHeadSha, parsePrMeta } from "../../shared/pr-meta.js";
 import { isTaskLocalOnlyAdvance } from "../../shared/task-local-freshness.js";
 import { loadBackendTask, loadCommandContext, } from "../../shared/task-backend.js";
 import { resolvePrPaths } from "./pr-paths.js";
 import { readPrHandoffNotes } from "./note-store.js";
-import { ghEnv } from "./gh-api.js";
-import { buildGithubPrTitle, renderGithubPrBody, renderPrAutoSummary, renderPrReviewDocument, } from "./review-template.js";
-function nowIso() {
-    return new Date().toISOString();
-}
-async function readTextIfExists(filePath) {
-    try {
-        return await readFile(filePath, "utf8");
-    }
-    catch (err) {
-        const code = err?.code;
-        if (code === "ENOENT")
-            return null;
-        throw err;
-    }
-}
-async function restoreIncidentRegistryIfNeeded(opts) {
-    const incidentsPath = path.join(opts.gitRoot, INCIDENTS_POLICY_PATH);
-    const nextText = await readTextIfExists(incidentsPath);
-    if (nextText === opts.previousText)
-        return;
-    if (opts.previousText === null) {
-        await rm(incidentsPath, { force: true });
-        return;
-    }
-    await writeTextIfChanged(incidentsPath, opts.previousText);
-}
-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) ||
-        /bad revision/i.test(message) ||
-        /ambiguous argument/i.test(message));
-}
-function parseGithubRepoFromRemoteUrl(remoteUrl) {
-    const trimmed = remoteUrl.trim();
-    if (!trimmed)
-        return null;
-    const httpsMatch = /^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/.exec(trimmed);
-    if (httpsMatch)
-        return `${httpsMatch[1]}/${httpsMatch[2]}`;
-    const sshMatch = /^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/.exec(trimmed);
-    if (sshMatch)
-        return `${sshMatch[1]}/${sshMatch[2]}`;
-    return null;
-}
-async function resolveGithubRepoFromOrigin(gitRoot) {
-    try {
-        const { stdout } = await execFileAsync("git", ["remote", "get-url", "origin"], {
-            cwd: gitRoot,
-            env: gitEnv(),
-        });
-        return parseGithubRepoFromRemoteUrl(stdout);
-    }
-    catch {
-        return null;
-    }
-}
-function normalizeObservedGithubPr(record) {
-    const number = Number(record.number);
-    if (!Number.isInteger(number) || number <= 0)
-        return null;
-    const state = record.state?.trim().toLowerCase() ?? "";
-    const mergedAt = record.merged_at?.trim() ?? null;
-    const status = mergedAt && mergedAt.length > 0
-        ? "MERGED"
-        : state === "open"
-            ? "OPEN"
-            : state === "closed"
-                ? "CLOSED"
-                : null;
-    if (!status)
-        return null;
-    const prUrl = record.html_url?.trim() ?? null;
-    const mergeCommit = record.merge_commit_sha?.trim() ?? null;
-    const base = record.base?.ref?.trim() ?? null;
-    const headSha = record.head?.sha?.trim() ?? null;
-    return {
-        prNumber: number,
-        prUrl,
-        status,
-        mergedAt,
-        mergeCommit,
-        base,
-        headSha,
-    };
-}
-async function tryLookupExistingGithubPrByBranch(opts) {
-    const repo = await resolveGithubRepoFromOrigin(opts.gitRoot);
-    if (!repo)
-        return null;
-    const owner = repo.split("/")[0]?.trim() ?? "";
-    if (!owner)
-        return null;
-    const query = new URLSearchParams({ state: "all", head: `${owner}:${opts.branch}` });
-    const baseBranch = opts.baseBranch?.trim() ?? "";
-    if (baseBranch)
-        query.set("base", baseBranch);
-    const endpoint = `repos/${repo}/pulls?${query.toString()}`;
-    try {
-        const { stdout } = await withGhTransportRetry(() => execFileAsync("gh", ["api", endpoint], {
-            cwd: opts.gitRoot,
-            env: ghEnv(),
-            maxBuffer: 10 * 1024 * 1024,
-        }), { label: `running gh api ${endpoint}` });
-        const parsed = JSON.parse(stdout);
-        if (!Array.isArray(parsed) || parsed.length === 0)
-            return null;
-        for (const record of parsed) {
-            const observed = normalizeObservedGithubPr(record);
-            if (observed)
-                return observed;
-        }
-        return null;
-    }
-    catch (err) {
-        const code = err?.code;
-        if (code === "ENOENT")
-            return null;
-        const message = normalizeGhTransportError(err);
-        if (message.trim().length > 0)
-            return null;
-        return null;
-    }
-}
-function formatGithubPrLink(prNumber, prUrl, verb) {
-    return prUrl?.trim()
-        ? `${verb} GitHub PR #${prNumber}: ${prUrl.trim()}`
-        : `${verb} GitHub PR #${prNumber}`;
-}
-function shouldPersistObservedGithubPrMeta(observed) {
-    if (!observed)
-        return false;
-    return observed.status === "MERGED";
-}
-function taskPrArtifactRefreshMessage(taskId) {
-    return `📝 ${extractTaskSuffix(taskId)} task: refresh PR artifacts`;
-}
-async function resolveRenderableBranchHead(opts) {
-    const branchHeadSha = await resolveBranchHeadSha({
-        gitRoot: opts.gitRoot,
+import { currentBranchMatchesTask, resolvePrSyncBranch, resolveRenderableBranchHead, } from "./sync-branch.js";
+import { runPrOpenSync } from "./sync-open-step.js";
+import { nowIso, readTextIfExists, restoreIncidentRegistryIfNeeded } from "./sync-support.js";
+import { runPrUpdateSync } from "./sync-update-step.js";
+async function buildPrSyncCommonState(opts) {
+    const handoffNotes = await readPrHandoffNotes(opts.notesPath);
+    const now = nowIso();
+    const createdAt = opts.existingMeta?.created_at ?? now;
+    const { headSha, artifactRefresh } = await resolveRenderableBranchHead({
+        gitRoot: opts.resolved.gitRoot,
+        taskId: opts.task.id,
         branch: opts.branch,
     });
-    if (!branchHeadSha)
-        return { headSha: null, artifactRefresh: false };
-    try {
-        const { stdout: subjectStdout } = await execFileAsync("git", ["log", "-1", "--pretty=%s", branchHeadSha], {
-            cwd: opts.gitRoot,
-            env: gitEnv(),
-        });
-        const subject = subjectStdout.trim();
-        return {
-            headSha: branchHeadSha,
-            artifactRefresh: subject === taskPrArtifactRefreshMessage(opts.taskId),
-        };
-    }
-    catch {
-        return { headSha: branchHeadSha, artifactRefresh: false };
-    }
-}
-function formatUnpublishedRemoteHeadReason(branch) {
-    return (`task branch ${branch} is not yet published on origin; push it with ` +
-        `\`git push -u origin ${branch}\` and rerun \`agentplane pr open\``);
-}
-function isMissingRemoteHeadCreateError(err) {
-    const text = normalizeGhTransportError(err);
-    if (!/\b422\b/i.test(text))
-        return false;
-    return (/head sha/i.test(text) ||
-        /head ref/i.test(text) ||
-        /head.*must be a branch/i.test(text) ||
-        /head.*not found/i.test(text) ||
-        /field["']?\s*:\s*["']head["']/i.test(text) ||
-        /field\s+head\b/i.test(text) ||
-        /no commits between/i.test(text));
-}
-function summarizeGithubPrCreateFailure(err) {
-    const text = normalizeGhTransportError(err);
-    if (err?.code === "ENOENT") {
-        return "gh CLI is unavailable";
-    }
-    if (/authentication required/i.test(text) ||
-        /not logged into github/i.test(text) ||
-        /bad credentials/i.test(text) ||
-        /permission denied/i.test(text) ||
-        /\b401\b/i.test(text) ||
-        /\b403\b/i.test(text)) {
-        return "GitHub auth or permissions unavailable";
-    }
-    if (isTransientGhTransportError(err)) {
-        return "GitHub transport failed; retry `agentplane pr open`";
-    }
-    return "GitHub PR creation failed";
-}
-async function tryCreateGithubPr(opts) {
-    const repo = await resolveGithubRepoFromOrigin(opts.gitRoot);
-    if (!repo) {
-        return {
-            observed: null,
-            stagedReason: "GitHub origin repo unavailable",
-        };
-    }
-    const baseBranch = opts.baseBranch?.trim() ?? "";
-    if (!baseBranch) {
-        return {
-            observed: null,
-            stagedReason: "base branch unresolved",
-        };
-    }
-    try {
-        const { stdout } = await withGhTransportRetry(() => execFileAsync("gh", [
-            "api",
-            `repos/${repo}/pulls`,
-            "-X",
-            "POST",
-            "-f",
-            `title=${opts.title}`,
-            "-f",
-            `body=${opts.body}`,
-            "-f",
-            `head=${opts.branch}`,
-            "-f",
-            `base=${baseBranch}`,
-        ], {
-            cwd: opts.gitRoot,
-            env: ghEnv(),
-            maxBuffer: 10 * 1024 * 1024,
-        }), { label: `running gh api repos/${repo}/pulls` });
-        return {
-            observed: normalizeObservedGithubPr(JSON.parse(stdout)),
-            stagedReason: null,
-        };
-    }
-    catch (err) {
-        if (isMissingRemoteHeadCreateError(err)) {
-            return {
-                observed: null,
-                stagedReason: formatUnpublishedRemoteHeadReason(opts.branch),
-            };
-        }
-        return {
-            observed: null,
-            stagedReason: summarizeGithubPrCreateFailure(err),
-        };
-    }
-}
-async function resolveBranchHeadSha(opts) {
-    try {
-        const { stdout } = await execFileAsync("git", ["rev-parse", opts.branch], {
-            cwd: opts.gitRoot,
-            env: gitEnv(),
+    const preservePreviousHead = Boolean(opts.existingMeta?.head_sha) &&
+        Boolean(headSha) &&
+        (await isTaskLocalOnlyAdvance({
+            gitRoot: opts.resolved.gitRoot,
+            workflowDir: opts.workflowDir,
+            tasksPath: opts.tasksPath,
+            taskId: opts.task.id,
+            fromRef: opts.existingMeta?.head_sha ?? null,
+            toRef: headSha,
+        }));
+    const renderedHeadSha = artifactRefresh
+        ? (opts.existingMeta?.head_sha ?? undefined)
+        : resolvePrArtifactHeadSha({
+            previousHeadSha: opts.existingMeta?.head_sha ?? null,
+            currentHeadSha: headSha,
+            preservePrevious: preservePreviousHead,
         });
-        return stdout.trim() || null;
-    }
-    catch (err) {
-        if (!isUnknownRevisionError(err))
-            throw err;
-        return null;
-    }
-}
-async function computePrDiffstat(opts) {
-    const diffBaseRef = await resolvePrDiffBaseRef({
-        gitRoot: opts.gitRoot,
+    const preservedRenderUpdatedAt = opts.existingMeta &&
+        (opts.existingMeta.branch ?? null) === opts.branch &&
+        (opts.existingMeta.base ?? null) === (opts.baseBranch ?? null) &&
+        (opts.existingMeta.head_sha ?? null) === (renderedHeadSha ?? null)
+        ? opts.existingMeta.updated_at
+        : null;
+    const renderUpdatedAt = preservedRenderUpdatedAt ?? now;
+    return {
+        task: opts.task,
+        resolved: opts.resolved,
+        workflowDir: opts.workflowDir,
+        tasksPath: opts.tasksPath,
+        prDir: opts.prDir,
+        metaPath: opts.metaPath,
+        diffstatPath: opts.diffstatPath,
+        notesPath: opts.notesPath,
+        verifyLogPath: opts.verifyLogPath,
+        reviewPath: opts.reviewPath,
+        githubTitlePath: opts.githubTitlePath,
+        githubBodyPath: opts.githubBodyPath,
+        existingMeta: opts.existingMeta,
+        handoffNotes,
+        now,
+        createdAt,
+        branch: opts.branch,
         baseBranch: opts.baseBranch,
-    });
-    const taskDir = path.dirname(opts.prDir);
-    try {
-        return await gitDiffStat(opts.gitRoot, diffBaseRef, opts.branch, {
-            excludePaths: [
-                path.relative(opts.gitRoot, opts.prDir),
-                path.relative(opts.gitRoot, path.join(taskDir, "README.md")),
-            ],
-        });
-    }
-    catch (err) {
-        if (!isUnknownRevisionError(err))
-            throw err;
-        return "";
-    }
-}
-async function resolvePrDiffBaseRef(opts) {
-    const upstreamRef = await gitBranchUpstream(opts.gitRoot, opts.baseBranch);
-    const candidate = upstreamRef?.trim() ?? "";
-    if (!candidate)
-        return opts.baseBranch;
-    try {
-        const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", candidate], {
-            cwd: opts.gitRoot,
-            env: gitEnv(),
-        });
-        return stdout.trim() ? candidate : opts.baseBranch;
-    }
-    catch (err) {
-        if (!isUnknownRevisionError(err))
-            throw err;
-        return opts.baseBranch;
-    }
-}
-async function resolvePrSyncBranch(opts) {
-    const explicitBranch = opts.branch?.trim() ?? "";
-    if (explicitBranch) {
-        return { branch: explicitBranch, source: "explicit" };
-    }
-    if (await fileExists(opts.metaPath)) {
-        const metaBranch = parsePrMeta(await readFile(opts.metaPath, "utf8"), opts.taskId).branch?.trim() ?? "";
-        if (metaBranch) {
-            return { branch: metaBranch, source: "meta" };
-        }
-    }
-    const currentBranchValue = await gitCurrentBranch(opts.resolved.gitRoot);
-    const currentBranch = currentBranchValue.trim();
-    if (currentBranch) {
-        return { branch: currentBranch, source: "current" };
-    }
-    return { branch: null, source: "none" };
+        headSha,
+        artifactRefresh,
+        renderedHeadSha,
+        renderUpdatedAt,
+    };
 }
 export async function ensurePrArtifactsSynced(opts) {
     const ctx = opts.ctx ??
@@ -340,7 +81,7 @@ export async function ensurePrArtifactsSynced(opts) {
     if (config.workflow_mode !== "branch_pr")
         return null;
     const resolvedBranch = await resolvePrSyncBranch({
-        resolved,
+        gitRoot: resolved.gitRoot,
         metaPath,
         taskId: opts.taskId,
         branch: opts.branch,
@@ -349,7 +90,7 @@ export async function ensurePrArtifactsSynced(opts) {
     if (!branch)
         return null;
     if (resolvedBranch.source === "current" &&
-        parseTaskIdFromBranch(config.branch.task_prefix, branch) !== opts.taskId) {
+        !currentBranchMatchesTask(config.branch.task_prefix, branch, opts.taskId)) {
         return null;
     }
     const baseBranch = await resolveBaseBranch({
@@ -402,7 +143,7 @@ export async function syncPrArtifacts(opts) {
                 });
             }
             const resolvedBranch = await resolvePrSyncBranch({
-                resolved,
+                gitRoot: resolved.gitRoot,
                 metaPath,
                 taskId: task.id,
                 branch: opts.branch,
@@ -433,226 +174,39 @@ export async function syncPrArtifacts(opts) {
             const existingMeta = metaExists && (await fileExists(metaPath))
                 ? parsePrMeta(await readFile(metaPath, "utf8"), task.id)
                 : null;
-            const handoffNotes = await readPrHandoffNotes(notesPath);
-            const now = nowIso();
-            const createdAt = existingMeta?.created_at ?? now;
             const baseBranch = await resolveBaseBranch({
                 cwd: opts.cwd,
                 rootOverride: opts.rootOverride ?? null,
                 cliBaseOpt: null,
                 mode: config.workflow_mode,
             });
-            const { headSha, artifactRefresh } = await resolveRenderableBranchHead({
-                gitRoot: resolved.gitRoot,
-                taskId: task.id,
+            const common = await buildPrSyncCommonState({
+                task,
+                resolved,
+                workflowDir: config.paths.workflow_dir,
+                tasksPath: config.paths.tasks_path,
+                prDir,
+                metaPath,
+                diffstatPath,
+                notesPath,
+                verifyLogPath,
+                reviewPath,
+                githubTitlePath,
+                githubBodyPath,
+                existingMeta,
                 branch,
+                baseBranch,
             });
-            const preservePreviousHead = Boolean(existingMeta?.head_sha) &&
-                Boolean(headSha) &&
-                (await isTaskLocalOnlyAdvance({
-                    gitRoot: resolved.gitRoot,
-                    workflowDir: config.paths.workflow_dir,
-                    tasksPath: config.paths.tasks_path,
-                    taskId: task.id,
-                    fromRef: existingMeta?.head_sha ?? null,
-                    toRef: headSha,
-                }));
-            const renderedHeadSha = artifactRefresh
-                ? (existingMeta?.head_sha ?? undefined)
-                : resolvePrArtifactHeadSha({
-                    previousHeadSha: existingMeta?.head_sha ?? null,
-                    currentHeadSha: headSha,
-                    preservePrevious: preservePreviousHead,
-                });
-            const preservedRenderUpdatedAt = existingMeta &&
-                (existingMeta.branch ?? null) === branch &&
-                (existingMeta.base ?? null) === (baseBranch ?? null) &&
-                (existingMeta.head_sha ?? null) === (renderedHeadSha ?? null)
-                ? existingMeta.updated_at
-                : null;
-            const renderUpdatedAt = preservedRenderUpdatedAt ?? now;
             if (opts.mode === "open") {
                 const remoteMode = opts.remoteMode ?? "auto";
-                const diffstat = baseBranch
-                    ? await computePrDiffstat({
-                        gitRoot: resolved.gitRoot,
-                        baseBranch,
-                        branch,
-                        prDir,
-                    })
-                    : "";
-                const renderedSummaryHeadSha = artifactRefresh
-                    ? renderedHeadSha
-                    : (renderedHeadSha ?? headSha);
-                let nextMeta = buildOpenedPrMeta({
-                    taskId: task.id,
-                    branch,
-                    at: now,
-                    previousMeta: existingMeta,
-                    base: baseBranch,
-                    headSha: renderedHeadSha,
-                });
-                const linkedExistingOutcome = typeof nextMeta.pr_number === "number" && nextMeta.pr_number > 0
-                    ? {
-                        action: "linked-existing",
-                        message: formatGithubPrLink(nextMeta.pr_number, nextMeta.pr_url ?? null, "linked to"),
-                    }
-                    : null;
-                let openOutcome;
-                const githubTitle = buildGithubPrTitle(task);
-                const githubBody = renderGithubPrBody({
-                    task,
-                    handoffNotes,
-                    autoSummary: renderPrAutoSummary({
-                        updatedAt: renderUpdatedAt,
-                        branch,
-                        headSha: renderedSummaryHeadSha ?? null,
-                        diffstat,
-                    }),
-                });
-                const observedGithubPr = await tryLookupExistingGithubPrByBranch({
-                    gitRoot: resolved.gitRoot,
-                    branch,
-                    baseBranch,
-                });
-                if (observedGithubPr) {
-                    if (shouldPersistObservedGithubPrMeta(observedGithubPr)) {
-                        nextMeta = buildObservedGithubPrMeta({
-                            meta: nextMeta,
-                            observed: observedGithubPr,
-                            at: now,
-                        });
-                    }
-                    openOutcome = {
-                        action: "linked-existing",
-                        message: formatGithubPrLink(observedGithubPr.prNumber, observedGithubPr.prUrl, "linked to"),
-                    };
-                }
-                else if (remoteMode === "sync-only") {
-                    openOutcome = linkedExistingOutcome ?? {
-                        action: "sync-only",
-                        message: "local PR artifacts synced; remote PR creation skipped (--sync-only)",
-                    };
-                }
-                else {
-                    const createdGithubPr = await tryCreateGithubPr({
-                        gitRoot: resolved.gitRoot,
-                        branch,
-                        baseBranch,
-                        title: githubTitle,
-                        body: githubBody,
-                    });
-                    if (createdGithubPr.observed) {
-                        if (shouldPersistObservedGithubPrMeta(createdGithubPr.observed)) {
-                            nextMeta = buildObservedGithubPrMeta({
-                                meta: nextMeta,
-                                observed: createdGithubPr.observed,
-                                at: now,
-                            });
-                        }
-                        openOutcome = {
-                            action: "created",
-                            message: formatGithubPrLink(createdGithubPr.observed.prNumber, createdGithubPr.observed.prUrl, "created"),
-                        };
-                    }
-                    else {
-                        openOutcome = linkedExistingOutcome ?? {
-                            action: "staged",
-                            message: `local PR artifacts synced; remote PR creation staged (${createdGithubPr.stagedReason ?? "remote creation unavailable"})`,
-                        };
-                    }
-                }
-                const nextAutoSummary = renderPrAutoSummary({
-                    updatedAt: renderUpdatedAt,
-                    branch,
-                    headSha: renderedSummaryHeadSha ?? null,
-                    diffstat,
-                });
-                const nextReview = renderPrReviewDocument({
-                    task,
+                const { meta, openOutcome } = await runPrOpenSync(common, {
                     author: opts.author,
-                    createdAt,
-                    branch,
-                    handoffNotes,
-                    autoSummary: nextAutoSummary,
-                });
-                const nextGithubBody = renderGithubPrBody({
-                    task,
-                    handoffNotes,
-                    autoSummary: nextAutoSummary,
-                });
-                await writeJsonStableIfChanged(metaPath, nextMeta);
-                await writeTextIfChanged(diffstatPath, diffstat ? `${diffstat}\n` : "");
-                if (!(await fileExists(notesPath))) {
-                    await writeTextIfChanged(notesPath, "");
-                }
-                if (!(await fileExists(verifyLogPath))) {
-                    await writeTextIfChanged(verifyLogPath, "");
-                }
-                await writeTextIfChanged(reviewPath, nextReview);
-                await writeTextIfChanged(githubTitlePath, `${githubTitle}\n`);
-                await writeTextIfChanged(githubBodyPath, nextGithubBody);
-                return { meta: nextMeta, prDir, resolved, openOutcome };
-            }
-            if (!baseBranch) {
-                throw new CliError({
-                    exitCode: exitCodeForError("E_USAGE"),
-                    code: "E_USAGE",
-                    message: "Base branch could not be resolved (use `agentplane branch base set`).",
+                    remoteMode,
                 });
+                return { meta, prDir, resolved, openOutcome };
             }
-            const diffstat = await computePrDiffstat({
-                gitRoot: resolved.gitRoot,
-                baseBranch,
-                branch,
-                prDir,
-            });
-            let nextMeta = buildUpdatedPrMeta({
-                meta: existingMeta,
-                branch,
-                at: now,
-                base: baseBranch,
-                headSha: renderedHeadSha,
-            });
-            const observedGithubPr = await tryLookupExistingGithubPrByBranch({
-                gitRoot: resolved.gitRoot,
-                branch,
-                baseBranch,
-            });
-            if (shouldPersistObservedGithubPrMeta(observedGithubPr)) {
-                nextMeta = buildObservedGithubPrMeta({
-                    meta: nextMeta,
-                    observed: observedGithubPr,
-                    at: now,
-                });
-            }
-            const nextAutoSummary = renderPrAutoSummary({
-                updatedAt: nextMeta.updated_at,
-                branch,
-                headSha: artifactRefresh
-                    ? (nextMeta.head_sha ?? renderedHeadSha ?? null)
-                    : (nextMeta.head_sha ?? renderedHeadSha ?? headSha ?? null),
-                diffstat,
-            });
-            const nextReview = renderPrReviewDocument({
-                task,
-                createdAt,
-                branch,
-                handoffNotes,
-                autoSummary: nextAutoSummary,
-            });
-            const githubTitle = buildGithubPrTitle(task);
-            const githubBody = renderGithubPrBody({
-                task,
-                handoffNotes,
-                autoSummary: nextAutoSummary,
-            });
-            await writeTextIfChanged(diffstatPath, diffstat ? `${diffstat}\n` : "");
-            await writeTextIfChanged(reviewPath, nextReview);
-            await writeTextIfChanged(githubTitlePath, `${githubTitle}\n`);
-            await writeTextIfChanged(githubBodyPath, githubBody);
-            await writeJsonStableIfChanged(metaPath, nextMeta);
-            return { meta: nextMeta, prDir, resolved };
+            const { meta } = await runPrUpdateSync(common);
+            return { meta, prDir, resolved };
         }
         finally {
             await restoreIncidentRegistryIfNeeded({

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

@@ -1 +1 @@
-{"version":3,"file":"open.d.ts","sourceRoot":"","sources":["../../../src/commands/pr/open.ts"],"names":[],"mappings":"AAQA,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAuCpF,wBAAsB,SAAS,CAAC,IAAI,EAAE;IACpC,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,OAAO,CAAC,MAAM,CAAC,CAgElB"}
+{"version":3,"file":"open.d.ts","sourceRoot":"","sources":["../../../src/commands/pr/open.ts"],"names":[],"mappings":"AAQA,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAuDpF,wBAAsB,SAAS,CAAC,IAAI,EAAE;IACpC,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,OAAO,CAAC,MAAM,CAAC,CAgElB"}