infinity-harness 2.7.0 → 2.8.1

package/src/ui/viewState.ts

@@ -0,0 +1,77 @@
+/**
+ * infinity-harness — ui/viewState.ts
+ *
+ * View states — "not running" is a state, not an absence.
+ * Every Interface reads daemon.json BEFORE rendering, and derives a view state.
+ * Heartbeat 20s, stale after 90s — v2.7 shipped values, kept deliberately.
+ * Only the single place these numbers are defined.
+ */
+
+import { readJsonSafe } from "../core/fsx.ts";
+import { daemonPath, runStatePath, supervisorPath } from "../core/paths.ts";
+
+export const HEARTBEAT_MS = 20_000;
+export const OWNER_STALE_MS = 90_000;
+
+export type ViewState =
+  | "running"
+  | "stale"
+  | "not-running"
+  | "never-armed"
+  | "awaiting-approval"
+  | "stopped";
+
+export type ViewSnapshot = {
+  state: ViewState;
+  daemon: { pid?: number; heartbeatAt?: string; runId?: string } | null;
+  run: { armed?: boolean; stopReason?: string | null; runId?: string } | null;
+  supervisor: { state?: string; updatedAt?: string } | null;
+  reason?: string;
+};
+
+export function deriveViewState(targetDir: string): ViewSnapshot {
+  const run = readJsonSafe<Record<string, unknown> | null>(runStatePath(targetDir), null);
+  const daemon = readJsonSafe<Record<string, unknown> | null>(daemonPath(targetDir), null);
+  const supervisor = readJsonSafe<Record<string, unknown> | null>(supervisorPath(targetDir), null);
+
+  if (!run || !run.runId) {
+    return { state: "never-armed", daemon: daemon as ViewSnapshot["daemon"], run: run as ViewSnapshot["run"], supervisor: supervisor as ViewSnapshot["supervisor"], reason: "No run has been armed. Run the wizard." };
+  }
+  if (run && (run as { armed?: boolean }).armed === false) {
+    const stopReason = typeof (run as { stopReason?: unknown }).stopReason === "string" ? (run as { stopReason?: string }).stopReason : null;
+    return { state: "stopped", daemon: daemon as ViewSnapshot["daemon"], run: run as ViewSnapshot["run"], supervisor: supervisor as ViewSnapshot["supervisor"], reason: stopReason ?? "Run stopped." };
+  }
+  // Armed but no daemon file
+  if (!daemon) {
+    return { state: "not-running", daemon: null, run: run as ViewSnapshot["run"], supervisor: supervisor as ViewSnapshot["supervisor"], reason: "Daemon not running — /infinity:run to start." };
+  }
+  const heartbeatAt = typeof (daemon as { heartbeatAt?: unknown }).heartbeatAt === "string" ? (daemon as { heartbeatAt: string }).heartbeatAt : null;
+  const ageMs = heartbeatAt ? Date.now() - new Date(heartbeatAt).getTime() : Infinity;
+  if (Number.isFinite(ageMs) && ageMs > OWNER_STALE_MS) {
+    // Check pid liveness as tiebreaker: stale heartbeat but pid still alive => stale, else not-running.
+    const pid = typeof (daemon as { pid?: unknown }).pid === "number" ? (daemon as { pid: number }).pid : undefined;
+    let pidAlive = false;
+    if (typeof pid === "number") { try { process.kill(pid, 0); pidAlive = true; } catch { pidAlive = false; } }
+    if (pidAlive) {
+      return { state: "stale", daemon: daemon as ViewSnapshot["daemon"], run: run as ViewSnapshot["run"], supervisor: supervisor as ViewSnapshot["supervisor"], reason: `Daemon unresponsive since ${heartbeatAt ?? "?"}` };
+    }
+    return { state: "not-running", daemon: null, run: run as ViewSnapshot["run"], supervisor: supervisor as ViewSnapshot["supervisor"], reason: "Daemon process is gone." };
+  }
+  // Check awaiting-approval (supervisor state)
+  const supState = typeof (supervisor as { state?: unknown } | null)?.state === "string" ? String((supervisor as { state: string }).state) : null;
+  if (supState === "awaiting-approval") {
+    return { state: "awaiting-approval", daemon: daemon as ViewSnapshot["daemon"], run: run as ViewSnapshot["run"], supervisor: supervisor as ViewSnapshot["supervisor"] };
+  }
+  return { state: "running", daemon: daemon as ViewSnapshot["daemon"], run: run as ViewSnapshot["run"], supervisor: supervisor as ViewSnapshot["supervisor"] };
+}
+
+export function viewStateLabel(s: ViewState): string {
+  switch (s) {
+    case "running": return "running";
+    case "stale": return "stale";
+    case "not-running": return "not running";
+    case "never-armed": return "never armed";
+    case "awaiting-approval": return "awaiting approval";
+    case "stopped": return "stopped";
+  }
+}

