@nyxa/nyx-agent 0.7.0 → 0.8.1

package/dist/runtime/runPipeline.js

@@ -1,22 +1,25 @@
 import path from "node:path";
+import { execa } from "execa";
 import { loadConfig } from "../config/loadConfig.js";
-import { ensureDir, pathExists, readText } from "./files.js";
+import { globalReviewRoles, } from "../config/schema.js";
+import { ensureDir, pathExists, readText, writeText } from "./files.js";
 import { deleteBranch, removeRunWorktree, setUpRunWorktree, } from "./gitLifecycle.js";
 import { markWorkItemCompleted, readWorkItemLedger, writeWorkItemLedger, } from "./ledger.js";
 import { getNyxDir, relativeToProject } from "./paths.js";
-import { buildContextBlock, buildPhasePrompt, EXECUTION_PROMPT, GLOBAL_REVIEW_PROMPT, GLOBAL_REVISION_PROMPT, REVIEW_PROMPT, REVISION_PROMPT, SELECTION_PROMPT, truncateForPrompt, } from "./prompts.js";
+import { buildContextBlock, buildPhasePrompt, EXECUTION_PROMPT, GLOBAL_REVIEW_CHALLENGE_PROMPT, GLOBAL_REVIEW_PROMPT, GLOBAL_REVIEW_VALIDATION_PROMPT, GLOBAL_REVISION_PROMPT, REVIEW_CHALLENGE_PROMPT, REVIEW_PROMPT, REVIEW_VALIDATION_PROMPT, REVISION_PROMPT, SELECTION_PROMPT, } from "./prompts.js";
 import { createRunReporter } from "./reporter.js";
 import { runAgentPhase, } from "./runPhase.js";
-import { GLOBAL_REVIEW_SCHEMA, REVIEW_SCHEMA, SELECTION_SCHEMA, } from "./schemas.js";
+import { REVIEW_CHALLENGE_SCHEMA, REVIEW_DISCOVERY_SCHEMA, GLOBAL_REVIEW_SCHEMA, REVIEW_VALIDATION_SCHEMA, SELECTION_SCHEMA, } from "./schemas.js";
 import { commitAll, commitsAhead, createPullRequest, pushBranch, rangeDiff, stageAllAndDiff, } from "./scm.js";
 import { confirmWorkItemSelection, } from "./selectionConfirmation.js";
 import { createRunId } from "./time.js";
-import { filterAvailable, listGitHubIssues, resolveSelectedQueue, } from "./workItems.js";
+import { filterAvailable, listGitHubWorkItemInventory, resolveSelectedQueue, } from "./workItems.js";
 const MAX_CANDIDATES = 50;
 const EXCERPT_CHARS = 800;
+const CORRECTION_VALIDATION_MAX_ATTEMPTS = 3;
 export function defaultPipelineDependencies() {
     return {
-        listIssues: listGitHubIssues,
+        listIssues: listGitHubWorkItemInventory,
         runPhase: runAgentPhase,
         pushBranch,
         createPullRequest,
@@ -37,25 +40,32 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
     const nyxDir = getNyxDir(projectRoot);
     const configPath = input.configPath ?? path.join(nyxDir, "config.json");
     const config = await loadConfig(configPath);
-    const harness = input.harness ?? config.harness;
+    const baseAgent = resolveAgentProfile({
+        config,
+        cliHarness: input.harness,
+    });
     const runId = createRunId();
     const runDir = path.join(nyxDir, "runs", runId);
     await ensureDir(runDir);
     const reporter = input.reporter ?? createRunReporter({ verbose: input.verbose ?? false });
     reporter.heading(`NyxAgent run ${runId}`);
-    reporter.info(`Harness: ${harness} · model: ${config.model} · review: ${config.review}`);
+    reporter.info(`Harness: ${baseAgent.harness} · model: ${baseAgent.model} · review: ${config.review}`);
     reporter.detail(`Config: ${relativeToProject(projectRoot, configPath)}`);
     reporter.detail(`Artifacts: ${relativeToProject(projectRoot, runDir)}`);
     reporter.detail(`Tracker: ${config.tracker.repo}`);
+    if (config.review_max_attempts !== undefined) {
+        reporter.warn("review_max_attempts is deprecated and ignored; use review_rounds.each/global instead.");
+    }
     const ledger = await readWorkItemLedger(nyxDir);
     reporter.detail(`Completed work items already in ledger: ${ledger.completed_work_item_keys.length}`);
     // 1. Selection runs read-only in the main checkout, before any branch exists.
+    const inventory = normalizeWorkItemInventory(await deps.listIssues({
+        repo: config.tracker.repo,
+        maxCandidates: MAX_CANDIDATES,
+        excerptChars: EXCERPT_CHARS,
+    }));
     const candidates = filterAvailable({
-        candidates: await deps.listIssues({
-            repo: config.tracker.repo,
-            maxCandidates: MAX_CANDIDATES,
-            excerptChars: EXCERPT_CHARS,
-        }),
+        candidates: inventory.candidates,
         completedKeys: ledger.completed_work_item_keys,
     });
     reporter.detail(`Available work item candidates: ${candidates.length}`);
@@ -66,7 +76,7 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
     const proposed = await runSelection({
         projectRoot,
         runDir,
-        harness,
+        cliHarness: input.harness,
         config,
         candidates,
         runPhase: deps.runPhase,
@@ -114,7 +124,7 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
                 item,
                 guidance: executionGuidance,
                 git,
-                harness,
+                cliHarness: input.harness,
                 config,
                 runPhase: deps.runPhase,
                 reporter,
@@ -124,9 +134,9 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
                     iterationDir,
                     item,
                     git,
-                    harness,
+                    cliHarness: input.harness,
                     config,
-                    maxAttempts: config.review_max_attempts,
+                    rounds: config.review_rounds.each,
                     runPhase: deps.runPhase,
                     reporter,
                 });
@@ -153,9 +163,10 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
             const corrections = await runGlobalReviewLoop({
                 runDir,
                 git,
-                harness,
+                completed,
+                cliHarness: input.harness,
                 config,
-                maxAttempts: config.review_max_attempts,
+                rounds: config.review_rounds.global,
                 runPhase: deps.runPhase,
                 reporter,
             });
@@ -177,7 +188,10 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
             base: git.base,
             head: git.branch,
             title: buildPrTitle(completed),
-            body: buildPrBody(completed),
+            body: buildPrBody({
+                items: completed,
+                parents: inventory.parents,
+            }),
         });
         reporter.success(`\nPull request opened: ${prUrl}`);
         success = true;
