@nyxa/nyx-agent 0.6.0 → 0.7.0

package/README.md

@@ -7,7 +7,8 @@ GitHub issue at a time, each phase with fresh context.
 
 For every run NyxAgent:
 
-1. **Selects** open GitHub issues to work on (read-only).
+1. **Selects** open GitHub issues to work on (read-only), then asks the user to
+   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),
@@ -27,8 +28,10 @@ is editable.
 
 ```bash
 nyxagent init                 # create .nyxagent/config.json (interactive)
-nyxagent run                  # run the pipeline
+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
 ```
 
@@ -63,3 +66,4 @@ unresolved feedback, so the work is never stranded on an orphaned branch.
 - A git repository with a GitHub remote.
 - The `gh` CLI authenticated for the configured repository.
 - The selected harness CLI (`codex` or `claude`) on `PATH`.
+- An interactive terminal for `nyxagent run`, unless `--yes` is used.

package/dist/cli.js

@@ -33,6 +33,8 @@ program
     .description("Run the NyxAgent pipeline")
     .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/run.js

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

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}`,
     };
 }

package/dist/runtime/runPipeline.js

@@ -1,16 +1,17 @@
 import path from "node:path";
-import pc from "picocolors";
 import { loadConfig } from "../config/loadConfig.js";
 import { ensureDir, pathExists, readText } from "./files.js";
-import { deleteBranch, removeRunWorktree, setUpRunWorktree } from "./gitLifecycle.js";
-import { markWorkItemCompleted, readWorkItemLedger, writeWorkItemLedger } from "./ledger.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 { runAgentPhase } from "./runPhase.js";
-import { GLOBAL_REVIEW_SCHEMA, REVIEW_SCHEMA, SELECTION_SCHEMA } from "./schemas.js";
-import { commitAll, commitsAhead, createPullRequest, pushBranch, rangeDiff, stageAllAndDiff } from "./scm.js";
+import { buildContextBlock, buildPhasePrompt, EXECUTION_PROMPT, GLOBAL_REVIEW_PROMPT, GLOBAL_REVISION_PROMPT, REVIEW_PROMPT, REVISION_PROMPT, SELECTION_PROMPT, truncateForPrompt, } 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 { 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, listGitHubIssues, resolveSelectedQueue, } from "./workItems.js";
 const MAX_CANDIDATES = 50;
 const EXCERPT_CHARS = 800;
 export function defaultPipelineDependencies() {
@@ -18,7 +19,8 @@ export function defaultPipelineDependencies() {
         listIssues: listGitHubIssues,
         runPhase: runAgentPhase,
         pushBranch,
-        createPullRequest
+        createPullRequest,
+        confirmSelection: confirmWorkItemSelection,
     };
 }
 /**
@@ -39,46 +41,64 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
     const runId = createRunId();
     const runDir = path.join(nyxDir, "runs", runId);
     await ensureDir(runDir);
-    console.log(pc.bold(`NyxAgent run ${runId}`));
-    console.log(`Harness: ${harness} · model: ${config.model} · review: ${config.review}`);
+    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.detail(`Config: ${relativeToProject(projectRoot, configPath)}`);
+    reporter.detail(`Artifacts: ${relativeToProject(projectRoot, runDir)}`);
+    reporter.detail(`Tracker: ${config.tracker.repo}`);
     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 candidates = filterAvailable({
         candidates: await deps.listIssues({
             repo: config.tracker.repo,
             maxCandidates: MAX_CANDIDATES,
-            excerptChars: EXCERPT_CHARS
+            excerptChars: EXCERPT_CHARS,
         }),
-        completedKeys: ledger.completed_work_item_keys
+        completedKeys: ledger.completed_work_item_keys,
     });
+    reporter.detail(`Available work item candidates: ${candidates.length}`);
     if (candidates.length === 0) {
-        console.log("No open work items available. Nothing to do.");
+        reporter.info("No open work items available. Nothing to do.");
         return;
     }
-    const selected = await runSelection({
+    const proposed = await runSelection({
         projectRoot,
         runDir,
         harness,
         config,
         candidates,
-        runPhase: deps.runPhase
+        runPhase: deps.runPhase,
+        reporter,
+    });
+    if (proposed.length === 0) {
+        reporter.info("Selection chose no work items. Nothing to do.");
+        return;
+    }
+    const selected = await deps.confirmSelection({
+        candidates,
+        proposed,
+        maxItems: config.max_iterations,
+        autoAccept: input.autoAcceptSelection ?? false,
     });
     if (selected.length === 0) {
-        console.log("Selection chose no work items. Nothing to do.");
+        reporter.info("No work items selected. Nothing to do.");
         return;
     }
     const planned = selected.slice(0, config.max_iterations);
-    console.log(`Selected ${planned.length} work item(s):`);
+    reporter.info(`Selected ${planned.length} work item(s):`);
     for (const item of planned) {
-        console.log(`  - ${item.title} (#${item.number})`);
+        reporter.info(`  - ${item.title} (#${item.number})`);
     }
     // 2. One branch + worktree per run (created only now that there is work).
     const git = await setUpRunWorktree({
         projectRoot,
         runId,
-        base: config.base_branch
+        base: config.base_branch,
     });
