opencode-akane 0.1.1 → 0.1.2

package/dist/workflow.js

@@ -0,0 +1,727 @@
+import { readFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { AKANE_SERVICE_NAME, AKANE_TOOL_IDS, } from "./constants.js";
+import { ensureArtifactLayout, resolveProjectRoot, resolveStageArtifactPath, writeStageArtifact, } from "./artifacts.js";
+const execFileAsync = promisify(execFile);
+const STAGE_ROLE_MAP = {
+    plan: "planner",
+    "plan-review": "plan_reviewer",
+    "implementation-context": "implementer",
+    "review-codex": "reviewer_codex",
+    "review-claude": "reviewer_claude",
+    "final-synthesis": "synthesizer",
+};
+const DEFAULT_ROLE_AGENTS = {
+    planner: "plan",
+    plan_reviewer: "general",
+    implementer: "build",
+    reviewer_codex: "general",
+    reviewer_claude: "general",
+    synthesizer: "general",
+};
+const IMPLEMENT_TIMEOUT_MS = 15 * 60 * 1000;
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+const POLL_INTERVAL_MS = 800;
+const STABILITY_POLLS_REQUIRED = 2;
+function nowIso() {
+    return new Date().toISOString();
+}
+function truncate(input, length) {
+    if (input.length <= length) {
+        return input;
+    }
+    return `${input.slice(0, Math.max(0, length - 1)).trimEnd()}...`;
+}
+function stageTitle(stage) {
+    return stage
+        .split("-")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function parseModelRef(modelRef) {
+    const [providerID, ...rest] = modelRef.split("/");
+    const modelID = rest.join("/").trim();
+    if (!providerID || !modelID) {
+        throw new Error(`Invalid Akane model mapping "${modelRef}". Expected provider/model.`);
+    }
+    return { providerID, modelID };
+}
+function resultErrorMessage(result, fallback) {
+    if (result.error instanceof Error) {
+        return result.error.message;
+    }
+    if (typeof result.error === "string") {
+        return result.error;
+    }
+    if (result.error) {
+        return JSON.stringify(result.error);
+    }
+    return fallback;
+}
+function requireResultData(result, action) {
+    if (!result.error && result.data !== undefined && result.data !== null) {
+        return result.data;
+    }
+    throw new Error(`${action} failed: ${resultErrorMessage(result, "unknown error")}`);
+}
+function extractAssistantText(parts) {
+    const text = parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.text.trim())
+        .filter(Boolean)
+        .join("\n\n")
+        .trim();
+    if (text) {
+        return text;
+    }
+    return "";
+}
+function findLatestAssistantMessage(messages) {
+    const assistants = messages
+        .filter((message) => message.info.role === "assistant")
+        .sort((left, right) => (left.info.time.created ?? 0) - (right.info.time.created ?? 0));
+    return assistants.at(-1) ?? null;
+}
+function makeToolRestrictions(allowWorkspaceMutation) {
+    const restrictions = Object.fromEntries(AKANE_TOOL_IDS.map((toolID) => [toolID, false]));
+    if (!allowWorkspaceMutation) {
+        for (const toolID of ["bash", "edit", "patch", "write", "task", "question"]) {
+            restrictions[toolID] = false;
+        }
+    }
+    return restrictions;
+}
+async function resolveAgentName(client, directory, role) {
+    const preferred = DEFAULT_ROLE_AGENTS[role];
+    if (!preferred) {
+        return undefined;
+    }
+    try {
+        const result = await client.app.agents({
+            query: { directory },
+        });
+        const agents = requireResultData(result, "agent list");
+        return agents.some((agent) => agent.name === preferred) ? preferred : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function createStageSession(input) {
+    const result = await input.client.session.create({
+        body: {
+            parentID: input.parentSessionID,
+            title: input.title,
+        },
+        query: {
+            directory: input.directory,
+        },
+    });
+    return requireResultData(result, "session creation");
+}
+async function waitForSessionCompletion(input) {
+    const startedAt = Date.now();
+    let stablePolls = 0;
+    let lastMessageCount = -1;
+    while (Date.now() - startedAt < input.timeoutMs) {
+        if (input.abort.aborted) {
+            throw new Error("Akane stage aborted.");
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        const statusResult = await input.client.session.status({
+            query: { directory: input.directory },
+        });
+        const statusMap = requireResultData(statusResult, "session status");
+        const sessionStatus = statusMap[input.sessionID];
+        if (sessionStatus && sessionStatus.type !== "idle") {
+            stablePolls = 0;
+            lastMessageCount = -1;
+            continue;
+        }
+        const messagesResult = await input.client.session.messages({
+            path: { id: input.sessionID },
+            query: { directory: input.directory },
+        });
+        const messages = requireResultData(messagesResult, "session messages");
+        const latestAssistant = findLatestAssistantMessage(messages);
+        if (!latestAssistant) {
+            stablePolls = 0;
+            lastMessageCount = messages.length;
+            continue;
+        }
+        if (messages.length === lastMessageCount) {
+            stablePolls += 1;
+        }
+        else {
+            stablePolls = 0;
+            lastMessageCount = messages.length;
+        }
+        if (stablePolls >= STABILITY_POLLS_REQUIRED) {
+            return messages;
+        }
+    }
+    throw new Error(`Akane stage timed out after ${Math.ceil(input.timeoutMs / 60000)} minute(s).`);
+}
+async function runGitCommand(projectRoot, args) {
+    try {
+        const { stdout } = await execFileAsync("git", args, {
+            cwd: projectRoot,
+            env: process.env,
+            maxBuffer: 1024 * 1024,
+        });
+        return stdout.trim();
+    }
+    catch {
+        return "";
+    }
+}
+async function captureWorkspaceSnapshot(projectRoot) {
+    const [statusShort, diffStat] = await Promise.all([
+        runGitCommand(projectRoot, ["status", "--short"]),
+        runGitCommand(projectRoot, ["diff", "--stat"]),
+    ]);
+    return { statusShort, diffStat };
+}
+function renderCodeBlock(content, language = "text") {
+    const normalized = content.trim();
+    if (!normalized) {
+        return "_None_";
+    }
+    return `\`\`\`${language}\n${normalized}\n\`\`\``;
+}
+function renderSection(title, body) {
+    return `## ${title}\n\n${body.trim()}\n`;
+}
+function renderStageDocument(input) {
+    const sections = [
+        `# ${stageTitle(input.stage)}`,
+        "",
+        `- Service: ${AKANE_SERVICE_NAME}`,
+        `- Role: ${input.role}`,
+        `- Model: ${input.model}`,
+        `- Session ID: ${input.sessionID}`,
+        `- Message ID: ${input.messageID}`,
+        `- Generated At: ${nowIso()}`,
+        "",
+        renderSection("Output", input.body),
+    ];
+    for (const extra of input.extraSections ?? []) {
+        sections.push(renderSection(extra.title, extra.body));
+    }
+    return sections.join("\n").trimEnd() + "\n";
+}
+async function readArtifactContent(projectRoot, configInfo, stage) {
+    const artifactPath = resolveStageArtifactPath(projectRoot, configInfo.config, stage);
+    try {
+        return await readFile(artifactPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+async function requireArtifactContent(projectRoot, configInfo, stage, instruction) {
+    const content = (await readArtifactContent(projectRoot, configInfo, stage)).trim();
+    if (!content) {
+        const artifactPath = resolveStageArtifactPath(projectRoot, configInfo.config, stage);
+        throw new Error(`Missing ${stage} artifact at ${artifactPath}. ${instruction}`);
+    }
+    return content;
+}
+function buildTaskBlock(task, notes) {
+    const blocks = [];
+    if (task?.trim()) {
+        blocks.push(renderSection("Task", task.trim()));
+    }
+    if (notes?.trim()) {
+        blocks.push(renderSection("Additional Notes", notes.trim()));
+    }
+    return blocks.join("\n");
+}
+function buildArtifactBlock(title, content) {
+    return renderSection(title, renderCodeBlock(content, "md"));
+}
+async function runStageSession(input) {
+    const role = STAGE_ROLE_MAP[input.stage];
+    const model = input.configInfo.config.roles[role];
+    const modelRef = parseModelRef(model);
+    const agent = await resolveAgentName(input.pluginInput.client, input.projectRoot, role);
+    const session = await createStageSession({
+        client: input.pluginInput.client,
+        parentSessionID: input.toolContext.sessionID,
+        directory: input.projectRoot,
+        title: input.title,
+    });
+    const promptResult = await input.pluginInput.client.session.promptAsync({
+        path: { id: session.id },
+        query: { directory: input.projectRoot },
+        signal: input.toolContext.abort,
+        body: {
+            ...(agent ? { agent } : {}),
+            model: modelRef,
+            system: input.system,
+            tools: makeToolRestrictions(input.allowWorkspaceMutation),
+            parts: [
+                {
+                    type: "text",
+                    text: input.prompt,
+                },
+            ],
+        },
+    });
+    if (promptResult.error) {
+        throw new Error(`${stageTitle(input.stage)} prompt failed: ${resultErrorMessage(promptResult, "unknown error")}`);
+    }
+    const messages = await waitForSessionCompletion({
+        client: input.pluginInput.client,
+        sessionID: session.id,
+        directory: input.projectRoot,
+        abort: input.toolContext.abort,
+        timeoutMs: input.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    });
+    const latestAssistant = findLatestAssistantMessage(messages);
+    if (!latestAssistant) {
+        throw new Error(`${stageTitle(input.stage)} completed without an assistant response.`);
+    }
+    const text = extractAssistantText(latestAssistant.parts).trim();
+    if (!text) {
+        throw new Error(`${stageTitle(input.stage)} completed without text output.`);
+    }
+    return {
+        stage: input.stage,
+        role,
+        model,
+        agent,
+        sessionID: session.id,
+        messageID: latestAssistant.info.id,
+        title: input.title,
+        text,
+    };
+}
+function planSystemPrompt() {
+    return [
+        `You are the ${AKANE_SERVICE_NAME} planning stage.`,
+        "Create a deterministic implementation plan in Markdown.",
+        "Focus on steps, risks, validation, and clear sequencing.",
+        "Do not modify files.",
+        "Do not rely on hidden context. Use only the task and repository inspection you perform in this session.",
+        "Output sections: Goal, Assumptions, Plan, Risks, Validation.",
+    ].join("\n");
+}
+function planReviewSystemPrompt() {
+    return [
+        `You are the ${AKANE_SERVICE_NAME} plan review stage.`,
+        "Critically review the plan and improve it without implementing anything.",
+        "Do not modify files.",
+        "Output sections: Verdict, Findings, Recommended Changes, Approved Plan Notes.",
+        "Be direct and specific.",
+    ].join("\n");
+}
+function implementSystemPrompt() {
+    return [
+        `You are the ${AKANE_SERVICE_NAME} implementation stage.`,
+        "Implement the approved plan in the current repository.",
+        "Use tools when needed to inspect, edit, and validate.",
+        "At the end, output concise Markdown with sections: Completed Work, Changed Files, Validation, Remaining Risks.",
+        "Do not include full diffs in the response.",
+    ].join("\n");
+}
+function reviewSystemPrompt(reviewer) {
+    return [
+        `You are the ${AKANE_SERVICE_NAME} ${reviewer} review stage.`,
+        "Review the current repository state after implementation.",
+        "Do not modify files.",
+        "Prioritize bugs, regressions, missing validation, and risky assumptions.",
+        "Output findings first with severity labels like P1/P2/P3 and file references when possible.",
+        'If there are no findings, explicitly say "No findings."',
+        "Then include Residual Risks and Suggested Follow-ups.",
+    ].join("\n");
+}
+function synthesizeSystemPrompt() {
+    return [
+        `You are the ${AKANE_SERVICE_NAME} synthesis stage.`,
+        "Produce the final synthesis across plan, implementation, and reviews.",
+        "Do not modify files.",
+        "Output sections: Outcome, Validation, Review Summary, Remaining Risks, Next Steps.",
+        "Keep it decision-oriented.",
+    ].join("\n");
+}
+export function resolveProjectRootFromArgs(input) {
+    return resolveProjectRoot({
+        directory: input.toolContext.directory,
+        worktree: input.toolContext.worktree,
+        projectRoot: input.projectRoot,
+    });
+}
+export async function executePlanStage(input) {
+    await ensureArtifactLayout({
+        projectRoot: input.projectRoot,
+        config: input.configInfo.config,
+        configPath: input.configInfo.path,
+    });
+    const result = await runStageSession({
+        pluginInput: input.pluginInput,
+        configInfo: input.configInfo,
+        toolContext: input.toolContext,
+        projectRoot: input.projectRoot,
+        stage: "plan",
+        title: `Akane Plan: ${truncate(input.task, 60)}`,
+        system: planSystemPrompt(),
+        prompt: [
+            buildTaskBlock(input.task, input.notes),
+            renderSection("Project Context", `Repository root: ${input.projectRoot}`),
+        ]
+            .filter(Boolean)
+            .join("\n"),
+        allowWorkspaceMutation: false,
+    });
+    const content = renderStageDocument({
+        stage: result.stage,
+        role: result.role,
+        model: result.model,
+        sessionID: result.sessionID,
+        messageID: result.messageID,
+        title: result.title,
+        body: result.text,
+    });
+    const writeResult = await writeStageArtifact({
+        projectRoot: input.projectRoot,
+        config: input.configInfo.config,
+        configPath: input.configInfo.path,
+        stage: "plan",
+        content,
+        mode: "replace",
+        details: {
+            role: result.role,
+            model: result.model,
+            sessionID: result.sessionID,
+            messageID: result.messageID,
+            title: result.title,
+        },
+    });
+    return {
+        ...result,
+        artifactPath: writeResult.artifactPath,
+        content,
+    };
+}
+export async function executePlanReviewStage(input) {
+    const plan = await requireArtifactContent(input.projectRoot, input.configInfo, "plan", "Run akane_plan first.");
+    const result = await runStageSession({
+        pluginInput: input.pluginInput,
+        configInfo: input.configInfo,
+        toolContext: input.toolContext,
+        projectRoot: input.projectRoot,
+        stage: "plan-review",
+        title: `Akane Plan Review${input.task ? `: ${truncate(input.task, 40)}` : ""}`,
+        system: planReviewSystemPrompt(),
+        prompt: [
+            buildTaskBlock(input.task, input.notes),
+            buildArtifactBlock("Plan Artifact", plan),
+        ]
+            .filter(Boolean)
+            .join("\n"),
+        allowWorkspaceMutation: false,
+    });
+    const content = renderStageDocument({
+        stage: result.stage,
+        role: result.role,
+        model: result.model,
+        sessionID: result.sessionID,
+        messageID: result.messageID,
+        title: result.title,
+        body: result.text,
+    });
+    const writeResult = await writeStageArtifact({
+        projectRoot: input.projectRoot,
+        config: input.configInfo.config,
+        configPath: input.configInfo.path,
+        stage: "plan-review",
+        content,
+        mode: "replace",
+        details: {
+            role: result.role,
+            model: result.model,
+            sessionID: result.sessionID,
+            messageID: result.messageID,
+            title: result.title,
+        },
+    });
+    return {
+        ...result,
+        artifactPath: writeResult.artifactPath,
+        content,
+    };
+}
+export async function executeImplementStage(input) {
+    const [plan, planReview, workspace] = await Promise.all([
+        requireArtifactContent(input.projectRoot, input.configInfo, "plan", "Run akane_plan first."),
+        requireArtifactContent(input.projectRoot, input.configInfo, "plan-review", "Run akane_plan_review first."),
+        captureWorkspaceSnapshot(input.projectRoot),
+    ]);
+    const result = await runStageSession({
+        pluginInput: input.pluginInput,
+        configInfo: input.configInfo,
+        toolContext: input.toolContext,
+        projectRoot: input.projectRoot,
+        stage: "implementation-context",
+        title: `Akane Implement${input.task ? `: ${truncate(input.task, 40)}` : ""}`,
+        system: implementSystemPrompt(),
+        prompt: [
+            buildTaskBlock(input.task, input.notes),
+            buildArtifactBlock("Plan Artifact", plan),
+            buildArtifactBlock("Plan Review Artifact", planReview),
+            renderSection("Workspace Snapshot Before Implementation", [
+                "### git status --short",
+                renderCodeBlock(workspace.statusShort || "Clean working tree"),
+                "### git diff --stat",
+                renderCodeBlock(workspace.diffStat || "No unstaged diff"),
+            ].join("\n\n")),
+        ]
+            .filter(Boolean)
+            .join("\n"),
+        allowWorkspaceMutation: true,
+        timeoutMs: IMPLEMENT_TIMEOUT_MS,
+    });
+    const diffResult = await input.pluginInput.client.session.diff({
+        path: { id: result.sessionID },
+        query: { directory: input.projectRoot },
+    });
+    const diffs = diffResult.error ? [] : diffResult.data ?? [];
+    const afterWorkspace = await captureWorkspaceSnapshot(input.projectRoot);
+    const diffSummary = diffs.length === 0
+        ? "No session diff records were returned."
+        : diffs
+            .map((diff) => `- ${diff.file} (+${diff.additions} / -${diff.deletions})`)
+            .join("\n");
+    const content = renderStageDocument({
+        stage: result.stage,
+        role: result.role,
+        model: result.model,
+        sessionID: result.sessionID,
+        messageID: result.messageID,
+        title: result.title,
+        body: result.text,
+        extraSections: [
+            {
+                title: "Session Diff Summary",
+                body: diffSummary,
+            },
+            {
+                title: "Workspace Snapshot After Implementation",
+                body: [
+                    "### git status --short",
+                    renderCodeBlock(afterWorkspace.statusShort || "Clean working tree"),
+                    "### git diff --stat",
+                    renderCodeBlock(afterWorkspace.diffStat || "No unstaged diff"),
+                ].join("\n\n"),
+            },
+        ],
+    });
+    const writeResult = await writeStageArtifact({
+        projectRoot: input.projectRoot,
+        config: input.configInfo.config,
+        configPath: input.configInfo.path,
+        stage: "implementation-context",
+        content,
+        mode: "replace",
+        details: {
+            role: result.role,
+            model: result.model,
+            sessionID: result.sessionID,
+            messageID: result.messageID,
+            title: result.title,
+        },
+    });
+    return {
+        ...result,
+        artifactPath: writeResult.artifactPath,
+        content,
+    };
+}
+async function executeReviewerStage(input) {
+    const [plan, planReview, implementation, workspace] = await Promise.all([
+        requireArtifactContent(input.projectRoot, input.configInfo, "plan", "Run akane_plan first."),
+        requireArtifactContent(input.projectRoot, input.configInfo, "plan-review", "Run akane_plan_review first."),
+        requireArtifactContent(input.projectRoot, input.configInfo, "implementation-context", "Run akane_implement first."),
+        captureWorkspaceSnapshot(input.projectRoot),
+    ]);
+    const reviewer = input.stage === "review-codex" ? "codex" : "claude";
+    const result = await runStageSession({
+        pluginInput: input.pluginInput,
+        configInfo: input.configInfo,
+        toolContext: input.toolContext,
+        projectRoot: input.projectRoot,
+        stage: input.stage,
+        title: `Akane ${reviewer === "codex" ? "Codex" : "Claude"} Review`,
+        system: reviewSystemPrompt(reviewer),
+        prompt: [
+            buildTaskBlock(input.task, input.notes),
+            buildArtifactBlock("Plan Artifact", plan),
+            buildArtifactBlock("Plan Review Artifact", planReview),
+            buildArtifactBlock("Implementation Artifact", implementation),
+            renderSection("Current Workspace Snapshot", [
+                "### git status --short",
+                renderCodeBlock(workspace.statusShort || "Clean working tree"),
+                "### git diff --stat",
+                renderCodeBlock(workspace.diffStat || "No unstaged diff"),
+            ].join("\n\n")),
+        ]
+            .filter(Boolean)
+            .join("\n"),
+        allowWorkspaceMutation: false,
+    });
+    const content = renderStageDocument({
+        stage: result.stage,
+        role: result.role,
+        model: result.model,
+        sessionID: result.sessionID,
+        messageID: result.messageID,
+        title: result.title,
+        body: result.text,
+    });
+    const writeResult = await writeStageArtifact({
+        projectRoot: input.projectRoot,
+        config: input.configInfo.config,
+        configPath: input.configInfo.path,
+        stage: input.stage,
+        content,
+        mode: "replace",
+        details: {
+            role: result.role,
+            model: result.model,
+            sessionID: result.sessionID,
+            messageID: result.messageID,
+            title: result.title,
+        },
+    });
+    return {
+        ...result,
+        artifactPath: writeResult.artifactPath,
+        content,
+    };
+}
+export async function executeReviewStage(input) {
+    const stages = input.reviewer === "both"
+        ? ["review-codex", "review-claude"]
+        : [input.reviewer === "codex" ? "review-codex" : "review-claude"];
+    const results = await Promise.all(stages.map((stage) => executeReviewerStage({
+        ...input,
+        stage,
+    })));
+    return {
+        requested: input.reviewer,
+        results,
+    };
+}
+export async function executeSynthesizeStage(input) {
+    const [plan, planReview, implementation, reviewCodex, reviewClaude, workspace] = await Promise.all([
+        requireArtifactContent(input.projectRoot, input.configInfo, "plan", "Run akane_plan first."),
+        requireArtifactContent(input.projectRoot, input.configInfo, "plan-review", "Run akane_plan_review first."),
+        requireArtifactContent(input.projectRoot, input.configInfo, "implementation-context", "Run akane_implement first."),
+        requireArtifactContent(input.projectRoot, input.configInfo, "review-codex", "Run akane_review first."),
+        requireArtifactContent(input.projectRoot, input.configInfo, "review-claude", "Run akane_review first."),
+        captureWorkspaceSnapshot(input.projectRoot),
+    ]);
+    const result = await runStageSession({
+        pluginInput: input.pluginInput,
+        configInfo: input.configInfo,
+        toolContext: input.toolContext,
+        projectRoot: input.projectRoot,
+        stage: "final-synthesis",
+        title: `Akane Final Synthesis${input.task ? `: ${truncate(input.task, 40)}` : ""}`,
+        system: synthesizeSystemPrompt(),
+        prompt: [
+            buildTaskBlock(input.task, input.notes),
+            buildArtifactBlock("Plan Artifact", plan),
+            buildArtifactBlock("Plan Review Artifact", planReview),
+            buildArtifactBlock("Implementation Artifact", implementation),
+            buildArtifactBlock("Codex Review Artifact", reviewCodex),
+            buildArtifactBlock("Claude Review Artifact", reviewClaude),
+            renderSection("Current Workspace Snapshot", [
+                "### git status --short",
+                renderCodeBlock(workspace.statusShort || "Clean working tree"),
+                "### git diff --stat",
+                renderCodeBlock(workspace.diffStat || "No unstaged diff"),
+            ].join("\n\n")),
+        ]
+            .filter(Boolean)
+            .join("\n"),
+        allowWorkspaceMutation: false,
+    });
+    const content = renderStageDocument({
+        stage: result.stage,
+        role: result.role,
+        model: result.model,
+        sessionID: result.sessionID,
+        messageID: result.messageID,
+        title: result.title,
+        body: result.text,
+    });
+    const writeResult = await writeStageArtifact({
+        projectRoot: input.projectRoot,
+        config: input.configInfo.config,
+        configPath: input.configInfo.path,
+        stage: "final-synthesis",
+        content,
+        mode: "replace",
+        details: {
+            role: result.role,
+            model: result.model,
+            sessionID: result.sessionID,
+            messageID: result.messageID,
+            title: result.title,
+        },
+    });
+    return {
+        ...result,
+        artifactPath: writeResult.artifactPath,
+        content,
+    };
+}
+export async function executeRunWorkflow(input) {
+    const completedStages = [];
+    const plan = await executePlanStage(input);
+    completedStages.push("plan");
+    if (input.throughStage === "plan") {
+        return { completedStages, plan };
+    }
+    const planReview = await executePlanReviewStage(input);
+    completedStages.push("plan-review");
+    if (input.throughStage === "plan-review") {
+        return { completedStages, plan, planReview };
+    }
+    const implementation = await executeImplementStage(input);
+    completedStages.push("implementation-context");
+    if (input.throughStage === "implementation-context") {
+        return { completedStages, plan, planReview, implementation };
+    }
+    const reviews = (await executeReviewStage({
+        ...input,
+        reviewer: "both",
+    })).results;
+    completedStages.push("review-codex", "review-claude");
+    if (input.throughStage === "review-codex" ||
+        input.throughStage === "review-claude") {
+        return { completedStages, plan, planReview, implementation, reviews };
+    }
+    const synthesis = await executeSynthesizeStage(input);
+    completedStages.push("final-synthesis");
+    return {
+        completedStages,
+        plan,
+        planReview,
+        implementation,
+        reviews,
+        synthesis,
+    };
+}
+export function reviewSelectionLabel(selection) {
+    if (selection === "both") {
+        return "codex + claude";
+    }
+    return selection;
+}