pi-goal-list-loop-audit 0.29.21 → 0.29.23

package/extensions/loops/goal.ts

@@ -238,26 +238,53 @@ function goStaleTerminal(ctx: ExtensionContext, where: string): void {
     updateGoal({ interruptedAt: nowIso(), interruptedReason: `extension api stale (${where})` }, ctx);
   }
   ctx.ui.notify(`glla: ${guidance}`, "warning");
-  notifyExternal(ctx, `glla: extension api stale — restart pi. (${where})`);
-  attemptTmuxAutoReload(ctx, where);
+  notifyExternal(ctx, `glla: extension api stale — run /reload, then /glla resume. (${where})`);
+  attemptAutoReload(ctx, where);
 }
 
 /** v0.29.13: automatic recovery — the zombie handle can't call ctx.reload()
  * (pi walls EVERY runtime method behind assertActive), but fs/child_process
- * are extension-side and still work. When pi runs inside tmux (this rig's
- * shape), inject /reload as keystrokes into our own pane: pi rebuilds the
- * extension runtime in place, the fresh instance loads .pi-glla state and
- * holds (autoresume=on resumes for you). Opt out: autoReloadOnStale=false.
- * Best-effort: the manual warning already fired, so failures cost nothing. */
-function attemptTmuxAutoReload(ctx: ExtensionContext, where: string): void {
+ * are extension-side and still work. Inject /reload as keystrokes into our
+ * own terminal pane: pi rebuilds the extension runtime in place, the fresh
+ * instance loads .pi-glla state and holds (autoresume=on resumes for you).
+ * v0.29.22: transport-generalized — tmux OR WezTerm. Field: this rig runs
+ * WezTerm (TERM_PROGRAM=WezTerm, WEZTERM_PANE set, no TMUX), so the
+ * tmux-only gate failed silently 100% of the time — auto_reload_injected
+ * never fired fleet-wide, and every stale handle fell back to the manual
+ * warning (user: "stopping and told to reload is common"). v0.29.22 also
+ * fires from the entry-probe path (the most common stale discovery).
+ * Opt out: autoReloadOnStale=false. Best-effort: the manual warning
+ * already fired, so failures cost nothing. */
+function attemptAutoReload(ctx: ExtensionContext, where: string): void {
   try {
     if (loadSettings(ctx.cwd).autoReloadOnStale === false) return;
-    const pane = process.env.TMUX_PANE;
-    if (!process.env.TMUX || !pane || !/^%\d+$/.test(pane)) return;
-    appendLedger(ctx.cwd, "auto_reload_injected", { where, pane });
-    ctx.ui.notify("glla: injecting /reload into this pane via tmux — extensions rebuild in place and the fresh instance holds state. /glla resume after (automatic with autoresume=on).", "info");
-    // Escape dismisses any overlay; the dead session sits at an empty prompt.
-    const cmd = `tmux send-keys -t ${pane} Escape && sleep 0.3 && tmux send-keys -t ${pane} -l '/reload' && tmux send-keys -t ${pane} Enter`;
+    const tmuxPane = process.env.TMUX_PANE;
+    const wezPane = process.env.WEZTERM_PANE;
+    let transport: "tmux" | "wezterm";
+    let cmd: string;
+    let pane: string;
+    if (process.env.TMUX && tmuxPane && /^%\d+$/.test(tmuxPane)) {
+      transport = "tmux";
+      pane = tmuxPane;
+      // v0.29.22: NO leading Escape — a late zombie probe can fire AFTER a
+      // fresh instance already resumed and started a turn, and Escape
+      // would abort that turn without consent (the consent line). /reload
+      // alone lands at a dead prompt and queues harmlessly mid-turn (pi
+      // refuses the reload itself if a response is streaming).
+      cmd = `tmux send-keys -t ${pane} -l '/reload' && tmux send-keys -t ${pane} Enter`;
+    } else if (wezPane && /^\d+$/.test(wezPane)) {
+      transport = "wezterm";
+      pane = wezPane;
+      // wezterm cli send-text --no-paste delivers bytes as keystrokes.
+      // /reload + CR only — no Escape (see above). Literal CR byte inside
+      // single quotes — no bash-isms (exec uses /bin/sh).
+      cmd = `wezterm cli send-text --pane-id ${pane} --no-paste '/reload\r'`;
+    } else {
+      appendLedger(ctx.cwd, "auto_reload_skipped", { where, reason: "no supported multiplexer (tmux/WezTerm) in env" });
+      return;
+    }
+    appendLedger(ctx.cwd, "auto_reload_injected", { where, transport, pane });
+    ctx.ui.notify("glla: injecting /reload into this pane — extensions rebuild in place and the fresh instance holds state. /glla resume after (automatic with autoresume=on).", "info");
     exec(cmd, () => { /* best-effort */ });
   } catch {
     /* never let recovery take the warning path down */
@@ -303,6 +330,11 @@ function warnIfStaleAtEntry(ctx: ExtensionContext, what: string): boolean {
     `glla: this session's extension handle is stale (pi session replacement) — ${what} can't send continuations in this process. State is safe in .pi-glla/ — run /reload (extensions rebuild in place), then /glla resume. Restart pi only if /reload fails.`,
     "warning",
   );
+  // v0.29.22: deliberately NO self-heal from the entry probe — it fires
+  // when the user is ACTIVELY typing a /glla command, and injected
+  // keystrokes would race their input. User-present cases keep the manual
+  // warning; the self-heal stays on the autonomous paths (heartbeat
+  // probe, send paths) where no one is at the keyboard.
   return true;
 }
 
@@ -601,9 +633,9 @@ function escalateSendRearmStorm(ctx: ExtensionContext, kind: "continuation" | "l
   appendLedger(ctx.cwd, "send_rearm_escalated", { kind, afterMinutes: mins, silentMinutes: silent });
   if (kind === "loop" && isLoopActive()) {
     clearLoopTimer();
-    state.loop = { ...state.loop!, active: false, stopReason: `send-retry storm: ${mins}m of re-arms with no session activity for ${silent}m — the session is wedged. Restart pi, then /loop resume (the loop holds on restore).` };
+    state.loop = { ...state.loop!, active: false, stopReason: `send-retry storm: ${mins}m of re-arms with no session activity for ${silent}m — the session is wedged. Press Escape to cancel the stuck run (pi's own rate-limit retry holds it; pi prints "escape to cancel"), then /loop resume — the loop holds on restore. If still wedged: /reload rebuilds extensions in place, then /loop resume again. Restart pi only if /reload itself fails.` };
     persistState(ctx);
-    ctx.ui.notify(`Loop stopped: send-retry storm (${mins}m, session silent ${silent}m). Restart pi, then /loop resume (the loop holds on restore).`, "warning");
+    ctx.ui.notify(`Loop stopped: send-retry storm (${mins}m, session silent ${silent}m). Escape cancels the stuck run, then /loop resume (the loop holds on restore). /reload if it persists; restart pi only if /reload fails.`, "warning");
     notifyExternal(ctx, "Loop stopped: send-retry storm.");
     return;
   }
@@ -619,7 +651,7 @@ function escalateSendRearmStorm(ctx: ExtensionContext, kind: "continuation" | "l
     // + junk-runner: "complete ending in a pause retry storm"). The audit
     // lifecycle owns its own pauses (quota etc.).
     appendLedger(ctx.cwd, "send_rearm_escalated_suppressed", { reason: "audit-lifecycle" });
-    ctx.ui.notify("Send-retry storm during the completion audit — NOT pausing; the auditor's silence is expected. If pi is wedged, restart; the stored claim survives.", "info");
+    ctx.ui.notify("Send-retry storm during the completion audit — NOT pausing; the auditor's silence is expected. If pi is wedged, Escape cancels the stuck run; the stored claim survives.", "info");
     return;
   }
   if (state.goal && state.goal.status === "active") {
@@ -627,9 +659,9 @@ function escalateSendRearmStorm(ctx: ExtensionContext, kind: "continuation" | "l
       status: "paused",
       pauseKind: "error",
       pauseReason: `send-retry storm: ${mins}m of re-arms with no session activity for ${silent}m — the session never went idle for the continuation`,
-      pauseSuggestedAction: "The session produced no events while the send retried (wedged queue). Restart pi, then /goal resume.",
+      pauseSuggestedAction: "The session produced no events while the send retried (wedged queue — often pi's own rate-limit retry holding the run; pi prints 'escape to cancel'). Press Escape, then /goal resume. If still wedged: /reload rebuilds extensions in place, then /goal resume again. Restart pi only if /reload fails.",
     }, ctx);
-    ctx.ui.notify(`${goalNoun()} paused: send-retry storm (${mins}m, session silent ${silent}m). Restart pi, then /goal resume.`, "warning");
+    ctx.ui.notify(`${goalNoun()} paused: send-retry storm (${mins}m, session silent ${silent}m). Escape cancels the stuck run, then /goal resume. /reload if it persists; restart pi only if /reload fails.`, "warning");
     notifyExternal(ctx, `${goalNoun()} paused: send-retry storm.`);
   }
 }
@@ -640,9 +672,9 @@ function escalateStallNow(ctx: ExtensionContext, threshold: number): boolean {
   appendLedger(ctx.cwd, "stall_escalated", { threshold, kind: isLoopActive() ? "loop" : "goal" });
   if (isLoopActive()) {
     clearLoopTimer();
-    state.loop = { ...state.loop!, active: false, stopReason: `stalled: ${threshold} continuation refires landed no turn — the session is not continuing (wedged message queue or stale API). Restart pi, then /loop resume (the loop holds on restore).` };
+    state.loop = { ...state.loop!, active: false, stopReason: `stalled: ${threshold} continuation refires landed no turn — the session is not continuing (wedged message queue or stale API). Press Escape to cancel any stuck run, then /loop resume — the loop holds on restore. If the handle is stale, /reload rebuilds extensions in place; restart pi only if /reload fails.` };
     persistState(ctx);
-    ctx.ui.notify(`Loop stopped: ${threshold} refires produced no turn — the continuation is not landing. Restart pi, then /loop resume (the loop holds on restore).`, "warning");
+    ctx.ui.notify(`Loop stopped: ${threshold} refires produced no turn — the continuation is not landing. Escape cancels a stuck run, then /loop resume (the loop holds on restore). /reload if stale; restart pi only if /reload fails.`, "warning");
     notifyExternal(ctx, "Loop stopped: stalled (continuation not landing).");
     return true;
   }
@@ -651,9 +683,9 @@ function escalateStallNow(ctx: ExtensionContext, threshold: number): boolean {
       status: "paused",
       pauseKind: "error",
       pauseReason: `stalled: ${threshold} continuation refires landed no turn`,
-      pauseSuggestedAction: "The continuation chain is broken in this process (wedged message queue or stale API). Restart pi, then /goal resume.",
+      pauseSuggestedAction: "The continuation chain is broken in this process (wedged message queue or stale API). Press Escape to cancel any stuck run, then /goal resume. If the handle is stale, /reload rebuilds extensions in place — restart pi only if /reload fails.",
     }, ctx);
-    ctx.ui.notify(`${goalNoun()} paused: ${threshold} refires produced no turn. Restart pi, then /goal resume.`, "warning");
+    ctx.ui.notify(`${goalNoun()} paused: ${threshold} refires produced no turn. Escape cancels a stuck run, then /goal resume. /reload if stale; restart pi only if /reload fails.`, "warning");
     notifyExternal(ctx, `${goalNoun()} paused: stalled (continuation not landing).`);
     return true;
   }