-    console.log(`Branch ${git.branch} (base ${git.base})`);
+    reporter.info(`Branch ${git.branch} (base ${git.base})`);
+    reporter.detail(`Worktree: ${relativeToProject(projectRoot, git.worktree)}`);
     let success = false;
     let producedCommits = false;
     let currentLedger = ledger;
@@ -88,7 +108,7 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
         for (const [index, item] of planned.entries()) {
             const iterationNumber = index + 1;
             const iterationDir = path.join(runDir, "iterations", String(iterationNumber).padStart(3, "0"));
-            console.log(pc.cyan(`\n[${iterationNumber}/${planned.length}] ${item.title} (#${item.number})`));
+            reporter.section(`\n[${iterationNumber}/${planned.length}] ${item.title} (#${item.number})`);
             await runExecution({
                 iterationDir,
                 item,
@@ -96,7 +116,8 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
                 git,
                 harness,
                 config,
-                runPhase: deps.runPhase
+                runPhase: deps.runPhase,
+                reporter,
             });
             if (config.review === "each" || config.review === "both") {
                 await runReviewLoop({
@@ -106,22 +127,24 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
                     harness,
                     config,
                     maxAttempts: config.review_max_attempts,
-                    runPhase: deps.runPhase
+                    runPhase: deps.runPhase,
+                    reporter,
                 });
             }
             const { committed } = await commitAll({
                 cwd: git.worktree,
-                message: buildCommitMessage(item)
+                message: buildCommitMessage(item),
             });
             if (committed) {
                 producedCommits = true;
+                reporter.detail(`Committed work item #${item.number}.`);
             }
             else {
-                console.log(pc.yellow("  No changes to commit for this item."));
+                reporter.warn("  No changes to commit for this item.");
             }
             currentLedger = markWorkItemCompleted({
                 ledger: currentLedger,
-                workItem: item
+                workItem: item,
             });
             await writeWorkItemLedger(nyxDir, currentLedger);
             completed.push(item);
@@ -133,17 +156,20 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
                 harness,
                 config,
                 maxAttempts: config.review_max_attempts,
-                runPhase: deps.runPhase
+                runPhase: deps.runPhase,
+                reporter,
             });
             if (corrections) {
                 producedCommits = true;
             }
         }
-        if (!producedCommits || (await commitsAhead(git.worktree, git.base)) === 0) {
-            console.log("\nRun produced no commits; skipping pull request.");
+        if (!producedCommits ||
+            (await commitsAhead(git.worktree, git.base)) === 0) {
+            reporter.info("\nRun produced no commits; skipping pull request.");
             success = true;
             return;
         }
+        reporter.detail(`Pushing branch ${git.branch}.`);
         await deps.pushBranch({ cwd: git.worktree, branch: git.branch });
         const prUrl = await deps.createPullRequest({
             cwd: git.worktree,
@@ -151,9 +177,9 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
             base: git.base,
             head: git.branch,
             title: buildPrTitle(completed),
-            body: buildPrBody(completed)
+            body: buildPrBody(completed),
         });
-        console.log(pc.green(`\nPull request opened: ${prUrl}`));
+        reporter.success(`\nPull request opened: ${prUrl}`);
         success = true;
     }
     catch (error) {
@@ -167,7 +193,8 @@ export async function runPipeline(input = {}, deps = defaultPipelineDependencies
             producedCommits,
             completed,
             config,
-            deps
+            deps,
+            reporter,
         });
         throw error;
     }
