infinity-harness 2.8.5 → 2.8.7

package/CHANGELOG.md

@@ -4,6 +4,26 @@ 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.
+
+### Fixed
+
+- **Main session started harness work without a widget after declining the final wizard prompt.** The post-wizard "parked" note was sent as `sendUserMessage(..., { deliverAs: "followUp" })`, which intentionally wakes the agent on the main-session model. Changed to `sendMessage(..., { triggerTurn: false })` (visible `infinity:brief` with `parked: true` but no turn) and hardened the control-panel system prompt to explicitly say "PARKED — do NOT start building/researching/validating; only answer questions; only `/infinity:run` starts the harness; background uses default/tiered models, not the main session model" when not armed. Session now simply does nothing until `/infinity:run`.
+
 ## [2.8.5] — 2026-08-31
 
 Richer top widget, one panel.

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 };
@@ -1933,22 +2056,23 @@ export default function (pi: ExtensionAPI): void {
         if (!dr.spawned) await startEngine(ctx, dir);
         notify(ctx, "infinity-harness: run armed — background run started. /infinity:halt stops it.", "info");
       } else {
+        // The harness is parked — do NOT trigger an agent turn. The
+        // control-panel contract (before_agent_start) already stops
+        // autonomous work, but a `followUp` brief starts one anyway.
+        // `triggerTurn: false` keeps it visible without waking the model.
         const brief = await briefText(dir);
-        if (!plan.brief) {
-          pi.sendUserMessage(
-            `The human has not said what they want built yet. Ask them, in one short question, and do not start any work or invent a scope until they answer. The harness is NOT running — "/infinity:run" starts it.\n\n${brief}`,
-            { deliverAs: "followUp" },
-          );
-        } else if (plan.phases[0] === "research") {
-          pi.sendUserMessage(
-            `${brief}\n\nThis is RESEARCH — survey constraints and options first, then validate (infinity_validate) to advance. The harness is NOT running yet. Run "/infinity:run" when you are ready, or answer "yes — start the run now" next time you init.`,
-            { deliverAs: "followUp" },
-          );
-        } else {
-          pi.sendUserMessage(
-            `${brief}\n\nThe harness is ready but NOT running. Run "/infinity:run" to start, or answer "yes — start the run now" in the wizard next time.`,
-            { deliverAs: "followUp" },
+        const parkedNote = !plan.brief
+          ? `The human has not said what they want built yet. Ask them, in one short question, and do not start any work or invent a scope until they answer. The harness is NOT running — "/infinity:run" starts it.\n\n${brief}`
+          : plan.phases[0] === "research"
+            ? `${brief}\n\nThis is RESEARCH — survey constraints and options first, then validate (infinity_validate) to advance. The harness is NOT running yet. Run "/infinity:run" when you are ready, or answer "yes — start the run now" next time you init.`
+            : `${brief}\n\nThe harness is ready but NOT running. Run "/infinity:run" to start, or answer "yes — start the run now" in the wizard next time.`;
+        try {
+          pi.sendMessage(
+            { customType: "infinity:brief", content: parkedNote, display: true, details: { parked: true, phase: plan.phases[0] ?? null } },
+            { triggerTurn: false },
           );
+        } catch (e) {
+          notify(ctx, `infinity-harness: ${errMsg(e as Error)}`, "warning");
         }
       }
     },
@@ -2774,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 };
@@ -3394,19 +3525,47 @@ function controlPanelContract(dir: string): string | null {
   if (!ok || !config.currentPhase) return null;
   const { list } = loadFeatureList(dir);
   const p = computeProgress(list);
+  let armed = false;
+  try {
+    const r = readJsonSafe<{ armed?: boolean } | null>(runStatePathSync(dir), null);
+    armed = r?.armed === true;
+  } catch {}
+  // When parked, the harness does NO work anywhere — not in this session and
+  // not in background sessions. When armed, background sessions do the work
+  // and this session is idle by design (it never spends the human's model).
+  const workLine = armed
+    ? "The work is being done by separate background pi sessions on their own models, not by you."
+    : "The harness is NOT running — nothing is happening in background. Only `/infinity:run` starts it.";
+  const rule1 = armed
+    ? "1. Do not implement plan tasks, advance phases, or edit `harness/` by hand. Answer the"
+    : "1. Do NOT start building, researching, or validating. The harness is parked. If the human";
+  const rule1b = armed
+    ? "   human's questions about the run, and use `/infinity:workers` and `infinity_status`"
+    : "   asks you to do harness work anyway, tell them it is parked and needs `/infinity:run`,";
+  const rule1c = armed
+    ? "   to see what the background sessions are doing."
+    : "   then stop. Do not touch `harness/` files.";
+  const rule2 = armed
+    ? "2. If the human asks you to build something, say that the harness is driving it and offer"
+    : "2. While parked, you may ONLY answer questions about the project — its stack, commands,";
+  const rule2b = armed
+    ? "   `/infinity:run`, `/infinity:halt`, or `/infinity:replan` instead."
+    : "   files, and how the harness would run. Do not write code, docs, plans, or validation.";
+  const rule3 = "3. The plan of record is `harness/features/feature-list.json`; your memory of it is not.";
+  const extra = armed ? [] : ["", "Parked means parked. No tool calls that mutate the project while parked."];
   return [
-    "## infinity-harness — you are the control panel",
+    "## infinity-harness — you are the control panel" + (armed ? "" : " (PARKED)"),
     "",
     `This project runs an infinity-harness pipeline at **${config.currentPhase.toUpperCase()}**, ` +
-      `${p.tasksDone}/${p.tasksTotal} tasks done. The work is being done by separate background ` +
-      `pi sessions on their own models, not by you.`,
+      `${p.tasksDone}/${p.tasksTotal} tasks done. ` + workLine,
     "",
-    "1. Do not implement plan tasks, advance phases, or edit `harness/` by hand. Answer the",
-    "   human's questions about the run, and use `/infinity:workers` and `infinity_status`",
-    "   to see what the background sessions are doing.",
-    "2. If the human asks you to build something, say that the harness is driving it and offer",
-    "   `/infinity:run`, `/infinity:halt`, or `/infinity:replan` instead.",
-    "3. The plan of record is `harness/features/feature-list.json`; your memory of it is not.",
+    rule1,
+    rule1b,
+    rule1c,
+    rule2,
+    rule2b,
+    rule3,
+    ...extra,
   ].join("\n");
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinity-harness",
-  "version": "2.8.5",
+  "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": [