@@ -1360,7 +1392,7 @@ function fireReviewer(
           // to still count as "proposed" in the report + notify. Now the
           // failure is LOUD and the proposal goes uncounted.
           ctx.ui.notify(
-            `Postaudit /goal proposal NOT delivered: ${err instanceof Error ? err.message : String(err)} — the follow-up never reached the session. Restart pi if the session was just replaced.`,
+            `Postaudit /goal proposal NOT delivered: ${err instanceof Error ? err.message : String(err)} — the follow-up never reached the session. Run /reload if the session was just replaced (extensions rebuild in place), then retry.`,
             "warning",
           );
           return false;
@@ -1496,7 +1528,7 @@ async function startDrafting(ctx: ExtensionContext, target: "goal" | "list" | "l
     if (isStaleApiError(err)) {
       extensionApiStale = true;
       appendLedger(ctx.cwd, "extension_api_stale", { where: "startDrafting seed" });
-      ctx.ui.notify("glla: can't start the drafting interview — this session's extension handle is stale (pi session replacement). Restart pi and re-run the command.", "warning");
+      ctx.ui.notify("glla: can't start the drafting interview — this session's extension handle is stale (pi session replacement). Run /reload (extensions rebuild in place), then re-run the command. Restart pi only if /reload fails.", "warning");
     } else {
       ctx.ui.notify(`glla: couldn't start the drafting interview (${err instanceof Error ? err.message : String(err)}) — try again.`, "warning");
     }
@@ -1616,7 +1648,7 @@ async function cmdSet(args: string, ctx: ExtensionContext, skipDraft = false): P
     // v0.28.1 (S3): the goal is persisted — mark the interrupt so the next
     // fresh session LOADS it (held by default since v0.28.21), and tell the truth instead of "starting now".
     updateGoal({ interruptedAt: nowIso(), interruptedReason: "created in a stale session" }, ctx);
-    ctx.ui.notify(`Goal saved: ${shortObj(goal.objective)} — safe in .pi-glla/, but this stale process can't send continuations. Restart pi, then /goal resume (v0.28.21: session loads no longer auto-start by default).`, "warning");
+    ctx.ui.notify(`Goal saved: ${shortObj(goal.objective)} — safe in .pi-glla/, but this stale process can't send continuations. Run /reload (extensions rebuild in place, state survives), then /goal resume. Restart pi only if /reload itself fails.`, "warning");
     return;
   }
   ctx.ui.notify(`Goal started: ${shortObj(goal.objective)} — the auditor will verify on completion.`, "info");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.29.21",
+  "version": "0.29.23",
   "description": "Goal. Loop. Audit. Done. \u2014 a pi-coding-agent extension that supervises long-running work, with isolated auditor on each completion. Beat bamboozling by design: the auditor runs in a fresh session with no extensions, no skills, no editor \u2014 only the read tools needed to verify your goal.",
   "license": "MIT",
   "author": "dracon",