@@ -199,14 +226,15 @@ async function salvageFailedRun(input) {
         }
     }
     if (ahead === 0) {
-        console.log(pc.red(`\nRun failed. Branch ${input.git.branch} and worktree kept for debugging: ${location}`));
+        input.reporter.error(`\nRun failed. Branch ${input.git.branch} and worktree kept for debugging: ${location}`);
         return;
     }
     const reason = input.error instanceof Error ? input.error.message : String(input.error);
     try {
+        input.reporter.detail(`Pushing failed run branch ${input.git.branch}.`);
         await input.deps.pushBranch({
             cwd: input.git.worktree,
-            branch: input.git.branch
+            branch: input.git.branch,
         });
         const url = await input.deps.createPullRequest({
             cwd: input.git.worktree,
@@ -215,17 +243,17 @@ async function salvageFailedRun(input) {
             head: input.git.branch,
             title: buildDraftPrTitle(input.completed),
             body: buildDraftPrBody(input.completed, reason),
-            draft: true
+            draft: true,
         });
-        console.log(pc.yellow(`\nRun failed, but the work was salvaged into a DRAFT pull request: ${url}`));
-        console.log(pc.yellow(`Branch ${input.git.branch} and worktree kept: ${location}`));
+        input.reporter.warn(`\nRun failed, but the work was salvaged into a DRAFT pull request: ${url}`);
+        input.reporter.warn(`Branch ${input.git.branch} and worktree kept: ${location}`);
     }
     catch (salvageError) {
         const detail = salvageError instanceof Error
             ? salvageError.message
             : String(salvageError);
-        console.log(pc.red(`\nRun failed, and salvaging the work into a draft pull request also failed: ${detail}`));
-        console.log(pc.red(`Branch ${input.git.branch} and worktree kept for debugging: ${location}`));
+        input.reporter.error(`\nRun failed, and salvaging the work into a draft pull request also failed: ${detail}`);
+        input.reporter.error(`Branch ${input.git.branch} and worktree kept for debugging: ${location}`);
     }
 }
 async function runSelection(input) {
@@ -239,9 +267,9 @@ async function runSelection(input) {
                 number: candidate.number,
                 title: candidate.title,
                 labels: candidate.labels,
-                excerpt: candidate.excerpt
-            }))
-        ]
+                excerpt: candidate.excerpt,
+            })),
+        ],
     ]);
     const result = await input.runPhase({
         phaseId: "selection",
@@ -254,9 +282,10 @@ async function runSelection(input) {
         prompt: buildPhasePrompt({
             guidance: SELECTION_PROMPT,
             context,
-            schema: SELECTION_SCHEMA
+            schema: SELECTION_SCHEMA,
         }),
-        schema: SELECTION_SCHEMA
+        schema: SELECTION_SCHEMA,
+        reporter: input.reporter,
     });
     if (!result.ok) {
         throw new Error(result.error);
@@ -267,7 +296,7 @@ async function runSelection(input) {
     }
     const resolved = resolveSelectedQueue({
         keys: value.work_item_keys,
-        candidates: input.candidates
+        candidates: input.candidates,
     });
     if (!resolved.ok) {
         throw new Error(`Selection produced an invalid queue: ${resolved.error}`);
@@ -279,7 +308,7 @@ async function runExecution(input) {
         ["Work item", workItemSummary(input.item)],
         ["Issue description", input.item.excerpt ?? "(no description provided)"],
         ["Working directory", input.git.worktree],
-        ["Branch", `${input.git.branch} (base ${input.git.base})`]
+        ["Branch", `${input.git.branch} (base ${input.git.base})`],
     ]);
     const result = await input.runPhase({
         phaseId: "execution",
@@ -289,7 +318,8 @@ async function runExecution(input) {
         model: input.config.model,
         reasoning: input.config.reasoning_effort,
         capability: "write",
-        prompt: buildPhasePrompt({ guidance: input.guidance, context })
+        prompt: buildPhasePrompt({ guidance: input.guidance, context }),
+        reporter: input.reporter,
     });
     if (!result.ok) {
         throw new Error(result.error);
@@ -310,17 +340,21 @@ async function runReviewLoop(input) {
                 guidance: REVIEW_PROMPT,
                 context: buildContextBlock([
                     ["Work item", workItemSummary(input.item)],
-                    ["Uncommitted changes (diff)", truncateForPrompt(diff || "(no changes)")]
+                    [
+                        "Uncommitted changes (diff)",
+                        truncateForPrompt(diff || "(no changes)"),
+                    ],
                 ]),
-                schema: REVIEW_SCHEMA
+                schema: REVIEW_SCHEMA,
             }),
-            schema: REVIEW_SCHEMA
+            schema: REVIEW_SCHEMA,
+            reporter: input.reporter,
         });
         if (!reviewResult.ok) {
             throw new Error(reviewResult.error);
         }
         const review = reviewResult.result;
-        console.log(`  review: ${review.outcome}`);
+        input.reporter.info(`  review: ${review.outcome}`);
         if (review.outcome === "approved") {
             return;
         }
@@ -339,9 +373,10 @@ async function runReviewLoop(input) {
                 guidance: REVISION_PROMPT,
                 context: buildContextBlock([
                     ["Work item", workItemSummary(input.item)],
-                    ["Required changes", review.required_changes ?? []]
-                ])
-            })
+                    ["Required changes", review.required_changes ?? []],
+                ]),
+            }),
+            reporter: input.reporter,
         });
         if (!revision.ok) {
             throw new Error(revision.error);
@@ -366,18 +401,19 @@ async function runGlobalReviewLoop(input) {
                     ["Run branch", `${input.git.branch} (base ${input.git.base})`],
                     [
                         "Combined run diff (base...HEAD)",
-                        truncateForPrompt(diff || "(no changes)")
-                    ]
+                        truncateForPrompt(diff || "(no changes)"),
+                    ],
                 ]),
