@phi-code-admin/phi-code 0.91.0 → 0.92.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [0.92.0] - 2026-07-11
+
+### Fixed — the two defects the n=13 SWE-bench measurement exposed
+
+The measured head-to-head (baseline 7/13 vs /debug 6/13, official harness) traced
+/debug's two lost points to concrete, reparable defects — both fixed here.
+
+- **Hasty BLOCKED (sympy-11897, halted at 51s).** The generic /debug//build
+  driver now routes phase completion through the same pure decision machine as
+  /plan (`decidePhaseTransition`), gaining what it measurably lacked: a fatal
+  401 stops the run, a transient provider error (timeout / 5xx / 429 / broken
+  stream) retries the SAME phase once on the fallback model instead of being
+  swallowed, and — new — a BLOCKED verdict gets ONE second chance on the
+  fallback model (a different family re-checks the reproduction) before the
+  halt. A confirmed second BLOCKED still halts honestly: no fabricated fix.
+  REPRODUCE's instructions now state BLOCKED is a last resort — adjust and
+  retry once before concluding.
+- **Timeout-blind VERIFY (sympy-11870, fix passed its repro but hung the real
+  suite for 900s).** VERIFY's instructions now treat a TIMEOUT of the
+  reproduction or the suite as a FAILURE of the candidate — a massive slowdown
+  or infinite loop IS a regression — with verdict BLOCKED, never FIXED. A
+  dramatic duration increase below the timeout is flagged as a red flag too.
+
+8 integration tests cover the new behaviours (BLOCKED retry → honest halt,
+BLOCKED retry → proceed on success, transient-error retry); full suite green
+(1439).
+
 ## [0.91.0] - 2026-07-11
 
 ### Added — Alibaba Cloud Coding Plan, first-class and one-command

package/extensions/phi/orchestrator.ts

@@ -284,6 +284,11 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		// Set true once this phase has been retried once (transient proxy failure /
 		// timeout / 0-tool-call). Hard cap of one retry per phase.
 		retried?: boolean;
+		// Generic driver (/debug, /build) only: set true once this phase was re-run
+		// after a BLOCKED verdict. One second chance on the fallback model — a hasty
+		// BLOCKED (measured: 51s on sympy-11897) is cheaper to re-check than to
+		// trust — then the halt is honest.
+		blockedRetried?: boolean;
 		// When true, switchModelForPhase resolves the fallback model first (used on retry
 		// to swap to a different model family rather than re-hit the one that just failed).
 		useFallback?: boolean;
@@ -1323,13 +1328,63 @@ Tag the note with relevant keywords for vector search.
 			phaseTimeoutId = null;
 		}
 
-		// A BLOCKED verdict (REPRODUCE cannot reproduce / VERIFY could not confirm)
-		// halts the pipeline honestly — no fabricated success.
+		// Route through the SAME pure decision machine as /plan so the generic
+		// driver gets the protections it was measured to lack (sympy-11897, a 51s
+		// hasty halt): fatal 401 stop, one retry on a transient provider error.
 		const structuredForThisPhase = currentPhaseResultKey === (currentPhase?.key ?? null) ? currentPhaseResult : null;
 		const outcome = resolvePhaseOutcome(structuredForThisPhase, null);
