@phi-code-admin/phi-code 0.93.0 → 0.93.2

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.93.2] - 2026-07-12
+
+### Fixed
+
+- /fix: a single shot that changed NOTHING (text-only reply, zero edits — a
+  measured 91s failure mode) no longer ends UNVERIFIED; in a git repo with a
+  clean tree it ESCALATES to the full pipeline (nothing to verify = the work
+  was not done). The shot instruction now states that acting with tools is
+  mandatory and a textual plan forfeits the attempt. +1 integration test.
+
+## [0.93.1] - 2026-07-12
+
+### Fixed
+
+- /fix on PROSE input now has a real oracle: the single shot is instructed to
+  WRITE a literal reproduction (from the issue's exact snippets) and declare
+  it on a REPRO-CMD: handoff line; the driver oracle re-runs it. Without this,
+  prose inputs (e.g. SWE-bench problem statements) finished UNVERIFIED with
+  nothing to check. +2 tests.
+
 ## [0.93.0] - 2026-07-12
 
 ### Added — the escalation architecture the n=13 measurement demanded

package/extensions/phi/orchestrator.ts

@@ -315,10 +315,11 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 	// untouched; "debug"/"build"/"fix" are driven by the separate linear generic
 	// driver so /plan's fragile review-fix + "/5" logic is never engaged for them.
 	let orchestrationMode: "plan" | "debug" | "build" | "fix" = "plan";
-	// /fix escalation state: the failing state the command started from, and
-	// whether the driver-level oracle already ran (it must run exactly once,
-	// after the single-shot phase, before the run can finish).
-	let fixContext: { state: FailingState; oracleRan: boolean } | null = null;
+	// /fix escalation state: the failing state the command started from, whether
+	// the driver-level oracle already ran (it must run exactly once, after the
+	// single-shot phase), and the reproduction the shot itself declared via its
+	// REPRO-CMD handoff line (prose inputs have no runnable check otherwise).
+	let fixContext: { state: FailingState; oracleRan: boolean; reproFromShot?: string } | null = null;
 	// /debug --candidates N state: each FIX candidate's captured patch, the
 	// reproduction command used for deterministic arbitration (from the input or
 	// the REPRODUCE handoff's REPRO-CMD line), and whether arbitration ran.
@@ -1359,9 +1360,24 @@ Tag the note with relevant keywords for vector search.
 		fixContext.oracleRan = true;
 		const cwd = ctx.cwd || process.cwd();
 		const sandbox = getSessionSandbox(cwd);
-		const reproCmd = fixContext.state.failingTest?.trim() || fixContext.state.reproCommand?.trim();
+		const reproCmd =
+			fixContext.state.failingTest?.trim() || fixContext.state.reproCommand?.trim() || fixContext.reproFromShot;
 		const suiteCmd = sandbox.recipe.test?.trim();
 
+		// A shot that changed NOTHING has nothing to verify — "UNVERIFIED" would be
+		// a lie of omission (measured: a text-only 91s shot ended UNVERIFIED with
+		// zero edits). In a git repo with a clean diff, escalate to the full
+		// pipeline instead: the work simply was not done.
+		const inGitRepo = passed(runCommand("git rev-parse --is-inside-work-tree", { cwd, timeoutMs: 15_000 }));
+		if (inGitRepo && !gitIn(cwd, "diff").trim() && !gitIn(cwd, "status --porcelain").trim()) {
+			ctx.ui.notify(
+				`\n🔺 **/fix escalating: the single shot made NO changes** — nothing to verify, the full /debug pipeline takes over.`,
+				"warning",
+			);
+			phaseQueue.push(...buildDebugPhases(fixContext.state));
+			return false; // dispatch REPRODUCE
+		}
+
 		if (!sandbox.available() && (reproCmd || suiteCmd)) {
 			ctx.ui.notify(
 				`\n⚠️ **/fix oracle: sandbox unavailable** (${sandbox.reason}) — the single shot cannot be verified. Treating it as UNVERIFIED.`,
@@ -1643,6 +1659,15 @@ Tag the note with relevant keywords for vector search.
 		//   handoff line (used later for deterministic arbitration);
 		// - after each FIX candidate: capture its patch (git diff of tracked
 		//   files) and RESET the tree so the next candidate starts clean.
+		// /fix: the single shot may have WRITTEN its own reproduction (prose
+		// inputs) and declared it via REPRO-CMD — the driver oracle re-runs it.
+		if (fixContext && currentPhase?.key === "shot" && !fixContext.reproFromShot) {
+			fixContext.reproFromShot = parseReproCmd(outcome.handoff);
+			if (fixContext.reproFromShot) {
+				ctx.ui.notify(`\n🧷 Shot-declared reproduction registered: \`${fixContext.reproFromShot}\``, "info");
+			}
+		}
+
 		if (candidateContext && currentPhase) {
 			const cwd = ctx.cwd || process.cwd();
 			if (currentPhase.key === "reproduce" && !candidateContext.reproCmd) {

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

@@ -126,12 +126,18 @@ export function singleShotInstruction(state: FailingState): string {
 **The problem:**
 ${failing}
 
+**You must ACT in this turn — call the read/edit/write tools and actually change the code. A textual plan or analysis with no edits counts as a FAILED shot (measured failure mode) and forfeits your attempt to the full pipeline.**
+
 **Do exactly this:**
 1. Read the relevant code and locate the root cause.
 2. Make the smallest change that addresses it. Do NOT edit tests. Every added guard/branch is a liability.
-3. You MAY use \`sandbox_run\` to check your work (the project's real environment) — recommended when a command is available.
-4. After your change, the orchestrator will run the reproduction and the project suite in the sandbox itself: your work is judged by those REAL runs, not by your confidence. If they are red, a full diagnostic pipeline takes over from your change.
-5. **Last action:** call \`phase_result\` with \`verdict: PASS\` and a one-line handoff describing what you changed and why.${DEBUG_RULES}`;
+3. If NO runnable check was provided above, WRITE a minimal reproduction script derived **literally from the issue** (copy its exact snippets/expected values — not your paraphrase) into an untracked file (e.g. \`repro_issue.py\`), and confirm with \`sandbox_run\` that it fails before your change / passes after.
+4. You MAY use \`sandbox_run\` to check your work at any point (the project's real environment).
+5. After your change, the orchestrator re-runs the reproduction (and the suite when known) in the sandbox itself: your work is judged by those REAL runs, not by your confidence. If they are red, a full diagnostic pipeline takes over from your change.
+6. **Last action:** call \`phase_result\` with \`verdict: PASS\` and a handoff describing what you changed — and, when you wrote a reproduction, its exact command on a machine-readable line:
+\`\`\`
+REPRO-CMD: <the exact command, e.g. python repro_issue.py>
+\`\`\`${DEBUG_RULES}`;
 }
 
 /**

package/package.json

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