agentplane 0.1.9 → 0.2.0

package/dist/commands/pr/integrate/artifacts.d.ts

@@ -0,0 +1,14 @@
+import type { CommandContext } from "../../shared/task-backend.js";
+export declare function readAndValidatePrArtifacts(opts: {
+    ctx: CommandContext;
+    resolved: {
+        gitRoot: string;
+    };
+    prDir: string;
+    metaPath: string;
+    branch: string;
+    taskId: string;
+}): Promise<{
+    verifyLogText: string | null;
+}>;
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/commands/pr/integrate/artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../../../../src/commands/pr/integrate/artifacts.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAWnE,wBAAsB,0BAA0B,CAAC,IAAI,EAAE;IACrD,GAAG,EAAE,cAAc,CAAC;IACpB,QAAQ,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC;IACV,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B,CAAC,CA0CD"}

package/dist/commands/pr/integrate/artifacts.js

@@ -0,0 +1,45 @@
+import path from "node:path";
+import { CliError } from "../../../shared/errors.js";
+import { readPrArtifact } from "../internal/pr-paths.js";
+import { validateReviewContents } from "../internal/review-template.js";
+export async function readAndValidatePrArtifacts(opts) {
+    const readPrArtifactTyped = readPrArtifact;
+    const { prDir } = opts;
+    const diffstatPath = path.join(prDir, "diffstat.txt");
+    const verifyLogPath = path.join(prDir, "verify.log");
+    const reviewPath = path.join(prDir, "review.md");
+    const errors = [];
+    const relDiffstat = path.relative(opts.resolved.gitRoot, diffstatPath);
+    const relVerifyLog = path.relative(opts.resolved.gitRoot, verifyLogPath);
+    const relReview = path.relative(opts.resolved.gitRoot, reviewPath);
+    const diffstatText = await readPrArtifactTyped({
+        resolved: opts.resolved,
+        prDir,
+        fileName: "diffstat.txt",
+        branch: opts.branch,
+    });
+    if (diffstatText === null)
+        errors.push(`Missing ${relDiffstat}`);
+    const verifyLogText = await readPrArtifactTyped({
+        resolved: opts.resolved,
+        prDir,
+        fileName: "verify.log",
+        branch: opts.branch,
+    });
+    if (verifyLogText === null)
+        errors.push(`Missing ${relVerifyLog}`);
+    const reviewText = await readPrArtifactTyped({
+        resolved: opts.resolved,
+        prDir,
+        fileName: "review.md",
+        branch: opts.branch,
+    });
+    if (reviewText === null)
+        errors.push(`Missing ${relReview}`);
+    if (reviewText)
+        validateReviewContents(reviewText, errors);
+    if (errors.length > 0) {
+        throw new CliError({ exitCode: 3, code: "E_VALIDATION", message: errors.join("\n") });
+    }
+    return { verifyLogText };
+}

package/dist/commands/pr/integrate/cmd.d.ts

@@ -0,0 +1,14 @@
+import type { CommandContext } from "../../shared/task-backend.js";
+export declare function cmdIntegrate(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string;
+    taskId: string;
+    branch?: string;
+    base?: string;
+    mergeStrategy: "squash" | "merge" | "rebase";
+    runVerify: boolean;
+    dryRun: boolean;
+    quiet: boolean;
+}): Promise<number>;
+//# sourceMappingURL=cmd.d.ts.map

package/dist/commands/pr/integrate/cmd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cmd.d.ts","sourceRoot":"","sources":["../../../../src/commands/pr/integrate/cmd.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAQnE,wBAAsB,YAAY,CAAC,IAAI,EAAE;IACvC,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;IAC7C,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CAqKlB"}

package/dist/commands/pr/integrate/cmd.js

