infinity-harness 2.3.0 → 2.3.1

package/CHANGELOG.md

@@ -4,7 +4,10 @@ All notable changes to this project are documented here.
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [2.3.0] — 2026-08-24
+## [2.3.1] — 2026-08-24
+
+*(2.3.0 was staged at the registry and never completed; 2.3.1 is that release plus the last two
+fixes below, and is the first version of this work anyone can install.)*
 
 Five bugs were reported against 2.1.0 by someone actually using the thing. Every one of them was
 real, none of them could be seen by a test that mocks pi, and finding out why led to the change
@@ -106,6 +109,23 @@ that matters most in this release: **the suite now drives a real `pi` process.**
 
 - **The phase picker did not offer RESEARCH** — a feature nobody could find.
 
+- **A handoff in a one-shot `pi -p` run replaced the session out from under the instance that
+  asked for it**, so every handler afterwards touched a torn-down context and pi reported
+  "This extension ctx is stale after session replacement" on every turn. A headless run has no
+  next turn to hand anything to, so it does not hand off — and the extension now stops touching
+  pi the moment its session is shut down, whatever the reason.
+
+- **A new phase counted as a stall.** The first failure of a phase was compared against the
+  fingerprint taken when the *previous* phase passed — identical, because nothing had happened
+  yet — so the run spent `retry` and `reframe` on the opening turn of every single phase, and
+  arrived at the rungs that matter with the cheap ones already gone. A stall is the agent
+  producing nothing when asked; a fresh brief has not asked yet.
+
+- **The gate history counted every pass twice.** `runChecks` recorded the verdict and
+  `transitionPhase` recorded it again, so the history read `define:pass → define:pass`, which says
+  a phase had to be attempted twice — the opposite of what happened. Repeated *failures* are still
+  every one of them: that is the fact a human comes back to read.
+
 ### Changed
 
 - The dashboard shows every subtask, not only the active task's. The widget has nine rows and a job

package/extensions/infinity-harness/index.ts

@@ -117,6 +117,17 @@ export default function (pi: ExtensionAPI): void {
   let remoteDir: string | null = null;
   let view: WidgetView = defaultView();
 
+  /**
+   * Is this instance's session still the live one?
+   *
+   * After `ctx.newSession()` pi tears the old runtime down and rebinds
+   * extensions, but this closure and its registered handlers still exist. Any
+   * of them that touches `pi` or a captured `ctx` afterwards gets
+   * "This extension ctx is stale after session replacement" — which is what a
+   * handoff produced on every single turn until this flag existed.
+   */
+  let sessionLive = true;
+
   /**
    * Is a continuous run armed?
    *
@@ -307,6 +318,10 @@ export default function (pi: ExtensionAPI): void {
     // this session stops driving and the replacement never arrives. One
     // attempt, then carry on here — a run that continues in a fat session is
     // far better than a run that stops.
+    // A one-shot `pi -p` run has no next turn to hand anything to: replacing
+    // its session mid-flight produces a stale-context error and nothing else.
+    if (ctx.mode !== "tui" && ctx.mode !== "rpc") return false;
+
     if (handingOff) {
       if (hasPendingHandoff(dir)) {
         notify(ctx, "infinity-harness: the new session never started — continuing here.", "warning");
@@ -531,6 +546,7 @@ export default function (pi: ExtensionAPI): void {
    * summarised. Anything the run cannot afford to forget belongs here.
    */
   pi.on("before_agent_start", async (event, ctx) => {
+    if (!sessionLive) return;
     const dir = projectDir(ctx);
     if (!isHarnessProject(dir)) return;
     try {
@@ -544,6 +560,7 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.on("session_tree", async (_event, ctx) => {
+    if (!sessionLive) return;
     refreshWidget(ctx);
   });
 
@@ -553,6 +570,7 @@ export default function (pi: ExtensionAPI): void {
    * few calls costs little and keeps the plan honest.
    */
   pi.on("context", async (event, ctx) => {
+    if (!sessionLive) return;
     const dir = projectDir(ctx);
     if (!isHarnessProject(dir)) return;
 
@@ -630,6 +648,7 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.on("session_compact", async (event, ctx) => {
+    if (!sessionLive) return;
     const dir = projectDir(ctx);
     if (!isHarnessProject(dir)) return;
     try {
@@ -658,6 +677,7 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.on("turn_end", async (_event, ctx) => {
+    if (!sessionLive) return;
     refreshWidget(ctx);
   });
 
@@ -670,6 +690,7 @@ export default function (pi: ExtensionAPI): void {
    * `/reload`, `/resume`, and pi being restarted.
    */
   pi.on("agent_settled", async (_event, ctx) => {
+    if (!sessionLive) return;
     const dir = projectDir(ctx);
     if (!isHarnessProject(dir)) return;
     if (loopBusy || handingOff) return;
@@ -749,6 +770,7 @@ export default function (pi: ExtensionAPI): void {
    * touch of the config would stop the harness configuring itself.
    */
   pi.on("tool_call", async (event, ctx) => {
+    if (!sessionLive) return;
     const dir = projectDir(ctx);
     if (!isHarnessProject(dir)) return;
 
@@ -791,6 +813,7 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.on("session_shutdown", async () => {
+    sessionLive = false;
     if (remoteServer) {
       try {
         await remoteServer.close();
@@ -1392,7 +1415,12 @@ export default function (pi: ExtensionAPI): void {
       } catch (e) {
         // A handoff that cannot happen must never end the run: fall back to
         // carrying on in this session, which is the pre-2.3 behaviour.
+        //
+        // Unless the session is already gone — `newSession` can fail *after*
+        // replacing the runtime, and reaching for the old `pi` then is the
+        // "stale ctx" error rather than a recovery.
         clearHandoff(dir);
+        if (!sessionLive) return;
         notify(ctx, `infinity-harness: could not start a new session — ${errMsg(e)}`, "warning");
         pi.sendUserMessage(pending.kickoff, { deliverAs: "followUp" });
       }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infinity-harness",
-  "version": "2.3.0",
-  "description": "A pi agent extension that runs a gated build pipeline unattended — enforces phases, validates with deterministic gates, and keeps working for hours or days without losing the plan.",
+  "version": "2.3.1",
+  "description": "A pi agent extension that runs a gated build pipeline unattended \u2014 enforces phases, validates with deterministic gates, and keeps working for hours or days without losing the plan.",
   "type": "module",
   "keywords": [
     "pi-package",