@nyxa/nyx-agent 0.6.1 → 0.8.0

package/README.md

@@ -11,7 +11,8 @@ For every run NyxAgent:
    confirm the proposed checklist.
 2. For each selected issue, in an isolated git **worktree**:
    - **implements** it (the agent — the only customizable prompt),
-   - optionally **reviews** and **revises** it (bounded loop),
+   - optionally **reviews** it in bounded discovery rounds, then revises only
+     verified blockers with locked validation,
    - **commits** the change (the engine, deterministically).
 3. Optionally runs a **global review** across the whole run.
 4. **Pushes** the run branch and **opens one pull request** (the engine).
@@ -31,6 +32,7 @@ nyxagent init                 # create .nyxagent/config.json (interactive)
 nyxagent run                  # run the pipeline, confirming selected work items
 nyxagent run --yes            # accept the agent selection without prompting
 nyxagent run --harness claude # override the configured harness for one run
+nyxagent run --verbose        # stream agent output and runtime details
 nyxagent update               # self-update to the latest published version
 ```
 
@@ -44,7 +46,7 @@ nyxagent update               # self-update to the latest published version
   "model": "gpt-5.5",
   "reasoning_effort": "medium",
   "review": "each",
-  "review_max_attempts": 4,
+  "review_rounds": { "each": 1, "global": 1 },
   "tracker": { "type": "github", "repo": "owner/repo" },
   "base_branch": "main",
   "max_iterations": 5
@@ -53,12 +55,19 @@ nyxagent update               # self-update to the latest published version
 
 - `harness`: `codex` or `claude` (override per run with `--harness`).
 - `review`: `each` (per task), `all` (global only), `both`, or `none`.
-- `review_max_attempts`: review+revise rounds per stage before the run fails (default 4).
+- `review_rounds.each`: fresh per-task discovery rounds (default 1).
+- `review_rounds.global`: fresh global discovery rounds (default 1).
+- `review_max_attempts`: deprecated; accepted for old configs with a warning, but
+  ignored by the review loop.
+- `agents.execution`, `agents.review`, `agents.global_review`, and
+  `agents.global_review.roles.<role>` can override `harness`, `model`, and
+  `reasoning_effort` for specialized phases. Global review roles are
+  `diff-contract`, `integration`, `domain-invariants`, and `tests-validation`.
 - `base_branch`: optional; defaults to the current branch at run time.
 
-If a run fails review after exhausting its attempts but has already produced
+If a run fails review validation but has already produced
 commits, NyxAgent pushes the branch and opens a **draft** pull request with the
-unresolved feedback, so the work is never stranded on an orphaned branch.
+unresolved blockers, so the work is never stranded on an orphaned branch.
 
 ## Requirements
 

package/dist/cli.js

@@ -20,7 +20,9 @@ program
     .option("--model <name>", "model name")
     .option("--reasoning-effort <level>", "reasoning effort (default: medium)")
     .option("--review <mode>", "review strategy: each, all, both, or none")
-    .option("--review-attempts <count>", "max review attempts per stage (default: 4)")
+    .option("--review-rounds-each <count>", "per-work-item review discovery rounds (default: 1)")
+    .option("--review-rounds-global <count>", "global review discovery rounds (default: 1)")
+    .option("--review-attempts <count>", "deprecated alias for both review round counts")
     .option("--repo <owner/repo>", "GitHub repository")
     .option("--base-branch <branch>", "base branch (default: current branch)")
     .option("--max-iterations <count>", "maximum work items per run")
@@ -34,6 +36,7 @@ program
     .option("--config <path>", "config path (default: .nyxagent/config.json)")
     .option("--harness <name>", "override the configured harness: codex or claude")
     .option("-y, --yes", "accept the agent-selected work items without prompting")
+    .option("--verbose", "stream agent output and NyxAgent runtime details")
     .action(async (options) => {
     await runCommand(options);
 });

package/dist/commands/init.js

@@ -2,8 +2,8 @@
 import path from "node:path";
 import { input, number as numberPrompt, select } from "@inquirer/prompts";
 import pc from "picocolors";
-import { harnessNames, reviewModes } from "../config/schema.js";
-import { ensureDir, pathExists, readText, writeText } from "../runtime/files.js";
+import { harnessNames, reviewModes, } from "../config/schema.js";
+import { ensureDir, pathExists, readText, writeText, } from "../runtime/files.js";
 import { getNyxDir, relativeToProject } from "../runtime/paths.js";
 import { EXECUTION_PROMPT_FILE } from "../runtime/prompts.js";
 const DEFAULT_CODEX_MODEL = "gpt-5.5";
@@ -17,7 +17,7 @@ const GITIGNORE_ENTRIES = [
     ".nyxagent/state.json",
     ".nyxagent/config.json",
     ".nyxagent/config.toml",
-    ".nyxagent/prompts/"
+    ".nyxagent/prompts/",
 ];
 export async function initCommand(options, projectRoot = process.cwd()) {
     const root = path.resolve(projectRoot);
@@ -46,14 +46,14 @@ async function resolveInitOptions(options) {
             message: "Default harness",
             choices: [
                 { name: "codex", value: "codex" },
-                { name: "claude", value: "claude" }
-            ]
+                { name: "claude", value: "claude" },
+            ],
         });
     const model = options.model ??
         (await input({
             message: "Model",
             default: harness === "codex" ? DEFAULT_CODEX_MODEL : "",
-            validate: (value) => value.trim().length > 0 || "Model is required"
+            validate: (value) => value.trim().length > 0 || "Model is required",
         }));
     const reasoning_effort = options.reasoningEffort ??
         (await input({ message: "Reasoning effort", default: "medium" }));
@@ -65,34 +65,27 @@ async function resolveInitOptions(options) {
                 { name: "After each task", value: "each" },
                 { name: "After all tasks (global review)", value: "all" },
                 { name: "Both per-task and global", value: "both" },
-                { name: "No review", value: "none" }
+                { name: "No review", value: "none" },
             ],
-            default: "each"
+            default: "each",
         });
-    const review_max_attempts = review === "none"
-        ? 4
-        : parseReviewAttempts(options.reviewAttempts) ??
-            (await numberPrompt({
-                message: "Max review attempts per stage",
-                default: 4,
-                required: true
-            }));
-    if (!Number.isInteger(review_max_attempts) || review_max_attempts <= 0) {
-        throw new Error("review attempts must be a positive integer");
-    }
-    const repo = options.repo ?? (await input({ message: "GitHub repository (owner/repo)" }));
+    const review_rounds = await resolveReviewRounds(options, review);
+    const repo = options.repo ??
+        (await input({ message: "GitHub repository (owner/repo)" }));
     validateRepository(repo);
     const baseBranchInput = options.baseBranch ??
         (await input({
             message: "Base branch (blank = current branch at run time)",
-            default: ""
+            default: "",
         }));
-    const base_branch = baseBranchInput.trim() ? baseBranchInput.trim() : undefined;
+    const base_branch = baseBranchInput.trim()
+        ? baseBranchInput.trim()
+        : undefined;
     const max_iterations = parseMaxIterations(options.maxIterations) ??
         (await numberPrompt({
             message: "Max work items per run",
             default: 5,
-            required: true
+            required: true,
         }));
     if (!Number.isInteger(max_iterations) || max_iterations <= 0) {
         throw new Error("max iterations must be a positive integer");
@@ -102,10 +95,10 @@ async function resolveInitOptions(options) {
         model: model.trim(),
         reasoning_effort: reasoning_effort.trim() || "medium",
         review,
-        review_max_attempts,
+        review_rounds,
         repo,
         base_branch,
-        max_iterations
+        max_iterations,
     };
 }
 function buildConfig(options) {
@@ -115,11 +108,11 @@ function buildConfig(options) {
         reasoning_effort: options.reasoning_effort,
         review: options.review,
         tracker: { type: "github", repo: options.repo },
-        max_iterations: options.max_iterations
+        max_iterations: options.max_iterations,
     };
-    // No point persisting an attempts cap when reviews are disabled.
+    // No point persisting review rounds when reviews are disabled.
     if (options.review !== "none") {
-        config.review_max_attempts = options.review_max_attempts;
+        config.review_rounds = options.review_rounds;
     }
     if (options.base_branch) {
         config.base_branch = options.base_branch;
@@ -149,7 +142,38 @@ function parseMaxIterations(value) {
     }
     return Number.parseInt(value, 10);
 }
-function parseReviewAttempts(value) {
+async function resolveReviewRounds(options, review) {
+    if (review === "none") {
+        return { each: 1, global: 1 };
+    }
+    const deprecatedAttempts = parsePositiveInteger(options.reviewAttempts);
+    const each = parsePositiveInteger(options.reviewRoundsEach) ??
+        deprecatedAttempts ??
+        (review === "each" || review === "both"
+            ? await numberPrompt({
+                message: "Review rounds per work item",
+                default: 1,
+                required: true,
+            })
+            : 1);
+    const global = parsePositiveInteger(options.reviewRoundsGlobal) ??
+        deprecatedAttempts ??
+        (review === "all" || review === "both"
+            ? await numberPrompt({
+                message: "Global review rounds",
+                default: 1,
+                required: true,
+            })
+            : 1);
+    if (!Number.isInteger(each) || each <= 0) {
+        throw new Error("review_rounds.each must be a positive integer");
+    }
+    if (!Number.isInteger(global) || global <= 0) {
+        throw new Error("review_rounds.global must be a positive integer");
+    }
+    return { each, global };
+}
+function parsePositiveInteger(value) {
     if (value === undefined) {
         return undefined;
     }

package/dist/commands/run.js

@@ -9,7 +9,8 @@ export async function runCommand(options, projectRoot = process.cwd()) {
             ? path.resolve(projectRoot, options.config)
             : undefined,
         harness: normalizeHarness(options.harness),
-        autoAcceptSelection: options.yes ?? false
+        autoAcceptSelection: options.yes ?? false,
+        verbose: options.verbose ?? false,
     });
 }
 function normalizeHarness(value) {

package/dist/config/schema.js

@@ -7,7 +7,37 @@ import { z } from "zod";
  */
 export const harnessNames = ["codex", "claude"];
 export const reviewModes = ["each", "all", "both", "none"];
+export const globalReviewRoles = [
+    "diff-contract",
+    "integration",
+    "domain-invariants",
+    "tests-validation",
+];
 const githubRepositoryPattern = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+const reviewRoundsSchema = z
+    .object({
+    each: z.number().int().positive().default(1),
+    global: z.number().int().positive().default(1),
+})
+    .default({ each: 1, global: 1 });
+const agentOverrideSchema = z
+    .object({
+    harness: z.enum(harnessNames).optional(),
+    model: z.string().min(1).optional(),
+    reasoning_effort: z.string().min(1).optional(),
+})
+    .strict();
+const globalReviewAgentOverrideSchema = agentOverrideSchema.extend({
+    roles: z
+        .object({
+        "diff-contract": agentOverrideSchema.optional(),
+        integration: agentOverrideSchema.optional(),
+        "domain-invariants": agentOverrideSchema.optional(),
+        "tests-validation": agentOverrideSchema.optional(),
+    })
+        .strict()
+        .optional(),
+});
 export const nyxConfigSchema = z
     .object({
     /** Which agent CLI runs each phase. Overridable per run via `run --harness`. */
@@ -18,18 +48,29 @@ export const nyxConfigSchema = z
     reasoning_effort: z.string().min(1).default("medium"),
     /** When the agent reviews its own work. */
     review: z.enum(reviewModes).default("each"),
-    /** How many review+revise rounds a review stage gets before the run fails. */
-    review_max_attempts: z.number().int().positive().default(4),
+    /** How many fresh discovery rounds each review stage may run. */
+    review_rounds: reviewRoundsSchema,
+    /** Deprecated: accepted for existing configs, but no longer drives reviews. */
+    review_max_attempts: z.number().int().positive().optional(),
+    /** Optional agent overrides by phase and global-review role. */
+    agents: z
+        .object({
+        execution: agentOverrideSchema.optional(),
+        review: agentOverrideSchema.optional(),
+        global_review: globalReviewAgentOverrideSchema.optional(),
+    })
+        .strict()
+        .optional(),
     /** Work item tracker. GitHub issues only in this version. */
     tracker: z.object({
         type: z.literal("github"),
         repo: z
             .string()
-            .regex(githubRepositoryPattern, 'tracker.repo must be "owner/repo"')
+            .regex(githubRepositoryPattern, 'tracker.repo must be "owner/repo"'),
     }),
     /** Base branch the run branch is cut from. Defaults to the current branch. */
     base_branch: z.string().min(1).optional(),
     /** Maximum work items processed in a single run. */
-    max_iterations: z.number().int().positive().default(5)
+    max_iterations: z.number().int().positive().default(5),
 })
     .strict();

package/dist/runtime/prompts.js

@@ -23,39 +23,72 @@ test, implement the smallest change that satisfies it, then tidy the result.
 
 Do not commit and do not touch git — NyxAgent commits your changes for you. Leave
 clear validation evidence (commands run and their results) in your final response.`;