@@ -0,0 +1,150 @@
+import { mapBackendError } from "../../../cli/error-map.js";
+import { successMessage } from "../../../cli/output.js";
+import { CliError } from "../../../shared/errors.js";
+import { execFileAsync, gitEnv } from "../../shared/git.js";
+import { gitRevParse } from "../../shared/git-ops.js";
+import { finalizeIntegrate } from "./internal/finalize.js";
+import { runMergeCommit, runRebaseFastForward, runSquashMerge } from "./internal/merge.js";
+import { prepareIntegrate } from "./internal/prepare.js";
+import { resolveWorktreeForIntegrate } from "./internal/worktree.js";
+import { runVerifyCommands } from "./verify.js";
+export async function cmdIntegrate(opts) {
+    let tempWorktreePath = null;
+    let createdTempWorktree = false;
+    try {
+        const prepared = await prepareIntegrate({
+            ctx: opts.ctx,
+            cwd: opts.cwd,
+            rootOverride: opts.rootOverride,
+            taskId: opts.taskId,
+            branch: opts.branch,
+            base: opts.base,
+            runVerify: opts.runVerify,
+        });
+        const { resolved, loadedConfig, task, prDir, metaPath, diffstatPath, verifyLogPath, metaSource, branch, base, verifyLogText, } = prepared;
+        const verifyCommands = prepared.verifyCommands;
+        let alreadyVerifiedSha = prepared.alreadyVerifiedSha;
+        let shouldRunVerify = prepared.shouldRunVerify;
+        let branchHeadSha = prepared.branchHeadSha;
+        if (opts.dryRun) {
+            if (!opts.quiet) {
+                process.stdout.write(`${successMessage("integrate dry-run", task.id, `base=${base} branch=${branch} verify=${shouldRunVerify ? "yes" : "no"}`)}\n`);
+            }
+            return 0;
+        }
+        const wt = await resolveWorktreeForIntegrate({
+            gitRoot: resolved.gitRoot,
+            worktreesDirRel: loadedConfig.paths.worktrees_dir,
+            branch,
+            taskId: task.id,
+            mergeStrategy: opts.mergeStrategy,
+            shouldRunVerify,
+        });
+        let worktreePath = wt.worktreePath;
+        tempWorktreePath = wt.tempWorktreePath;
+        createdTempWorktree = wt.createdTempWorktree;
+        const verifyEntries = [];
+        if (opts.mergeStrategy !== "rebase" && shouldRunVerify && verifyCommands.length > 0) {
+            if (!worktreePath) {
+                throw new CliError({
+                    exitCode: 2,
+                    code: "E_USAGE",
+                    message: "Unable to locate or create a worktree for verify execution",
+                });
+            }
+            verifyEntries.push(...(await runVerifyCommands({
+                commands: verifyCommands,
+                worktreePath,
+                branchHeadSha,
+                quiet: opts.quiet,
+                taskId: task.id,
+            })));
+        }
+        const baseShaBeforeMerge = await gitRevParse(resolved.gitRoot, [base]);
+        const headBeforeMerge = await gitRevParse(resolved.gitRoot, ["HEAD"]);
+        let mergeHash = "";
+        if (opts.mergeStrategy === "squash") {
+            mergeHash = await runSquashMerge({
+                gitRoot: resolved.gitRoot,
+                base,
+                branch,
+                headBeforeMerge,
+                taskId: task.id,
+                genericTokens: loadedConfig.commit.generic_tokens,
+            });
+        }
+        else if (opts.mergeStrategy === "merge") {
+            mergeHash = await runMergeCommit({ gitRoot: resolved.gitRoot, branch, taskId: task.id });
+        }
+        else {
+            if (!worktreePath) {
+                throw new CliError({
+                    exitCode: 2,
+                    code: "E_USAGE",
+                    message: "rebase strategy requires an existing worktree for the task branch",
+                });
+            }
+            const rebaseRes = await runRebaseFastForward({
+                gitRoot: resolved.gitRoot,
+                worktreePath,
+                base,
+                branch,
+                headBeforeMerge,
+                rawVerify: task.verify,
+                metaSource: metaSource ?? null,
+                verifyLogText,
+                runVerify: opts.runVerify,
+                verifyCommands,
+                alreadyVerifiedSha,
+                shouldRunVerify,
+                quiet: opts.quiet,
+                taskId: task.id,
+            });
+            mergeHash = rebaseRes.mergeHash;
+            branchHeadSha = rebaseRes.branchHeadSha;
+            alreadyVerifiedSha = rebaseRes.alreadyVerifiedSha;
+            shouldRunVerify = rebaseRes.shouldRunVerify;
+            verifyEntries.push(...rebaseRes.verifyEntries);
+        }
+        await finalizeIntegrate({
+            cwd: opts.cwd,
+            rootOverride: opts.rootOverride,
+            gitRoot: resolved.gitRoot,
+            prDir,
+            metaPath,
+            diffstatPath,
+            verifyLogPath,
+            taskId: task.id,
+            branch,
+            base,
+            mergeStrategy: opts.mergeStrategy,
+            mergeHash,
+            branchHeadSha,
+            baseShaBeforeMerge,
+            verifyEntries,
+            verifyCommands,
+            alreadyVerifiedSha,
+            shouldRunVerify,
+            quiet: opts.quiet,
+        });
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        throw mapBackendError(err, { command: "integrate", root: opts.rootOverride ?? null });
+    }
+    finally {
+        if (createdTempWorktree && tempWorktreePath) {
+            try {
+                await execFileAsync("git", ["worktree", "remove", "--force", tempWorktreePath], {
+                    cwd: opts.cwd,
+                    env: gitEnv(),
+                });
+            }
+            catch {
+                // ignore cleanup errors
+            }
+        }
+    }
+}

