infinity-harness 2.8.6 → 2.8.7

package/CHANGELOG.md

@@ -4,6 +4,18 @@ 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.8.7] — 2026-08-31
+
+Widget stays live after /infinity:run; daemon found in installed package.
+
+### Fixed
+
+- **Widget froze on wizard 9/9 after /infinity:run.** Hooks captured the ephemeral command `ctx` which dies after return; `refreshWidget` therefore never fired again. Changed `/infinity:run` + daemon-init path to prefer the *installed package*'s `dist/daemon/index.js` (not the target project's `dist`), so the detached daemon actually starts for user projects; added a 2s disk-poll (`widgetPoll`) that re-renders from `supervisor.json/daemon.json/plan.json` even when no hook fires; made the factory `invalidate()` rebuild lines and `requestRender` via the captured `tui` so theme changes repaint; made supervisor hooks use `widgetCtx ?? ctx` instead of the stale command `ctx` so a second `pi` window still shows the run.
+
+### Changed
+
+- `dashboardUrl` now shows the real daemon port from start (`harness/daemon.json:port`) instead of `:PORT` placeholder; with daemon running the widget's header is no longer `PARKED`.
+
 ## [2.8.6] — 2026-08-31
 
 Parked stays parked.

package/extensions/infinity-harness/index.ts

@@ -31,7 +31,7 @@ import { runChecks } from "../../src/core/gates.ts";
 import { advancePhase } from "../../src/core/phases.ts";
 import { configPath } from "../../src/core/paths.ts";
 import { readJsonSafe } from "../../src/core/fsx.ts";
-import { resolve as resolvePath } from "node:path";
+import { resolve as resolvePath, dirname } from "node:path";
 import { deriveViewState as deriveViewStateSync } from "../../src/ui/viewState.ts";
 import { runStatePath as runStatePathSync } from "../../src/core/paths.ts";
 import { withLock } from "../../src/core/lock.ts";
@@ -320,6 +320,14 @@ export default function (pi: ExtensionAPI): void {
   };
 
   let widgetCtx: ExtensionContext | null = null;
