looply-cli 0.5.18 → 0.5.19

package/dist/run-cmd.js

@@ -73,6 +73,7 @@ const run_base_2 = require("./run-base");
 const round_records_1 = require("./round-records");
 const goal_gap_1 = require("./goal-gap");
 const visual_proof_run_1 = require("./visual-proof-run");
+const bug_repro_1 = require("./bug-repro");
 const goal_adaptive_1 = require("./goal-adaptive");
 const pending_action_1 = require("./pending-action");
 const approval_resolution_1 = require("./approval-resolution");
@@ -2875,6 +2876,9 @@ async function runLoop(opts) {
     const compileReaders = (0, citation_readers_1.nodeCitationReaders)(cwd, stateDir);
     const compileProvider = (0, provider_identity_1.providerRecordFor)(resolved.spec, resolved.spec.command === agent_exec_1.DEFAULT_AGENT.command ? (0, provider_discovery_1.claudeExecutable)(resolved.spec.executable) : null);
     const compiles = new compile_store_1.CompileStore(stateDir, ledger_store_1.nodeLedgerFs);
+    // Per PROJECT, like the goal mirror: the reproduction a Start recorded is the one every later Start reads.
+    const reproStore = new bug_repro_1.ReproStore(projectStateDirPath);
+    const reproFor = (id, version) => reproStore.read(id, version);
     const recordCompile = async (forGoalId, forGoalVersion, treeSha, outcome, checked) => {
         try {
             if (!compiles.isOpen())
@@ -2930,17 +2934,62 @@ async function runLoop(opts) {
     /** The first compile's authority answer, kept so its reason is the acted-on one. */
     let stillOurs = { ok: true };
     let seamFailure = null;
+    /** A bug that did not show: the one question for the ticket, asked before any plan (`bug-repro.ts`). */
+    let reproAsks = null;
     try {
-        if (verdict.compile && scope !== null && binding.kind === 'bound') {
+        /**
+         * BUG TICKETS ARE REPRODUCTION-FIRST (`bug-repro.ts`). Before a bug goal's first plan, a test
+         * is written and run red on the base tree, and its text travels into the plan and every round.
+         * A bug that does not show asks one question instead of spending a fix attempt — only when the
+         * reproduction happened in THIS Start, so a resumed goal is never asked the same thing twice.
+         */
+        if (verdict.compile && scope !== null && binding.kind === 'bound' && (0, bug_repro_1.isBugGoal)(binding.goal.text)) {
+            let repro = reproStore.read(binding.goal.id, binding.goal.version);
+            if (repro === null) {
+                log('repro   : this is a bug — writing a test that shows it before planning the fix');
+                repro = await (0, bug_repro_1.reproduceBug)({
+                    goalId: binding.goal.id,
+                    goalVersion: binding.goal.version,
+                    goalText: binding.goal.text,
+                    projectName: config.project.name,
+                    gates: config.gates,
+                }, {
+                    invoke: agent,
+                    run: (0, untrusted_gate_1.makeUntrustedGateRunner)(cwd),
+                    git: { changedEntries: () => git.changedEntries(), headSha: () => git.headSha(), discard: () => git.discard() },
+                    readFile: (0, bug_repro_1.checkoutReader)(cwd),
+                    download: (0, bug_repro_1.nodeAttachmentDownloader)(cwd),
+                    now: () => new Date(),
+                    log,
+                });
+                try {
+                    reproStore.write(repro);
+                }
+                catch (e) {
+                    log(`repro   : the record could not be written — ${e.message}`);
+                }
+                log(repro.outcome === 'reproduced'
+                    ? `repro   : reproduced — "${repro.test}" fails on the base tree (exit ${repro.failedBefore?.exitCode ?? '?'})`
+                    : `repro   : ${repro.outcome} — ${repro.because ?? ''}`);
+                if (repro.outcome === 'question')
+                    reproAsks = (0, bug_repro_1.reproQuestion)(repro);
+            }
+            else if (repro.outcome === 'question') {
+                log('repro   : a question was already asked for this goal; going on without a reproduction');
+            }
+        }
+        if (reproAsks === null && verdict.compile && scope !== null && binding.kind === 'bound') {
             compiledThisRun = true;
             log(`compile : ${binding.goal.text}`);
             // Read before the compile: the compiler is told not to change anything, and every check of its
             // answer (the first and any re-plan) is made against the same committed tree.
             const compiledAt = await git.headTreeSha().catch(() => null);
+            // A reproduced bug's test rides with the goal's words: the plan's first job is to make it pass.
+            const planText = (0, bug_repro_1.withReproduction)(binding.goal.text, reproFor(binding.goal.id, binding.goal.version));
             const recovered = await (0, plan_recovery_1.compileWithRecovery)({
                 goalId: binding.goal.id,
                 goalVersion: binding.goal.version,
-                goalText: binding.goal.text,
+                goalText: planText,
                 projectId,
                 projectName: config.project.name,
                 /**
@@ -3291,7 +3340,7 @@ async function runLoop(opts) {
                 adaptive = await (0, goal_adaptive_1.decideAdaptive)({
                     goalId: scope.goalId,
                     goalVersion: bound.version,
-                    goalText: bound.text,
+                    goalText: (0, bug_repro_1.withReproduction)(bound.text, reproFor(scope.goalId, bound.version)),
                     projectId,
                     projectName: config.project.name,
                     currentRevision: revision,
@@ -3337,7 +3386,18 @@ async function runLoop(opts) {
                             ...(config.run.baseBranch === undefined ? {} : { configuredBase: config.run.baseBranch }),
                             log,
                         });
-                        return (0, goal_gap_1.evaluateGoalGap)(screenshots.length > 0 ? { ...i, screenshots } : i, { invoke: planAgent });
+                        // A reproduced bug is met only when its test passes at this tree, run by the machine (`bug-repro.ts`).
+                        const gap = await (0, goal_gap_1.evaluateGoalGap)(screenshots.length > 0 ? { ...i, screenshots } : i, { invoke: planAgent });
+                        return (0, bug_repro_1.evaluateWithReproduction)(gap, reproFor(goalId, bound.version), {
+                            run: (0, untrusted_gate_1.makeUntrustedGateRunner)(cwd),
+                            readFile: (0, bug_repro_1.checkoutReader)(cwd),
+                            headSha: () => git.headSha(),
+                            changedPaths: () => git.changedPaths(),
+                            discard: () => git.discard(),
+                            store: reproStore,
+                            now: () => new Date(),
+                            log,
+                        });
                     },
                     // The same recovery as the first plan: re-plan refused steps, read an empty answer as
                     // an instruction, and fall back to one direct step before this revision is empty.
@@ -3598,6 +3658,8 @@ async function runLoop(opts) {
      * of that block and the ending is written there, before any of them.
      */
     const nothingPickableBecause = () => {
+        if (reproAsks !== null)
+            return reproAsks;
         if (seamFailure !== null)
             return `could not check this goal — ${seamFailure}`;
         const said = adaptive === null ? null : (0, goal_adaptive_1.describeAdaptive)(adaptive, attestedNow(), coverage);
@@ -3700,6 +3762,11 @@ async function runLoop(opts) {
         // disk. That is safe — the write is one whole-file rename and the next
         // Start converges on the same rows — but the message should not claim more
         // than it knows, so it says what happened rather than what it hopes.
+        // The bug did not show: one precise question on the ticket, before any fix is attempted.
+        if (reproAsks !== null) {
+            await releaseHold();
+            throw new RunRefused(reproAsks, 'human_required');
+        }
         if (seamFailure !== null) {
             await releaseHold();
             throw new Error(`could not check this goal — ${seamFailure}`);
@@ -3951,7 +4018,7 @@ async function runLoop(opts) {
                  * bound to — a second read could straddle an amendment and show a
                  * goal this work was never authorised against.
                  */
-                binding.kind === 'bound' ? binding.goal.text : undefined, 
+                binding.kind === 'bound' ? (0, bug_repro_1.withReproduction)(binding.goal.text, reproFor(binding.goal.id, binding.goal.version)) : undefined, 
                 // The other repositories this change spans, resolved once for the run.
                 span),
                 timeoutMs: AGENT_TIMEOUT_MS,