package/dist/commands/pr/integrate/internal/finalize.d.ts

@@ -0,0 +1,25 @@
+export declare function finalizeIntegrate(opts: {
+    cwd: string;
+    rootOverride?: string;
+    gitRoot: string;
+    prDir: string;
+    metaPath: string;
+    diffstatPath: string;
+    verifyLogPath: string;
+    taskId: string;
+    branch: string;
+    base: string;
+    mergeStrategy: "squash" | "merge" | "rebase";
+    mergeHash: string;
+    branchHeadSha: string;
+    baseShaBeforeMerge: string;
+    verifyEntries: {
+        header: string;
+        content: string;
+    }[];
+    verifyCommands: string[];
+    alreadyVerifiedSha: string | null;
+    shouldRunVerify: boolean;
+    quiet: boolean;
+}): Promise<void>;
+//# sourceMappingURL=finalize.d.ts.map

package/dist/commands/pr/integrate/internal/finalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize.d.ts","sourceRoot":"","sources":["../../../../../src/commands/pr/integrate/internal/finalize.ts"],"names":[],"mappings":"AAmBA,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IAEf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAE3B,aAAa,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACrD,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;IAEzB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsFhB"}

package/dist/commands/pr/integrate/internal/finalize.js

@@ -0,0 +1,86 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { fileExists } from "../../../../cli/fs-utils.js";
+import { successMessage } from "../../../../cli/output.js";
+import { CliError } from "../../../../shared/errors.js";
+import { writeJsonStableIfChanged, writeTextIfChanged, } from "../../../../shared/write-if-changed.js";
+import { gitDiffStat } from "../../../shared/git-diff.js";
+import { appendVerifyLog, parsePrMeta } from "../../../shared/pr-meta.js";
+import { cmdFinish } from "../../../task/index.js";
+function nowIso() {
+    return new Date().toISOString();
+}
+export async function finalizeIntegrate(opts) {
+    if (!(await fileExists(opts.prDir))) {
+        throw new CliError({
+            exitCode: 3,
+            code: "E_VALIDATION",
+            message: `Missing PR artifact dir after merge: ${path.relative(opts.gitRoot, opts.prDir)}`,
+        });
+    }
+    if (opts.verifyEntries.length > 0) {
+        for (const entry of opts.verifyEntries) {
+            await appendVerifyLog(opts.verifyLogPath, entry.header, entry.content);
+        }
+    }
+    const rawMeta = await readFile(opts.metaPath, "utf8");
+    const mergedMeta = parsePrMeta(rawMeta, opts.taskId);
+    const now = nowIso();
+    const nextMeta = {
+        ...mergedMeta,
+        branch: opts.branch,
+        base: opts.base,
+        merge_strategy: opts.mergeStrategy,
+        status: "MERGED",
+        merged_at: mergedMeta.merged_at ?? now,
+        merge_commit: opts.mergeHash,
+        head_sha: opts.branchHeadSha,
+        updated_at: now,
+    };
+    if (opts.verifyCommands.length > 0 && (opts.shouldRunVerify || opts.alreadyVerifiedSha)) {
+        nextMeta.last_verified_sha = opts.branchHeadSha;
+        nextMeta.last_verified_at = now;
+        nextMeta.verify = mergedMeta.verify
+            ? { ...mergedMeta.verify, status: "pass" }
+            : { status: "pass", command: opts.verifyCommands.join(" && ") };
+    }
+    await writeJsonStableIfChanged(opts.metaPath, nextMeta);
+    const diffstat = await gitDiffStat(opts.gitRoot, opts.baseShaBeforeMerge, opts.branch);
+    await writeTextIfChanged(opts.diffstatPath, diffstat ? `${diffstat}\n` : "");
+    const verifyDesc = opts.verifyCommands.length === 0
+        ? "skipped(no commands)"
+        : opts.shouldRunVerify
+            ? "ran"
+            : opts.alreadyVerifiedSha
+                ? `skipped(already verified_sha=${opts.alreadyVerifiedSha})`
+                : "skipped";
+    const finishBody = `Verified: Integrated via ${opts.mergeStrategy}; verify=${verifyDesc}; pr=${path.relative(opts.gitRoot, opts.prDir)}.`;
+    await cmdFinish({
+        cwd: opts.cwd,
+        rootOverride: opts.rootOverride,
+        taskIds: [opts.taskId],
+        author: "INTEGRATOR",
+        body: finishBody,
+        result: `integrate: ${opts.mergeStrategy} ${opts.branch}`,
+        risk: undefined,
+        breaking: false,
+        commit: undefined,
+        force: false,
+        commitFromComment: false,
+        commitEmoji: undefined,
+        commitAllow: [],
+        commitAutoAllow: false,
+        commitAllowTasks: false,
+        commitRequireClean: false,
+        statusCommit: false,
+        statusCommitEmoji: undefined,
+        statusCommitAllow: [],
+        statusCommitAutoAllow: false,
+        statusCommitRequireClean: false,
+        confirmStatusCommit: false,
+        quiet: opts.quiet,
+    });
+    if (!opts.quiet) {
+        process.stdout.write(`${successMessage("integrate", opts.taskId, `merge=${opts.mergeHash.slice(0, 12)}`)}\n`);
+    }
+}

