@nyxa/nyx-agent 0.4.1 → 0.6.0

package/dist/runtime/runWorkflow.js

@@ -1,680 +0,0 @@
-import path from "node:path";
-import { checkbox, Separator } from "@inquirer/prompts";
-import pc from "picocolors";
-import { loadConfig } from "../config/loadConfig.js";
-import { ensureDir, writeJson } from "./files.js";
-import { getGitSnapshot } from "./git.js";
-import { setUpGitContext, tearDownGitContext } from "./gitLifecycle.js";
-import { markWorkItemCompleted, readWorkItemLedger, writeWorkItemLedger } from "./ledger.js";
-import { getNyxDir, relativeToProject } from "./paths.js";
-import { runPhase } from "./runPhase.js";
-import { createRunId } from "./time.js";
-import { validateWorkItemQueue } from "./validateWorkItem.js";
-import { buildWorkItemKindMap, formatWorkItemChoiceName, normalizeWorkItemAnnotations } from "./workItemAnnotations.js";
-import { filterAvailableWorkItems, listWorkItemCandidates } from "./workItems.js";
-export async function runWorkflow(options) {
-    const projectRoot = path.resolve(options.projectRoot);
-    const nyxDir = getNyxDir(projectRoot);
-    const configPath = options.configPath ?? path.join(nyxDir, "config.toml");
-    const config = await loadConfig(configPath);
-    const runId = createRunId();
-    const runDir = path.join(nyxDir, "runs", runId);
-    await ensureDir(runDir);
-    let ledger = await readWorkItemLedger(nyxDir);
-    await writeWorkItemLedger(nyxDir, ledger);
-    const git = await getGitSnapshot(projectRoot);
-    const runState = {
-        run_id: runId,
-        status: "running",
-        current_iteration: 0,
-        completed_iterations: 0,
-        available_work_items: [],
-        recommended_work_item_queue: [],
-        selected_work_item_queue: [],
-        work_item_annotations: [],
-        skipped_work_item_keys: [],
-        selection_groups: [],
-        seen_work_item_keys: [],
-        completed_work_item_keys: [...ledger.completed_work_item_keys],
-        last_completed_work_item: ledger.last_completed_work_item
-    };
-    await writeJson(path.join(runDir, "run.json"), {
-        run_id: runId,
-        project_root: projectRoot,
-        started_at: new Date().toISOString(),
-        config_path: relativeToProject(projectRoot, configPath),
-        harness: {
-            preset: config.harness.preset,
-            command: config.harness.command
-        },
-        git
-    });
-    await writeJson(path.join(runDir, "state.json"), runState);
-    console.log(pc.bold(`NyxAgent run ${runId}`));
-    console.log(`Project: ${projectRoot}`);
-    console.log(`Harness: ${config.harness.preset ?? "custom"} (${config.harness.command})`);
-    console.log(`Model: ${config.model.name}`);
-    console.log("");
-    const phasesById = new Map(config.phases.map((phase) => [phase.id, phase]));
-    const selection = await runSelectionPhase({
-        projectRoot,
-        runDir,
-        config,
-        phasesById,
-        runState,
-        ledger
-    });
-    if (selection.status === "stopped") {
-        return;
-    }
-    runState.available_work_items = selection.availableWorkItems;
-    runState.recommended_work_item_queue = selection.workItems;
-    runState.work_item_annotations = selection.workItemAnnotations;
-    runState.selection_groups = selection.selectionGroups;
-    await writeJson(path.join(runDir, "state.json"), runState);
-    let confirmedWorkItems;
-    try {
-        confirmedWorkItems = normalizeConfirmedWorkItems({
-            availableWorkItems: selection.availableWorkItems,
-            confirmed: await (options.confirmWorkItems ?? confirmWorkItemsWithCheckbox)({
-                availableWorkItems: selection.availableWorkItems,
-                recommendedWorkItems: selection.workItems,
-                workItems: selection.availableWorkItems,
-                workItemAnnotations: selection.workItemAnnotations,
-                selectionGroups: selection.selectionGroups,
-                maxIterations: config.workflow.max_iterations
-            })
-        });
-    }
-    catch (error) {
-        runState.status = "failed";
-        await writeJson(path.join(runDir, "state.json"), runState);
-        throw error;
-    }
-    const selectedWorkItems = confirmedWorkItems.slice(0, config.workflow.max_iterations);
-    const selectedKeys = new Set(selectedWorkItems.map((item) => item.key));
-    runState.selected_work_item_queue = selectedWorkItems;
-    runState.skipped_work_item_keys = selection.workItems
-        .filter((item) => !selectedKeys.has(item.key))
-        .map((item) => item.key);
-    runState.seen_work_item_keys = selectedWorkItems.map((item) => item.key);
-    await writeJson(path.join(runDir, "state.json"), runState);
-    if (confirmedWorkItems.length > config.workflow.max_iterations) {
-        console.log(pc.yellow(`Only the first ${config.workflow.max_iterations} selected work items will run.`));
-    }
-    if (selectedWorkItems.length === 0) {
-        runState.status = "completed_no_selected_work";
-        await writeJson(path.join(runDir, "state.json"), runState);
-        console.log("");
-        console.log(`Done: ${runState.status}`);
-        console.log(`Run dir: ${relativeToProject(projectRoot, runDir)}`);
-        return;
-    }
-    let gitContext;
-    if (config.git && config.git.mode !== "off") {
-        gitContext = await setUpGitContext({ projectRoot, git: config.git, runId });
-    }
-    if (gitContext) {
-        console.log(`Git: ${gitContext.mode} on "${gitContext.branch}" (base "${gitContext.base}")`);
-        if (gitContext.mode === "worktree") {
-            console.log(`Worktree: ${relativeToProject(projectRoot, gitContext.worktree)}`);
-        }
-        console.log("");
-    }
-    const cleanup = config.git?.cleanup ?? "on_success";
-    let runSucceeded = false;
-    try {
-        runSucceeded = await runSelectedQueue({
-            projectRoot,
-            nyxDir,
-            runDir,
-            config,
-            phasesById,
-            selection,
-            selectedWorkItems,
-            runState,
-            ledger,
-            workdir: gitContext?.worktree ?? projectRoot,
-            gitContext
-        });
-    }
-    finally {
-        if (gitContext) {
-            await tearDownGitContext({
-                projectRoot,
-                context: gitContext,
-                cleanup,
-                success: runSucceeded
-            });
-        }
-    }
-}
-/**
- * Run the confirmed work item queue and, when configured, the run-scoped final
- * phase (e.g. opening the PRD pull request). Returns true when the whole run
- * completed normally, false when it stopped early (stop_run).
- */
-async function runSelectedQueue(input) {
-    const { projectRoot, nyxDir, runDir, config, phasesById, selection, selectedWorkItems, runState, workdir, gitContext } = input;
-    let ledger = input.ledger;
-    for (let queueIndex = 0; queueIndex < selectedWorkItems.length; queueIndex += 1) {
-        const iterationNumber = queueIndex + 1;
-        const workItem = selectedWorkItems[queueIndex];
-        runState.current_iteration = iterationNumber;
-        await writeJson(path.join(runDir, "state.json"), runState);
-        const iterationDir = path.join(runDir, "iterations", String(iterationNumber).padStart(3, "0"));
-        await ensureDir(iterationDir);
-        const iterationState = {
-            iteration: iterationNumber,
-            status: "running",
-            work_item: workItem,
-            available_work_items: selectedWorkItems,
-            recommended_work_item_queue: selection.workItems,
-            selected_work_item_queue: selectedWorkItems,
-            work_item_annotations: selection.workItemAnnotations,
-            seen_work_item_keys: [...runState.seen_work_item_keys],
-            completed_work_item_keys: [...ledger.completed_work_item_keys],
-            last_completed_work_item: ledger.last_completed_work_item,
-            phase_results: {},
-            phase_visit_counts: {}
-        };
-        const iterationStateFile = path.join(iterationDir, "state.json");
-        await writeJson(iterationStateFile, iterationState);
-        let currentPhaseId = selection.nextPhaseId;
-        while (currentPhaseId) {
-            const phase = phasesById.get(currentPhaseId);
-            if (!phase) {
-                throw new Error(`Unknown phase "${currentPhaseId}"`);
-            }
-            const phaseResult = await runWorkflowPhase({
-                projectRoot,
-                runDir,
-                iterationDir,
-                iterationStateFile,
-                config,
-                phase,
-                iterationState,
-                runState,
-                iterationNumber,
-                maxIterations: selectedWorkItems.length,
-                workdir,
-                git: gitContext
-            });
-            if (!phaseResult.ok) {
-                throw new Error(phaseResult.error);
-            }
-            const nextTarget = resolveNextTarget(phase, phaseResult.outcome);
-            if (nextTarget === "stop_run") {
-                iterationState.status =
-                    phaseResult.outcome === "no_work" ? "no_work" : "stopped";
-                runState.status =
-                    phaseResult.outcome === "no_work" ? "completed_no_work" : "stopped";
-                await writeJson(iterationStateFile, iterationState);
-                await writeJson(path.join(runDir, "state.json"), runState);
-                console.log("");
-                console.log(`Done: ${runState.status}`);
-                console.log(`Run dir: ${relativeToProject(projectRoot, runDir)}`);
-                return false;
-            }
-            if (nextTarget === "stop_iteration" || nextTarget === "next_iteration") {
-                iterationState.status = "completed";
-                runState.completed_iterations += 1;
-                ledger = await completeIterationWorkItem({
-                    nyxDir,
-                    ledger,
-                    runState,
-                    iterationState
-                });
-                iterationState.completed_work_item_keys = [
-                    ...ledger.completed_work_item_keys
-                ];
-                iterationState.last_completed_work_item = ledger.last_completed_work_item;
-                await writeJson(iterationStateFile, iterationState);
-                await writeJson(path.join(runDir, "state.json"), runState);
-                break;
-            }
-            currentPhaseId = nextTarget;
-        }
-    }
-    if (config.workflow.final_phase) {
-        const finalized = await runFinalPhase({
-            projectRoot,
-            runDir,
-            config,
-            phasesById,
-            runState,
-            selectedWorkItems,
-            ledger,
-            workdir,
-            gitContext,
-            workItemAnnotations: selection.workItemAnnotations
-        });
-        if (!finalized) {
-            return false;
-        }
-    }
-    runState.status =
-        selectedWorkItems.length >= config.workflow.max_iterations
-            ? "completed_max_iterations"
-            : "completed_queue";
-    await writeJson(path.join(runDir, "state.json"), runState);
-    console.log("");
-    console.log(`Done: ${runState.status}`);
-    console.log(`Run dir: ${relativeToProject(projectRoot, runDir)}`);
-    return true;
-}
-/**
- * Execute the run-scoped finalization flow after all iterations complete. This
- * is a self-contained phase graph (symmetric to the iteration flow started by
- * `entry_phase`): it begins at `workflow.final_phase` and follows each phase's
- * `next`/`transitions` until it reaches a leaf phase (success) or `stop_run`
- * (abort). This is where, for example, a review -> revision -> pull request
- * chain runs. The engine only provides the branch/worktree context and
- * run-level state; the GitHub/PR semantics live in the phase prompts, keeping
- * the engine agnostic. A single leaf `final_phase` simply runs once.
- *
- * Returns true when finalization completed normally, false when a phase routed
- * to `stop_run`.
- */
-async function runFinalPhase(input) {
-    const finalPhaseId = input.config.workflow.final_phase;
-    if (!finalPhaseId) {
-        return true;
-    }
-    const finalizationDir = path.join(input.runDir, "finalization");
-    await ensureDir(finalizationDir);
-    const finalizationState = {
-        iteration: 0,
-        status: "running",
-        available_work_items: input.selectedWorkItems,
-        recommended_work_item_queue: input.selectedWorkItems,
-        selected_work_item_queue: input.selectedWorkItems,
-        work_item_annotations: input.workItemAnnotations,
-        seen_work_item_keys: [...input.runState.seen_work_item_keys],
-        completed_work_item_keys: [...input.ledger.completed_work_item_keys],
-        last_completed_work_item: input.ledger.last_completed_work_item,
-        phase_results: {},
-        phase_visit_counts: {}
-    };
-    const finalizationStateFile = path.join(finalizationDir, "state.json");
-    await writeJson(finalizationStateFile, finalizationState);
-    let currentPhaseId = finalPhaseId;
-    let lastResult;
-    while (currentPhaseId) {
-        const phase = input.phasesById.get(currentPhaseId);
-        if (!phase) {
-            throw new Error(`Unknown final phase "${currentPhaseId}"`);
-        }
-        const phaseResult = await runWorkflowPhase({
-            projectRoot: input.projectRoot,
-            runDir: input.runDir,
-            iterationDir: finalizationDir,
-            iterationStateFile: finalizationStateFile,
-            config: input.config,
-            phase,
-            iterationState: finalizationState,
-            runState: input.runState,
-            iterationNumber: "final",
-            maxIterations: input.selectedWorkItems.length,
-            workdir: input.workdir,
-            git: input.gitContext
-        });
-        if (!phaseResult.ok) {
-            throw new Error(phaseResult.error);
-        }
-        if (phaseResult.result !== undefined) {
-            lastResult = phaseResult.result;
-        }
-        const nextTarget = resolveNextTarget(phase, phaseResult.outcome);
-        if (nextTarget === "stop_run") {
-            finalizationState.status = "stopped";
-            input.runState.status = "stopped";
-            input.runState.final_result = phaseResult.result ?? { status: "stopped" };
-            await writeJson(finalizationStateFile, finalizationState);
-            await writeJson(path.join(input.runDir, "state.json"), input.runState);
-            console.log("");
-            console.log(`Done: ${input.runState.status}`);
-            console.log(`Run dir: ${relativeToProject(input.projectRoot, input.runDir)}`);
-            return false;
-        }
-        if (nextTarget === "next_iteration" || nextTarget === "stop_iteration") {
-            throw new Error(`Final phase "${phase.id}" routed to iteration-only target "${nextTarget}"; finalization phases must end at a leaf phase (no next/transitions) or "stop_run"`);
-        }
-        currentPhaseId = nextTarget;
-    }
-    finalizationState.status = "completed";
-    input.runState.final_result = lastResult ?? { status: "ok" };
-    await writeJson(finalizationStateFile, finalizationState);
-    return true;
-}
-async function runSelectionPhase(input) {
-    const selectionPhase = input.phasesById.get(input.config.workflow.entry_phase);
-    if (!selectionPhase) {
-        throw new Error(`Unknown phase "${input.config.workflow.entry_phase}"`);
-    }
-    const availableWorkItems = await loadAvailableWorkItems({
-        projectRoot: input.projectRoot,
-        config: input.config,
-        runState: input.runState,
-        ledger: input.ledger
-    });
-    const selectionDir = path.join(input.runDir, "selection");
-    await ensureDir(selectionDir);
-    const selectionState = {
-        iteration: 0,
-        status: "running",
-        available_work_items: availableWorkItems,
-        recommended_work_item_queue: [],
-        selected_work_item_queue: [],
-        work_item_annotations: [],
-        seen_work_item_keys: [...input.runState.seen_work_item_keys],
-        completed_work_item_keys: [...input.ledger.completed_work_item_keys],
-        last_completed_work_item: input.ledger.last_completed_work_item,
-        phase_results: {},
-        phase_visit_counts: {}
-    };
-    const selectionStateFile = path.join(selectionDir, "state.json");
-    await writeJson(selectionStateFile, selectionState);
-    const phaseResult = await runWorkflowPhase({
-        projectRoot: input.projectRoot,
-        runDir: input.runDir,
-        iterationDir: selectionDir,
-        iterationStateFile: selectionStateFile,
-        config: input.config,
-        phase: selectionPhase,
-        iterationState: selectionState,
-        runState: input.runState,
-        iterationNumber: "selection",
-        maxIterations: input.config.workflow.max_iterations
-    });
-    if (!phaseResult.ok) {
-        throw new Error(phaseResult.error);
-    }
-    const nextTarget = resolveNextTarget(selectionPhase, phaseResult.outcome);
-    if (nextTarget === "stop_run") {
-        selectionState.status =
-            phaseResult.outcome === "no_work" ? "no_work" : "stopped";
-        input.runState.status =
-            phaseResult.outcome === "no_work" ? "completed_no_work" : "stopped";
-        await writeJson(selectionStateFile, selectionState);
-        await writeJson(path.join(input.runDir, "state.json"), input.runState);
-        console.log("");
-        console.log(`Done: ${input.runState.status}`);
-        console.log(`Run dir: ${relativeToProject(input.projectRoot, input.runDir)}`);
-        return { status: "stopped" };
-    }
-    if (!nextTarget || isReservedTarget(nextTarget)) {
-        throw new Error(`Selection phase must transition to a runnable phase, got "${nextTarget ?? "none"}"`);
-    }
-    const workItems = readSelectedWorkItems({
-        config: input.config,
-        result: phaseResult.result,
-        availableWorkItems,
-        seenWorkItemKeys: selectionState.seen_work_item_keys,
-        completedWorkItemKeys: selectionState.completed_work_item_keys
-    });
-    const selectionGroups = readSelectionGroups(phaseResult.result);
-    const workItemAnnotations = readWorkItemAnnotations({
-        result: phaseResult.result,
-        availableWorkItems
-    });
-    selectionState.status = "completed";
-    selectionState.recommended_work_item_queue = workItems;
-    selectionState.selected_work_item_queue = workItems;
-    selectionState.work_item_annotations = workItemAnnotations;
-    await writeJson(selectionStateFile, selectionState);
-    await writeJson(path.join(input.runDir, "state.json"), input.runState);
-    return {
-        status: "selected",
-        workItems,
-        workItemAnnotations,
-        selectionGroups,
-        availableWorkItems,
-        nextPhaseId: nextTarget
-    };
-}
-async function runWorkflowPhase(input) {
-    const visits = (input.iterationState.phase_visit_counts[input.phase.id] ?? 0) + 1;
-    input.iterationState.phase_visit_counts[input.phase.id] = visits;
-    if (visits > input.phase.max_visits_per_iteration) {
-        input.iterationState.status = "failed";
-        input.runState.status = "failed";
-        await writeJson(input.iterationStateFile, input.iterationState);
-        await writeJson(path.join(input.runDir, "state.json"), input.runState);
-        return {
-            ok: false,
-            error: `Phase "${input.phase.id}" exceeded max_visits_per_iteration=${input.phase.max_visits_per_iteration}`
-        };
-    }
-    process.stdout.write(`[${input.iterationNumber}/${input.maxIterations}] ${input.phase.id} ... `);
-    await writeJson(input.iterationStateFile, input.iterationState);
-    const phaseResult = await runPhase({
-        projectRoot: input.projectRoot,
-        runDir: input.runDir,
-        iterationDir: input.iterationDir,
-        stateFile: input.iterationStateFile,
-        config: input.config,
-        phase: input.phase,
-        state: input.iterationState,
-        workdir: input.workdir,
-        git: input.git
-    });
-    if (!phaseResult.ok) {
-        console.log(pc.red("failed"));
-        input.iterationState.status = "failed";
-        input.iterationState.phase_results[input.phase.id] = {
-            status: "failed",
-            error: phaseResult.error
-        };
-        input.runState.status = "failed";
-        await writeJson(input.iterationStateFile, input.iterationState);
-        await writeJson(path.join(input.runDir, "state.json"), input.runState);
-        return phaseResult;
-    }
-    input.iterationState.phase_results[input.phase.id] =
-        phaseResult.result ?? { status: "ok" };
-    const workItem = readObjectProperty(phaseResult.result, "work_item");
-    if (workItem !== undefined && input.iterationNumber !== "selection") {
-        input.iterationState.work_item = workItem;
-        const key = readObjectProperty(workItem, "key");
-        if (typeof key === "string" &&
-            !input.runState.seen_work_item_keys.includes(key)) {
-            input.runState.seen_work_item_keys.push(key);
-            input.iterationState.seen_work_item_keys = [
-                ...input.runState.seen_work_item_keys
-            ];
-        }
-    }
-    const label = phaseResult.outcome ?? "ok";
-    console.log(pc.green(label));
-    await writeJson(input.iterationStateFile, input.iterationState);
-    await writeJson(path.join(input.runDir, "state.json"), input.runState);
-    return phaseResult;
-}
-export async function confirmWorkItemsWithCheckbox(input) {
-    if (input.availableWorkItems.length === 0) {
-        return [];
-    }
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-        throw new Error("Work item selection confirmation requires an interactive TTY");
-    }
-    const confirmationView = buildConfirmationView(input);
-    const selectedKeys = await checkbox({
-        message: `Confirm work items to run (max ${input.maxIterations})`,
-        choices: confirmationView.choices,
-        required: false,
-        pageSize: Math.min(Math.max(input.availableWorkItems.length + 2, 5), 20),
-        validate: (selected) => selected.length <= input.maxIterations ||
-            `Select at most ${input.maxIterations} work items.`
-    });
-    const selected = new Set(selectedKeys);
-    return confirmationView.workItems.filter((item) => selected.has(item.key));
-}
-function buildConfirmationView(input) {
-    const choices = [];
-    const workItems = [];
-    const byKey = new Map(input.availableWorkItems.map((item) => [item.key, item]));
-    const recommendedKeys = new Set(input.recommendedWorkItems.map((item) => item.key));
-    const annotationsByKey = buildWorkItemKindMap(input.workItemAnnotations ?? []);
-    const displayed = new Set();
-    for (const group of input.selectionGroups) {
-        const groupItems = group.work_item_keys
-            .map((key) => byKey.get(key))
-            .filter((item) => {
-            if (!item) {
-                return false;
-            }
-            return !displayed.has(item.key);
-        });
-        if (groupItems.length === 0) {
-            continue;
-        }
-        choices.push(new Separator(`-- ${group.title} --`));
-        for (const item of groupItems) {
-            choices.push(buildConfirmationChoice({ item, recommendedKeys, annotationsByKey }));
-            workItems.push(item);
-            displayed.add(item.key);
-        }
-    }
-    const ungroupedItems = input.availableWorkItems.filter((item) => !displayed.has(item.key));
-    if (input.selectionGroups.length > 0 && ungroupedItems.length > 0) {
-        choices.push(new Separator("-- Ungrouped --"));
-    }
-    for (const item of ungroupedItems) {
-        choices.push(buildConfirmationChoice({ item, recommendedKeys, annotationsByKey }));
-        workItems.push(item);
-    }
-    return { choices, workItems };
-}
-function buildConfirmationChoice(input) {
-    return {
-        value: input.item.key,
-        name: formatWorkItemChoiceName({
-            item: input.item,
-            annotationsByKey: input.annotationsByKey
-        }),
-        description: input.item.excerpt,
-        checked: input.recommendedKeys.has(input.item.key)
-    };
-}
-function resolveNextTarget(phase, outcome) {
-    if (phase.transitions) {
-        if (!outcome) {
-            throw new Error(`Phase "${phase.id}" requires an outcome`);
-        }
-        const target = phase.transitions[outcome];
-        if (!target) {
-            throw new Error(`Phase "${phase.id}" returned unknown outcome "${outcome}"`);
-        }
-        return target;
-    }
-    return phase.next;
-}
-async function loadAvailableWorkItems(input) {
-    const candidates = await listWorkItemCandidates({
-        projectRoot: input.projectRoot,
-        config: input.config
-    });
-    return filterAvailableWorkItems({
-        candidates,
-        seenWorkItemKeys: input.runState.seen_work_item_keys,
-        completedWorkItemKeys: input.ledger.completed_work_item_keys
-    });
-}
-async function completeIterationWorkItem(input) {
-    const ledger = markWorkItemCompleted({
-        ledger: input.ledger,
-        workItem: input.iterationState.work_item
-    });
-    input.runState.completed_work_item_keys = [
-        ...ledger.completed_work_item_keys
-    ];
-    input.runState.last_completed_work_item = ledger.last_completed_work_item;
-    await writeWorkItemLedger(input.nyxDir, ledger);
-    return ledger;
-}
-function readSelectedWorkItems(input) {
-    const workItems = readObjectProperty(input.result, "work_items");
-    const legacyWorkItem = readObjectProperty(input.result, "work_item");
-    const selection = workItems ?? (legacyWorkItem === undefined ? undefined : [legacyWorkItem]);
-    if (selection === undefined) {
-        throw new Error('Selection phase returned "selected" without work_items');
-    }
-    const validation = validateWorkItemQueue({
-        config: input.config,
-        workItems: selection,
-        availableWorkItems: input.availableWorkItems,
-        seenWorkItemKeys: input.seenWorkItemKeys,
-        completedWorkItemKeys: input.completedWorkItemKeys
-    });
-    if (!validation.ok) {
-        throw new Error(validation.error);
-    }
-    return validation.workItems;
-}
-function normalizeConfirmedWorkItems(input) {
-    const availableByKey = new Map(input.availableWorkItems.map((item) => [item.key, item]));
-    const selected = new Set();
-    const normalized = [];
-    for (const item of input.confirmed) {
-        const available = availableByKey.get(item.key);
-        if (!available) {
-            throw new Error(`Confirmed work item key "${item.key}" is not in available_work_items`);
-        }
-        if (selected.has(item.key)) {
-            throw new Error(`Confirmed work item key "${item.key}" was selected twice`);
-        }
-        selected.add(item.key);
-        normalized.push(available);
-    }
-    return normalized;
-}
-function readWorkItemAnnotations(input) {
-    return normalizeWorkItemAnnotations({
-        annotations: readObjectProperty(input.result, "work_item_annotations"),
-        availableWorkItems: input.availableWorkItems
-    });
-}
-function readSelectionGroups(result) {
-    const groups = readObjectProperty(result, "selection_groups");
-    if (!Array.isArray(groups)) {
-        return [];
-    }
-    return groups
-        .map((group) => {
-        if (!isRecord(group) || typeof group.title !== "string") {
-            return undefined;
-        }
-        const keys = Array.isArray(group.work_item_keys)
-            ? group.work_item_keys.filter((key) => typeof key === "string")
-            : [];
-        if (keys.length === 0) {
-            return undefined;
-        }
-        const normalized = {
-            title: group.title,
-            work_item_keys: keys
-        };
-        if (typeof group.kind === "string") {
-            normalized.kind = group.kind;
-        }
-        return normalized;
-    })
-        .filter((group) => Boolean(group));
-}
-function isReservedTarget(target) {
-    return (target === "stop_run" ||
-        target === "stop_iteration" ||
-        target === "next_iteration");
-}
-function readObjectProperty(value, key) {
-    if (value &&
-        typeof value === "object" &&
-        Object.prototype.hasOwnProperty.call(value, key)) {
-        return value[key];
-    }
-    return undefined;
-}
-function isRecord(value) {
-    return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}