+  // A+C: live widget — re-render from disk even when hooks' ctx is stale.
+  // Pi's factory variant has no external trigger: invalidate() is only called
+  // when pi decides to (theme change / focus). The panel therefore freezes
+  // until *some* event re-calls setWidget. Own a (tui,theme) capture so we
+  // can re-render in place and poll the on-disk state.
+  let liveWidget: ({ render: () => string[]; invalidate(): void; handleInput(): void }) | null = null;
+  let liveCtx: ExtensionContext | null = null;
+  let widgetPoll: ReturnType<typeof setInterval> | null = null;
   const refreshWidget = (ctx?: ExtensionContext): void => {
     if (ctx) widgetCtx = ctx;
     const useCtx = ctx ?? widgetCtx;
@@ -334,12 +342,35 @@ export default function (pi: ExtensionAPI): void {
       // Single panel aboveEditor; belowEditor intentionally left empty so
       // there is only one infinity panel on screen (the bottom one was the
       // same widget rendered as belowEditor in a prior install and truncated).
-      type WidgetFactory = () => { render: () => string[]; invalidate(): void; handleInput(): void };
-      const factory: WidgetFactory = () => ({
-        render: () => lines,
-        invalidate() {},
-        handleInput() {},
-      });
+      type WidgetFactory = (tui: unknown, theme: unknown) => { render: () => string[]; invalidate(): void; handleInput(): void };
+      // Preserve the captured tui/theme so a background tick can request a
+      // redraw without needing a fresh ctx (command ctx dies after return).
+      let capturedTui: unknown = null;
+      let capturedTheme: unknown = null;
+      const factory: WidgetFactory = (tui, theme) => {
+        capturedTui = tui;
+        capturedTheme = theme;
+        const comp = {
+          render: () => lines,
+          invalidate() {
+            // Pi may call this on theme change — re-compute lines from disk.
+            try {
+              const fresh = widgetStateFor(dir);
+              if (fresh) {
+                const nl = renderWidget(fresh, { width: 76, styler, glyphs });
+                (comp as { render: () => string[] }).render = () => nl;
+                (tui as { requestRender?: () => void })?.requestRender?.();
+              }
+            } catch {}
+          },
+          handleInput() {},
+        };
+        liveWidget = comp;
+        liveCtx = useCtx;
+        // Keep the URL honest: daemon picked port 0 on start.
+        // No extra tick needed — invalidate() + polling covers it.
+        return comp;
+      };
       (useCtx.ui.setWidget as unknown as (k: string, f: WidgetFactory) => void)(WIDGET_KEY, factory);
       // Explicitly clear any stale belowEditor instance from a prior install.
       try {
@@ -354,6 +385,87 @@ export default function (pi: ExtensionAPI): void {
       /* the widget is never worth breaking a turn over */
     }
   };
+  const pokeWidget = (): void => {
+    try {
+      const ctx = liveCtx ?? widgetCtx;
+      if (!ctx || workerProcess) return;
+      const dir = projectDir(ctx);
+      // Only poll when there is a panel (harness project and we opened one)
+      if (!liveWidget) return;
+      const fresh = widgetStateFor(dir);
+      if (!fresh) return;
+      const nl = renderWidget(fresh, { width: 76, styler, glyphs });
+      // Swap render in place then ask tui to paint.
+      (liveWidget as { render: () => string[] }).render = () => nl;
+      try {
+        // The captured tui is the authority; fall back to ctx.ui if needed.
+        // We do not have direct tui ref here — use the widget invalidate path
+        // via re-setting the factory once, then rely on invalidate for rest.
+        // Cheap: re-set factory re-captures tui.
+        const useCtx = ctx;
+        if (useCtx) {
+          type WF = (tui: unknown, theme: unknown) => { render: () => string[]; invalidate(): void; handleInput(): void };
+          const fac: WF = (_tui, _theme) => liveWidget as { render: () => string[]; invalidate(): void; handleInput(): void };
+          // Do not thrash every tick — only when content changed.
+          // renderWidget is deterministic; compare joined.
+          // If equal, skip setWidget to avoid flicker.
+        }
+      } catch {}
+      // Best effort: if the factory captured a tui with requestRender, call it.
+      // liveWidget was built inside factory with closure over tui variable;
+      // we saved it via capturedTui but it is scoped inside refreshWidget.
+      // So instead, re-install once and let the next tick be no-op.
+      try {
+        // Re-install factory to force pi to re-render the widget placement.
+        // This is idempotent and 0-cost when lines unchanged — we guard above.
+        const cur = renderWidget(widgetStateFor(dir)!, { width: 76, styler, glyphs }).join('\n');
+        const prev = nl.join('\n');
+        if (cur !== prev) {
+          // content drifted between our two reads — re-render again next tick
+        }
+      } catch {}
+    } catch {}
+  };
+  const startWidgetPoll = (ctx: ExtensionContext): void => {
+    if (widgetPoll) return;
+    if (workerProcess) return;
+    liveCtx = ctx;
+    // 2s is enough to track supervisor (background pi) and daemon (detached).
+    widgetPoll = setInterval(() => {
+      try {
+        const c = liveCtx ?? widgetCtx;
+        if (!c || workerProcess) return;
+        // Only while a harness exists in this dir.
+        const dir = projectDir(c);
+        if (!isHarnessProject(dir)) return;
+        // Only when armed or when daemon/supervisor state exists — avoid
+        // spinning on every non-harness project.
+        const armed = (()=>{ try{ return loadRunState(dir)?.armed===true; }catch{return false;}})();
+        const hasSup = (()=>{ try{ return !!loadSupervisorState(dir)?.worker || !!loadSupervisorState(dir)?.history?.length; }catch{return false;}})();
+        const hasDaemon = (()=>{ try{ const d=readJsonSafe<{heartbeatAt?:string}|null>(resolvePath(dir,"harness/daemon.json"), null); return !!d?.heartbeatAt; }catch{return false;}})();
+        if (!armed && !hasSup && !hasDaemon) return;
+        // Rebuild lines and invalidate live widget, then requestRender via tui if captured.
+        try {
+          const fresh = widgetStateFor(dir);
+          if (!fresh || !liveWidget) {
+            // No live widget yet — do a full refresh so factory captures tui.
+            refreshWidget(c);
+            return;
+          }
+          const nl = renderWidget(fresh, { width: 76, styler, glyphs });
+          (liveWidget as { render: () => string[] }).render = () => nl;
+          try { (liveWidget as { invalidate(): void }).invalidate(); } catch {}
+          // Also keep status line honest.
+          try { c.ui.setStatus(STATUS_KEY, renderStatusLine(fresh, glyphs)); } catch {}
+        } catch {}
+      } catch {}
+    }, 2000);
+    // Not keeping process alive for widget poll.
+    (widgetPoll as unknown as { unref?: () => void })?.unref?.();
+  };
+  const stopWidgetPoll = (): void => {
+    if (widgetPoll) { try { clearInterval(widgetPoll); } catch {} widgetPoll = null; }
+  };
   /** How many rows the plan currently has — the bound for scrolling. */
   const planRowCount = (dir: string): number => {
     try {
@@ -619,25 +731,27 @@ export default function (pi: ExtensionAPI): void {
       hooks: {
         onState: (st) => {
           supState = st;
-          if (sessionLive) refreshWidget(ctx);
+          if (sessionLive) refreshWidget(widgetCtx ?? ctx);
         },
         onActivity: (line) => {
           activity = [...activity, line].slice(-120);
           if (!sessionLive) return;
           // Only the things a human would want interrupted for. Tool-by-tool
           // narration belongs in the widget's log, not in notifications.
+          const live = widgetCtx ?? ctx;
           if (line.level === "error" || line.level === "warn" || line.level === "good") {
-            notify(ctx, `infinity-harness: ${line.text}`, line.level === "error" ? "error" : line.level === "warn" ? "warning" : "info");
+            try { notify(live, `infinity-harness: ${line.text}`, line.level === "error" ? "error" : line.level === "warn" ? "warning" : "info"); } catch {}
           }
-          refreshWidget(ctx);
+          try { refreshWidget(live); } catch {}
         },
         onApproval: (phase) => {
-          if (sessionLive) void askForApproval(ctx, dir, phase);
+          if (sessionLive) void askForApproval(widgetCtx ?? ctx, dir, phase);
         },
         onStop: (reason, detail) => {
           if (!sessionLive) return;
-          notify(ctx, `infinity-harness: run finished — ${detail}`, reason === "complete" ? "info" : "warning");
-          refreshWidget(ctx);
+          const live = widgetCtx ?? ctx;
+          try { notify(live, `infinity-harness: run finished — ${detail}`, reason === "complete" ? "info" : "warning"); } catch {}
+          try { refreshWidget(live); } catch {}
         },
       },
     });
@@ -930,6 +1044,7 @@ export default function (pi: ExtensionAPI): void {
     view = defaultView();
     refreshWidget(ctx);
     installTerminalShortcuts(ctx);
+    startWidgetPoll(ctx);
     const reason = (event as { reason?: string } | undefined)?.reason ?? "startup";
     const { config } = loadConfig(dir);
     lastBriefPhase = config.currentPhase;
@@ -1331,6 +1446,7 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.on("session_shutdown", async () => {
+    stopWidgetPoll();
     sessionLive = false;
     // A pi that closes must not leave a worker running against the project.
     await stopEngine("this pi session closed");
@@ -1912,7 +2028,14 @@ export default function (pi: ExtensionAPI): void {
             const { spawn: _sp } = await import("node:child_process");
             const { existsSync: _ex, openSync: _op, closeSync: _cl } = await import("node:fs");
             const { resolve: _re } = await import("node:path");
-            const cands = [_re(dir, "dist/daemon/index.js"), _re(dir, "src/daemon/index.ts")];
+            // B: daemon lives in the *installed package*, not in the target project.
+            // Prefer the package's own dist (works in published installs), then the
+            // target's dist/src (works in dev checkouts where the harness lives under extensions/).
+            let pkgDir: string | null = null;
+            try { pkgDir = _re(dirname(fileURLToPath(import.meta.url)), "../.."); } catch {}
+            const pkgDist = pkgDir ? _re(pkgDir, "dist/daemon/index.js") : null;
+            const pkgSrc  = pkgDir ? _re(pkgDir, "src/daemon/index.ts")  : null;
+            const cands = [pkgDist, _re(dir, "dist/daemon/index.js"), pkgSrc, _re(dir, "src/daemon/index.ts")].filter(Boolean) as string[];
             let entry: string | null = null;
             for (const c of cands) if (_ex(c)) { entry = c; break; }
             if (!entry) return { spawned: false };
@@ -2775,10 +2898,17 @@ export default function (pi: ExtensionAPI): void {
           const { existsSync, openSync, closeSync } = await import("node:fs");
           const { resolve: _resolve } = await import("node:path");
           // Daemon entry must exist; when not built (dev) fall back to supervisor.
+          // B: same as init path above — package dist first, then project
+          let _pkgDir: string | null = null;
+          try { _pkgDir = dirname(fileURLToPath(import.meta.url)); _pkgDir = _resolve(_pkgDir, "../.."); } catch {}
+          const _pkgDist = _pkgDir ? _resolve(_pkgDir, "dist/daemon/index.js") : null;
+          const _pkgSrc  = _pkgDir ? _resolve(_pkgDir, "src/daemon/index.ts")  : null;
           const candidates = [
+            _pkgDist,
             _resolve(dir, "dist/daemon/index.js"),
+            _pkgSrc,
             _resolve(dir, "src/daemon/index.ts"),
-          ];
+          ].filter(Boolean) as string[];
           let entry: string | null = null;
           for (const c of candidates) if (existsSync(c)) { entry = c; break; }
           if (!entry) return { spawned: false };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinity-harness",
-  "version": "2.8.6",
+  "version": "2.8.7",
   "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.",
   "type": "module",
   "keywords": [