phantom-pr 0.1.0

package/dist/commands/tests.js

@@ -0,0 +1,801 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { stableStringify } from '../core/stableJson.js';
+import { writeStableJson } from '../core/state/storage.js';
+import { resolveTargetIdOrPath } from '../core/targets/resolve.js';
+import { loadOrInitPolicy } from '../core/state/policy.js';
+import { loadConfigFile } from '../core/config/load.js';
+import { validateConfig } from '../core/config/validate.js';
+import { runTestCommand } from '../core/testRunner/runner.js';
+import { inferTestCommandAndRunner } from '../core/testRunner/infer.js';
+import { extractRunnerHints } from '../core/testRunner/hints.js';
+import { createGenerator, pickGenerator } from '../core/generator/registry.js';
+import { previewGeneratedTestFiles } from '../core/testGenerator/generate.js';
+import { parseJestOutput } from '../core/jest/parser.js';
+import { applyFixers } from '../core/tests/fixers.js';
+import { createGitAdapter } from '../adapters/git.js';
+import { createGithubAdapter } from '../adapters/github.js';
+import { findNearestRepoBoundary } from '../core/repo/boundary.js';
+import { HttpProvider } from '../core/llm/provider.js';
+/**
+ * Fork safety note: The tests command does not independently check fork safety
+ * because it has no PR context. Fork safety is enforced by the calling orchestrator
+ * (full, pr) which must check fork context before invoking tests.
+ *
+ * When invoked directly (invoker=tests), the user is responsible for ensuring
+ * they are not operating on a fork-derived ref in a way that violates policy.
+ */
+function toPosix(p) {
+    return p.replace(/\\/g, '/');
+}
+function parseArgs(argv) {
+    const errors = [];
+    let root;
+    let target;
+    let configPath;
+    let reportPath;
+    let invoker;
+    let baseRef;
+    let branch;
+    let dryRun = false;
+    let noPr = false;
+    let inferOnly = false;
+    let remote;
+    let maxIterations;
+    let mustPassConsecutiveRuns;
+    let timeoutMs;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i] ?? '';
+        if (a === '--root') {
+            const v = argv[i + 1];
+            if (typeof v !== 'string' || v.trim() === '')
+                errors.push('tests: --root requires a path');
+            else {
+                root = v;
+                i++;
+            }
+            continue;
+        }
+        if (a.startsWith('--root=')) {
+            const v = a.slice('--root='.length);
+            if (v.trim() === '')
+                errors.push('tests: --root requires a path');
+            else
+                root = v;
+            continue;
+        }
+        if (a === '--target') {
+            const v = argv[i + 1];
+            if (typeof v !== 'string' || v.trim() === '')
+                errors.push('tests: --target requires a value');
+            else {
+                target = v;
+                i++;
+            }
+            continue;
+        }
+        if (a.startsWith('--target=')) {
+            const v = a.slice('--target='.length);
+            if (v.trim() === '')
+                errors.push('tests: --target requires a value');
+            else
+                target = v;
+            continue;
+        }
+        if (a === '--config' || a === '-c') {
+            const v = argv[i + 1];
+            if (typeof v !== 'string' || v.trim() === '')
+                errors.push('tests: --config requires a path');
+            else {
+                configPath = v;
+                i++;
+            }
+            continue;
+        }
+        if (a.startsWith('--config=')) {
+            const v = a.slice('--config='.length);
+            if (v.trim() === '')
+                errors.push('tests: --config requires a path');
+            else
+                configPath = v;
+            continue;
+        }
+        if (a === '--report') {
+            const v = argv[i + 1];
+            if (typeof v !== 'string' || v.trim() === '')
+                errors.push('tests: --report requires a path');
+            else {
+                reportPath = v;
+                i++;
+            }
+            continue;
+        }
+        if (a.startsWith('--report=')) {
+            const v = a.slice('--report='.length);
+            if (v.trim() === '')
+                errors.push('tests: --report requires a path');
+            else
+                reportPath = v;
+            continue;
+        }
+        if (a === '--invoker') {
+            const v = argv[i + 1];
+            if (typeof v !== 'string' || v.trim() === '')
+                errors.push('tests: --invoker requires a value');
+            else {
+                invoker = v.trim();
+                i++;
+            }
+            continue;
+        }
+        if (a.startsWith('--invoker=')) {
+            const v = a.slice('--invoker='.length).trim();
+            if (v === '')
+                errors.push('tests: --invoker requires a value');
+            else
+                invoker = v;
+            continue;
+        }
+        if (a === '--baseRef') {
+            const v = argv[i + 1];
+            if (typeof v !== 'string' || v.trim() === '')
+                errors.push('tests: --baseRef requires a value');
+            else {
+                baseRef = v.trim();
+                i++;
+            }
+            continue;
+        }
+        if (a.startsWith('--baseRef=')) {
+            const v = a.slice('--baseRef='.length).trim();
+            if (v === '')
+                errors.push('tests: --baseRef requires a value');
+            else
+                baseRef = v;
+            continue;
+        }
+        if (a === '--branch') {
+            const v = argv[i + 1];
+            if (typeof v !== 'string' || v.trim() === '')
+                errors.push('tests: --branch requires a value');
+            else {
+                branch = v.trim();
+                i++;
+            }
+            continue;
+        }
+        if (a.startsWith('--branch=')) {
+            const v = a.slice('--branch='.length).trim();
+            if (v === '')
+                errors.push('tests: --branch requires a value');
+            else
+                branch = v;
+            continue;
+        }
+        if (a === '--help' || a === '-h')
+            continue;
+        if (a === '--dryRun' || a === '--dry-run') {
+            dryRun = true;
+            continue;
+        }
+        if (a === '--noPr' || a === '--no-pr') {
+            noPr = true;
+            continue;
+        }
+        if (a === '--inferOnly' || a === '--infer-only' || a === '--noExec' || a === '--no-exec') {
+            inferOnly = true;
+            continue;
+        }
+        if (a === '--remote') {
+            const v = argv[i + 1];
+            if (typeof v !== 'string' || v.trim() === '')
+                errors.push('tests: --remote requires a value');
+            else {
+                remote = v;
+                i++;
+            }
+            continue;
+        }
+        if (a.startsWith('--remote=')) {
+            const v = a.slice('--remote='.length);
+            if (v.trim() === '')
+                errors.push('tests: --remote requires a value');
+            else
+                remote = v;
+            continue;
+        }
+        if (a === '--max-iterations') {
+            const v = argv[i + 1];
+            const n = v ? Number(v) : NaN;
+            if (!Number.isInteger(n) || n <= 0)
+                errors.push('tests: --max-iterations must be a positive integer');
+            else {
+                maxIterations = n;
+                i++;
+            }
+            continue;
+        }
+        if (a.startsWith('--max-iterations=')) {
+            const v = a.slice('--max-iterations='.length);
+            const n = Number(v);
+            if (!Number.isInteger(n) || n <= 0)
+                errors.push('tests: --max-iterations must be a positive integer');
+            else
+                maxIterations = n;
+            continue;
+        }
+        if (a === '--must-pass-consecutive-runs') {
+            const v = argv[i + 1];
+            const n = v ? Number(v) : NaN;
+            if (!Number.isInteger(n) || n <= 0)
+                errors.push('tests: --must-pass-consecutive-runs must be a positive integer');
+            else {
+                mustPassConsecutiveRuns = n;
+                i++;
+            }
+            continue;
+        }
+        if (a.startsWith('--must-pass-consecutive-runs=')) {
+            const v = a.slice('--must-pass-consecutive-runs='.length);
+            const n = Number(v);
+            if (!Number.isInteger(n) || n <= 0)
+                errors.push('tests: --must-pass-consecutive-runs must be a positive integer');
+            else
+                mustPassConsecutiveRuns = n;
+            continue;
+        }
+        if (a === '--timeout-ms') {
+            const v = argv[i + 1];
+            const n = v ? Number(v) : NaN;
+            if (!Number.isInteger(n) || n <= 0)
+                errors.push('tests: --timeout-ms must be a positive integer');
+            else {
+                timeoutMs = n;
+                i++;
+            }
+            continue;
+        }
+        if (a.startsWith('--timeout-ms=')) {
+            const v = a.slice('--timeout-ms='.length);
+            const n = Number(v);
+            if (!Number.isInteger(n) || n <= 0)
+                errors.push('tests: --timeout-ms must be a positive integer');
+            else
+                timeoutMs = n;
+            continue;
+        }
+        errors.push(`tests: unknown argument "${a}"`);
+    }
+    errors.sort((x, y) => x.localeCompare(y));
+    const args = {};
+    if (root !== undefined)
+        args.root = root;
+    if (target !== undefined)
+        args.target = target;
+    if (configPath !== undefined)
+        args.configPath = configPath;
+    if (reportPath !== undefined)
+        args.reportPath = reportPath;
+    if (invoker !== undefined)
+        args.invoker = invoker;
+    if (baseRef !== undefined)
+        args.baseRef = baseRef;
+    if (branch !== undefined)
+        args.branch = branch;
+    args.dryRun = dryRun;
+    args.noPr = noPr;
+    args.inferOnly = inferOnly;
+    if (remote !== undefined)
+        args.remote = remote;
+    if (maxIterations !== undefined)
+        args.maxIterations = maxIterations;
+    if (mustPassConsecutiveRuns !== undefined)
+        args.mustPassConsecutiveRuns = mustPassConsecutiveRuns;
+    if (timeoutMs !== undefined)
+        args.timeoutMs = timeoutMs;
+    return { args, errors };
+}
+export async function runTestsWithLogger(argv, logger, deps) {
+    const parsed = parseArgs(argv);
+    if (parsed.errors.length > 0) {
+        for (const e of parsed.errors)
+            logger.error(e);
+        return 2;
+    }
+    const targetInput = parsed.args.target?.trim() ?? '';
+    const rootAbs = path.resolve(process.cwd(), parsed.args.root ?? '.');
+    const planPathAbs = path.join(rootAbs, '.test-agent', 'plan.json');
+    const indexPathAbs = path.join(rootAbs, '.test-agent', 'index.json');
+    const reportArg = parsed.args.reportPath?.trim();
+    const reportRel = reportArg ? reportArg.replace(/\\/g, '/') : '.test-agent/report.json';
+    const reportAbs = reportArg && path.isAbsolute(reportArg) ? reportArg : path.resolve(rootAbs, reportRel);
+    const remote = parsed.args.remote?.trim() || 'origin';
+    const maxIterations = Math.max(1, Math.trunc(parsed.args.maxIterations ?? 5));
+    const baseReport = {
+        schemaVersion: 1,
+        command: 'tests',
+        dryRun: parsed.args.dryRun ?? false,
+        noPr: parsed.args.noPr ?? false,
+        inferOnly: parsed.args.inferOnly ?? false,
+        remote,
+        decision: {
+            lane: 'tests',
+            skipReason: null,
+            caps: { maxIterations: { limit: maxIterations, used: 0 }, maxPRsPerRun: { limit: null, used: null } },
+            llm: { enabled: false, reason: 'pending', generatorWarnings: [] },
+        },
+        generatorKind: 'smoke',
+        generatorSummary: '',
+        generatorWarnings: [],
+        llmAccess: { invoker: 'unknown', allowCommands: [], allowed: false, denylistHits: [] },
+        llmContext: null,
+        runner: 'unknown',
+        runnerInferred: 'unknown',
+        runnerObserved: 'unknown',
+        boundary: { kind: 'unknown', boundaryFileRel: null, packageRootAbs: rootAbs, packageRootRel: '' },
+        reportPath: reportRel.replace(/\\/g, '/'),
+        planPath: '.test-agent/plan.json',
+        indexPath: '.test-agent/index.json',
+        targetInput,
+        targetId: null,
+        targetPath: null,
+        generatedFiles: [],
+        testCommandUsed: null,
+        testCommandSource: 'none',
+        testCommandReason: null,
+        mustPassConsecutiveRuns: Math.max(1, Math.trunc(parsed.args.mustPassConsecutiveRuns ?? 1)),
+        maxIterations,
+        finalOutcome: null,
+        git: { branch: null, pushed: false },
+        pr: { created: false, url: null, skippedReason: 'not_attempted' },
+        suggestions: [],
+        warnings: [],
+        errors: [],
+        attempts: [],
+    };
+    if (!targetInput) {
+        const report = { ...baseReport, errors: ['Missing --target <id|path>'] };
+        writeStableJson(reportAbs, report);
+        logger.output(stableStringify(report));
+        return 2;
+    }
+    if (!fs.existsSync(planPathAbs)) {
+        const report = {
+            ...baseReport,
+            errors: [`Missing plan at .test-agent/plan.json. Run "test-agent plan" first.`],
+        };
+        writeStableJson(reportAbs, report);
+        logger.output(stableStringify(report));
+        return 2;
+    }
+    if (!fs.existsSync(indexPathAbs)) {
+        const report = { ...baseReport, errors: ['Missing index at .test-agent/index.json. Run "test-agent index" first.'] };
+        writeStableJson(reportAbs, report);
+        logger.output(stableStringify(report));
+        return 2;
+    }
+    let planData;
+    try {
+        planData = JSON.parse(fs.readFileSync(planPathAbs, 'utf8'));
+    }
+    catch (e) {
+        const report = { ...baseReport, errors: [`Failed to parse plan.json: ${String(e)}`] };
+        writeStableJson(reportAbs, report);
+        logger.output(stableStringify(report));
+        return 2;
+    }
+    const resolved = resolveTargetIdOrPath({ root: rootAbs, plan: planData, targetInput });
+    if (!resolved.found) {
+        const report = { ...baseReport, suggestions: resolved.suggestions };
+        writeStableJson(reportAbs, report);
+        logger.output(stableStringify(report));
+        return 2;
+    }
+    const target = resolved.target;
+    const targetPaths = [...new Set(target.paths)].sort((a, b) => a.localeCompare(b));
+    const boundaryStartAbs = path.resolve(rootAbs, targetPaths[0] ?? '.');
+    const boundary = findNearestRepoBoundary({ rootAbs, targetPathOrDirAbs: boundaryStartAbs });
+    baseReport.boundary = {
+        kind: boundary.kind,
+        boundaryFileRel: boundary.boundaryFileRel,
+        packageRootAbs: boundary.packageRootAbs,
+        packageRootRel: toPosix(path.relative(rootAbs, boundary.packageRootAbs)),
+    };
+    // Load index files for convention detection and idempotency.
+    const indexData = JSON.parse(fs.readFileSync(indexPathAbs, 'utf8'));
+    const indexFiles = Array.isArray(indexData.files) ? indexData.files : [];
+    // Determine which test files we would create (for deterministic branch naming).
+    const predictedGeneratedFiles = targetPaths
+        .filter((p) => {
+        const abs = path.resolve(rootAbs, p);
+        return fs.existsSync(abs) && !fs.statSync(abs).isDirectory();
+    })
+        .map((p) => previewGeneratedTestFiles({ targetPath: p, indexFiles }))
+        .filter((x) => x.wouldCreate)
+        .map((x) => x.testPath)
+        .sort((a, b) => a.localeCompare(b));
+    // Resolve test command (config -> policy -> package.json scripts).
+    const cfgLoaded = loadConfigFile(parsed.args.configPath, {
+        cwd: () => rootAbs,
+        resolve: (...parts) => path.resolve(...parts),
+        existsSync: (p) => fs.existsSync(p),
+        readFileSync: (p, enc) => fs.readFileSync(p, enc),
+    });
+    const cfgValidated = validateConfig(cfgLoaded.data);
+    const policy = loadOrInitPolicy({ root: rootAbs }).policy;
+    // Read package.json from the boundary root (if present) for script-based inference.
+    const pkgPath = path.join(boundary.packageRootAbs, 'package.json');
+    const pkg = boundary.kind === 'js' && fs.existsSync(pkgPath)
+        ? JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+        : null;
+    const decision = inferTestCommandAndRunner({
+        rootAbs: boundary.packageRootAbs,
+        packageJson: pkg,
+        pythonBoundary: boundary.kind === 'py' ? { boundaryFileRel: boundary.boundaryFileRel } : null,
+        config: { testCommand: cfgValidated.resolved.test.command },
+        policy: { workingTestCommand: policy.workingTestCommand },
+    });
+    baseReport.runnerInferred = decision.runner;
+    baseReport.testCommandSource = decision.source;
+    baseReport.testCommandReason = decision.reason;
+    baseReport.testCommandUsed = decision.command;
+    const invokerRaw = parsed.args.invoker ?? 'tests';
+    const invoker = invokerRaw === 'tests' || invokerRaw === 'full' ? invokerRaw : 'unknown';
+    const allowCommands = cfgValidated.resolved.llm.allowCommands ?? [];
+    const denylistHits = (() => {
+        if (!cfgValidated.resolved.llm.enabled)
+            return ['llm_deny_disabled'];
+        if (allowCommands.length === 0)
+            return ['llm_deny_no_allowlist'];
+        if (invoker === 'unknown')
+            return ['llm_deny_unknown_invoker'];
+        if (!allowCommands.includes(invoker))
+            return ['llm_deny_invoker_not_allowed'];
+        return [];
+    })();
+    const llmAllowed = cfgValidated.resolved.llm.enabled && denylistHits.length === 0;
+    baseReport.llmAccess = {
+        invoker,
+        allowCommands: [...new Set(allowCommands)].sort((a, b) => a.localeCompare(b)),
+        allowed: llmAllowed,
+        denylistHits: [...new Set(denylistHits)].sort((a, b) => a.localeCompare(b)),
+    };
+    // Update decision.llm for audit summary
+    const llmReason = llmAllowed ? 'allowed' : denylistHits[0] ?? 'disabled';
+    baseReport.decision.llm = { enabled: llmAllowed, reason: llmReason, generatorWarnings: [] };
+    let generatorKind = pickGenerator({ generator: cfgValidated.resolved.generator }, policy);
+    if (generatorKind === 'llm' && !llmAllowed) {
+        baseReport.generatorWarnings = [...new Set([...baseReport.generatorWarnings, ...baseReport.llmAccess.denylistHits])].sort((a, b) => a.localeCompare(b));
+        generatorKind = 'smoke';
+    }
+    const llmProvider = generatorKind === 'llm'
+        ? deps?.llmProvider ??
+            new HttpProvider({
+                baseUrl: cfgValidated.resolved.llm.providerBaseUrl,
+                endpointPath: cfgValidated.resolved.llm.endpointPath,
+                apiKeyEnvVar: cfgValidated.resolved.llm.apiKeyEnvVar,
+                env: process.env,
+                timeoutMs: 20_000,
+                outputCharCap: 20_000,
+                dryRun: baseReport.dryRun,
+                logger: { debug: (s) => logger.debug(s) },
+            })
+        : undefined;
+    const generator = createGenerator(generatorKind, {
+        indexFiles,
+        llm: cfgValidated.resolved.llm,
+        dryRun: baseReport.dryRun,
+        env: process.env,
+        nowMs: () => Date.now(),
+        ...(llmProvider ? { llmProvider } : {}),
+    });
+    baseReport.generatorKind = generatorKind;
+    if (!decision.command) {
+        const report = {
+            ...baseReport,
+            targetId: target.id,
+            targetPath: targetPaths[0] ?? null,
+            generatedFiles: predictedGeneratedFiles,
+            warnings: [],
+            errors: [
+                ...baseReport.errors,
+                'No test command could be resolved (config.test.command, policy.workingTestCommand, or package.json scripts test/test:unit).',
+            ],
+        };
+        writeStableJson(reportAbs, report);
+        logger.output(stableStringify(report));
+        return 2;
+    }
+    if (baseReport.inferOnly) {
+        const report = {
+            ...baseReport,
+            decision: { ...baseReport.decision, lane: 'skipped', skipReason: 'infer_only' },
+            targetId: target.id,
+            targetPath: targetPaths[0] ?? null,
+            generatedFiles: predictedGeneratedFiles,
+            generatorSummary: 'infer_only',
+            generatorWarnings: ['infer_only'],
+            attempts: [],
+            warnings: ['infer_only'],
+            errors: [],
+            finalOutcome: null,
+        };
+        writeStableJson(reportAbs, report);
+        logger.output(stableStringify(report));
+        return 0;
+    }
+    const timeoutMs = Math.max(1, Math.trunc(parsed.args.timeoutMs ?? 10 * 60 * 1000));
+    const mustPass = baseReport.mustPassConsecutiveRuns;
+    let consecutivePasses = 0;
+    const attempts = [];
+    const warnings = [];
+    // Real mode: license gating + create deterministic branch before generating tests.
+    let branchToUse = null;
+    if (!baseReport.dryRun) {
+        const license = process.env.TEST_AGENT_LICENSE ?? cfgValidated.resolved.licenseKey;
+        if (!license || license.trim() === '') {
+            const gated = {
+                ...baseReport,
+                targetId: target.id,
+                targetPath: targetPaths[0] ?? null,
+                generatedFiles: predictedGeneratedFiles,
+                testCommandUsed: baseReport.testCommandUsed,
+                errors: [...baseReport.errors, 'Missing license: set TEST_AGENT_LICENSE or config licenseKey (required for real mode).'],
+            };
+            writeStableJson(reportAbs, gated);
+            logger.output(stableStringify(gated));
+            return 2;
+        }
+        const branchHash = crypto
+            .createHash('sha1')
+            .update(predictedGeneratedFiles.join('\n'))
+            .digest('hex')
+            .slice(0, 8);
+        const baseBranch = cfgValidated.resolved.baseBranch;
+        const baseRef = parsed.args.baseRef?.trim() || baseBranch;
+        const requestedBranch = parsed.args.branch?.trim() || null;
+        const baseBranchName = requestedBranch ?? `test-agent/${target.id}/${branchHash}`;
+        const git = createGitAdapter({ cwd: rootAbs });
+        await git.ensureCleanWorkingTree({ ignoreUntrackedPrefixes: ['.test-agent/'] });
+        const branch = baseBranchName;
+        await git.checkoutOrCreateBranch({ remote, baseRef, branchName: branch, ignoreUntrackedPrefixes: ['.test-agent/'] });
+        branchToUse = branch;
+        baseReport.git.branch = branch;
+    }
+    function isSafeRepoRelPosix(p) {
+        const raw = (p ?? '').trim();
+        if (!raw)
+            return false;
+        if (raw.includes('\\'))
+            return false;
+        if (raw.startsWith('/'))
+            return false;
+        if (/^[A-Za-z]:/.test(raw))
+            return false;
+        if (raw.split('/').includes('..'))
+            return false;
+        return !/[\u0000-\u001F\u007F]/.test(raw);
+    }
+    function safeAbsFromRepoRelPosix(root, p) {
+        if (!isSafeRepoRelPosix(p))
+            return null;
+        const abs = path.resolve(root, ...p.split('/'));
+        const rel = path.relative(root, abs).replace(/\\/g, '/');
+        if (rel.startsWith('../') || rel === '..')
+            return null;
+        return abs;
+    }
+    function deleteRepoRelFiles(root, pathsPosix) {
+        const uniq = [...new Set(pathsPosix)].sort((a, b) => a.localeCompare(b));
+        for (const p of uniq) {
+            const abs = safeAbsFromRepoRelPosix(root, p);
+            if (!abs)
+                continue;
+            try {
+                if (fs.existsSync(abs) && fs.statSync(abs).isFile())
+                    fs.unlinkSync(abs);
+            }
+            catch {
+                // best-effort cleanup; keep deterministic behavior by ignoring
+            }
+        }
+    }
+    async function generatePass(opts) {
+        const generated = [];
+        const created = [];
+        const genWarnings = [];
+        const genSummaries = [];
+        for (const p of targetPaths) {
+            const abs = path.resolve(rootAbs, p);
+            if (!fs.existsSync(abs) || fs.statSync(abs).isDirectory())
+                continue;
+            const out = await generator.generate({
+                rootAbs,
+                targetId: target.id,
+                targetPathPosix: toPosix(p),
+                boundary: { kind: boundary.kind, rootPathPosix: toPosix(path.relative(rootAbs, boundary.packageRootAbs)) || null },
+                runner: baseReport.runnerInferred,
+                testCommand: baseReport.testCommandUsed,
+                policy: {
+                    allowTestabilityEdits: policy.allowTestabilityEdits,
+                    notes: policy.notes,
+                    workingTestCommand: policy.workingTestCommand,
+                },
+                budgets: { maxFiles: cfgValidated.resolved.limits.maxFilesChanged, maxChars: cfgValidated.resolved.limits.maxLinesChanged },
+                ...(opts.hints ? { hints: opts.hints } : {}),
+                ...(opts.feedback ? { feedback: opts.feedback } : {}),
+            });
+            genWarnings.push(...out.warnings);
+            genSummaries.push(out.summary);
+            generated.push(...out.generatedFiles);
+            if (out.created)
+                created.push(...out.generatedFiles);
+            if (out.context)
+                baseReport.llmContext = out.context;
+        }
+        return {
+            generatedFiles: [...new Set(generated)].sort((a, b) => a.localeCompare(b)),
+            createdFiles: [...new Set(created)].sort((a, b) => a.localeCompare(b)),
+            warnings: [...new Set(genWarnings)].sort((a, b) => a.localeCompare(b)),
+            summaries: [...new Set(genSummaries)].sort((a, b) => a.localeCompare(b)),
+        };
+    }
+    // First generation pass (no feedback).
+    const pass1 = await generatePass({ hints: undefined, feedback: null });
+    let generatedFiles = pass1.generatedFiles;
+    let createdFilesForCleanup = generator.kind() === 'llm' ? pass1.createdFiles : [];
+    warnings.push(...pass1.warnings);
+    baseReport.generatorWarnings = [...new Set(pass1.warnings)].sort((a, b) => a.localeCompare(b));
+    baseReport.generatorSummary = `createdFiles=${generatedFiles.length}; ${pass1.summaries.join('; ')}`;
+    const runTest = deps?.runTestCommand ?? runTestCommand;
+    let regeneratedForNextAttempt = false;
+    for (let attempt = 1; attempt <= maxIterations; attempt++) {
+        const wasRegenerated = regeneratedForNextAttempt;
+        regeneratedForNextAttempt = false;
+        const r = await runTest({
+            command: decision.command,
+            cwd: boundary.packageRootAbs,
+            timeoutMs,
+        });
+        baseReport.runnerObserved = r.runner;
+        baseReport.runner = r.runner;
+        const parsedJest = parseJestOutput(r.rawOutput);
+        const fix = r.exitCode === 0
+            ? { applied: [], warnings: [] }
+            : applyFixers({
+                failures: parsedJest.failures,
+                ctx: { rootAbs: rootAbs, testFiles: generatedFiles, targetPaths },
+            });
+        const fixersApplied = fix.applied.sort((a, b) => a.localeCompare(b));
+        warnings.push(...fix.warnings);
+        attempts.push({
+            attempt,
+            exitCode: r.exitCode,
+            timedOut: r.timedOut,
+            durationMs: r.durationMs,
+            rawOutput: r.rawOutput,
+            failures: parsedJest.failures,
+            fixersApplied,
+            regenerated: wasRegenerated,
+        });
+        if (r.exitCode === 0 && !r.timedOut) {
+            consecutivePasses++;
+            if (consecutivePasses >= mustPass)
+                break;
+        }
+        else {
+            consecutivePasses = 0;
+            if (r.timedOut)
+                break;
+            // LLM semantic loop v1: on failure, extract runner hints + feed back redacted output, regenerate, and retry.
+            if (generator.kind() === 'llm' && attempt < maxIterations) {
+                const extracted = extractRunnerHints({ command: decision.command, rawOutput: r.rawOutput });
+                const hints = {
+                    runner: extracted.runner,
+                    failingFiles: extracted.hints.failingFiles,
+                    failingTests: extracted.hints.failingTests,
+                };
+                const feedback = { attempt, exitCode: r.exitCode ?? 1, rawOutput: r.rawOutput };
+                // Allow "add file only" diffs on subsequent attempts by removing previous generated test files first.
+                deleteRepoRelFiles(rootAbs, createdFilesForCleanup);
+                const next = await generatePass({ hints, feedback });
+                generatedFiles = next.generatedFiles;
+                createdFilesForCleanup = next.createdFiles;
+                warnings.push(...next.warnings);
+                baseReport.generatorWarnings = [...new Set([...baseReport.generatorWarnings, ...next.warnings])].sort((a, b) => a.localeCompare(b));
+                baseReport.generatorSummary = `createdFiles=${generatedFiles.length}; ${next.summaries.join('; ')}`;
+                regeneratedForNextAttempt = true;
+            }
+            // If no fixers applied, we still continue until maxIterations to be deterministic and bounded.
+        }
+    }
+    const finalAttempt = attempts[attempts.length - 1];
+    const passedConsecutive = consecutivePasses >= mustPass;
+    const finalOutcome = finalAttempt && finalAttempt.timedOut ? 'timeout' : passedConsecutive ? 'pass' : 'fail';
+    const exitCode = finalOutcome === 'pass' ? 0 : 1;
+    if (baseReport.runnerInferred !== 'unknown' &&
+        baseReport.runnerObserved !== 'unknown' &&
+        baseReport.runnerInferred !== baseReport.runnerObserved) {
+        warnings.push(`runner_mismatch inferred=${baseReport.runnerInferred} observed=${baseReport.runnerObserved}`);
+    }
+    // Finalize decision summary for audit trail
+    const decisionFinal = {
+        ...baseReport.decision,
+        caps: {
+            maxIterations: { limit: maxIterations, used: attempts.length },
+            maxPRsPerRun: baseReport.decision.caps.maxPRsPerRun,
+        },
+        llm: {
+            ...baseReport.decision.llm,
+            generatorWarnings: [...new Set(baseReport.generatorWarnings)].sort((a, b) => a.localeCompare(b)),
+        },
+    };
+    const report = {
+        ...baseReport,
+        decision: decisionFinal,
+        targetId: target.id,
+        targetPath: targetPaths[0] ?? null,
+        generatedFiles,
+        testCommandUsed: baseReport.testCommandUsed,
+        attempts,
+        warnings: [...new Set(warnings)].sort((a, b) => a.localeCompare(b)),
+        finalOutcome,
+    };
+    // Real mode: commit + push (+ optional PR) only on success.
+    if (!baseReport.dryRun && finalOutcome === 'pass') {
+        const git = createGitAdapter({ cwd: rootAbs });
+        // Only commit generated test files (avoid committing .test-agent/report.json etc).
+        await git.commitFilesIfChanged(generatedFiles, `test-agent: add tests for ${target.id}`, { ignoreUntrackedPrefixes: ['.test-agent/'] });
+        await git.pushBranch(remote, report.git.branch ?? branchToUse ?? '');
+        report.git.pushed = true;
+        if (baseReport.noPr) {
+            report.pr = { created: false, url: null, skippedReason: '--noPr' };
+        }
+        else {
+            const owner = cfgValidated.resolved.github.owner;
+            const repo = cfgValidated.resolved.github.repo;
+            const tokenEnvVar = cfgValidated.resolved.github.tokenEnvVar;
+            if (!owner || !repo || !tokenEnvVar) {
+                report.pr = { created: false, url: null, skippedReason: 'missing_github_config' };
+            }
+            else {
+                const token = process.env[tokenEnvVar];
+                if (!token) {
+                    report.pr = { created: false, url: null, skippedReason: `missing_env:${tokenEnvVar}` };
+                }
+                else {
+                    const gh = createGithubAdapter({ token });
+                    const headRef = report.git.branch ?? '';
+                    const existing = await gh.listOpenPullRequests({ owner, repo, branchPrefix: headRef, max: 50 });
+                    const existingExact = existing.filter((p) => p.headRef === headRef).sort((a, b) => a.number - b.number)[0] ?? null;
+                    if (existingExact) {
+                        await gh.commentOnPullRequest({
+                            owner,
+                            repo,
+                            number: existingExact.number,
+                            body: `Updated run for target ${target.id}.\n\nReport: ${report.reportPath}`,
+                        });
+                        report.pr = { created: false, url: existingExact.url, skippedReason: 'existing_pr' };
+                    }
+                    else {
+                        const pr = await gh.openPullRequest({
+                            owner,
+                            repo,
+                            title: `test-agent: add tests for ${target.id}`,
+                            body: `Automated test generation/run for target ${target.id}.\n\nReport: ${report.reportPath}`,
+                            base: cfgValidated.resolved.baseBranch,
+                            head: headRef,
+                        });
+                        report.pr = { created: true, url: pr.url, skippedReason: null };
+                    }
+                }
+            }
+        }
+    }
+    // Determinism: generatedFiles and attempt.fixersApplied are sorted; stable JSON writer ensures stable keys.
+    writeStableJson(reportAbs, report);
+    logger.output(stableStringify(report));
+    return exitCode;
+}
+//# sourceMappingURL=tests.js.map