-                schema: GLOBAL_REVIEW_SCHEMA
+                schema: GLOBAL_REVIEW_SCHEMA,
             }),
-            schema: GLOBAL_REVIEW_SCHEMA
+            schema: GLOBAL_REVIEW_SCHEMA,
+            reporter: input.reporter,
         });
         if (!reviewResult.ok) {
             throw new Error(reviewResult.error);
         }
         const review = reviewResult.result;
-        console.log(`global review: ${review.outcome}`);
+        input.reporter.info(`global review: ${review.outcome}`);
         if (review.outcome === "approved") {
             return committedCorrections;
         }
@@ -395,19 +431,21 @@ async function runGlobalReviewLoop(input) {
             prompt: buildPhasePrompt({
                 guidance: GLOBAL_REVISION_PROMPT,
                 context: buildContextBlock([
-                    ["Required changes", review.required_changes ?? []]
-                ])
-            })
+                    ["Required changes", review.required_changes ?? []],
+                ]),
+            }),
+            reporter: input.reporter,
         });
         if (!revision.ok) {
             throw new Error(revision.error);
         }
         const { committed } = await commitAll({
             cwd: input.git.worktree,
-            message: "Apply global review corrections"
+            message: "Apply global review corrections",
         });
         if (committed) {
             committedCorrections = true;
+            input.reporter.detail("Committed global review corrections.");
         }
     }
     return committedCorrections;
