@sireai/optimus 0.1.1

package/dist/task-environment/delivery/task-publication-service.js

@@ -0,0 +1,1369 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { promisify } from "node:util";
+import { collectBusinessChangePaths, filterBusinessChangeEntries, parseGitStatusOutput } from "../orchestration/git-change-classifier.js";
+import { CommitMessageBuilder } from "./commit-message/commit-message-builder.js";
+const execFileAsync = promisify(execFile);
+const EXEC_MAX_BUFFER = 4 * 1024 * 1024;
+export class TaskPublicationService {
+    logger;
+    commitMessageBuilder = new CommitMessageBuilder();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async publish(input) {
+        const createdAt = new Date().toISOString();
+        const publication = input.bundle.publication;
+        if (!publication?.applicable) {
+            return {
+                attempts: [this.buildAttempt(input.bundle, {
+                        mode: input.dryRun ? "dry_run" : "review_submit",
+                        status: "skipped",
+                        summary: "Publication not applicable for this task.",
+                        createdAt
+                    })],
+                artifacts: []
+            };
+        }
+        if (!publication.hasPatch) {
+            return {
+                attempts: [this.buildAttempt(input.bundle, {
+                        mode: input.dryRun ? "dry_run" : "review_submit",
+                        status: "skipped",
+                        summary: "Publication skipped because no patch artifact was produced.",
+                        createdAt
+                    })],
+                artifacts: []
+            };
+        }
+        if (publication.action !== "ready_for_publish") {
+            return {
+                attempts: [this.buildAttempt(input.bundle, {
+                        mode: input.dryRun ? "dry_run" : "review_submit",
+                        status: "skipped",
+                        summary: `Publication not ready: ${publication.reason ?? publication.action}.`,
+                        createdAt
+                    })],
+                artifacts: []
+            };
+        }
+        const planContext = this.resolvePlanContext(input.bundle, input.reviewMode ?? "auto", input.dryRun);
+        if (!input.dryRun && planContext.reviewSystem.strategy === "manual") {
+            return {
+                attempts: [this.buildAttempt(input.bundle, {
+                        mode: "review_submit",
+                        status: "skipped",
+                        summary: "Review submission skipped because only manual handoff is available.",
+                        createdAt
+                    })],
+                artifacts: []
+            };
+        }
+        const artifactDir = input.context?.addresses.artifactDir;
+        if (!artifactDir) {
+            return {
+                attempts: [this.buildAttempt(input.bundle, {
+                        mode: input.dryRun ? "dry_run" : "review_submit",
+                        status: "failed",
+                        summary: `Publication ${input.dryRun ? "dry-run" : "review-submit"} failed because artifactDir is missing.`,
+                        createdAt,
+                        error: "artifact_dir_missing"
+                    })],
+                artifacts: []
+            };
+        }
+        await mkdir(artifactDir, { recursive: true });
+        if (input.dryRun) {
+            const artifactPath = join(artifactDir, "publication-plan.md");
+            await writeFile(artifactPath, this.renderPlan(input.bundle, planContext), "utf8");
+            return {
+                attempts: [this.buildAttempt(input.bundle, {
+                        mode: "dry_run",
+                        status: "planned",
+                        summary: `Publication dry-run plan generated for ${planContext.reviewSystem.strategy} -> ${this.renderTarget(input.bundle)}.`,
+                        createdAt,
+                        artifactPath
+                    })],
+                artifacts: [{
+                        kind: "publication_plan",
+                        path: artifactPath,
+                        createdAt
+                    }]
+            };
+        }
+        const taskRootDir = input.context?.taskRootDir;
+        if (!taskRootDir) {
+            return {
+                attempts: [this.buildAttempt(input.bundle, {
+                        mode: "review_submit",
+                        status: "failed",
+                        summary: "Review submission failed because taskRootDir is missing.",
+                        createdAt,
+                        error: "task_root_missing"
+                    })],
+                artifacts: []
+            };
+        }
+        const packetPath = join(artifactDir, "review-packet.md");
+        try {
+            const execution = await this.executeReviewSubmit(input.bundle, planContext, input.context, taskRootDir, artifactDir);
+            await writeFile(packetPath, this.renderReviewPacket(input.bundle, planContext, execution.records), "utf8");
+            return {
+                attempts: [this.buildAttempt(input.bundle, {
+                        mode: "review_submit",
+                        status: execution.status,
+                        summary: execution.summary,
+                        createdAt,
+                        artifactPath: packetPath,
+                        ...(this.collectReviewMetadata(execution.records))
+                    })],
+                artifacts: [{
+                        kind: "review_packet",
+                        path: packetPath,
+                        createdAt
+                    }]
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await this.logger?.error("task.publication.review_submit.failed", {
+                taskId: input.bundle.taskId,
+                taskType: input.bundle.taskType,
+                publicationStrategy: planContext.reviewSystem.strategy,
+                reviewSystemType: planContext.reviewSystem.type,
+                reason: this.compact(message)
+            });
+            await writeFile(packetPath, this.renderReviewPacket(input.bundle, planContext, [{
+                    label: "publication",
+                    status: "failed",
+                    strategy: planContext.reviewSystem.strategy,
+                    detail: message
+                }]), "utf8");
+            return {
+                attempts: [this.buildAttempt(input.bundle, {
+                        mode: "review_submit",
+                        status: "failed",
+                        summary: `Review submission failed: ${this.compact(message)}`,
+                        createdAt,
+                        artifactPath: packetPath,
+                        error: this.compact(message)
+                    })],
+                artifacts: [{
+                        kind: "review_packet",
+                        path: packetPath,
+                        createdAt
+                    }]
+            };
+        }
+    }
+    buildAttempt(bundle, attempt) {
+        return {
+            taskId: bundle.taskId,
+            ...(bundle.runId ? { runId: bundle.runId } : {}),
+            ...attempt
+        };
+    }
+    resolvePlanContext(bundle, reviewMode, dryRun) {
+        const publication = bundle.publication;
+        const projectTargets = publication?.git?.repoProjects ?? [];
+        return {
+            mode: dryRun ? "dry_run" : "review_submit",
+            projectTargets,
+            reviewSystem: this.resolveEffectiveReviewSystem(bundle, reviewMode, projectTargets)
+        };
+    }
+    resolveEffectiveReviewSystem(bundle, reviewMode, projectTargets) {
+        const detected = bundle.publication?.git?.reviewSystem;
+        if (reviewMode !== "auto") {
+            return this.buildOverrideReviewSystem(reviewMode, detected);
+        }
+        if (detected) {
+            return detected;
+        }
+        const projectStrategies = [...new Set(projectTargets
+                .map((project) => project.reviewSystem?.strategy)
+                .filter((value) => Boolean(value)))];
+        if (projectStrategies.length > 1) {
+            return {
+                type: "mixed",
+                strategy: "manual"
+            };
+        }
+        const firstProjectStrategy = projectStrategies[0];
+        if (firstProjectStrategy) {
+            return this.buildReviewSystemFromStrategy(firstProjectStrategy);
+        }
+        return {
+            type: "unknown",
+            strategy: "manual"
+        };
+    }
+    buildOverrideReviewSystem(reviewMode, detected) {
+        const strategyByMode = {
+            gerrit: "gerrit_change",
+            github: "github_pr",
+            manual: "manual"
+        };
+        const typeByMode = {
+            gerrit: "gerrit",
+            github: "github",
+            manual: "unknown"
+        };
+        return {
+            ...(detected ?? {}),
+            type: typeByMode[reviewMode],
+            strategy: strategyByMode[reviewMode]
+        };
+    }
+    buildReviewSystemFromStrategy(strategy) {
+        switch (strategy) {
+            case "gerrit_change":
+                return { type: "gerrit", strategy };
+            case "github_pr":
+                return { type: "github", strategy };
+            default:
+                return { type: "unknown", strategy: "manual" };
+        }
+    }
+    renderTarget(bundle) {
+        const publication = bundle.publication;
+        if (publication?.git?.upstreamRemote && publication.git.upstreamBranch) {
+            return `${publication.git.upstreamRemote}/${publication.git.upstreamBranch}`;
+        }
+        if (publication?.git?.repoProjects?.length) {
+            return `${publication.git.repoProjects.length} project target(s)`;
+        }
+        if (publication?.git?.targetBranch) {
+            return publication.git.targetSource === "manifest_revision"
+                ? `manifest revision ${publication.git.targetBranch}`
+                : publication.git.targetBranch;
+        }
+        return "upstream target";
+    }
+    renderPlan(bundle, plan) {
+        const publication = bundle.publication;
+        const lines = [
+            "# Publication Plan",
+            "",
+            "## Summary",
+            "",
+            `- Task: ${bundle.taskId}`,
+            `- Task Type: ${bundle.taskType}`,
+            `- Outcome: ${bundle.outcome}`,
+            `- Decision: ${bundle.summary.decision}`,
+            `- Mode: ${plan.mode}`,
+            `- Workspace Kind: ${publication?.git?.workspaceKind ?? "unknown"}`,
+            `- Publication Action: ${publication?.action ?? "none"}`,
+            `- Publication Reason: ${publication?.reason ?? "n/a"}`,
+            `- Branch: ${publication?.git?.branch ?? "n/a"}`,
+            `- Upstream: ${publication?.git?.upstreamRemote && publication.git.upstreamBranch ? `${publication.git.upstreamRemote}/${publication.git.upstreamBranch}` : "n/a"}`,
+            `- Manifest Revision: ${publication?.git?.manifestRevision ?? "n/a"}`,
+            `- Target Branch: ${publication?.git?.targetBranch ?? "n/a"}`,
+            `- Target Source: ${publication?.git?.targetSource ?? "n/a"}`,
+            `- Review System: ${this.renderReviewSystem(plan.reviewSystem)}`,
+            `- Patch: ${bundle.artifacts.patchDiff ?? "n/a"}`,
+            "",
+            "## Review Strategy",
+            "",
+            ...this.renderStrategySection(bundle, plan),
+            "",
+            "## Project Targets",
+            "",
+            ...(plan.projectTargets.length > 0
+                ? plan.projectTargets.map((project) => this.renderProjectTarget(project))
+                : ["- n/a"]),
+            ...(publication?.git?.unresolvedPaths?.length ? ["", `- Unresolved Paths: ${publication.git.unresolvedPaths.join(", ")}`] : []),
+            "",
+            "## Planned Next Step",
+            "",
+            ...this.renderPlannedNextSteps(bundle, plan.reviewSystem.strategy),
+            "",
+            "## Notes",
+            "",
+            "- Review submission stays decoupled from delivery notification.",
+            "- Patch publication remains review-first; no direct branch push is planned."
+        ];
+        return lines.join("\n");
+    }
+    renderReviewSystem(reviewSystem) {
+        const parts = [`${reviewSystem.type} (${reviewSystem.strategy})`];
+        if (reviewSystem.remoteName) {
+            parts.push(reviewSystem.remoteName);
+        }
+        if (reviewSystem.repository) {
+            parts.push(reviewSystem.repository);
+        }
+        return parts.join(" | ");
+    }
+    renderStrategySection(bundle, plan) {
+        const workspaceKind = bundle.publication?.git?.workspaceKind;
+        switch (plan.reviewSystem.strategy) {
+            case "gerrit_change":
+                if (workspaceKind === "repo_managed") {
+                    return this.renderRepoManagedGerritStrategy(bundle, plan.projectTargets, plan.reviewSystem);
+                }
+                return this.renderGerritStrategy(bundle, plan.projectTargets, plan.reviewSystem);
+            case "github_pr":
+                return this.renderGithubStrategy(bundle, plan.projectTargets, plan.reviewSystem);
+            default:
+                return this.renderManualStrategy(bundle, plan.projectTargets, plan.reviewSystem);
+        }
+    }
+    renderRepoManagedGerritStrategy(bundle, projectTargets, reviewSystem) {
+        const targets = projectTargets.length > 0 ? projectTargets : [this.buildRootProjectTarget(bundle)];
+        const topic = targets.length > 1 ? this.buildTopic(bundle.taskId) : undefined;
+        return [
+            `- Strategy: split the patch by repo project, create commits in each project, then submit Gerrit changes per project${topic ? " with a shared topic" : ""}.`,
+            `- Submit: git push <remote> HEAD:refs/for/<branch>${topic ? `%topic=${topic}` : ""}`,
+            ...targets.map((target) => {
+                const effectiveReviewSystem = target.reviewSystem?.strategy ? target.reviewSystem : reviewSystem;
+                return `- ${this.renderTargetLabel(target)}: ${target.targetBranch ?? bundle.publication?.git?.targetBranch ?? "target branch unresolved"} | ${effectiveReviewSystem.remoteName ?? "origin"}`;
+            })
+        ];
+    }
+    renderGerritStrategy(bundle, projectTargets, reviewSystem) {
+        const targets = projectTargets.length > 0 ? projectTargets : [this.buildRootProjectTarget(bundle)];
+        const topic = targets.length > 1 ? this.buildTopic(bundle.taskId) : undefined;
+        const commands = targets.map((target) => {
+            const effectiveReviewSystem = target.reviewSystem?.strategy ? target.reviewSystem : reviewSystem;
+            const remote = target.upstreamRemote ?? effectiveReviewSystem.remoteName ?? "origin";
+            const branch = this.normalizeGerritTarget(target.targetBranch ?? bundle.publication?.git?.targetBranch);
+            if (!branch) {
+                return `- ${this.renderTargetLabel(target)}: missing target branch; cannot form refs/for push plan.`;
+            }
+            return `- ${this.renderTargetLabel(target)}: git push ${remote} ${this.buildGerritPushRef(branch, topic)}`;
+        });
+        return [
+            "- Strategy: create Gerrit changes via refs/for review refs.",
+            ...commands
+        ];
+    }
+    renderGithubStrategy(bundle, projectTargets, reviewSystem) {
+        const targets = projectTargets.length > 0 ? projectTargets : [this.buildRootProjectTarget(bundle)];
+        const commands = targets.flatMap((target) => {
+            const effectiveReviewSystem = target.reviewSystem?.strategy ? target.reviewSystem : reviewSystem;
+            const branchName = this.buildGithubBranchName(bundle.taskId, target.projectPath);
+            const remote = target.upstreamRemote ?? effectiveReviewSystem.remoteName ?? "origin";
+            const baseBranch = this.normalizeGitHubBaseBranch(target.targetBranch ?? bundle.publication?.git?.targetBranch);
+            const label = this.renderTargetLabel(target);
+            if (!baseBranch) {
+                return [`- ${label}: missing base branch; cannot form PR plan.`];
+            }
+            return [
+                `- ${label}: git push ${remote} HEAD:refs/heads/${branchName}`,
+                `- ${label}: gh pr create --base ${baseBranch} --head ${branchName}`
+            ];
+        });
+        return [
+            "- Strategy: push a review branch, then open a GitHub pull request.",
+            ...commands
+        ];
+    }
+    renderManualStrategy(bundle, projectTargets, reviewSystem) {
+        const targets = projectTargets.length > 0 ? projectTargets : [this.buildRootProjectTarget(bundle)];
+        return [
+            `- Strategy: manual review delivery because detected review path is ${reviewSystem.type}/${reviewSystem.strategy}.`,
+            ...targets.map((target) => `- ${this.renderTargetLabel(target)}: attach patch/result artifacts and hand off against ${target.targetBranch ?? bundle.publication?.git?.targetBranch ?? "target branch unresolved"}.`)
+        ];
+    }
+    buildRootProjectTarget(bundle) {
+        const git = bundle.publication?.git;
+        return {
+            projectPath: ".",
+            ...(git?.upstreamRemote ? { upstreamRemote: git.upstreamRemote } : {}),
+            ...(git?.upstreamBranch ? { upstreamBranch: git.upstreamBranch } : {}),
+            ...(git?.manifestRevision ? { manifestRevision: git.manifestRevision } : {}),
+            ...(git?.targetBranch ? { targetBranch: git.targetBranch } : {}),
+            ...(git?.targetSource ? { targetSource: git.targetSource } : {}),
+            ...(git?.reviewSystem ? { reviewSystem: git.reviewSystem } : {})
+        };
+    }
+    renderProjectTarget(project) {
+        const parts = [`- ${project.projectPath}: ${project.targetBranch ?? "n/a"} (${project.targetSource ?? "unknown"})`];
+        if (project.upstreamRemote && project.upstreamBranch) {
+            parts.push(`${project.upstreamRemote}/${project.upstreamBranch}`);
+        }
+        if (project.reviewSystem) {
+            parts.push(`${project.reviewSystem.type}/${project.reviewSystem.strategy}`);
+        }
+        return parts.join(" | ");
+    }
+    renderTargetLabel(target) {
+        return target.projectPath === "." ? "repo-root" : target.projectPath;
+    }
+    normalizeGerritTarget(branch) {
+        if (!branch) {
+            return undefined;
+        }
+        return branch.replace(/^refs\/heads\//, "");
+    }
+    normalizeGitHubBaseBranch(branch) {
+        if (!branch) {
+            return undefined;
+        }
+        return branch.replace(/^refs\/heads\//, "");
+    }
+    renderPlannedNextSteps(bundle, strategy) {
+        const workspaceKind = bundle.publication?.git?.workspaceKind;
+        switch (strategy) {
+            case "gerrit_change":
+                if (workspaceKind === "repo_managed") {
+                    return [
+                        "- Submit the patch as per-project Gerrit changes, with one shared topic only when multiple changes exist.",
+                        "- Notify humans with result.md, patch.diff, and Gerrit topic/change metadata."
+                    ];
+                }
+                return [
+                    "- Submit the patch as Gerrit review changes, not as a direct branch update.",
+                    "- Notify humans with result.md, patch.diff, and Gerrit-ready target refs."
+                ];
+            case "github_pr":
+                return [
+                    "- Submit the patch through a pull request workflow, not as a direct branch update.",
+                    "- Notify humans with result.md, patch.diff, and the planned PR base branch."
+                ];
+            default:
+                return [
+                    "- Keep artifacts in manual review handoff because no safe automated review endpoint is resolved.",
+                    "- Notify humans with result.md, patch.diff, and the unresolved publication context."
+                ];
+        }
+    }
+    async executeReviewSubmit(bundle, plan, context, taskRootDir, artifactDir) {
+        const session = {
+            bundle,
+            reviewSystem: plan.reviewSystem
+        };
+        await this.logger?.info("task.publication.review_submit.started", {
+            taskId: bundle.taskId,
+            taskType: bundle.taskType,
+            publicationStrategy: plan.reviewSystem.strategy,
+            reviewSystemType: plan.reviewSystem.type,
+            workspaceKind: bundle.publication?.git?.workspaceKind ?? "unknown"
+        });
+        const records = await this.submitBundle(session, plan, context, taskRootDir, artifactDir);
+        const status = this.resolveExecutionStatus(records);
+        const summary = this.buildExecutionSummary(records, plan.reviewSystem.strategy);
+        const reviewMetadata = this.collectReviewMetadata(records);
+        await this.logger?.debug("task.publication.review_submit.review_metadata", {
+            taskId: bundle.taskId,
+            taskType: bundle.taskType,
+            publicationStatus: status,
+            publicationStrategy: plan.reviewSystem.strategy,
+            topic: reviewMetadata.topic ?? null,
+            topicUrl: reviewMetadata.topicUrl ?? null,
+            reviewUrl: reviewMetadata.reviewUrl ?? null,
+            reviewUrls: reviewMetadata.reviewUrls ?? [],
+            changeIds: reviewMetadata.changeIds ?? (reviewMetadata.changeId ? [reviewMetadata.changeId] : [])
+        });
+        await this.logger?.info("task.publication.review_submit.completed", {
+            taskId: bundle.taskId,
+            taskType: bundle.taskType,
+            publicationStatus: status,
+            publicationStrategy: plan.reviewSystem.strategy,
+            submittedCount: records.filter((record) => record.status === "submitted").length,
+            failedCount: records.filter((record) => record.status === "failed").length,
+            skippedCount: records.filter((record) => record.status === "skipped").length,
+            topic: reviewMetadata.topic ?? null,
+            topicUrl: reviewMetadata.topicUrl ?? null,
+            reviewUrl: reviewMetadata.reviewUrl ?? null,
+            summary
+        });
+        return {
+            status,
+            summary,
+            records
+        };
+    }
+    async submitBundle(session, plan, context, taskRootDir, artifactDir) {
+        const publication = session.bundle.publication?.git;
+        if (!publication?.repoDir) {
+            throw new Error("Publication execution requires repoDir.");
+        }
+        const targets = await this.buildPatchTargets(session.bundle, plan, artifactDir);
+        await this.logger?.debug("task.publication.review_submit.targets_resolved", {
+            taskId: session.bundle.taskId,
+            taskType: session.bundle.taskType,
+            publicationStrategy: plan.reviewSystem.strategy,
+            reviewSystemType: plan.reviewSystem.type,
+            targetCount: targets.length,
+            targets: targets.map((target) => ({
+                label: target.label,
+                projectPath: target.projectPath,
+                repoDir: target.repoDir,
+                targetBranch: target.targetBranch ?? null,
+                remoteName: target.upstreamRemote ?? target.reviewSystem.remoteName ?? null,
+                hasPatchContent: Boolean(target.patchContent.trim())
+            }))
+        });
+        if (targets.length === 0) {
+            return [this.buildExecutionRecord({
+                    label: "publication",
+                    status: "skipped",
+                    strategy: plan.reviewSystem.strategy,
+                    targetBranch: undefined,
+                    remoteName: plan.reviewSystem.remoteName,
+                    submittedRef: undefined,
+                    reviewUrl: undefined,
+                    changeId: undefined,
+                    detail: "No publishable patch target was resolved."
+                })];
+        }
+        const repoKind = this.resolveRepositoryKind(session.bundle, targets);
+        await this.logger?.debug("task.publication.review_submit.targets_resolved", {
+            taskId: session.bundle.taskId,
+            taskType: session.bundle.taskType,
+            publicationStrategy: plan.reviewSystem.strategy,
+            reviewSystemType: plan.reviewSystem.type,
+            repositoryKind: repoKind.kind,
+            repositories: repoKind.repos
+        });
+        if (repoKind.kind === "repo_managed") {
+            return this.submitRepoManagedGerrit(session, targets, context);
+        }
+        if (repoKind.kind === "plain_directory") {
+            return this.submitMultiGitRepositories(session, targets, context, taskRootDir);
+        }
+        return this.submitGitRoot(session, targets, context, taskRootDir);
+    }
+    async buildPatchTargets(bundle, plan, artifactDir) {
+        const publication = bundle.publication?.git;
+        const patchPath = bundle.artifacts.patchDiff;
+        if (!publication?.repoDir || !patchPath) {
+            throw new Error("Publication execution requires repoDir and patchDiff.");
+        }
+        await mkdir(artifactDir, { recursive: true });
+        const patchContent = await readFile(patchPath, "utf8");
+        const projectTargets = plan.projectTargets.length > 0 ? plan.projectTargets : [this.buildRootProjectTarget(bundle)];
+        const patchSections = projectTargets.some((project) => project.projectPath !== ".")
+            ? this.parsePatchSections(patchContent)
+            : [];
+        return projectTargets.map((project) => {
+            const targetPatch = project.projectPath === "."
+                ? patchContent
+                : this.buildProjectPatch(patchSections, project.projectPath) ?? "";
+            const repoRoot = publication.repoDir;
+            const targetRepoDir = project.projectPath === "."
+                ? repoRoot
+                : join(repoRoot, project.projectPath);
+            return this.buildPatchTarget({
+                label: this.renderTargetLabel(project),
+                projectPath: project.projectPath,
+                repoDir: targetRepoDir,
+                targetBranch: project.targetBranch ?? publication.targetBranch,
+                upstreamRemote: project.upstreamRemote ?? publication.upstreamRemote,
+                upstreamBranch: project.upstreamBranch,
+                reviewSystem: project.reviewSystem ?? plan.reviewSystem,
+                patchContent: targetPatch
+            });
+        });
+    }
+    resolveRepositoryKind(bundle, targets) {
+        const workspaceKind = bundle.publication?.git?.workspaceKind;
+        if (workspaceKind === "repo_managed") {
+            return {
+                kind: "repo_managed",
+                repos: targets.map((target) => ({ label: target.label, repoDir: target.repoDir }))
+            };
+        }
+        const uniqueRepos = [...new Map(targets.map((target) => [resolve(target.repoDir), { label: target.label, repoDir: resolve(target.repoDir) }])).values()];
+        if (workspaceKind === "plain_directory" || uniqueRepos.length > 1) {
+            return {
+                kind: "plain_directory",
+                repos: uniqueRepos
+            };
+        }
+        return {
+            kind: "git_root",
+            repos: uniqueRepos
+        };
+    }
+    async submitRepoManagedGerrit(session, targets, context) {
+        const commitMaterials = [];
+        const directWorkspace = this.shouldUseDirectWorkspaceCommits(context);
+        try {
+            for (const target of targets) {
+                try {
+                    if (!target.patchContent.trim()) {
+                        commitMaterials.push({
+                            target,
+                            commitHash: "",
+                            changeId: undefined,
+                            baseHead: undefined
+                        });
+                        continue;
+                    }
+                    const materialized = directWorkspace
+                        ? await this.commitExistingWorkspace(session.bundle, target)
+                        : await this.materializePatchCommit(session.bundle, target);
+                    commitMaterials.push(materialized);
+                }
+                catch (error) {
+                    commitMaterials.push({ target, commitHash: "", changeId: undefined, baseHead: undefined });
+                    throw error;
+                }
+            }
+            const submittedMaterials = commitMaterials.filter((materialized) => materialized.target.patchContent.trim());
+            const topic = submittedMaterials.length > 1 ? this.buildTopic(session.bundle.taskId) : undefined;
+            await this.logger?.info("task.publication.repo_managed.submit_started", {
+                taskId: session.bundle.taskId,
+                taskType: session.bundle.taskType,
+                projectCount: submittedMaterials.length,
+                projects: submittedMaterials.map((materialized) => materialized.target.projectPath),
+                topic: topic ?? null
+            });
+            const records = [];
+            for (const materialized of commitMaterials) {
+                if (!materialized.target.patchContent.trim()) {
+                    const topicUrl = this.buildGerritTopicUrl(materialized.target.reviewSystem, topic);
+                    records.push(this.buildExecutionRecord({
+                        label: materialized.target.label,
+                        status: "skipped",
+                        strategy: materialized.target.reviewSystem.strategy,
+                        ...(topic ? { topic } : {}),
+                        ...(topicUrl ? { topicUrl } : {}),
+                        targetBranch: materialized.target.targetBranch,
+                        remoteName: materialized.target.upstreamRemote ?? materialized.target.reviewSystem.remoteName,
+                        submittedRef: undefined,
+                        reviewUrl: undefined,
+                        changeId: undefined,
+                        detail: "No patch content mapped to this publication target."
+                    }));
+                    continue;
+                }
+                records.push(await this.uploadRepoManagedCommit(materialized, topic));
+            }
+            await this.logger?.info("task.publication.repo_managed.submit_completed", {
+                taskId: session.bundle.taskId,
+                taskType: session.bundle.taskType,
+                projectCount: submittedMaterials.length,
+                topic: topic ?? null,
+                submittedCount: records.filter((record) => record.status === "submitted").length,
+                skippedCount: records.filter((record) => record.status === "skipped").length,
+                failedCount: records.filter((record) => record.status === "failed").length
+            });
+            return records;
+        }
+        finally {
+            await this.cleanupMaterializedCommits(commitMaterials);
+        }
+    }
+    async uploadRepoManagedCommit(materialized, topic) {
+        return this.pushGerritCommit(materialized, topic);
+    }
+    async submitMultiGitRepositories(session, targets, context, taskRootDir) {
+        const materials = [];
+        const directWorkspace = this.shouldUseDirectWorkspaceCommits(context);
+        try {
+            for (const target of targets) {
+                try {
+                    if (!target.patchContent.trim()) {
+                        materials.push({ target, commitHash: "", changeId: undefined, baseHead: undefined });
+                        continue;
+                    }
+                    const materialized = directWorkspace
+                        ? await this.commitExistingWorkspace(session.bundle, target)
+                        : await this.materializePatchCommit(session.bundle, target);
+                    materials.push(materialized);
+                }
+                catch (error) {
+                    materials.push({ target, commitHash: "", changeId: undefined, baseHead: undefined });
+                    throw error;
+                }
+            }
+            const submittedMaterialCount = materials.filter((materialized) => materialized.target.patchContent.trim()).length;
+            const topic = submittedMaterialCount > 1 ? this.buildTopic(session.bundle.taskId) : undefined;
+            const records = [];
+            for (const materialized of materials) {
+                if (!materialized.target.patchContent.trim()) {
+                    records.push(this.buildExecutionRecord({
+                        label: materialized.target.label,
+                        status: "skipped",
+                        strategy: materialized.target.reviewSystem.strategy,
+                        targetBranch: materialized.target.targetBranch,
+                        remoteName: materialized.target.upstreamRemote ?? materialized.target.reviewSystem.remoteName,
+                        submittedRef: undefined,
+                        reviewUrl: undefined,
+                        changeId: undefined,
+                        detail: "No patch content mapped to this publication target."
+                    }));
+                    continue;
+                }
+                records.push(await this.pushGerritCommit(materialized, topic));
+            }
+            return records;
+        }
+        finally {
+            if (!directWorkspace) {
+                await this.cleanupMaterializedCommits(materials);
+                await rm(join(taskRootDir, ".optimus", "publication", "stage"), { recursive: true, force: true });
+            }
+        }
+    }
+    async submitGitRoot(session, targets, context, taskRootDir) {
+        const target = targets[0];
+        if (!target) {
+            throw new Error("No git-root publication target resolved.");
+        }
+        if (session.reviewSystem.strategy === "github_pr") {
+            return [await this.submitGithubTarget(session.bundle, target, context, taskRootDir)];
+        }
+        if (context?.addresses.mode === "copy") {
+            return [await this.submitGitRootCopyWorkspace(session.bundle, target, context)];
+        }
+        if (context?.addresses.mode === "inplace") {
+            return [await this.submitGitRootInplaceGerrit(session.bundle, target)];
+        }
+        return [await this.submitGitRootStagedGerrit(session.bundle, target, taskRootDir)];
+    }
+    async submitGitRootInplaceGerrit(bundle, target) {
+        const materialized = await this.commitExistingWorkspace(bundle, target);
+        try {
+            return await this.pushGerritCommit(materialized);
+        }
+        finally {
+            await this.cleanupMaterializedCommits([materialized]);
+        }
+    }
+    async submitGitRootCopyWorkspace(bundle, target, context) {
+        const workspaceDir = context.addresses.workspaceDir;
+        const statusBefore = await this.readCommand("git", ["-C", workspaceDir, "status", "--short"]);
+        if (!statusBefore.trim()) {
+            throw new Error(`Copy workspace ${workspaceDir} has no changes to publish.`);
+        }
+        const materialized = await this.commitExistingWorkspace(bundle, { ...target, repoDir: workspaceDir });
+        try {
+            return await this.pushGerritCommit(materialized);
+        }
+        finally {
+            await this.cleanupMaterializedCommits([materialized]);
+        }
+    }
+    async submitGitRootStagedGerrit(bundle, target, taskRootDir) {
+        const stageDir = join(taskRootDir, ".optimus", "publication", "stage", "repo-root");
+        const baseRef = await this.resolveBaseRef(target.repoDir, target.upstreamRemote ?? target.reviewSystem.remoteName, target.targetBranch);
+        await this.prepareStageWorktree(target.repoDir, stageDir, baseRef);
+        try {
+            const materialized = await this.materializePatchCommit(bundle, { ...target, repoDir: stageDir });
+            const output = await this.readCommand("git", [
+                "-C",
+                stageDir,
+                "push",
+                target.upstreamRemote ?? target.reviewSystem.remoteName ?? "origin",
+                this.buildGerritPushRef(this.requireGerritBranch(target.targetBranch))
+            ]);
+            return this.buildExecutionRecord({
+                label: target.label,
+                status: "submitted",
+                strategy: target.reviewSystem.strategy,
+                targetBranch: target.targetBranch,
+                remoteName: target.upstreamRemote ?? target.reviewSystem.remoteName,
+                reviewUrl: this.extractReviewUrl(output, target.reviewSystem),
+                changeId: materialized.changeId,
+                detail: this.compact(output)
+            });
+        }
+        finally {
+            await this.cleanupStageWorktree(target.repoDir, stageDir);
+        }
+    }
+    async submitGithubTarget(bundle, target, context, taskRootDir) {
+        const directWorkspace = context?.addresses.mode === "copy" || context?.addresses.mode === "inplace";
+        const stageDir = directWorkspace
+            ? (context?.addresses.mode === "copy" ? context.addresses.workspaceDir : target.repoDir)
+            : join(taskRootDir, ".optimus", "publication", "stage", this.slugify(target.label));
+        const branchTracking = context?.addresses.mode === "inplace"
+            ? await this.captureBranchTrackingSnapshot(stageDir)
+            : undefined;
+        let stagedWithWorktree = false;
+        if (!directWorkspace) {
+            const baseRef = await this.resolveBaseRef(target.repoDir, target.upstreamRemote ?? target.reviewSystem.remoteName, target.targetBranch);
+            await this.prepareStageWorktree(target.repoDir, stageDir, baseRef);
+            stagedWithWorktree = true;
+        }
+        let materialized;
+        try {
+            materialized = directWorkspace
+                ? await this.commitExistingWorkspace(bundle, { ...target, repoDir: stageDir })
+                : await this.materializePatchCommit(bundle, { ...target, repoDir: stageDir });
+            const branchName = this.buildGithubBranchName(bundle.taskId, target.projectPath);
+            await this.runCommand("git", ["-C", stageDir, "push", "-u", target.upstreamRemote ?? target.reviewSystem.remoteName ?? "origin", `HEAD:refs/heads/${branchName}`]);
+            const prOutput = await this.readCommand("gh", [
+                "pr", "create",
+                "--base", this.requireGithubBranch(target.targetBranch),
+                "--head", branchName,
+                "--title", bundle.summary.title,
+                "--body", this.buildGithubPrBody(bundle, target)
+            ], { cwd: stageDir });
+            const reviewUrl = this.extractReviewUrl(prOutput, target.reviewSystem);
+            return this.buildExecutionRecord({
+                label: target.label,
+                status: "submitted",
+                strategy: target.reviewSystem.strategy,
+                targetBranch: target.targetBranch,
+                remoteName: target.upstreamRemote ?? target.reviewSystem.remoteName,
+                submittedRef: branchName,
+                reviewUrl,
+                changeId: materialized.changeId,
+                detail: this.compact(prOutput)
+            });
+        }
+        finally {
+            if (directWorkspace && materialized) {
+                await this.cleanupMaterializedCommits([materialized]);
+            }
+            if (branchTracking) {
+                await this.restoreBranchTrackingSnapshot(stageDir, branchTracking);
+            }
+            if (stagedWithWorktree) {
+                await this.cleanupStageWorktree(target.repoDir, stageDir);
+            }
+        }
+    }
+    async captureBranchTrackingSnapshot(repoDir) {
+        const headCommit = await this.readCommand("git", ["-C", repoDir, "rev-parse", "HEAD"])
+            .then((value) => value.trim())
+            .catch(() => undefined);
+        if (!headCommit) {
+            return undefined;
+        }
+        const branchName = await this.readCommand("git", ["-C", repoDir, "rev-parse", "--abbrev-ref", "HEAD"])
+            .then((value) => value.trim())
+            .catch(() => undefined);
+        const normalizedBranchName = branchName && branchName !== "HEAD" ? branchName : undefined;
+        const upstreamRef = normalizedBranchName
+            ? await this.readCommand("git", ["-C", repoDir, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"])
+                .then((value) => value.trim())
+                .catch(() => undefined)
+            : undefined;
+        return {
+            headCommit,
+            ...(normalizedBranchName ? { branchName: normalizedBranchName } : {}),
+            ...(upstreamRef ? { upstreamRef } : {})
+        };
+    }
+    async restoreBranchTrackingSnapshot(repoDir, snapshot) {
+        if (!snapshot.branchName) {
+            return;
+        }
+        try {
+            await this.runCommand("git", ["-C", repoDir, "branch", "--unset-upstream", snapshot.branchName]);
+        }
+        catch {
+            // Keep cleanup best-effort when the branch has no upstream.
+        }
+        if (snapshot.upstreamRef) {
+            await this.runCommand("git", ["-C", repoDir, "branch", "--set-upstream-to", snapshot.upstreamRef, snapshot.branchName]);
+        }
+    }
+    async materializePatchCommit(bundle, target) {
+        const baseHead = await this.readCommand("git", ["-C", target.repoDir, "rev-parse", "HEAD"])
+            .then((value) => value.trim())
+            .catch(() => undefined);
+        const patchFile = join(dirname(target.repoDir), `${this.slugify(target.label)}.publication.diff`);
+        await writeFile(patchFile, this.ensureTrailingNewline(target.patchContent), "utf8");
+        try {
+            await this.runCommand("git", ["-C", target.repoDir, "apply", patchFile]);
+            const statusEntries = await this.readGitStatusEntries(target.repoDir);
+            await this.stageBusinessChanges(target.repoDir, statusEntries);
+            if (!filterBusinessChangeEntries(statusEntries).length) {
+                return { target, commitHash: "", changeId: undefined, baseHead };
+            }
+            const changeId = target.reviewSystem.strategy === "gerrit_change"
+                ? this.buildGerritChangeId(bundle, target)
+                : undefined;
+            const changedPaths = collectBusinessChangePaths(statusEntries);
+            await this.runCommand("git", ["-C", target.repoDir, "commit", "--signoff", "-m", this.buildCommitMessage(bundle, target, changedPaths)]);
+            const commitHash = await this.readCommand("git", ["-C", target.repoDir, "rev-parse", "HEAD"]);
+            return {
+                target,
+                commitHash: commitHash.trim(),
+                changeId,
+                baseHead
+            };
+        }
+        finally {
+            await rm(patchFile, { force: true });
+        }
+    }
+    async commitExistingWorkspace(bundle, target) {
+        const baseHead = await this.readCommand("git", ["-C", target.repoDir, "rev-parse", "HEAD"])
+            .then((value) => value.trim())
+            .catch(() => undefined);
+        const statusEntries = await this.readGitStatusEntries(target.repoDir);
+        await this.stageBusinessChanges(target.repoDir, statusEntries);
+        if (!filterBusinessChangeEntries(statusEntries).length) {
+            throw new Error(`Workspace ${target.repoDir} has no changes to publish.`);
+        }
+        const changedPaths = collectBusinessChangePaths(statusEntries);
+        await this.runCommand("git", ["-C", target.repoDir, "commit", "--signoff", "-m", this.buildCommitMessage(bundle, target, changedPaths)]);
+        const commitHash = await this.readCommand("git", ["-C", target.repoDir, "rev-parse", "HEAD"]);
+        return {
+            target,
+            commitHash: commitHash.trim(),
+            changeId: target.reviewSystem.strategy === "gerrit_change" ? this.buildGerritChangeId(bundle, target) : undefined,
+            baseHead
+        };
+    }
+    async pushGerritCommit(materialized, topic) {
+        const branch = this.requireGerritBranch(materialized.target.targetBranch);
+        const output = await this.readCommand("git", [
+            "-C",
+            materialized.target.repoDir,
+            "push",
+            materialized.target.upstreamRemote ?? materialized.target.reviewSystem.remoteName ?? "origin",
+            this.buildGerritPushRef(branch, topic)
+        ]);
+        const topicUrl = this.buildGerritTopicUrl(materialized.target.reviewSystem, topic);
+        return this.buildExecutionRecord({
+            label: materialized.target.label,
+            status: "submitted",
+            strategy: materialized.target.reviewSystem.strategy,
+            ...(topic ? { topic } : {}),
+            ...(topicUrl ? { topicUrl } : {}),
+            targetBranch: materialized.target.targetBranch,
+            remoteName: materialized.target.upstreamRemote ?? materialized.target.reviewSystem.remoteName,
+            submittedRef: topic,
+            reviewUrl: this.extractReviewUrl(output, materialized.target.reviewSystem),
+            changeId: materialized.changeId,
+            detail: this.compact(output)
+        });
+    }
+    async refreshRepoProjectTarget(target, targetBranch) {
+        if (!targetBranch) {
+            return;
+        }
+        const branch = this.normalizeGerritTarget(targetBranch);
+        const remote = target.upstreamRemote ?? target.reviewSystem.remoteName ?? "origin";
+        if (!branch) {
+            return;
+        }
+        await this.runCommand("git", ["-C", target.repoDir, "fetch", remote, branch]);
+        await this.runCommand("git", ["-C", target.repoDir, "reset", "--hard", "FETCH_HEAD"]);
+    }
+    async refreshGitTarget(target, targetBranch, repoDirOverride) {
+        const branch = this.normalizeGitHubBaseBranch(targetBranch);
+        const remote = target.upstreamRemote ?? target.reviewSystem.remoteName ?? "origin";
+        const repoDir = repoDirOverride ?? target.repoDir;
+        if (!branch) {
+            return;
+        }
+        await this.runCommand("git", ["-C", repoDir, "fetch", remote, branch]);
+    }
+    shouldUseDirectWorkspaceCommits(context) {
+        return context?.addresses.mode === "inplace";
+    }
+    async cleanupMaterializedCommits(materials) {
+        for (const materialized of materials) {
+            if (!materialized.commitHash) {
+                await this.resetWorkspaceToBase(materialized.target.repoDir, materialized.baseHead);
+                continue;
+            }
+            try {
+                await this.resetWorkspaceToBase(materialized.target.repoDir, materialized.baseHead ?? `${materialized.commitHash}^`);
+            }
+            catch {
+                await this.resetWorkspaceToBase(materialized.target.repoDir, materialized.baseHead);
+            }
+        }
+    }
+    async resetWorkspaceToBase(repoDir, baseRef) {
+        await this.runCommand("git", ["-C", repoDir, "reset", "--hard", baseRef ?? "HEAD"]);
+        const statusEntries = await this.readGitStatusEntries(repoDir);
+        const untrackedBusinessPaths = collectBusinessChangePaths(statusEntries.filter((entry) => entry.isUntracked));
+        for (const relativePath of untrackedBusinessPaths) {
+            await rm(join(repoDir, relativePath), { recursive: true, force: true });
+        }
+    }
+    async resolveBaseRef(repoDir, remoteName, targetBranch) {
+        const normalizedBranch = this.normalizeGitHubBaseBranch(targetBranch);
+        if (remoteName && normalizedBranch) {
+            try {
+                await this.runCommand("git", ["-C", repoDir, "fetch", remoteName, normalizedBranch]);
+                return "FETCH_HEAD";
+            }
+            catch {
+                // Fall back to local HEAD when fetch is unavailable or blocked.
+            }
+        }
+        const head = await this.readCommand("git", ["-C", repoDir, "rev-parse", "HEAD"]);
+        return head.trim() || "HEAD";
+    }
+    async prepareStageWorktree(repoDir, stageDir, baseRef) {
+        await rm(stageDir, { recursive: true, force: true });
+        await mkdir(dirname(stageDir), { recursive: true });
+        await this.runCommand("git", ["-C", repoDir, "worktree", "add", "--detach", stageDir, baseRef]);
+    }
+    async cleanupStageWorktree(repoDir, stageDir) {
+        try {
+            await this.runCommand("git", ["-C", repoDir, "worktree", "remove", "--force", stageDir]);
+        }
+        catch {
+            await rm(stageDir, { recursive: true, force: true });
+        }
+    }
+    parsePatchSections(content) {
+        const normalized = content.replace(/\r\n/g, "\n");
+        const lines = normalized.split("\n");
+        const sections = [];
+        let current = [];
+        for (const line of lines) {
+            if (line.startsWith("diff --git ") && current.length > 0) {
+                sections.push(current);
+                current = [];
+            }
+            current.push(line);
+        }
+        if (current.length > 0) {
+            sections.push(current);
+        }
+        return sections.map((sectionLines) => {
+            const raw = this.ensureTrailingNewline(sectionLines.join("\n"));
+            return this.buildPatchSection(raw, this.extractPatchPath(raw));
+        });
+    }
+    extractPatchPath(raw) {
+        const plusLine = raw.split("\n").find((line) => line.startsWith("+++ "));
+        if (!plusLine) {
+            return undefined;
+        }
+        const value = plusLine.slice(4).trim();
+        if (value === "/dev/null") {
+            const minusLine = raw.split("\n").find((line) => line.startsWith("--- a/"));
+            return minusLine ? minusLine.slice("--- a/".length).trim() : undefined;
+        }
+        return value.startsWith("b/") ? value.slice(2).trim() : value;
+    }
+    buildProjectPatch(sections, projectPath) {
+        const matched = sections
+            .filter((section) => section.path && this.pathMatchesProject(section.path, projectPath))
+            .map((section) => this.rewritePatchForProject(section.raw, projectPath));
+        if (matched.length === 0) {
+            return undefined;
+        }
+        return this.ensureTrailingNewline(matched.join("\n"));
+    }
+    rewritePatchForProject(raw, projectPath) {
+        const prefix = `${projectPath.replace(/^\/+|\/+$/g, "")}/`;
+        const lines = raw.replace(/\r\n/g, "\n").split("\n");
+        const rewritten = lines.map((line) => {
+            if (line.startsWith("diff --git ")) {
+                return line
+                    .replace(` a/${prefix}`, " a/")
+                    .replace(` b/${prefix}`, " b/");
+            }
+            if (line.startsWith("--- a/")) {
+                return line.replace(`--- a/${prefix}`, "--- a/");
+            }
+            if (line.startsWith("+++ b/")) {
+                return line.replace(`+++ b/${prefix}`, "+++ b/");
+            }
+            if (line.startsWith("rename from ")) {
+                return line.replace(`rename from ${prefix}`, "rename from ");
+            }
+            if (line.startsWith("rename to ")) {
+                return line.replace(`rename to ${prefix}`, "rename to ");
+            }
+            if (line.startsWith("copy from ")) {
+                return line.replace(`copy from ${prefix}`, "copy from ");
+            }
+            if (line.startsWith("copy to ")) {
+                return line.replace(`copy to ${prefix}`, "copy to ");
+            }
+            return line;
+        });
+        return this.ensureTrailingNewline(rewritten.join("\n"));
+    }
+    pathMatchesProject(changedPath, projectPath) {
+        return changedPath === projectPath || changedPath.startsWith(`${projectPath}/`);
+    }
+    buildCommitMessage(bundle, target, changedPaths) {
+        return this.commitMessageBuilder.build({
+            bundle,
+            target,
+            changedPaths
+        });
+    }
+    buildGerritChangeId(bundle, target) {
+        const hash = createHash("sha1")
+            .update(`${bundle.taskId}:${target.projectPath}:${target.targetBranch ?? "none"}:${bundle.summary.title}`)
+            .digest("hex");
+        return `I${hash}`;
+    }
+    buildGithubPrBody(bundle, target) {
+        const lines = [
+            `Task: ${bundle.taskId}`,
+            `Outcome: ${bundle.outcome}`,
+            `Decision: ${bundle.summary.decision}`
+        ];
+        if (target.projectPath !== ".") {
+            lines.push(`Project: ${target.projectPath}`);
+        }
+        if (bundle.summary.validation) {
+            lines.push(`Validation: ${bundle.summary.validation}`);
+        }
+        return lines.join("\n");
+    }
+    buildGithubBranchName(taskId, projectPath) {
+        const suffix = projectPath === "." ? "root" : this.slugify(projectPath);
+        return `optimus/${taskId}-${suffix}`;
+    }
+    buildTopic(taskId) {
+        const normalized = taskId.trim();
+        const runtimeTaskSuffix = normalized.match(/^task-\d+-([a-f0-9]{8,})$/i)?.[1]?.toLowerCase();
+        if (runtimeTaskSuffix) {
+            return `optimus-${runtimeTaskSuffix}`;
+        }
+        const fallback = normalized.replace(/[^a-zA-Z0-9]+/g, "").toLowerCase();
+        return fallback ? `optimus-${fallback}` : "optimus";
+    }
+    buildGerritPushRef(branch, topic) {
+        return `HEAD:refs/for/${branch}${topic ? `%topic=${topic}` : ""}`;
+    }
+    requireGerritBranch(branch) {
+        const normalized = this.normalizeGerritTarget(branch);
+        if (!normalized) {
+            throw new Error("Missing Gerrit target branch.");
+        }
+        return normalized;
+    }
+    requireGithubBranch(branch) {
+        const normalized = this.normalizeGitHubBaseBranch(branch);
+        if (!normalized) {
+            throw new Error("Missing GitHub base branch.");
+        }
+        return normalized;
+    }
+    buildPatchTarget(input) {
+        return {
+            label: input.label,
+            projectPath: input.projectPath,
+            repoDir: input.repoDir,
+            ...(input.targetBranch ? { targetBranch: input.targetBranch } : {}),
+            ...(input.upstreamRemote ? { upstreamRemote: input.upstreamRemote } : {}),
+            ...(input.upstreamBranch ? { upstreamBranch: input.upstreamBranch } : {}),
+            reviewSystem: input.reviewSystem,
+            patchContent: input.patchContent
+        };
+    }
+    buildExecutionRecord(input) {
+        return {
+            label: input.label,
+            status: input.status,
+            strategy: input.strategy,
+            ...(input.topic ? { topic: input.topic } : {}),
+            ...(input.topicUrl ? { topicUrl: input.topicUrl } : {}),
+            ...(input.targetBranch ? { targetBranch: input.targetBranch } : {}),
+            ...(input.remoteName ? { remoteName: input.remoteName } : {}),
+            ...(input.submittedRef ? { submittedRef: input.submittedRef } : {}),
+            ...(input.reviewUrl ? { reviewUrl: input.reviewUrl } : {}),
+            ...(input.changeId ? { changeId: input.changeId } : {}),
+            detail: input.detail
+        };
+    }
+    buildPatchSection(raw, path) {
+        return path ? { raw, path } : { raw };
+    }
+    resolveExecutionStatus(records) {
+        const submittedCount = records.filter((record) => record.status === "submitted").length;
+        const failedCount = records.filter((record) => record.status === "failed").length;
+        const skippedCount = records.filter((record) => record.status === "skipped").length;
+        if (submittedCount > 0 && failedCount === 0 && skippedCount === 0) {
+            return "submitted";
+        }
+        if (submittedCount > 0) {
+            return "partial";
+        }
+        if (failedCount > 0) {
+            return "failed";
+        }
+        return "skipped";
+    }
+    buildExecutionSummary(records, strategy) {
+        const submittedCount = records.filter((record) => record.status === "submitted").length;
+        const failedCount = records.filter((record) => record.status === "failed").length;
+        const skippedCount = records.filter((record) => record.status === "skipped").length;
+        const total = records.length;
+        if (submittedCount === total) {
+            return `Review submission completed for ${submittedCount}/${total} target(s) via ${strategy}.`;
+        }
+        if (submittedCount > 0) {
+            return `Review submission partially completed via ${strategy}: submitted=${submittedCount}, failed=${failedCount}, skipped=${skippedCount}.`;
+        }
+        if (failedCount > 0) {
+            return `Review submission failed for ${failedCount}/${total} target(s) via ${strategy}.`;
+        }
+        return `Review submission skipped for ${skippedCount}/${total} target(s) via ${strategy}.`;
+    }
+    collectReviewMetadata(records) {
+        const submittedGerritRecords = records.filter((record) => record.status === "submitted" && record.strategy === "gerrit_change");
+        const topics = [...new Set(submittedGerritRecords.map((record) => record.topic).filter((value) => Boolean(value)))];
+        const topicUrls = [...new Set(submittedGerritRecords.map((record) => record.topicUrl).filter((value) => Boolean(value)))];
+        const reviewUrls = [...new Set(records.map((record) => record.reviewUrl).filter((value) => Boolean(value)))];
+        const changeIds = [...new Set(records.map((record) => record.changeId).filter((value) => Boolean(value)))];
+        const topic = topics.length === 1 ? topics[0] : undefined;
+        const topicUrl = topicUrls.length === 1 ? topicUrls[0] : undefined;
+        const primaryReviewUrl = submittedGerritRecords.length > 1 && topicUrl ? topicUrl : reviewUrls[0];
+        const firstChangeId = changeIds[0];
+        return {
+            ...(topic ? { topic } : {}),
+            ...(topicUrl ? { topicUrl } : {}),
+            ...(primaryReviewUrl ? { reviewUrl: primaryReviewUrl } : {}),
+            ...(reviewUrls.length > 0 ? { reviewUrls } : {}),
+            ...(firstChangeId ? { changeId: firstChangeId } : {}),
+            ...(changeIds.length > 0 ? { changeIds } : {})
+        };
+    }
+    renderReviewPacket(bundle, plan, records) {
+        const lines = [
+            "# Review Packet",
+            "",
+            `- Task: ${bundle.taskId}`,
+            `- Task Type: ${bundle.taskType}`,
+            `- Outcome: ${bundle.outcome}`,
+            `- Review System: ${this.renderReviewSystem(plan.reviewSystem)}`,
+            `- Patch: ${bundle.artifacts.patchDiff ?? "n/a"}`,
+            "",
+            "## Submission Results",
+            ""
+        ];
+        for (const record of records) {
+            const parts = [`- ${record.label}: ${record.status}`, record.strategy];
+            if (record.remoteName) {
+                parts.push(record.remoteName);
+            }
+            if (record.targetBranch) {
+                parts.push(record.targetBranch);
+            }
+            if (record.submittedRef) {
+                parts.push(record.submittedRef);
+            }
+            if (record.topicUrl) {
+                parts.push(`Topic=${record.topicUrl}`);
+            }
+            if (record.changeId) {
+                parts.push(`Change-Id=${record.changeId}`);
+            }
+            if (record.reviewUrl) {
+                parts.push(record.reviewUrl);
+            }
+            parts.push(this.compact(record.detail));
+            lines.push(parts.join(" | "));
+        }
+        return lines.join("\n");
+    }
+    extractReviewUrl(output, reviewSystem) {
+        const urls = [...output.matchAll(/https?:\/\/\S+/g)]
+            .map((match) => match[0]?.replace(/[)\].,]+$/, ""))
+            .filter((value) => Boolean(value));
+        const githubUrl = urls.find((url) => /github\.com\/.+\/pull\/\d+/i.test(url));
+        if (githubUrl) {
+            return githubUrl;
+        }
+        const gerritUrl = urls.find((url) => /\/c\/.+\/\+\/\d+/i.test(url) || /\/c\/\d+/i.test(url));
+        if (gerritUrl) {
+            return gerritUrl;
+        }
+        const host = reviewSystem?.host;
+        if (!host) {
+            return undefined;
+        }
+        const changeMatch = output.match(/\b(\d{4,})\b/);
+        if (!changeMatch?.[1]) {
+            return undefined;
+        }
+        if (reviewSystem.type === "gerrit" && reviewSystem.repository) {
+            return `https://${host}/c/${reviewSystem.repository}/+/${changeMatch[1]}`;
+        }
+        return `https://${host}/c/${changeMatch[1]}`;
+    }
+    buildGerritTopicUrl(reviewSystem, topic) {
+        if (reviewSystem?.type !== "gerrit" || !topic) {
+            return undefined;
+        }
+        const host = reviewSystem.host?.trim() || this.extractHostFromRemoteUrl(reviewSystem.remoteUrl);
+        if (!host) {
+            return undefined;
+        }
+        return `https://${host}/q/topic:${encodeURIComponent(topic)}`;
+    }
+    extractHostFromRemoteUrl(remoteUrl) {
+        const normalized = remoteUrl?.trim();
+        if (!normalized) {
+            return undefined;
+        }
+        const sshMatch = normalized.match(/^[a-z]+:\/\/[^@]+@([^/:]+)(?::\d+)?\//i);
+        if (sshMatch?.[1]) {
+            return sshMatch[1];
+        }
+        const httpsMatch = normalized.match(/^[a-z]+:\/\/([^/:]+)(?::\d+)?\//i);
+        return httpsMatch?.[1];
+    }
+    slugify(value) {
+        return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "target";
+    }
+    compact(value) {
+        return value.replace(/\s+/g, " ").trim();
+    }
+    ensureTrailingNewline(value) {
+        return value.endsWith("\n") ? value : `${value}\n`;
+    }
+    async readGitStatusEntries(repoDir) {
+        try {
+            const { stdout } = await execFileAsync("git", ["-C", repoDir, "status", "--porcelain=v1", "--untracked-files=all"], {
+                maxBuffer: EXEC_MAX_BUFFER
+            });
+            return parseGitStatusOutput(stdout);
+        }
+        catch (error) {
+            throw new Error(this.renderExecError("git", ["-C", repoDir, "status", "--porcelain=v1", "--untracked-files=all"], error));
+        }
+    }
+    async stageBusinessChanges(repoDir, entries) {
+        const paths = collectBusinessChangePaths(entries);
+        if (paths.length === 0) {
+            return;
+        }
+        await this.runCommand("git", ["-C", repoDir, "add", "-A", "--", ...paths]);
+    }
+    async runCommand(command, args, options) {
+        try {
+            await execFileAsync(command, args, {
+                cwd: options?.cwd,
+                maxBuffer: EXEC_MAX_BUFFER,
+                ...(typeof options?.timeoutMs === "number" ? { timeout: options.timeoutMs } : {})
+            });
+        }
+        catch (error) {
+            throw new Error(this.renderExecError(command, args, error));
+        }
+    }
+    async readCommand(command, args, options) {
+        try {
+            const { stdout, stderr } = await execFileAsync(command, args, {
+                cwd: options?.cwd,
+                maxBuffer: EXEC_MAX_BUFFER,
+                ...(typeof options?.timeoutMs === "number" ? { timeout: options.timeoutMs } : {})
+            });
+            return `${stdout}${stderr}`.trim();
+        }
+        catch (error) {
+            throw new Error(this.renderExecError(command, args, error));
+        }
+    }
+    renderExecError(command, args, error) {
+        if (error && typeof error === "object") {
+            const failure = error;
+            if (command === "gh" && (failure.code === "ENOENT" || failure.message?.includes("spawn ENOTDIR") || failure.message?.includes("spawn ENOENT"))) {
+                return `gh ${args.join(" ")} failed: github_cli_missing. Install GitHub CLI and run 'gh auth login'.`;
+            }
+            const output = [failure.stdout, failure.stderr].filter(Boolean).join(" ").trim();
+            const timeoutDetail = failure.killed && failure.signal === "SIGTERM" ? ": command timed out" : "";
+            return `${command} ${args.join(" ")} failed${timeoutDetail}${failure.message ? `${timeoutDetail ? ";" : ":"} ${failure.message}` : ""}${output ? ` | ${this.compact(output)}` : ""}`;
+        }
+        return `${command} ${args.join(" ")} failed: ${String(error)}`;
+    }
+}
+//# sourceMappingURL=task-publication-service.js.map