-export const REVIEW_PROMPT = `Review the implementation of the selected work item.
+export const REVIEW_PROMPT = `Discover findings in the implementation of the selected work item.
 
-The uncommitted changes for this item are shown as a diff in the context above; you
-may also read files in the working directory. Stay read-only and do not modify
-anything.
+Use the review-context artifact paths in the context above. Inspect the patch file,
+diffstat, changed-files list, and the working directory as needed. Stay read-only
+and do not modify anything.
 
-Assess: alignment with the work item, correctness and regression risk, test or
-validation evidence, design fit, and security or data-safety concerns.
+This is discovery for the current review round only. Assess alignment with the work
+item, correctness and regression risk, test or validation evidence, design fit, and
+security or data-safety concerns.
 
-Set outcome to "approved" when the work is ready, or "changes_requested" with a
-concrete, actionable list in required_changes. Always include a short summary.`;
+Put only must-fix issues in blockers. Put missing or weak validation in test_gaps,
+non-blocking concerns in advisory_findings, uncertain suspicions in
+uncertain_findings, and explicitly refuted candidates in rejected_findings.`;
+export const REVIEW_CHALLENGE_PROMPT = `Challenge the proposed blockers for the selected work item.
+
+Stay read-only. Try to refute each proposed blocker using the current code,
+review-context artifacts, and concrete evidence. Return only blockers that remain
+valid and actionable. Move false positives or already-satisfied findings to
+rejected_findings with evidence. Do not introduce new findings in this phase.`;
 export const REVISION_PROMPT = `Apply the changes requested by the review for the selected work item.
 
-The required changes are listed in the context above. Address exactly those, keeping
-the work focused. Do not commit — NyxAgent commits your changes for you.`;
+The verified blockers are listed in the context above. Address exactly those,
+keeping the work focused. Do not commit — NyxAgent commits your changes for you.`;
+export const REVIEW_VALIDATION_PROMPT = `Validate the correction for the previously verified blockers.
+
+Stay read-only. Validate only the blockers listed in the context above. Do not run a
+new review and do not introduce unrelated new findings. For each blocker, return one
+status: resolved, unresolved, false_positive, or regression_from_correction.
+
+Use regression_from_correction only when the correction itself directly created a
+new blocker and the evidence proves that causal link.`;
 export const GLOBAL_REVIEW_PROMPT = `Review the entire run as a whole, now that every selected work item is implemented
 and committed.
 