package/src/ui/widget.ts

@@ -46,6 +46,12 @@ export type WidgetState = {
   enabledPhases?: readonly string[] | null;
   paused?: boolean;
   gate?: { overall: boolean; failures: string[] } | null;
+  viewState?: import("./viewState.ts").ViewSnapshot | null;
+  pilot?: string | null;
+  phaseModes?: Record<string, string> | null;
+  tierSpend?: Record<string, { input: number; output: number; cost: number; calls: number }> | null;
+  reworkDepth?: number | null;
+  replanDiff?: string | null;
   /** Dashboard URL to show near the top, clickable. Meaningful host:port, not just numbers. */
   dashboardUrl?: string | null;
   /** Model routing note: e.g. "Model per task — subtasks share parent". Shown once. */
@@ -510,6 +516,55 @@ export function renderWidget(state: WidgetState, options: WidgetOptions = {}): s
 
   const progress = computeProgress(state.list);
   const tasks = flattenTasks(state.list);
+  const viewSnap = (state as WidgetState & { viewState?: import("./viewState.ts").ViewSnapshot | null }).viewState ?? null;
+
+  // -- viewState banner -----------------------------------------------------
+  // Reads daemon.json first. Widget never renders dead run as live.
+  if (viewSnap && viewSnap.state !== "running" && viewSnap.state !== "awaiting-approval") {
+    const hb = (viewSnap.daemon as { heartbeatAt?: string } | null)?.heartbeatAt ?? null;
+    const ts = hb ? s.fg("muted", ` (as of ${String(hb).slice(11, 16)})`) : "";
+    const msg =
+      viewSnap.state === "stale"
+        ? s.fg("rework", `\u26A0 Daemon unresponsive since ${hb ? String(hb).slice(11, 16) : "?"}`) + ts
+        : viewSnap.state === "not-running"
+          ? s.fg("blocked", "Daemon not running \u2014 /infinity:run to start.") + ts
+          : viewSnap.state === "never-armed"
+            ? s.fg("muted", viewSnap.reason ?? "Never armed \u2014 run the wizard.")
+            : viewSnap.state === "stopped"
+              ? s.fg("blocked", `STOPPED: ${viewSnap.reason ?? (viewSnap.run as { stopReason?: string } | null)?.stopReason ?? "stopped"}`) + ts
+              : s.fg("muted", viewSnap.reason ?? "");
+    push(truncate(msg, inner));
+  }
+  if (viewSnap && viewSnap.state === "awaiting-approval") {
+    const phase2 = ((viewSnap.supervisor as { phase?: string } | null)?.phase ?? state.phase ?? "?");
+    push(truncate(s.fg("active", `\u23F8 Awaiting approval: ${String(phase2).toUpperCase()} \u2192 /infinity:approve`) + s.fg("muted", " (run is healthy, not stuck)"), inner));
+  }
+
+  // -- pilot badge + per-tier spend + rework queue ---------------------------
+  if ((state as WidgetState).pilot) {
+    const pilot = (state as WidgetState).pilot as string;
+    const tag = s.bold(s.fg(pilot === "full" ? "rework" : pilot === "autopilot" ? "success" : "accent", pilot.toUpperCase()));
+    const pModes = (state as WidgetState).phaseModes ?? null;
+    const modesStr = pModes ? Object.entries(pModes).map(([ph, m]) => s.fg(m === "autopilot" ? "success" : "active", `${ph}:${m}`)).join(s.fg("rule", " \u00b7 ")) : "";
+    push(truncate(s.fg("muted", "Pilot ") + tag + (modesStr ? s.fg("rule", "  ") + modesStr : ""), inner));
+  }
+  {
+    const ts2 = (state as WidgetState).tierSpend ?? null;
+    if (ts2) {
+      const parts: string[] = [];
+      for (const tier of ["A", "B", "C", "D", "X"] as const) {
+        const t = (ts2 as Record<string,{input:number;output:number;cost:number;calls:number}>)[tier];
+        if (!t) continue;
+        const label = `${tier}:${t.input + t.output}`;
+        parts.push(tier === "X" && (t.cost > 0 || t.input + t.output > 0) ? s.bold(s.fg("blocked", label)) : s.fg("muted", label));
+      }
+      if (parts.length) push(truncate(s.fg("muted", "Spend ") + parts.join(s.fg("rule", " \u00b7 ")), inner));
+    }
+  }
+  if (typeof (state as WidgetState).reworkDepth === "number" && ((state as WidgetState).reworkDepth as number) > 0) {
+    push(truncate(s.fg("rework", `\u21BB Rework queue: ${(state as WidgetState).reworkDepth} item(s) holding gate open`), inner));
+  }
+  if ((state as WidgetState).replanDiff) push(truncate(s.fg("muted", "Replan: ") + s.fg("text", String((state as WidgetState).replanDiff).slice(0, 80)), inner));
 
   // -- header ---------------------------------------------------------------
   const brand = s.bold(s.fg("brand", "∞ INFINITY"));

package/src/worker.ts

@@ -11,7 +11,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from "node:fs";
 import { resolve, join, dirname } from "node:path";
 import { spawn, execSync } from "node:child_process";
-import { stripBom } from "./core/fsx.ts";
+import { loadFeatureList, resolvePlanFile } from "./core/featureList.ts";
+import { planPath } from "./core/paths.ts";
 
 // ── constants ───────────────────────────────────────────────────────────────
 export const WORKER_ROOT_SEGMENT = "tmp/infinity-harness";
@@ -53,10 +54,8 @@ function gitHeadSync(projectDir: string): string | undefined {
 
 function readBaseRevision(projectDir: string): number {
   try {
-    const p = resolve(projectDir, "harness", "features", "feature-list.json");
-    if (!existsSync(p)) return 0;
-    const raw = JSON.parse(stripBom(readFileSync(p, "utf-8")));
-    return typeof raw.baseRevision === "number" ? raw.baseRevision : 0;
+    const { list } = loadFeatureList(projectDir);
+    return typeof list.baseRevision === "number" ? list.baseRevision : 0;
   } catch {
     return 0;
   }
@@ -75,8 +74,8 @@ export function buildFingerprint(opts: {
   const baseRevision = opts.baseRevision ?? readBaseRevision(projectDir);
   let featureListHash: number | undefined;
   try {
-    const p = resolve(projectDir, "harness", "features", "feature-list.json");
-    if (existsSync(p)) featureListHash = hashLite(readFileSync(p, "utf-8"));
+    const { path: planFile } = resolvePlanFile(projectDir);
+    if (existsSync(planFile)) featureListHash = hashLite(readFileSync(planFile, "utf-8"));
   } catch {}
   return {
     runId: opts.runId,
@@ -178,7 +177,12 @@ async function withLock<T>(targetPath: string, fn: () => Promise<T> | T): Promis
 }
 
 export async function withFeatureListLock<T>(projectDir: string, fn: () => Promise<T> | T): Promise<T> {
-  const p = resolve(projectDir, "harness", "features", "feature-list.json");
+  const p = planPath(projectDir);
+  try {
+    const d = dirname(p);
+    mkdirSync(d, { recursive: true });
+    if (!existsSync(p)) writeFileSync(p, "", "utf-8");
+  } catch {}
   return withLock(p, fn);
 }