package/dist/commands/pr/integrate/internal/merge.d.ts

@@ -0,0 +1,40 @@
+import type { PrMeta } from "../../../shared/pr-meta.js";
+export declare function runSquashMerge(opts: {
+    gitRoot: string;
+    base: string;
+    branch: string;
+    headBeforeMerge: string;
+    taskId: string;
+    genericTokens: string[];
+}): Promise<string>;
+export declare function runMergeCommit(opts: {
+    gitRoot: string;
+    branch: string;
+    taskId: string;
+}): Promise<string>;
+export declare function runRebaseFastForward(opts: {
+    gitRoot: string;
+    worktreePath: string;
+    base: string;
+    branch: string;
+    headBeforeMerge: string;
+    rawVerify: string[];
+    metaSource: PrMeta | null;
+    verifyLogText: string;
+    runVerify: boolean;
+    verifyCommands: string[];
+    alreadyVerifiedSha: string | null;
+    shouldRunVerify: boolean;
+    quiet: boolean;
+    taskId: string;
+}): Promise<{
+    mergeHash: string;
+    branchHeadSha: string;
+    verifyEntries: {
+        header: string;
+        content: string;
+    }[];
+    alreadyVerifiedSha: string | null;
+    shouldRunVerify: boolean;
+}>;
+//# sourceMappingURL=merge.d.ts.map

package/dist/commands/pr/integrate/internal/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../../../src/commands/pr/integrate/internal/merge.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAIzD,wBAAsB,cAAc,CAAC,IAAI,EAAE;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,GAAG,OAAO,CAAC,MAAM,CAAC,CAuElB;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CAoBlB;AAED,wBAAsB,oBAAoB,CAAC,IAAI,EAAE;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC;IACV,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACrD,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC,CAsDD"}

package/dist/commands/pr/integrate/internal/merge.js