-		if (outcome.verdict === "BLOCKED" && currentPhase) {
+		const decision = decidePhaseTransition({
+			analysis,
+			phase: currentPhase ? { key: currentPhase.key, retried: currentPhase.retried } : null,
+			verdict: outcome.verdict,
+			// The generic driver has no review-fix cycle; pass the cap as spent.
+			reviewFixRounds: 1,
+			maxToolCallsPerPhase: MAX_TOOL_CALLS_PER_PHASE,
+		});
+
+		if (decision.action === "stop") {
+			ctx.ui.notify(
+				`\n❌ **/${orchestrationMode} aborted:** API authentication error (401). Check your API key.`,
+				"error",
+			);
+			finishGenericOrchestration(ctx, `❌ **/${orchestrationMode} aborted (auth error).**`);
+			return;
+		}
+
+		if (decision.action === "retry-fallback" && currentPhase) {
+			// Transient provider failure (timeout / 5xx / 429 / broken stream): retry
+			// the SAME phase once on the fallback model before treating any of its
+			// output as a real outcome.
+			currentPhase.retried = true;
+			currentPhase.useFallback = true;
+			phaseQueue.unshift(currentPhase);
+			phasePending = false;
+			ctx.ui.notify(
+				`\n🔁 **Transient provider error** in ${currentPhase.label} — retrying once on the fallback model.`,
+				"warning",
+			);
+			sendNextGenericPhase(ctx);
+			return;
+		}
+
+		// BLOCKED (REPRODUCE cannot reproduce / VERIFY could not confirm): give the
+		// phase ONE second chance on the fallback model — a hasty BLOCKED is cheaper
+		// to re-check than to trust — then halt honestly. No fabricated success.
+		if (decision.action === "pause-blocked" && currentPhase) {
+			if (!currentPhase.blockedRetried) {
+				currentPhase.blockedRetried = true;
+				currentPhase.useFallback = true;
+				phaseQueue.unshift(currentPhase);
+				phasePending = false;
+				ctx.ui.notify(
+					`\n🔁 **${currentPhase.label} reported BLOCKED on the first attempt** — retrying once on the fallback model before halting. ${outcome.handoff || ""}`,
+					"warning",
+				);
+				sendNextGenericPhase(ctx);
+				return;
+			}
 			ctx.ui.notify(
-				`\n⏸️ **${currentPhase.label} reported BLOCKED.** ${outcome.handoff || "No reproducible/verifiable result."}`,
+				`\n⏸️ **${currentPhase.label} reported BLOCKED (confirmed on retry).** ${outcome.handoff || "No reproducible/verifiable result."}`,
 				"warning",
 			);
 			finishGenericOrchestration(ctx, `⏸️ **/${orchestrationMode} stopped: BLOCKED at ${currentPhase.label}.**`);

package/extensions/phi/providers/debug-build-commands.ts

@@ -59,7 +59,8 @@ ${failing}
    - If it PASSES → STOP. Write \`BLOCKED: cannot reproduce — passes on current code\` with the run pasted. Do not invent a bug.
    - If \`sandbox_run\` reports \`SANDBOX UNAVAILABLE\` → STOP. Write \`BLOCKED: no executable environment\`.
 4. Do NOT edit any source yet. This phase only observes.
-5. **Last action:** call \`phase_result\` — \`verdict: PASS\` if it reproduced (proceed to LOCALIZE), or \`verdict: BLOCKED\` with the reason if you stopped.` +
+5. **BLOCKED is a last resort, not a first reaction.** If a run fails for an infrastructure-looking reason (tool error, missing file you guessed wrong, transient failure), adjust and retry at least once — e.g. locate the real test paths, try an alternative reproduction — before concluding. Only report BLOCKED after a genuine attempt showed the state is not reproducible or not runnable.
+6. **Last action:** call \`phase_result\` — \`verdict: PASS\` if it reproduced (proceed to LOCALIZE), or \`verdict: BLOCKED\` with the reason if you stopped.` +
 			DEBUG_RULES,
 
 		localize: `You are the LOCALIZE agent (phase 2 of /debug). Drive from the REAL symptom the previous phase captured.
@@ -96,6 +97,7 @@ ${failing}
 3. Verdict (from what \`sandbox_run\` returned, not from inspection):
    - Both green → \`FIXED\`, and paste the before(fail)/after(pass) reproduction runs and the green suite as evidence.
    - Reproduction still fails, or the suite regresses → \`BLOCKED\` with the closest diagnostic. Do NOT ship the least-bad patch; a wrong fix is worse than an honest BLOCKED.
+   - **A TIMEOUT counts as a FAILURE.** If the reproduction or the suite TIMES OUT with the fix applied (\`sandbox_run\` verdict TIMEOUT), the fix has introduced a massive slowdown or an infinite loop — that IS a regression (measured: a fix that passed its repro but made the real test suite hang for 900s). Verdict \`BLOCKED\`, never \`FIXED\`. Compare rough durations before/after: a check that got dramatically slower is a red flag even below the timeout.
 4. Write the final verdict block, then call \`phase_result\` with \`verdict: PASS\` (FIXED) or \`verdict: BLOCKED\`, plus a one-line handoff:
 \`\`\`
 VERDICT: FIXED | BLOCKED

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@phi-code-admin/phi-code",
-	"version": "0.91.0",
+	"version": "0.92.0",
 	"description": "Coding agent CLI with persistent memory, sub-agents, intelligent routing, and orchestration",
 	"type": "module",
 	"piConfig": {