-The combined diff for the run is shown in the context above; you may also read files
-in the working directory. Stay read-only and do not modify anything.
+Use the review-context artifact paths in the context above. Inspect the patch file,
+diffstat, changed-files list, commit list, and the working directory as needed. Stay
+read-only and do not modify anything.
 
 Focus on cross-cutting concerns a per-item review cannot see: integration between
 items, regressions one item introduced in another, overall design coherence,
 duplication, and gaps versus the issues' intent.
 
-Set outcome to "approved" when the run is coherent and ready, or
-"changes_requested" with a concrete, actionable list in required_changes. Always
-include a short summary.`;
+Return typed findings. Put only must-fix issues in blockers. Put missing or weak
+validation in test_gaps, non-blocking concerns in advisory_findings, uncertain
+suspicions in uncertain_findings, and explicitly refuted candidates in
+rejected_findings.`;
+export const GLOBAL_REVIEW_CHALLENGE_PROMPT = `Challenge the aggregated global-review blockers.
+
+Stay read-only. Try to refute each proposed blocker using the current code,
+review-context artifacts, and concrete evidence. Return only blockers that remain
+valid and actionable. Move false positives or already-satisfied findings to
+rejected_findings with evidence. Do not introduce new findings in this phase.`;
 export const GLOBAL_REVISION_PROMPT = `Apply the changes requested by the global review of the whole run.
 
-The required changes are listed in the context above. Address exactly those, across
+The verified blockers are listed in the context above. Address exactly those, across
 whichever work items are affected. Do not commit — NyxAgent commits your corrections
 for you.`;