@@ -0,0 +1,138 @@
+import { extractTaskSuffix, validateCommitSubject } from "@agentplaneorg/core";
+import { CliError } from "../../../../shared/errors.js";
+import { execFileAsync, gitEnv } from "../../../shared/git.js";
+import { gitRevParse } from "../../../shared/git-ops.js";
+import { computeVerifyState, runVerifyCommands } from "../verify.js";
+export async function runSquashMerge(opts) {
+    try {
+        await execFileAsync("git", ["merge", "--squash", opts.branch], {
+            cwd: opts.gitRoot,
+            env: gitEnv(),
+        });
+    }
+    catch (err) {
+        await execFileAsync("git", ["reset", "--hard", opts.headBeforeMerge], {
+            cwd: opts.gitRoot,
+            env: gitEnv(),
+        });
+        const message = err instanceof Error ? err.message : "git merge --squash failed";
+        throw new CliError({ exitCode: 2, code: "E_GIT", message });
+    }
+    const { stdout: staged } = await execFileAsync("git", ["diff", "--cached", "--name-only"], {
+        cwd: opts.gitRoot,
+        env: gitEnv(),
+    });
+    if (!staged.trim()) {
+        await execFileAsync("git", ["reset", "--hard", opts.headBeforeMerge], {
+            cwd: opts.gitRoot,
+            env: gitEnv(),
+        });
+        throw new CliError({
+            exitCode: 2,
+            code: "E_USAGE",
+            message: `Nothing to integrate: ${opts.branch} is already merged into ${opts.base}`,
+        });
+    }
+    const { stdout: subjectOut } = await execFileAsync("git", ["log", "-1", "--pretty=format:%s", opts.branch], {
+        cwd: opts.gitRoot,
+        env: gitEnv(),
+    });
+    let subject = subjectOut.trim();
+    const subjectPolicy = validateCommitSubject({
+        subject,
+        taskId: opts.taskId,
+        genericTokens: opts.genericTokens,
+    });
+    if (!subjectPolicy.ok) {
+        const suffix = extractTaskSuffix(opts.taskId);
+        subject = `🧩 ${suffix} integrate: squash ${opts.branch}`;
+    }
+    const env = {
+        ...process.env,
+        AGENTPLANE_TASK_ID: opts.taskId,
+        AGENTPLANE_ALLOW_BASE: "1",
+        AGENTPLANE_ALLOW_TASKS: "0",
+    };
+    try {
+        await execFileAsync("git", ["commit", "-m", subject], {
+            cwd: opts.gitRoot,
+            env,
+        });
+    }
+    catch (err) {
+        await execFileAsync("git", ["reset", "--hard", opts.headBeforeMerge], {
+            cwd: opts.gitRoot,
+            env: gitEnv(),
+        });
+        const message = err instanceof Error ? err.message : "git commit failed";
+        throw new CliError({ exitCode: 2, code: "E_GIT", message });
+    }
+    return await gitRevParse(opts.gitRoot, ["HEAD"]);
+}
+export async function runMergeCommit(opts) {
+    const suffix = extractTaskSuffix(opts.taskId);
+    const env = {
+        ...process.env,
+        AGENTPLANE_TASK_ID: opts.taskId,
+        AGENTPLANE_ALLOW_BASE: "1",
+        AGENTPLANE_ALLOW_TASKS: "0",
+    };
+    try {
+        await execFileAsync("git", ["merge", "--no-ff", opts.branch, "-m", `🔀 ${suffix} integrate: merge ${opts.branch}`], { cwd: opts.gitRoot, env });
+    }
+    catch (err) {
+        await execFileAsync("git", ["merge", "--abort"], { cwd: opts.gitRoot, env: gitEnv() });
+        const message = err instanceof Error ? err.message : "git merge failed";
+        throw new CliError({ exitCode: 2, code: "E_GIT", message });
+    }
+    return await gitRevParse(opts.gitRoot, ["HEAD"]);
+}
+export async function runRebaseFastForward(opts) {
+    try {
+        await execFileAsync("git", ["rebase", opts.base], { cwd: opts.worktreePath, env: gitEnv() });
+    }
+    catch (err) {
+        await execFileAsync("git", ["rebase", "--abort"], { cwd: opts.worktreePath, env: gitEnv() });
+        const message = err instanceof Error ? err.message : "git rebase failed";
+        throw new CliError({ exitCode: 2, code: "E_GIT", message });
+    }
+    let branchHeadSha = await gitRevParse(opts.gitRoot, [opts.branch]);
+    let alreadyVerifiedSha = opts.alreadyVerifiedSha;
+    let shouldRunVerify = opts.shouldRunVerify;
+    if (!opts.runVerify && opts.verifyCommands.length > 0) {
+        ({ alreadyVerifiedSha, shouldRunVerify } = computeVerifyState({
+            rawVerify: opts.rawVerify,
+            metaLastVerifiedSha: opts.metaSource?.last_verified_sha ?? null,
+            verifyLogText: opts.verifyLogText,
+            branchHeadSha,
+            runVerify: false,
+        }));
+    }
+    const verifyEntries = [];
+    if (shouldRunVerify && opts.verifyCommands.length > 0) {
+        verifyEntries.push(...(await runVerifyCommands({
+            commands: opts.verifyCommands,
+            worktreePath: opts.worktreePath,
+            branchHeadSha,
+            quiet: opts.quiet,
+            taskId: opts.taskId,
+        })));
+    }
+    try {
+        await execFileAsync("git", ["merge", "--ff-only", opts.branch], {
+            cwd: opts.gitRoot,
+            env: gitEnv(),
+        });
+    }
+    catch (err) {
+        await execFileAsync("git", ["reset", "--hard", opts.headBeforeMerge], {
+            cwd: opts.gitRoot,
+            env: gitEnv(),
+        }).catch(() => null);
+        const message = err instanceof Error ? err.message : "git merge --ff-only failed";
+        throw new CliError({ exitCode: 2, code: "E_GIT", message });
+    }
+    const mergeHash = await gitRevParse(opts.gitRoot, ["HEAD"]);
+    branchHeadSha = await gitRevParse(opts.gitRoot, [opts.branch]);
+    return { mergeHash, branchHeadSha, verifyEntries, alreadyVerifiedSha, shouldRunVerify };
+}

