@miller-tech/uap 1.207.1 → 1.209.0

package/dist/cli/deliver.js

@@ -187,7 +187,7 @@ export function bestKeepFastScore(gateResults, fastRungIds) {
 export { resolveAcceptanceVerdict } from '../delivery/mission-acceptance.js';
 import { createAgenticExecutor, noopApplier, selectExecutorMode, lockContractFiles } from '../delivery/agentic-executor.js';
 import { createRepairEscalation } from '../delivery/repair-escalation.js';
-import { clearStop, isRunBudgetExpired, isStopRequested, makeStopLatch, requestStop, runBudgetMinutes, loadRunState, newRunId, saveRunState, isEpicResume, MAX_PERSISTED_PHASES } from '../delivery/run-state.js';
+import { clearProjectStop, clearStop, finalRunStatus, isRunBudgetExpired, isStopRequested, makeStopLatch, requestStop, runBudgetMinutes, loadRunState, newRunId, saveRunState, isEpicResume, MAX_PERSISTED_PHASES } from '../delivery/run-state.js';
 import { planDeliveryPhases, shouldDecompose } from '../delivery/decompose.js';
 import { initLedger, markItem } from '../delivery/completion-ledger.js';
 import { loadUapConfigRaw } from '../utils/config-loader.js';
@@ -2678,15 +2678,36 @@ async function runDeliver(instruction, options) {
     const budgetMinutes = runBudgetMinutes(projectRoot);
     const runStartedAtMs = Date.now();
     let stoppedForBudget = false;
+    // Captured at OBSERVATION time: isStopRequested consumes the project-level
+    // STOP file when it sees it, so this flag is the only record of the stop
+    // that survives to final bookkeeping (a re-check there returns false and the
+    // run lands 'failed' — the misread that caused the 2026-08-15 stop/relaunch
+    // thrash).
+    let stoppedByRequest = false;
     const stopLatch = makeStopLatch(() => {
         if (isRunBudgetExpired(runStartedAtMs, budgetMinutes)) {
             stoppedForBudget = true;
             return true;
         }
-        return isStopRequested(projectRoot, runId);
+        if (isStopRequested(projectRoot, runId)) {
+            stoppedByRequest = true;
+            return true;
+        }
+        return false;
     });
     loopConfig.shouldStop = stopLatch;
     clearStop(projectRoot, runId);
+    // A project-level STOP that PREDATES this launch was aimed at a previous
+    // run — consuming it keeps it from instant-stopping this one at turn 0
+    // (observed 2026-08-15: a leaked STOP latched a resume dead in 0 turns).
+    // mtime-gated against PROCESS start, not this line's timestamp: planning
+    // runs for minutes before we get here, and a stop touched during planning
+    // (the impatient pre-runId window the project STOP exists for) is a live
+    // operator signal that must reach the stop latch untouched.
+    const processStartedAtMs = Date.now() - process.uptime() * 1000;
+    if (clearProjectStop(projectRoot, processStartedAtMs)) {
+        console.error(chalk.dim('  cleared a stale project-level STOP left over from a previous run'));
+    }
     // The restored checkpoint feeds exactly one loop (the in-flight phase).
     let resumeCheckpoint = resumeState?.checkpoint;
     // A model switch cannot serialize into the checkpoint; when the interrupted
@@ -2997,6 +3018,15 @@ async function runDeliver(instruction, options) {
             persistCompleted: ({ summaries, completed }) => {
                 runState.phaseSummaries = [...summaries];
                 runState.completedEpicIds = [...completed];
+                // Advance the visible phase pointer as epics are ACCEPTED. Followers
+                // read state.json for progress; a phaseIndex frozen at 0 through a
+                // 30-minute first epic read as "stuck at phase 1/20" and got a healthy
+                // run cooperatively stopped (2026-08-15). Clamped to the plan's last
+                // index: the loader validates the cursor's range and silently DROPS an
+                // out-of-range value (split sub-epic ids can push completed.length past
+                // the top-level plan), which would erase the very progress signal this
+                // write exists to provide.
+                runState.phaseIndex = Math.min(completed.length, Math.max(0, (runState.phases?.length ?? 1) - 1));
                 // The checkpoint belongs to the finished epic (phased-path parity) —
                 // never seed a later loop with a completed epic's session state.
                 runState.checkpoint = undefined;
@@ -3415,15 +3445,27 @@ async function runDeliver(instruction, options) {
             disposeSnapshot(regressSnapshot);
         }
     }
+    // Surface the observed stop on the result itself: the JSON output (and the
+    // MCP deliver tool reading it) is what the NEXT agent decides from, and a
+    // stopped run that prints as a plain failure gets relaunched instead of
+    // resumed. The epic path may have set this already; the plain loop's stop is
+    // only visible here, via the latch flags.
+    if (!result.success && (stoppedByRequest || stoppedForBudget))
+        result.stopped = true;
     haloTracer.finish(result);
     // Durable-run bookkeeping + task/memory trail (all fail-soft): the run's
     // outcome lands in the task DB and short-term memory so future sessions
     // know exactly what was delivered (or what failed and why).
-    runState.status = result.success
-        ? 'delivered'
-        : isStopRequested(projectRoot, runId)
-            ? 'interrupted'
-            : 'failed';
+    // Deliberate side effect: isStopRequested CONSUMES a project-level STOP it
+    // finds, on the success path too — a stop file that outlived its run would
+    // silently stop the NEXT mission (that stale-STOP hazard is real; observed
+    // 2026-08-15). Hoisted so the consumption is visible, not buried in an
+    // argument list to a pure function.
+    const lateStopFilePresent = isStopRequested(projectRoot, runId);
+    runState.status = finalRunStatus(result.success, 
+    // The latch flags ride along directly so this mapping cannot silently
+    // regress if the result.stopped annotation above ever moves below it.
+    result.stopped === true || stoppedByRequest || stoppedForBudget, lateStopFilePresent);
     if (result.success)
         runState.checkpoint = undefined;
     clearStop(projectRoot, runId);
@@ -3534,6 +3576,14 @@ async function runDeliver(instruction, options) {
                 `\`uap deliver --resume\`, and raise the budget for this mission with delivery.maxRunMinutes ` +
                 `in .uap.json if the mission is genuinely this long.`));
         }
+        else if (result.stopped) {
+            // Budget stops are named by the branch above; anything else that set
+            // result.stopped is a cooperative stop of some kind — keep the copy
+            // cause-neutral so it stays true if new stop sources appear.
+            console.log(chalk.yellow(`  Stopped by a cooperative stop request — interrupted, not failed. The work is ` +
+                `checkpointed and the lock is released. Resume it with \`uap deliver --resume ${runId}\`; ` +
+                `relaunching from scratch discards the accepted work.`));
+        }
         if (result.finalFeedback) {
             console.log(chalk.dim(stripControl(result.finalFeedback)));
         }