infinity-harness 2.6.6 → 2.8.0

package/src/taskList.ts

@@ -33,8 +33,9 @@ import {
   validateKey,
   type FlatTask,
 } from "./core/featureList.ts";
-import { featureListPath } from "./core/paths.ts";
+import { featureListPath, planPath } from "./core/paths.ts";
 import { withLockSync } from "./core/lock.ts";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 
 /** One task as submitted by the agent. Only `key` is mandatory. */
 export type TaskInput = {
@@ -47,6 +48,8 @@ export type TaskInput = {
   difficulty?: string;
   modelHint?: string;
   criteria?: string[];
+  phase?: string;
+  serialize?: boolean;
 };
 
 /**
@@ -300,7 +303,20 @@ export function applyTaskList(current: FeatureList, input: ApplyInput): ApplyRes
 
     if (raw.difficulty !== undefined) task.difficulty = raw.difficulty as Task["difficulty"];
     if (raw.modelHint !== undefined) task.modelHint = raw.modelHint;
-    if (raw.criteria !== undefined) task.criteria = raw.criteria;
+    if (raw.phase !== undefined) {
+      const pa = String(raw.phase).trim().toLowerCase();
+      const VALID_PHASES = ["init","research","define","plan","build","verify","simplify","review","ship"];
+      if (!VALID_PHASES.includes(pa)) throw new ValidationError(`${path}.phase is invalid: ${String(raw.phase)}`);
+      (task as unknown as { phase: string }).phase = pa;
+    }
+    if (raw.serialize !== undefined) {
+      (task as unknown as { serialize: boolean }).serialize = Boolean(raw.serialize);
+    }
+    if (raw.criteria !== undefined) {
+      if (!Array.isArray(raw.criteria)) throw new ValidationError(`${path}.criteria must be an array`);
+      const criteria = validateCriteria(raw.criteria, `${path}.criteria`);
+      (task as unknown as { criteria: string[] }).criteria = criteria;
+    }
 
     staged.push({ featureId, task, compositeKey: key });
   }
@@ -479,7 +495,29 @@ function stripView(t: FlatTask): Task {
  * losing an edit.
  */
 export function writeTaskList(targetDir: string, input: ApplyInput): ApplyResult {
-  return withLockSync(featureListPath(targetDir), () => {
+  // Acquire a lock that covers both legacy and canonical to avoid racing with
+  // hand-edits that touch legacy. We lock canonical (which is plan.json), then
+  // sync any legacy hand-edit before reading.
+  return withLockSync(planPath(targetDir), () => {
+    // Back-compat: tests modify legacy via readFileSync+writeFileSync then call writeTaskList.
+    // Since loadFeatureList prefers canonical when both exist, a legacy-only hand-edit would be lost.
+    // Detect and mirror a legacy that differs from canonical.
+    const legacy = featureListPath(targetDir);
+    const canonical = planPath(targetDir);
+    if (existsSync(legacy) && existsSync(canonical)) {
+      try {
+        const rawLegacy = readFileSync(legacy, "utf-8");
+        const rawCanon = readFileSync(canonical, "utf-8");
+        if (rawLegacy !== rawCanon) {
+          try {
+            const p = JSON.parse(rawLegacy);
+            if (p && typeof p === "object" && Array.isArray(p.features) && typeof p.baseRevision === "number") {
+              writeFileSync(canonical, rawLegacy, "utf-8");
+            }
+          } catch {}
+        }
+      } catch {}
+    }
     const { list } = loadFeatureList(targetDir);
     const result = applyTaskList(list, input);
     if (result.changed) saveFeatureList(targetDir, result.list);

package/src/ui/dashboard.ts

@@ -68,8 +68,30 @@ export type DashboardState = {
    * reads, so a level turned off in one is off in the other.
    */
   display?: DisplayPolicy | null;
+  /** Where the work is happening. */
+  engine?: "background" | "main-session" | null;
+  /** The background pi sessions doing the work, and what each is on. */
+  workers?: DashWorker[] | null;
+  /** The tail of the background log. */
+  activity?: DashActivity[] | null;
 };
 
+export type DashWorker = {
+  name: string;
+  unitLabel: string;
+  level: string;
+  model: string;
+  servedModel?: string | null;
+  difficulty?: string | null;
+  state: string;
+  doing?: string | null;
+  turns?: number;
+  tokens?: { inputTokens: number; outputTokens: number } | null;
+  contextRatio?: number | null;
+};
+
+export type DashActivity = { at: string; level: string; worker: string | null; text: string };
+
 // ── escaping ────────────────────────────────────────────────────────────────
 
 const HTML_ESCAPES: Record<string, string> = {
@@ -799,6 +821,50 @@ body{
   color:var(--faint);font-weight:600;margin-bottom:6px;
 }
 
+
+/* -- background sessions --------------------------------------------------- */
+/*
+ * The run's work happens in other pi processes now, so this panel is the only
+ * place it is visible. It is deliberately the loudest thing under the meter:
+ * a live dot, the model each session is on, and a reverse-chronological log.
+ */
+.card.background h2{margin:0 0 4px;font-size:14px;letter-spacing:.01em}
+.bg-note{margin:0 0 12px;color:var(--muted);font-size:13px}
+.bg-workers{list-style:none;margin:0;padding:0;display:grid;gap:8px}
+.bg-worker{
+  display:grid;grid-template-columns:auto auto 1fr;gap:4px 10px;align-items:baseline;
+  padding:10px 12px;border:1px solid var(--border);border-radius:10px;background:var(--surface-2);
+}
+.bg-dot{
+  width:8px;height:8px;border-radius:50%;background:var(--muted);
+  align-self:center;grid-row:1;
+}
+.bg-worker.is-working .bg-dot,.bg-worker.is-starting .bg-dot{
+  background:var(--c-accent);box-shadow:0 0 0 3px var(--ring);animation:bgpulse 1.6s ease-in-out infinite;
+}
+.bg-worker.is-failed .bg-dot{background:var(--t-blocked,#C0392B)}
+@keyframes bgpulse{0%,100%{opacity:1}50%{opacity:.35}}
+@media (prefers-reduced-motion:reduce){.bg-worker .bg-dot{animation:none}}
+.bg-name{font-weight:650}
+.bg-model{
+  font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:12px;
+  color:var(--c-accent);overflow-wrap:anywhere;
+}
+.bg-meta{grid-column:2/-1;color:var(--muted);font-size:12.5px}
+.bg-doing{grid-column:2/-1;font-size:13px;overflow-wrap:anywhere}
+.bg-log{
+  list-style:none;margin:12px 0 0;padding:10px 0 0;border-top:1px solid var(--border);
+  max-height:260px;overflow:auto;display:grid;gap:2px;
+}
+.bg-line{display:grid;grid-template-columns:44px 34px 1fr;gap:8px;font-size:12.5px;align-items:baseline}
+.bg-time{color:var(--faint);font-variant-numeric:tabular-nums}
+.bg-who{color:var(--c-accent);font-weight:600}
+.bg-text{color:var(--muted);overflow-wrap:anywhere}
+.bg-line.lvl-work .bg-text{color:var(--text)}
+.bg-line.lvl-good .bg-text{color:var(--t-success,#177245)}
+.bg-line.lvl-warn .bg-text{color:var(--t-rework,#8E44AD)}
+.bg-line.lvl-error .bg-text{color:var(--t-blocked,#C0392B)}
+
 /* -- masthead ------------------------------------------------------------- */
 .masthead{
   position:sticky;top:0;z-index:20;
@@ -1210,6 +1276,66 @@ function formatTimestamp(iso: string): string {
   return d.toISOString().replace("T", " ").replace(/\.\d+Z$/, "Z");
 }
 
+/**
+ * The background sessions, and the log of what they have done.
+ *
+ * When the work moved out of the human's terminal this became the only place
+ * a run is visible at all — so it says, per session, which unit it owns, what
+ * model is answering for it, and the last thing it did. The model is on the
+ * card because "routed to the difficult tier" is a claim, and a claim you
+ * cannot see is one nobody believes.
+ */
+export function renderBackground(
+  engine: DashboardState["engine"],
+  workers: readonly DashWorker[],
+  activity: readonly DashActivity[],
+): string {
+  if (!engine && workers.length === 0 && activity.length === 0) return "";
+  const head =
+    engine === "main-session"
+      ? `<p class="bg-note">Work runs in the pi session you started the harness from.</p>`
+      : `<p class="bg-note">Work runs in separate background pi sessions, each on the model its difficulty tier names.</p>`;
+  const cards = workers.length
+    ? workers
+        .map((w) => {
+          const tokens = w.tokens ? w.tokens.inputTokens + w.tokens.outputTokens : 0;
+          const ctx = typeof w.contextRatio === "number" ? `${Math.round(w.contextRatio * 100)}% ctx` : "";
+          const bits = [
+            `${w.level} · ${w.unitLabel}`,
+            w.difficulty ? `${w.difficulty} tier` : "",
+            `${w.turns ?? 0} turn${(w.turns ?? 0) === 1 ? "" : "s"}`,
+            tokens ? `${tokens.toLocaleString("en-US")} tokens` : "",
+            ctx,
+          ].filter(Boolean);
+          return (
+            `<li class="bg-worker is-${esc(w.state)}">` +
+            `<span class="bg-dot" aria-hidden="true"></span>` +
+            `<span class="bg-name">${esc(w.name)}</span>` +
+            `<span class="bg-model">${esc(w.servedModel || w.model || "pi default")}</span>` +
+            `<span class="bg-meta">${esc(bits.join(" · "))}</span>` +
+            (w.doing ? `<span class="bg-doing">${esc(w.doing)}</span>` : "") +
+            `</li>`
+          );
+        })
+        .join("")
+    : `<li class="bg-worker is-idle"><span class="bg-dot" aria-hidden="true"></span><span class="bg-name">idle</span><span class="bg-meta">no background session running</span></li>`;
+  const log = activity.length
+    ? `<ol class="bg-log">` +
+      activity
+        .slice(-40)
+        .reverse()
+        .map(
+          (l) =>
+            `<li class="bg-line lvl-${esc(l.level)}"><span class="bg-time">${esc(l.at.slice(11, 16))}</span>` +
+            (l.worker ? `<span class="bg-who">${esc(l.worker)}</span>` : `<span class="bg-who"></span>`) +
+            `<span class="bg-text">${esc(l.text)}</span></li>`,
+        )
+        .join("") +
+      `</ol>`
+    : "";
+  return `<section class="card background"><h2>Background</h2>${head}<ul class="bg-workers">${cards}</ul>${log}</section>`;
+}
+
 export function renderDashboard(state: DashboardState): string {
   const list = normalizeForRender(state.list ?? { version: "0", baseRevision: 0, features: [] });
   const features = list.features ?? [];
@@ -1349,6 +1475,7 @@ ${
     : ""
 }
 ${display.progress ? renderProgress(counts, progress.tasksTotal, progress.featuresDone, progress.featuresTotal) : ""}
+${renderBackground(state.engine ?? null, state.workers ?? [], state.activity ?? [])}
 ${renderGate(gate)}
 ${goalTabsHtml}${phaseTabsHtml}
 ${body}

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. */
@@ -86,6 +92,27 @@ export type WidgetState = {
    * there too — configuring how you read a plan once, rather than twice.
    */
   display?: DisplayPolicy | null;
+  /**
+   * Where the work is actually happening.
+   *
+   * `background` means the run is being driven by separate pi sessions and
+   * this one is a control panel. It is the single most important thing the
+   * widget can say, because it is the difference between "my model is being
+   * spent on this" and "it is not".
+   */
+  engine?: "background" | "main-session" | null;
+  /**
+   * The background sessions doing the work right now.
+   *
+   * This is the answer to "what is happening?" when the answer is no longer
+   * visible in the transcript — which, once the work moved out of this
+   * session, is always.
+   */
+  workers?: WorkerLine[] | null;
+  /** The tail of the background log: what the workers have been doing. */
+  activity?: ActivityLine[] | null;
+  /** Rows of background log to draw. 0 hides the section. */
+  activityRows?: number;
   /**
    * What the human asked for, before a plan exists to hold a goal.
    *
@@ -96,6 +123,26 @@ export type WidgetState = {
   intake?: string | null;
 };
 
+/** One background pi session, as the widget draws it. */
+export type WorkerLine = {
+  name: string;
+  unit: string;
+  level: string;
+  model: string;
+  difficulty?: string | null;
+  state: "starting" | "working" | "idle" | "closed" | "failed";
+  doing?: string | null;
+  tokens?: number;
+  contextRatio?: number | null;
+};
+
+export type ActivityLine = {
+  at: string;
+  level: "info" | "work" | "warn" | "error" | "good";
+  worker: string | null;
+  text: string;
+};
+
 export type WidgetView = {
   /** First visible row, or null to follow the active task. */
   scroll: number | null;
@@ -378,6 +425,78 @@ export function rowWindow(
  * Returns plain strings so the host can hand them straight to
  * `ctx.ui.setWidget`. Colour is embedded as ANSI when the styler is colouring.
  */
+
+/** Rows of background log drawn by default. Enough to see the shape of a minute. */
+export const ACTIVITY_ROWS = 5;
+
+const ACTIVITY_ROLE: Record<ActivityLine["level"], Role> = {
+  info: "muted",
+  work: "text",
+  warn: "rework",
+  error: "blocked",
+  good: "success",
+};
+
+const WORKER_ROLE: Record<WorkerLine["state"], Role> = {
+  starting: "active",
+  working: "active",
+  idle: "muted",
+  closed: "muted",
+  failed: "blocked",
+};
+
+/** `HH:MM` in local time — a full ISO stamp is six columns of nothing. */
+function clock(iso: string): string {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return "--:--";
+  return String(d.getHours()).padStart(2, "0") + ":" + String(d.getMinutes()).padStart(2, "0");
+}
+
+/**
+ * The background sessions, one line each.
+ *
+ * The model is on the line on purpose. The whole point of routing work out of
+ * the human's session is that a different model does it, and a claim you
+ * cannot see is a claim nobody believes — least of all after the version
+ * where it silently did not happen.
+ */
+export function renderWorkers(workers: readonly WorkerLine[], inner: number, g: GlyphSet, s: Styler): string[] {
+  const out: string[] = [];
+  for (const w of workers) {
+    const role = WORKER_ROLE[w.state] ?? "muted";
+    const dot = s.fg(role, w.state === "working" || w.state === "starting" ? g.inProgress : g.pending);
+    const head =
+      dot +
+      " " +
+      s.bold(s.fg(role, w.name)) +
+      s.fg("rule", " · ") +
+      s.fg("text", w.unit) +
+      (w.difficulty ? s.fg("muted", " (" + w.difficulty + ")") : "");
+    const model = s.fg("accent", w.model || "pi default");
+    const ctx =
+      typeof w.contextRatio === "number" ? s.fg(w.contextRatio > 0.75 ? "rework" : "muted", " " + Math.round(w.contextRatio * 100) + "%") : "";
+    const right = model + ctx;
+    const gap = Math.max(1, inner - width(head) - width(right));
+    out.push(truncate(head + " ".repeat(gap) + right, inner));
+    if (w.doing) out.push(truncate("   " + s.fg("muted", g.arrow + " " + w.doing), inner));
+  }
+  return out;
+}
+
+/** The background log: the only place a human sees what the workers did. */
+export function renderActivity(lines: readonly ActivityLine[], rows: number, inner: number, s: Styler): string[] {
+  const tail = lines.slice(-Math.max(0, rows));
+  return tail.map((l) =>
+    truncate(
+      s.fg("rule", clock(l.at)) +
+        " " +
+        (l.worker ? s.fg("accent", l.worker) + " " : "") +
+        s.fg(ACTIVITY_ROLE[l.level] ?? "muted", l.text),
+      inner,
+    ),
+  );
+}
+
 export function renderWidget(state: WidgetState, options: WidgetOptions = {}): string[] {
   const total = options.width ?? DEFAULT_WIDTH;
   const s = options.styler ?? createStyler();
@@ -397,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"));
@@ -535,6 +703,27 @@ export function renderWidget(state: WidgetState, options: WidgetOptions = {}): s
     }
   }
 
+  // -- background sessions --------------------------------------------------
+  //
+  // Placed above the rail because, on a run driven by workers, this is the
+  // part of the widget that changes second by second. A human glancing at the
+  // terminal is checking that something is alive.
+  const workers = state.workers ?? [];
+  if (workers.length) {
+    push();
+    push(s.fg("rule", "background") + s.fg("rule", " " + g.rail.repeat(Math.max(1, inner - 12))));
+    for (const line of renderWorkers(workers, inner, g, s)) push(line);
+  } else if (state.engine === "background" && state.list.features.length > 0) {
+    push();
+    push(truncate(s.fg("muted", "background · no worker running — /infinity:run starts one"), inner));
+  }
+
+  const activityRows = state.activityRows ?? (state.activity?.length ? ACTIVITY_ROWS : 0);
+  if (activityRows > 0 && state.activity?.length) {
+    push();
+    for (const line of renderActivity(state.activity, view.expanded ? activityRows * 3 : activityRows, inner, s)) push(line);
+  }
+
   // -- phase rail -----------------------------------------------------------
   if (display.rail) {
     push();

package/src/ui/wizard.ts

@@ -109,14 +109,49 @@ async function pickThinkingLevel(prompt: Prompter, title: string): Promise<Think
   return picked as ThinkingLevel;
 }
 
-async function pickModelsStep(prompt: Prompter, modelsFn?: WizardOptions["models"]): Promise<{ router: NonNullable<IntakeAnswers["router"]> } | undefined> {
+/**
+ * What a difficulty tier actually buys, at the level the human just chose.
+ *
+ * Difficulty is scored per task, but the *model* changes only where the
+ * session changes — that is what makes it a model boundary at all. So at
+ * feature-level handoff a feature runs on its hardest task's model and the
+ * easy tasks inside it get the hard model too. Saying that here, in the
+ * question, is the difference between a setting that behaves surprisingly and
+ * one the human chose with their eyes open.
+ */
+export function tierScopeNote(handoff: string): string {
+  switch (handoff) {
+    case "off":
+    case "goal":
+      return "one session for the whole run, so the run takes the hardest tier in the plan";
+    case "phase":
+      return "one session per phase, so every task in a phase takes that phase's hardest tier";
+    case "sprint":
+      return "one session per sprint, so every task in a sprint takes that sprint's hardest tier";
+    case "feature":
+      return "one session per feature, so every task in a feature takes that feature's hardest tier";
+    case "subtask":
+      return "one session per subtask, so each subtask can take its own tier";
+    default:
+      return "one session per task, so each task takes its own tier";
+  }
+}
+
+async function pickModelsStep(
+  prompt: Prompter,
+  modelsFn?: WizardOptions["models"],
+  handoff: string = "task",
+): Promise<{ router: NonNullable<IntakeAnswers["router"]> } | undefined> {
   const models = modelsFn ? (await modelsFn()) ?? [] : [];
   // First ask whether routing is even wanted — most runs don't need it, and
   // skipping the 8 follow-up questions keeps the wizard short. Old tests that
   // don't know about this step get routing off by default so they keep passing.
   const ROUTE_ON = "yes — pick models per tier";
   const ROUTE_OFF = "no — use pi's current model for everything";
-  const enablePick = await prompt.select("Route work by difficulty to different models?", [ROUTE_ON, ROUTE_OFF]);
+  const enablePick = await prompt.select(
+    `Route work by difficulty to different models? (${tierScopeNote(handoff)})`,
+    [ROUTE_ON, ROUTE_OFF],
+  );
   if (enablePick === undefined) {
     // No answer scripted (e.g. an older test) → treat as "off" so the
     // wizard doesn't look cancelled to callers that only scripted four steps.
@@ -178,10 +213,11 @@ export async function runIntakeWizard(options: WizardOptions): Promise<WizardRes
     const handoffLabels = handoffOptions.map((o) => line(o.label, o.help));
     const handoffPick = await prompt.select(HANDOFF_QUESTION.title, handoffLabels);
     if (handoffPick === undefined) return { cancelled: true };
-    const handoff = (handoffOptions[handoffLabels.indexOf(handoffPick)]?.value ?? "phase") as
-      | "off"
-      | "phase"
-      | "task";
+    // Every level the question offers, not the three this cast used to allow:
+    // picking "every feature" and getting the task-level narrowing is how a
+    // setting silently becomes a different setting.
+    const handoff = (handoffOptions[handoffLabels.indexOf(handoffPick)]?.value ??
+      "phase") as import("../core/types.ts").HandoffGranularity;
 
     // -- 3b. research depth (only when research is in the pipeline) ----------
     let researchDepth: import("../intake.ts").ResearchDepth | undefined;
@@ -201,7 +237,7 @@ export async function runIntakeWizard(options: WizardOptions): Promise<WizardRes
     }
 
     // -- 4. models ----------------------------------------------------------
-    const modelsAnswer = await pickModelsStep(prompt, options.models);
+    const modelsAnswer = await pickModelsStep(prompt, options.models, handoff);
     if (modelsAnswer === undefined) return { cancelled: true };
 
     // -- 5. execution (parallelism) -----------------------------------------

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);
 }