+export const GLOBAL_REVIEW_VALIDATION_PROMPT = `Validate the global review correction for the previously verified blockers.
+
+Stay read-only. Validate only the blockers listed in the context above. Do not run a
+new global review and do not introduce unrelated new findings. For each blocker,
+return one status: resolved, unresolved, false_positive, or
+regression_from_correction.
+
+Use regression_from_correction only when the correction itself directly created a
+new blocker and the evidence proves that causal link.`;
 /** Rendered into .nyxagent/prompts/execution.md at init; the only editable prompt. */
 export const EXECUTION_PROMPT_FILE = `${EXECUTION_PROMPT}
 `;
@@ -88,7 +121,7 @@ export function buildPhasePrompt(input) {
         "",
         "## Instructions",
         "",
-        input.guidance.trim()
+        input.guidance.trim(),
     ];
     if (input.schema) {
         parts.push("", "## Required result", "", "End your response with a single <nyxagent_result> block containing JSON that", "matches this schema. NyxAgent parses the last such block, validates it, and", "ignores everything else for control flow.", "", "```json", JSON.stringify(input.schema, null, 2), "```", "", "<nyxagent_result>", "{ ... }", "</nyxagent_result>");

package/dist/runtime/reporter.js

@@ -0,0 +1,65 @@
+import path from "node:path";
+import pc from "picocolors";
+export function createRunReporter(options = {}) {
+    const verbose = options.verbose ?? false;
+    const writeStdout = options.writeStdout ?? ((line) => console.log(line));
+    const writeStderr = options.writeStderr ??
+        ((line) => {
+            process.stderr.write(`${line}\n`);
+        });
+    const stdout = (line) => writeStdout(line);
+    const stderr = (line) => writeStderr(line);
+    return {
+        verbose,
+        heading: (message) => stdout(pc.bold(message)),
+        info: (message) => stdout(message),
+        section: (message) => stdout(pc.cyan(message)),
+        success: (message) => stdout(pc.green(message)),
+        warn: (message) => stdout(pc.yellow(message)),
+        error: (message) => stdout(pc.red(message)),
+        detail: (message) => {
+            if (verbose) {
+                stderr(pc.dim(message));
+            }
+        },
+        phaseStarted: (event) => {
+            if (!verbose) {
+                return;
+            }
+            const attempt = attemptLabel(event.attemptDir);
+            const command = [event.invocation.command, ...event.invocation.args].join(" ");
+            stderr(pc.dim(`[${event.phaseId} ${attempt}] start ${command} (cwd ${event.workdir}, capability ${event.capability}, model ${event.model}, reasoning ${event.reasoning})`));
+        },
+        phaseFinished: (event) => {
+            if (!verbose) {
+                return;
+            }
+            stderr(pc.dim(`[${event.phaseId} ${attemptLabel(event.attemptDir)}] exit ${event.exitCode} in ${formatDuration(event.durationMs)}`));
+        },
+        phaseArtifact: (event) => {
+            if (!verbose) {
+                return;
+            }
+            const prefix = event.attemptDir
+                ? `${event.phaseId} ${attemptLabel(event.attemptDir)}`
+                : event.phaseId;
+            stderr(pc.dim(`[${prefix}] artifact ${event.filePath}`));
+        },
+        agentOutput: (event) => {
+            if (!verbose) {
+                return;
+            }
+            const outputType = event.stream ?? event.eventType;
+            stderr(`[${event.phaseId} ${attemptLabel(event.attemptDir)} ${outputType}] ${event.message}`);
+        },
+    };
+}
+function attemptLabel(attemptDirOrPath) {
+    return path.basename(attemptDirOrPath);
+}
+function formatDuration(durationMs) {
+    if (durationMs < 1000) {
+        return `${durationMs}ms`;
+    }
+    return `${(durationMs / 1000).toFixed(1)}s`;
+}

package/dist/runtime/runPhase.js

@@ -15,12 +15,12 @@ export async function runAgentPhase(input) {
     const attempt = await invokeHarness({
         attemptDir: path.join(input.phaseDir, "attempt-001"),
         input,
-        prompt: input.prompt
+        prompt: input.prompt,
     });
     if (attempt.exitCode !== 0) {
         return {
             ok: false,
-            error: `Phase "${input.phaseId}" failed with exit code ${attempt.exitCode}`
+            error: `Phase "${input.phaseId}" failed with exit code ${attempt.exitCode}`,
         };
     }
     if (!input.schema) {
@@ -28,16 +28,26 @@ export async function runAgentPhase(input) {
     }
     const parsed = parseAndValidate(input.schema, attempt.stdout);
     if (parsed.ok) {
-        await writeJson(path.join(input.phaseDir, "result.json"), parsed.result);
+        const resultPath = path.join(input.phaseDir, "result.json");
+        await writeJson(resultPath, parsed.result);
+        input.reporter?.phaseArtifact({
+            phaseId: input.phaseId,
+            filePath: resultPath,
+        });
         return parsed;
     }
     const repaired = await repairResult({
         input,
         originalStdout: attempt.stdout,
-        validationError: parsed.error
+        validationError: parsed.error,
     });
     if (repaired.ok && repaired.result !== undefined) {
-        await writeJson(path.join(input.phaseDir, "result.json"), repaired.result);
+        const resultPath = path.join(input.phaseDir, "result.json");
+        await writeJson(resultPath, repaired.result);
+        input.reporter?.phaseArtifact({
+            phaseId: input.phaseId,
+            filePath: resultPath,
+        });
     }
     return repaired;
 }
@@ -48,19 +58,53 @@ async function invokeHarness(args) {
         harness: args.input.harness,
         capability: args.forceReadonly ? "readonly" : args.input.capability,
         model: args.input.model,
-        reasoning: args.input.reasoning
+        reasoning: args.input.reasoning,
     });
     const startedAt = new Date().toISOString();
     const started = Date.now();
     const gitBefore = await getGitSnapshot(args.input.workdir);
+    args.input.reporter?.phaseStarted({
+        phaseId: args.input.phaseId,
+        attemptDir: args.attemptDir,
+        workdir: args.input.workdir,
+        capability: args.forceReadonly ? "readonly" : args.input.capability,
+        model: args.input.model,
+        reasoning: args.input.reasoning,
+        invocation,
+    });
     let stdout = "";
     let stderr = "";
     let exitCode = 0;
     try {
+        const verbose = args.input.reporter?.verbose
+            ? {
+                stdout: (line, event) => {
+                    args.input.reporter?.agentOutput({
+                        phaseId: args.input.phaseId,
+                        attemptDir: args.attemptDir,
+                        eventType: event.type,
+                        stream: event.type === "output" ? "stdout" : undefined,
+                        message: line,
+                    });
+                    return "";
+                },
+                stderr: (line, event) => {
+                    args.input.reporter?.agentOutput({
+                        phaseId: args.input.phaseId,
+                        attemptDir: args.attemptDir,
+                        eventType: event.type,
+                        stream: event.type === "output" ? "stderr" : undefined,
+                        message: line,
+                    });
+                    return "";
+                },
+            }
+            : "none";
         const result = await execa(invocation.command, invocation.args, {
             cwd: args.input.workdir,
             input: args.prompt,
-            reject: false
+            reject: false,
+            verbose,
         });
         stdout = result.stdout;
         stderr = result.stderr;
@@ -71,18 +115,35 @@ async function invokeHarness(args) {
         stderr = error instanceof Error ? error.message : String(error);
     }
     const gitAfter = await getGitSnapshot(args.input.workdir);
-    await writeText(path.join(args.attemptDir, "stdout.log"), stdout);
-    await writeText(path.join(args.attemptDir, "stderr.log"), stderr);
-    await writeJson(path.join(args.attemptDir, "meta.json"), {
+    const durationMs = Date.now() - started;
+    const stdoutPath = path.join(args.attemptDir, "stdout.log");
+    const stderrPath = path.join(args.attemptDir, "stderr.log");
+    const metaPath = path.join(args.attemptDir, "meta.json");
+    await writeText(stdoutPath, stdout);
+    await writeText(stderrPath, stderr);
+    await writeJson(metaPath, {
         command: invocation.command,
         args: invocation.args,
         started_at: startedAt,
         ended_at: new Date().toISOString(),
-        duration_ms: Date.now() - started,
+        duration_ms: durationMs,
         exit_code: exitCode,
         git_before: gitBefore,
-        git_after: gitAfter
+        git_after: gitAfter,
+    });
+    args.input.reporter?.phaseFinished({
+        phaseId: args.input.phaseId,
+        attemptDir: args.attemptDir,
+        durationMs,
+        exitCode,
     });
+    for (const filePath of [stdoutPath, stderrPath, metaPath]) {
+        args.input.reporter?.phaseArtifact({
+            phaseId: args.input.phaseId,
+            attemptDir: args.attemptDir,
+            filePath,
+        });
+    }
     return { stdout, stderr, exitCode };
 }
 function parseAndValidate(schema, stdout) {
@@ -118,13 +179,13 @@ async function repairResult(args) {
             "",
             "Original prompt:",
             "",
-            args.input.prompt
+            args.input.prompt,
         ].join("\n");
         const attempt = await invokeHarness({
             attemptDir: path.join(args.input.phaseDir, `repair-${String(attemptNumber).padStart(3, "0")}`),
             input: args.input,
             prompt: repairPrompt,
-            forceReadonly: true
+            forceReadonly: true,
         });
         if (attempt.exitCode !== 0) {
             lastError = `Repair harness exited with code ${attempt.exitCode}`;
@@ -138,6 +199,6 @@ async function repairResult(args) {
     }
     return {
         ok: false,
-        error: `Phase "${args.input.phaseId}" produced an invalid result: ${lastError}`
+        error: `Phase "${args.input.phaseId}" produced an invalid result: ${lastError}`,
     };
 }