@@ -429,7 +467,7 @@ function workItemSummary(item) {
         title: item.title,
         locator: item.source.locator,
         url: item.url,
-        labels: item.labels
+        labels: item.labels,
     };
 }
 function buildCommitMessage(item) {
@@ -442,7 +480,9 @@ function buildPrTitle(items) {
     return `NyxAgent: ${items.length} work items`;
 }
 function buildPrBody(items) {
-    const list = items.map((item) => `- ${item.title} (#${item.number})`).join("\n");
+    const list = items
+        .map((item) => `- ${item.title} (#${item.number})`)
+        .join("\n");
     const closes = items.map((item) => `Closes #${item.number}`).join("\n");
     return [
         "Automated changes by NyxAgent.",
@@ -451,7 +491,7 @@ function buildPrBody(items) {
         "",
         list,
         "",
-        closes
+        closes,
     ].join("\n");
 }
 function buildDraftPrTitle(items) {
@@ -465,7 +505,7 @@ function buildDraftPrBody(items, reason) {
         "",
         `**Why the run failed:** ${reason}`,
         "",
-        buildPrBody(items)
+        buildPrBody(items),
     ].join("\n");
 }
 /** Render review `required_changes` as a bullet list to append to a failure message. */

package/dist/runtime/selectionConfirmation.js

@@ -0,0 +1,85 @@
+import { checkbox, Separator } from "@inquirer/prompts";
+export async function confirmWorkItemSelection(input) {
+    if (input.autoAccept) {
+        return input.proposed;
+    }
+    const isInteractive = input.isInteractive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    if (!isInteractive) {
+        throw new Error('Interactive work item selection requires a TTY. Re-run with "nyxagent run --yes" to accept the agent selection.');
+    }
+    const selectedKeys = await checkbox({
+        message: `Select work items to run (max ${input.maxItems})`,
+        choices: buildSelectionChoiceItems(input).map(toInquirerChoice),
+        pageSize: Math.min(Math.max(input.candidates.length, 7), 20),
+        required: false,
+        validate: (selected) => selected.length <= input.maxItems ||
+            `Select at most ${input.maxItems} work item(s).`,
+        shortcuts: {
+            all: null,
+            invert: null
+        }
+    });
+    const selected = new Set(selectedKeys);
+    return input.candidates.filter((candidate) => selected.has(candidate.key));
+}
+export function buildSelectionChoiceItems(input) {
+    const proposedKeys = new Set(input.proposed.map((item) => item.key));
+    const items = [];
+    let currentGroup;
+    for (const candidate of input.candidates) {
+        const group = detectPlanGroup(candidate);
+        if (group && group !== currentGroup) {
+            items.push({ type: "separator", label: group });
+        }
+        currentGroup = group;
+        const proposed = proposedKeys.has(candidate.key);
+        items.push({
+            type: "choice",
+            value: candidate.key,
+            name: `#${candidate.number} ${candidate.title}${proposed ? " (agent)" : ""}`,
+            checked: proposed
+        });
+    }
+    return items;
+}
+function toInquirerChoice(item) {
+    if (item.type === "separator") {
+        return new Separator(item.label);
+    }
+    return {
+        value: item.value,
+        name: item.name,
+        checked: item.checked
+    };
+}
+function detectPlanGroup(candidate) {
+    for (const label of candidate.labels ?? []) {
+        const group = parseGroupLabel(label);
+        if (group) {
+            return group;
+        }
+    }
+    return parseBracketedTitleGroup(candidate.title);
+}
+function parseGroupLabel(label) {
+    const match = /^(plan|prd)\s*[:/=-]\s*(.+)$/i.exec(label.trim());
+    if (!match) {
+        return undefined;
+    }
+    return formatGroupLabel(match[1], match[2]);
+}
+function parseBracketedTitleGroup(title) {
+    const match = /^\[(plan|prd)\s*[:/=-]\s*([^\]]+)\]/i.exec(title.trim());
+    if (!match) {
+        return undefined;
+    }
+    return formatGroupLabel(match[1], match[2]);
+}
+function formatGroupLabel(kind, rawName) {
+    const name = rawName.trim();
+    if (!name) {
+        return undefined;
+    }
+    const prefix = kind.toLowerCase() === "prd" ? "PRD" : "Plan";
+    return `${prefix}: ${name}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nyxa/nyx-agent",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "A lightweight phase orchestrator for repeatedly launching coding agents with fresh context.",
   "type": "module",
   "repository": {