@@ -193,6 +207,7 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
             producedCommits,
             completed,
             config,
+            parents: inventory.parents,
             deps,
             reporter,
         });
@@ -242,7 +257,11 @@ async function salvageFailedRun(input) {
             base: input.git.base,
             head: input.git.branch,
             title: buildDraftPrTitle(input.completed),
-            body: buildDraftPrBody(input.completed, reason),
+            body: buildDraftPrBody({
+                items: input.completed,
+                parents: input.parents,
+                reason,
+            }),
             draft: true,
         });
         input.reporter.warn(`\nRun failed, but the work was salvaged into a DRAFT pull request: ${url}`);
@@ -257,6 +276,10 @@ async function salvageFailedRun(input) {
     }
 }
 async function runSelection(input) {
+    const agent = resolveAgentProfile({
+        config: input.config,
+        cliHarness: input.cliHarness,
+    });
     const context = buildContextBlock([
         ["Repository", input.config.tracker.repo],
         ["Max work items this run", input.config.max_iterations],
@@ -267,6 +290,7 @@ async function runSelection(input) {
                 number: candidate.number,
                 title: candidate.title,
                 labels: candidate.labels,
+                parent: candidate.parent,
                 excerpt: candidate.excerpt,
             })),
         ],
@@ -275,9 +299,9 @@ async function runSelection(input) {
         phaseId: "selection",
         phaseDir: path.join(input.runDir, "selection"),
         workdir: input.projectRoot,
-        harness: input.harness,
-        model: input.config.model,
-        reasoning: input.config.reasoning_effort,
+        harness: agent.harness,
+        model: agent.model,
+        reasoning: agent.reasoning_effort,
         capability: "readonly",
         prompt: buildPhasePrompt({
             guidance: SELECTION_PROMPT,
@@ -304,6 +328,11 @@ async function runSelection(input) {
     return resolved.queue;
 }
 async function runExecution(input) {
+    const agent = resolveAgentProfile({
+        config: input.config,
+        cliHarness: input.cliHarness,
+        phase: "execution",
+    });
     const context = buildContextBlock([
         ["Work item", workItemSummary(input.item)],
         ["Issue description", input.item.excerpt ?? "(no description provided)"],
@@ -314,9 +343,9 @@ async function runExecution(input) {
         phaseId: "execution",
         phaseDir: path.join(input.iterationDir, "execution"),
         workdir: input.git.worktree,
-        harness: input.harness,
-        model: input.config.model,
-        reasoning: input.config.reasoning_effort,
+        harness: agent.harness,
+        model: agent.model,
+        reasoning: agent.reasoning_effort,
         capability: "write",
         prompt: buildPhasePrompt({ guidance: input.guidance, context }),
         reporter: input.reporter,
@@ -326,54 +355,275 @@ async function runExecution(input) {
     }
 }
 async function runReviewLoop(input) {
-    for (let attempt = 1; attempt <= input.maxAttempts; attempt += 1) {
-        const diff = await stageAllAndDiff(input.git.worktree);
-        const reviewResult = await input.runPhase({
+    const agent = resolveAgentProfile({
+        config: input.config,
+        cliHarness: input.cliHarness,
+        phase: "review",
+    });
+    const validationHistory = [];
+    for (let round = 1; round <= input.rounds; round += 1) {
+        const roundDir = path.join(input.iterationDir, `review-round-${round}`);
+        const discoveryPack = await createReviewContextPack({
+            dir: path.join(roundDir, "discovery", "review-context"),
+            git: input.git,
+            scope: "item",
+            workItems: [input.item],
+            validations: validationHistory,
+        });
+        const discoveryResult = await input.runPhase({
             phaseId: "review",
-            phaseDir: path.join(input.iterationDir, `review-${attempt}`),
+            phaseDir: path.join(roundDir, "discovery"),
             workdir: input.git.worktree,
-            harness: input.harness,
-            model: input.config.model,
-            reasoning: input.config.reasoning_effort,
+            harness: agent.harness,
+            model: agent.model,
+            reasoning: agent.reasoning_effort,
             capability: "readonly",
             prompt: buildPhasePrompt({
                 guidance: REVIEW_PROMPT,
                 context: buildContextBlock([
                     ["Work item", workItemSummary(input.item)],
-                    [
-                        "Uncommitted changes (diff)",
-                        truncateForPrompt(diff || "(no changes)"),
-                    ],
+                    ["Review round", round],
+                    ["Review context", reviewContextSummary(discoveryPack)],
                 ]),
-                schema: REVIEW_SCHEMA,
+                schema: REVIEW_DISCOVERY_SCHEMA,
             }),
-            schema: REVIEW_SCHEMA,
+            schema: REVIEW_DISCOVERY_SCHEMA,
             reporter: input.reporter,
         });
-        if (!reviewResult.ok) {
-            throw new Error(reviewResult.error);
+        if (!discoveryResult.ok) {
+            throw new Error(discoveryResult.error);
         }
-        const review = reviewResult.result;
-        input.reporter.info(`  review: ${review.outcome}`);
-        if (review.outcome === "approved") {
-            return;
+        const discovery = discoveryResult.result;
+        const proposedBlockers = normalizeFindings(discovery.blockers);
+        input.reporter.info(`  review round ${round}: ${proposedBlockers.length} proposed blocker(s)`);
+        const challenge = await runReviewChallenge({
+            phaseId: "review_challenge",
+            phaseDir: path.join(roundDir, "challenge"),
+            workdir: input.git.worktree,
+            agent,
+            runPhase: input.runPhase,
+            reporter: input.reporter,
+            guidance: REVIEW_CHALLENGE_PROMPT,
+            contextEntries: [
+                ["Work item", workItemSummary(input.item)],
+                ["Review round", round],
+                ["Review context", reviewContextSummary(discoveryPack)],
+                ["Proposed blockers", proposedBlockers],
+                ["Rejected findings from discovery", discovery.rejected_findings ?? []],
+            ],
+        });
+        input.reporter.info(`  review round ${round}: ${challenge.blockers.length} verified blocker(s)`);
+        await runCorrectionValidationLoop({
+            scope: "item",
+            roundDir,
+            git: input.git,
+            workItems: [input.item],
+            validationHistory,
+            blockers: challenge.blockers,
+            agent,
+            runPhase: input.runPhase,
+            reporter: input.reporter,
+            revisionPhaseId: "revision",
+            validationPhaseId: "review_validation",
+            revisionGuidance: REVISION_PROMPT,
+            validationGuidance: REVIEW_VALIDATION_PROMPT,
+            failureMessage: (blockers) => `Review for #${input.item.number} has unresolved blocker(s) after ${CORRECTION_VALIDATION_MAX_ATTEMPTS} correction validation attempts:${formatBlockers(blockers)}`,
+        });
+    }
+}
+async function runGlobalReviewLoop(input) {
+    let committedCorrections = false;
+    const validationHistory = [];
+    for (let round = 1; round <= input.rounds; round += 1) {
+        const roundDir = path.join(input.runDir, "final", `global-round-${round}`);
+        const discoveryPack = await createReviewContextPack({
+            dir: path.join(roundDir, "discovery", "review-context"),
+            git: input.git,
+            scope: "global",
+            workItems: input.completed,
+            validations: validationHistory,
+        });
+        const discoveries = [];
+        for (const role of globalReviewRoles) {
+            const roleAgent = resolveAgentProfile({
+                config: input.config,
+                cliHarness: input.cliHarness,
+                phase: "global_review",
+                role,
+            });
+            const reviewResult = await input.runPhase({
+                phaseId: "global_review",
+                phaseDir: path.join(roundDir, "discovery", role),
+                workdir: input.git.worktree,
+                harness: roleAgent.harness,
+                model: roleAgent.model,
+                reasoning: roleAgent.reasoning_effort,
+                capability: "readonly",
+                prompt: buildPhasePrompt({
+                    guidance: buildGlobalReviewGuidance(role),
+                    context: buildContextBlock([
+                        ["Run branch", `${input.git.branch} (base ${input.git.base})`],
+                        ["Review round", round],
+                        ["Reviewer role", role],
+                        ["Review context", reviewContextSummary(discoveryPack)],
+                    ]),
+                    schema: GLOBAL_REVIEW_SCHEMA,
+                }),
+                schema: GLOBAL_REVIEW_SCHEMA,
+                reporter: input.reporter,
+            });
+            if (!reviewResult.ok) {
+                throw new Error(reviewResult.error);
+            }
+            discoveries.push(reviewResult.result);
         }
-        if (attempt === input.maxAttempts) {
-            throw new Error(`Review for #${input.item.number} not approved after ${input.maxAttempts} attempts: ${review.summary}${formatRequiredChanges(review.required_changes)}`);
+        const aggregated = aggregateDiscoveries(discoveries);
+        input.reporter.info(`global review round ${round}: ${aggregated.blockers.length} proposed blocker(s)`);
+        const challengeAgent = resolveAgentProfile({
+            config: input.config,
+            cliHarness: input.cliHarness,
+            phase: "global_review",
+        });
+        const challenge = await runReviewChallenge({
+            phaseId: "global_review_challenge",
+            phaseDir: path.join(roundDir, "challenge"),
+            workdir: input.git.worktree,
+            agent: challengeAgent,
+            runPhase: input.runPhase,
+            reporter: input.reporter,
+            guidance: GLOBAL_REVIEW_CHALLENGE_PROMPT,
+            contextEntries: [
+                ["Run branch", `${input.git.branch} (base ${input.git.base})`],
+                ["Review round", round],
+                ["Review context", reviewContextSummary(discoveryPack)],
+                ["Aggregated proposed blockers", aggregated.blockers],
+                ["Aggregated rejected findings", aggregated.rejected_findings],
+            ],
+        });
+        input.reporter.info(`global review round ${round}: ${challenge.blockers.length} verified blocker(s)`);
+        const roundCommittedCorrections = await runCorrectionValidationLoop({
+            scope: "global",
+            roundDir,
+            git: input.git,
+            workItems: input.completed,
+            validationHistory,
+            blockers: challenge.blockers,
+            agent: challengeAgent,
+            runPhase: input.runPhase,
+            reporter: input.reporter,
+            revisionPhaseId: "global_revision",
+            validationPhaseId: "global_review_validation",
+            revisionGuidance: GLOBAL_REVISION_PROMPT,
+            validationGuidance: GLOBAL_REVIEW_VALIDATION_PROMPT,
+            commitMessage: "Apply global review corrections",
+            failureMessage: (blockers) => `Global review has unresolved blocker(s) after ${CORRECTION_VALIDATION_MAX_ATTEMPTS} correction validation attempts:${formatBlockers(blockers)}`,
+        });
+        if (roundCommittedCorrections) {
+            committedCorrections = true;
         }
+    }
+    return committedCorrections;
+}
+function resolveAgentProfile(input) {
+    const profile = {
+        harness: input.cliHarness ?? input.config.harness,
+        model: input.config.model,
+        reasoning_effort: input.config.reasoning_effort,
+    };
+    const phaseOverride = input.phase
+        ? phaseAgentOverride(input.config, input.phase)
+        : undefined;
+    const roleOverride = input.role
+        ? input.config.agents?.global_review?.roles?.[input.role]
+        : undefined;
+    return applyAgentOverride(applyAgentOverride(profile, phaseOverride), roleOverride);
+}
+function phaseAgentOverride(config, phase) {
+    if (phase === "execution") {
+        return config.agents?.execution;
+    }
+    if (phase === "review") {
+        return config.agents?.review;
+    }
+    return config.agents?.global_review;
+}
+function applyAgentOverride(profile, override) {
+    if (!override) {
+        return profile;
+    }
+    return {
+        harness: override.harness ?? profile.harness,
+        model: override.model ?? profile.model,
+        reasoning_effort: override.reasoning_effort ?? profile.reasoning_effort,
+    };
+}
+function buildGlobalReviewGuidance(role) {
+    const focus = {
+        "diff-contract": "Focus on the public contract of the diff: APIs, CLI behavior, schemas, config compatibility, and generated artifacts.",
+        integration: "Focus on integration across touched modules, phase sequencing, artifact paths, and cross-item behavior.",
+        "domain-invariants": "Focus on NyxAgent workflow invariants: engine-owned git side effects, read-only review phases, closed pipeline control flow, and review semantics.",
+        "tests-validation": "Focus on test coverage, validation evidence, failure modes, and whether the committed changes are demonstrably safe.",
+    };
+    return `${GLOBAL_REVIEW_PROMPT}\n\nRole focus (${role}): ${focus[role]}`;
+}
+async function runReviewChallenge(input) {
+    const result = await input.runPhase({
+        phaseId: input.phaseId,
+        phaseDir: input.phaseDir,
+        workdir: input.workdir,
+        harness: input.agent.harness,
+        model: input.agent.model,
+        reasoning: input.agent.reasoning_effort,
+        capability: "readonly",
+        prompt: buildPhasePrompt({
+            guidance: input.guidance,
+            context: buildContextBlock(input.contextEntries),
+            schema: REVIEW_CHALLENGE_SCHEMA,
+        }),
+        schema: REVIEW_CHALLENGE_SCHEMA,
+        reporter: input.reporter,
+    });
+    if (!result.ok) {
+        throw new Error(result.error);
+    }
+    const challenge = result.result;
+    return {
+        ...challenge,
+        blockers: normalizeFindings(challenge.blockers),
+        rejected_findings: normalizeFindings(challenge.rejected_findings),
+    };
+}
+async function runCorrectionValidationLoop(input) {
+    let pending = normalizeFindings(input.blockers);
+    let committedCorrections = false;
+    if (pending.length === 0) {
+        return committedCorrections;
+    }
+    for (let attempt = 1; attempt <= CORRECTION_VALIDATION_MAX_ATTEMPTS; attempt += 1) {
+        const revisionPack = await createReviewContextPack({
+            dir: path.join(input.roundDir, `${input.revisionPhaseId}-${attempt}`, "review-context"),
+            git: input.git,
+            scope: input.scope,
+            workItems: input.workItems,
+            validations: input.validationHistory,
+        });
         const revision = await input.runPhase({
-            phaseId: "revision",
-            phaseDir: path.join(input.iterationDir, `revision-${attempt}`),
+            phaseId: input.revisionPhaseId,
+            phaseDir: path.join(input.roundDir, `${input.revisionPhaseId}-${attempt}`),
             workdir: input.git.worktree,
-            harness: input.harness,
-            model: input.config.model,
-            reasoning: input.config.reasoning_effort,
+            harness: input.agent.harness,
+            model: input.agent.model,
+            reasoning: input.agent.reasoning_effort,
             capability: "write",
             prompt: buildPhasePrompt({
-                guidance: REVISION_PROMPT,
+                guidance: input.revisionGuidance,
                 context: buildContextBlock([
-                    ["Work item", workItemSummary(input.item)],
-                    ["Required changes", review.required_changes ?? []],
+                    ["Review context", reviewContextSummary(revisionPack)],
+                    [
+                        "Correction attempt",
+                        `${attempt}/${CORRECTION_VALIDATION_MAX_ATTEMPTS}`,
+                    ],
+                    ["Verified blockers", pending],
                 ]),
             }),
             reporter: input.reporter,
@@ -381,74 +631,233 @@ async function runReviewLoop(input) {
         if (!revision.ok) {
             throw new Error(revision.error);
         }
-    }
-}
-async function runGlobalReviewLoop(input) {
-    let committedCorrections = false;
-    for (let attempt = 1; attempt <= input.maxAttempts; attempt += 1) {
-        const diff = await rangeDiff(input.git.worktree, input.git.base);
-        const reviewResult = await input.runPhase({
-            phaseId: "global_review",
-            phaseDir: path.join(input.runDir, "final", `global-review-${attempt}`),
+        if (input.commitMessage) {
+            const { committed } = await commitAll({
+                cwd: input.git.worktree,
+                message: input.commitMessage,
+            });
+            if (committed) {
+                committedCorrections = true;
+                input.reporter.detail("Committed global review corrections.");
+            }
+        }
+        const validationPack = await createReviewContextPack({
+            dir: path.join(input.roundDir, `${input.validationPhaseId}-${attempt}`, "review-context"),
+            git: input.git,
+            scope: input.scope,
+            workItems: input.workItems,
+            validations: input.validationHistory,
+        });
+        const validationResult = await input.runPhase({
+            phaseId: input.validationPhaseId,
+            phaseDir: path.join(input.roundDir, `${input.validationPhaseId}-${attempt}`),
             workdir: input.git.worktree,
-            harness: input.harness,
-            model: input.config.model,
-            reasoning: input.config.reasoning_effort,
+            harness: input.agent.harness,
+            model: input.agent.model,
+            reasoning: input.agent.reasoning_effort,
             capability: "readonly",
             prompt: buildPhasePrompt({
-                guidance: GLOBAL_REVIEW_PROMPT,
+                guidance: input.validationGuidance,
                 context: buildContextBlock([
-                    ["Run branch", `${input.git.branch} (base ${input.git.base})`],
+                    ["Review context", reviewContextSummary(validationPack)],
                     [
-                        "Combined run diff (base...HEAD)",
-                        truncateForPrompt(diff || "(no changes)"),
+                        "Correction attempt",
+                        `${attempt}/${CORRECTION_VALIDATION_MAX_ATTEMPTS}`,
                     ],
+                    ["Validated blockers", pending],
                 ]),
-                schema: GLOBAL_REVIEW_SCHEMA,
+                schema: REVIEW_VALIDATION_SCHEMA,
             }),
-            schema: GLOBAL_REVIEW_SCHEMA,
+            schema: REVIEW_VALIDATION_SCHEMA,
             reporter: input.reporter,
         });
-        if (!reviewResult.ok) {
-            throw new Error(reviewResult.error);
+        if (!validationResult.ok) {
+            throw new Error(validationResult.error);
         }
-        const review = reviewResult.result;
-        input.reporter.info(`global review: ${review.outcome}`);
-        if (review.outcome === "approved") {
+        const validation = validationResult.result;
+        const validations = normalizeValidations(validation.validations);
+        input.validationHistory.push(...validations);
+        pending = blockersNeedingCorrection(pending, validations);
+        input.reporter.info(`${input.scope} validation attempt ${attempt}: ${pending.length} unresolved blocker(s)`);
+        if (pending.length === 0) {
             return committedCorrections;
         }
-        if (attempt === input.maxAttempts) {
-            throw new Error(`Global review not approved after ${input.maxAttempts} attempts: ${review.summary}${formatRequiredChanges(review.required_changes)}`);
+    }
+    throw new Error(input.failureMessage(pending));
+}
+async function createReviewContextPack(input) {
+    await ensureDir(input.dir);
+    const patch = input.scope === "item"
+        ? await stageAllAndDiff(input.git.worktree)
+        : await rangeDiff(input.git.worktree, input.git.base);
+    const diffstat = input.scope === "item"
+        ? await gitOutput(input.git.worktree, ["diff", "--cached", "--stat"], "diff --cached --stat")
+        : await gitOutput(input.git.worktree, ["diff", "--stat", `${input.git.base}..HEAD`], "diff --stat range");
+    const files = input.scope === "item"
+        ? await gitOutput(input.git.worktree, ["diff", "--cached", "--name-only"], "diff --cached --name-only")
+        : await gitOutput(input.git.worktree, ["diff", "--name-only", `${input.git.base}..HEAD`], "diff --name-only range");
+    const commits = await gitOutput(input.git.worktree, ["log", "--oneline", `${input.git.base}..HEAD`], "log range");
+    const pack = {
+        dir: input.dir,
+        summaryPath: path.join(input.dir, "summary.md"),
+        patchPath: path.join(input.dir, "combined.patch"),
+        diffstatPath: path.join(input.dir, "diffstat.txt"),
+        commitsPath: path.join(input.dir, "commits.txt"),
+        filesPath: path.join(input.dir, "modified-files.txt"),
+        issuesPath: path.join(input.dir, "issues.json"),
+        validationsPath: path.join(input.dir, "validations.json"),
+    };
+    await writeText(pack.patchPath, textOrPlaceholder(patch, "(no changes)"));
+    await writeText(pack.diffstatPath, textOrPlaceholder(diffstat, "(no diffstat)"));
+    await writeText(pack.commitsPath, textOrPlaceholder(commits, "(no commits yet)"));
+    await writeText(pack.filesPath, textOrPlaceholder(files, "(no modified files)"));
+    await writeText(pack.issuesPath, `${JSON.stringify((input.workItems ?? []).map(workItemSummary), null, 2)}\n`);
+    await writeText(pack.validationsPath, `${JSON.stringify(input.validations, null, 2)}\n`);
+    await writeText(pack.summaryPath, [
+        "# NyxAgent review context",
+        "",
+        `Scope: ${input.scope}`,
+        `Branch: ${input.git.branch}`,
+        `Base: ${input.git.base}`,
+        "",
+        "Artifacts:",
+        `- combined patch: ${pack.patchPath}`,
+        `- diffstat: ${pack.diffstatPath}`,
+        `- modified files: ${pack.filesPath}`,
+        `- commits: ${pack.commitsPath}`,
+        `- issues: ${pack.issuesPath}`,
+        `- validations: ${pack.validationsPath}`,
+        "",
+        "Inspect these files, or run the corresponding git commands in the working directory.",
+    ].join("\n"));
+    return pack;
+}
+async function gitOutput(cwd, args, label) {
+    const result = await execa("git", args, { cwd, reject: false });
+    if (result.exitCode !== 0) {
+        const detail = (result.stderr || result.stdout || "unknown error").trim();
+        throw new Error(`git ${label} failed: ${detail}`);
+    }
+    return result.stdout;
+}
+function reviewContextSummary(pack) {
+    return {
+        directory: pack.dir,
+        summary: pack.summaryPath,
+        combined_patch: pack.patchPath,
+        diffstat: pack.diffstatPath,
+        modified_files: pack.filesPath,
+        commits: pack.commitsPath,
+        issues: pack.issuesPath,
+        validations: pack.validationsPath,
+    };
+}
+function aggregateDiscoveries(discoveries) {
+    return {
+        summary: discoveries
+            .map((discovery) => discovery.summary)
+            .filter((summary) => Boolean(summary))
+            .join("\n"),
+        blockers: dedupeFindings(discoveries.flatMap((discovery) => normalizeFindings(discovery.blockers))),
+        test_gaps: dedupeFindings(discoveries.flatMap((discovery) => normalizeFindings(discovery.test_gaps))),
+        advisory_findings: dedupeFindings(discoveries.flatMap((discovery) => normalizeFindings(discovery.advisory_findings))),
+        uncertain_findings: dedupeFindings(discoveries.flatMap((discovery) => normalizeFindings(discovery.uncertain_findings))),
+        rejected_findings: dedupeFindings(discoveries.flatMap((discovery) => normalizeFindings(discovery.rejected_findings))),
+    };
+}
+function blockersNeedingCorrection(pending, validations) {
+    const byTitle = new Map(pending.map((blocker) => [normalizeTitle(blocker.title), blocker]));
+    const seen = new Set();
+    const unresolved = [];
+    for (const validation of validations) {
+        const key = normalizeTitle(validation.blocker_title);
+        seen.add(key);
+        if (validation.status === "unresolved") {
+            const original = byTitle.get(key);
+            if (original) {
+                unresolved.push({
+                    ...original,
+                    required_change: validation.required_change ?? original.required_change,
+                    evidence: normalizeEvidence(validation.evidence, original.evidence),
+                });
+            }
+            continue;
         }
-        const revision = await input.runPhase({
-            phaseId: "global_revision",
-            phaseDir: path.join(input.runDir, "final", `global-revision-${attempt}`),
-            workdir: input.git.worktree,
-            harness: input.harness,
-            model: input.config.model,
-            reasoning: input.config.reasoning_effort,
-            capability: "write",
-            prompt: buildPhasePrompt({
-                guidance: GLOBAL_REVISION_PROMPT,
-                context: buildContextBlock([
-                    ["Required changes", review.required_changes ?? []],
-                ]),
-            }),
-            reporter: input.reporter,
-        });
-        if (!revision.ok) {
-            throw new Error(revision.error);
+        if (validation.status === "regression_from_correction") {
+            unresolved.push({
+                title: validation.blocker_title,
+                required_change: validation.required_change ??
+                    `Fix regression from correction: ${validation.blocker_title}`,
+                confidence: "high",
+                evidence: normalizeEvidence(validation.evidence),
+            });
         }
-        const { committed } = await commitAll({
-            cwd: input.git.worktree,
-            message: "Apply global review corrections",
-        });
-        if (committed) {
-            committedCorrections = true;
-            input.reporter.detail("Committed global review corrections.");
+    }
+    for (const blocker of pending) {
+        if (!seen.has(normalizeTitle(blocker.title))) {
+            unresolved.push(blocker);
         }
     }
-    return committedCorrections;
+    return dedupeFindings(unresolved);
+}
+function normalizeFindings(findings) {
+    return dedupeFindings((findings ?? [])
+        .filter((finding) => finding.title && finding.required_change)
+        .map((finding) => ({
+        title: finding.title,
+        required_change: finding.required_change,
+        confidence: normalizeConfidence(finding.confidence),
+        evidence: normalizeEvidence(finding.evidence),
+    })));
+}
+function normalizeValidations(validations) {
+    const allowed = new Set([
+        "resolved",
+        "unresolved",
+        "false_positive",
+        "regression_from_correction",
+    ]);
+    return (validations ?? [])
+        .filter((validation) => validation.blocker_title && allowed.has(validation.status))
+        .map((validation) => ({
+        ...validation,
+        evidence: normalizeEvidence(validation.evidence),
+    }));
+}
+function dedupeFindings(findings) {
+    const seen = new Set();
+    const deduped = [];
+    for (const finding of findings) {
+        const key = `${normalizeTitle(finding.title)}\n${finding.required_change.trim().toLowerCase()}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(finding);
+    }
+    return deduped;
+}
+function normalizeEvidence(evidence, fallback) {
+    if (Array.isArray(evidence) && evidence.length > 0) {
+        return evidence;
+    }
+    if (fallback && fallback.length > 0) {
+        return fallback;
+    }
+    return [{ detail: "No evidence provided." }];
+}
+function normalizeConfidence(value) {
+    if (value === "low" || value === "medium" || value === "high") {
+        return value;
+    }
+    return "medium";
+}
+function normalizeTitle(value) {
+    return value.trim().toLowerCase();
+}
+function textOrPlaceholder(text, placeholder) {
+    const trimmed = text.trim();
+    return `${trimmed.length > 0 ? trimmed : placeholder}\n`;
 }
 async function loadExecutionGuidance(nyxDir) {
     const override = path.join(nyxDir, "prompts", "execution.md");
@@ -468,6 +877,7 @@ function workItemSummary(item) {
         locator: item.source.locator,
         url: item.url,
         labels: item.labels,
+        parent: item.parent,
     };
 }
 function buildCommitMessage(item) {
@@ -479,41 +889,90 @@ function buildPrTitle(items) {
     }
     return `NyxAgent: ${items.length} work items`;
 }
-function buildPrBody(items) {
-    const list = items
+function normalizeWorkItemInventory(result) {
+    if (Array.isArray(result)) {
+        return { candidates: result, parents: [] };
+    }
+    return {
+        candidates: result.candidates,
+        parents: result.parents ?? [],
+    };
+}
+function buildPrBody(input) {
+    const list = input.items
         .map((item) => `- ${item.title} (#${item.number})`)
         .join("\n");
-    const closes = items.map((item) => `Closes #${item.number}`).join("\n");
-    return [
+    const completedParents = completedParentClosures(input);
+    const closeNumbers = [
+        ...uniqueNumbers(input.items.map((item) => item.number)),
+        ...uniqueNumbers(completedParents.map((parent) => parent.number)),
+    ];
+    const closes = closeNumbers.map((number) => `Closes #${number}`).join("\n");
+    const sections = [
         "Automated changes by NyxAgent.",
         "",
         "## Work items",
         "",
         list,
-        "",
-        closes,
-    ].join("\n");
+    ];
+    if (completedParents.length > 0) {
+        sections.push("", "## Completed plans", "", completedParents
+            .map((parent) => `- ${parent.title ?? `Parent issue ${parent.number}`} (#${parent.number})`)
+            .join("\n"));
+    }
+    sections.push("", closes);
+    return sections.join("\n");
 }
 function buildDraftPrTitle(items) {
     return `[Draft] ${buildPrTitle(items)}`;
 }
-function buildDraftPrBody(items, reason) {
+function buildDraftPrBody(input) {
     return [
         "> [!WARNING]",
         "> This pull request was opened automatically by NyxAgent after the run",
         "> **failed review**. The work is preserved here for a human to finish.",
         "",
-        `**Why the run failed:** ${reason}`,
+        `**Why the run failed:** ${input.reason}`,
         "",
-        buildPrBody(items),
+        buildPrBody({
+            items: input.items,
+            parents: input.parents,
+        }),
     ].join("\n");
 }
-/** Render review `required_changes` as a bullet list to append to a failure message. */
-function formatRequiredChanges(changes) {
-    if (!changes || changes.length === 0) {
+function completedParentClosures(input) {
+    const completedKeys = new Set(input.items.map((item) => item.key));
+    const completedParentKeys = new Set(input.items
+        .map((item) => item.parent?.key)
+        .filter((key) => Boolean(key)));
+    const completedParents = [];
+    for (const parent of input.parents ?? []) {
+        if (!parent.closable || !completedParentKeys.has(parent.key)) {
+            continue;
+        }
+        const openChildren = parent.children.filter((child) => child.state !== "closed");
+        const openContainerChild = openChildren.some((child) => !child.executable);
+        if (openContainerChild) {
+            continue;
+        }
+        const completedChildInThisPr = parent.children.some((child) => completedKeys.has(child.key));
+        if (!completedChildInThisPr ||
+            openChildren.some((child) => !completedKeys.has(child.key))) {
+            continue;
+        }
+        completedParents.push(parent);
+    }
+    return completedParents;
+}
+function uniqueNumbers(numbers) {
+    return [...new Set(numbers)];
+}
+/** Render unresolved blockers as a bullet list to append to a failure message. */
+function formatBlockers(blockers) {
+    if (blockers.length === 0) {
         return "";
     }
-    return `\n\nUnresolved review feedback:\n${changes
-        .map((change) => `- ${change}`)
+    return `\n\nUnresolved review blockers:\n${blockers
+        .map((blocker) => `- ${blocker.title}: ${blocker.required_change}`)
         .join("\n")}`;
 }