package/dist/commands/pr/integrate/internal/prepare.d.ts

@@ -0,0 +1,33 @@
+import { loadBackendTask, type CommandContext } from "../../../shared/task-backend.js";
+import { type PrMeta } from "../../../shared/pr-meta.js";
+export type PreparedIntegrate = {
+    ctx: CommandContext;
+    resolved: CommandContext["resolvedProject"];
+    loadedConfig: CommandContext["config"];
+    task: Awaited<ReturnType<typeof loadBackendTask>>["task"];
+    baseBranch: string;
+    currentBranch: string;
+    prDir: string;
+    metaPath: string;
+    diffstatPath: string;
+    verifyLogPath: string;
+    meta: PrMeta | null;
+    metaSource: PrMeta;
+    branch: string;
+    base: string;
+    verifyLogText: string;
+    branchHeadSha: string;
+    verifyCommands: string[];
+    alreadyVerifiedSha: string | null;
+    shouldRunVerify: boolean;
+};
+export declare function prepareIntegrate(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string;
+    taskId: string;
+    branch?: string;
+    base?: string;
+    runVerify: boolean;
+}): Promise<PreparedIntegrate>;
+//# sourceMappingURL=prepare.d.ts.map

package/dist/commands/pr/integrate/internal/prepare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare.d.ts","sourceRoot":"","sources":["../../../../../src/commands/pr/integrate/internal/prepare.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,eAAe,EAEf,KAAK,cAAc,EACpB,MAAM,iCAAiC,CAAC;AAUzC,OAAO,EAAe,KAAK,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEtE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,cAAc,CAAC;IACpB,QAAQ,EAAE,cAAc,CAAC,iBAAiB,CAAC,CAAC;IAC5C,YAAY,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;IACvC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAE1D,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IAEtB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IAEtB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IAEb,aAAa,EAAE,MAAM,CAAC;IAEtB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,wBAAsB,gBAAgB,CAAC,IAAI,EAAE;IAC3C,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;CACpB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAoJ7B"}