infinity-harness 2.6.5 → 2.7.0

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;
@@ -991,10 +1057,14 @@ table.tasks tr:last-child td{border-bottom:0}
 /* While-developed: the whole active branch pulses — every active box, not just one feature. */
 .dash-url{margin:8px 0 0;font-size:13px} .dash-url a{color:var(--t-accent);text-decoration:none;border-bottom:1px dashed rgba(var(--rgb-accent),.45)} .dash-url a:hover{border-bottom-style:solid}
 .handoff-note{margin:4px 0 0;color:var(--muted);font-size:12px}
-.tier.is-current,.feature.is-current{animation:cardPulse 1.2s ease-in-out infinite; border-color:var(--c-accent)!important; box-shadow:0 0 0 3px rgba(var(--rgb-accent),.45), 0 0 12px rgba(var(--rgb-accent),.25), var(--shadow)}
-.tier.is-current .tier-name,.feature.is-current .feature-name{color:var(--t-accent);font-weight:650}
-.row.is-active{animation:taskBlink 0.9s ease-in-out infinite; outline:2px solid var(--c-active); outline-offset:-2px; box-shadow:0 0 8px rgba(var(--rgb-active),.35)}
-@keyframes cardPulse{0%,100%{box-shadow:0 0 0 3px rgba(var(--rgb-accent),.45),0 0 12px rgba(var(--rgb-accent),.25),var(--shadow); border-color:var(--c-accent)}50%{box-shadow:0 0 0 7px rgba(var(--rgb-accent),.22),0 0 16px rgba(var(--rgb-accent),.32),var(--shadow); border-color:rgba(var(--rgb-accent),.70)}}
+/* Active branching: make it scream, not whisper. Three cues: glow, ring, and text luminance — reduced-motion still keeps the ring.
+   Pulse is strong at the crest, not near-reduced-motion. */
+.tier.is-current,.feature.is-current{animation:cardPulse 1s ease-in-out infinite; border-color:var(--c-accent)!important; box-shadow:0 0 0 4px rgba(var(--rgb-accent),.60), 0 0 16px rgba(var(--rgb-accent),.45), var(--shadow)}
+.tier.is-current .tier-name,.feature.is-current .feature-name{color:var(--t-accent);font-weight:800; animation:textPulse 1s ease-in-out infinite}
+.row.is-active{animation:taskBlink 0.85s ease-in-out infinite; outline:2.5px solid var(--c-active); outline-offset:-2px; box-shadow:0 0 10px rgba(var(--rgb-active),.45)}
+.step.is-current .dot{box-shadow:0 0 0 5px rgba(var(--rgb-accent),.50), 0 0 14px rgba(var(--rgb-accent),.40); animation:phasePulse 1s ease-in-out infinite}
+@keyframes cardPulse{0%,100%{box-shadow:0 0 0 4px rgba(var(--rgb-accent),.60),0 0 16px rgba(var(--rgb-accent),.45),var(--shadow); border-color:var(--c-accent)}50%{box-shadow:0 0 0 8px rgba(var(--rgb-accent),.15),0 0 20px rgba(var(--rgb-accent),.55),var(--shadow); border-color:rgba(var(--rgb-accent),.40)}}
+@keyframes phasePulse{0%,100%{box-shadow:0 0 0 5px rgba(var(--rgb-accent),.50),0 0 14px rgba(var(--rgb-accent),.40)}50%{box-shadow:0 0 0 9px rgba(var(--rgb-accent),.10),0 0 18px rgba(var(--rgb-accent),.55)}}
 @keyframes textPulse{0%,100%{opacity:1}50%{opacity:.78}}
 .row-blocked{background:rgba(var(--rgb-blocked),.07)}
 .row-blocked .cell-n{box-shadow:inset 2px 0 0 var(--c-blocked)}
@@ -1120,6 +1190,43 @@ const SCRIPT = `
     return o;
   }
 
+  // Tabs: remember selection in localStorage; Goal hidden when only one goal; filter by phase/goal.
+  function tabBind() {
+    try {
+      var GK='ih-goal', PK='ih-phase';
+      function read(k){ try{ return localStorage.getItem(k); }catch(e){ return null; } }
+      function write(k,v){ try{ localStorage.setItem(k,v); }catch(e){} }
+      var selGoal = read(GK);
+      var selPhase = read(PK);
+      var goalEls = document.querySelectorAll('[data-goal]');
+      var phaseEls = document.querySelectorAll('[data-phase]');
+      // Seed from is-current when no stored choice.
+      if(!selGoal){ var cur=document.querySelector('[data-goal].is-current'); if(cur) selGoal=cur.getAttribute('data-goal'); }
+      if(!selPhase){ var curP=document.querySelector('[data-phase].is-current'); if(curP) selPhase=curP.getAttribute('data-phase'); }
+      function apply(){
+        var gTabs=document.querySelectorAll('.dash-tabs [data-goal]');
+        var pTabs=document.querySelectorAll('.dash-tabs [data-phase]');
+        gTabs.forEach(function(el){ el.classList.toggle('is-current', el.getAttribute('data-goal')===selGoal); });
+        pTabs.forEach(function(el){ el.classList.toggle('is-current', el.getAttribute('data-phase')===selPhase); });
+        // If user picked a goal that doesn't exist anymore, fall back to first.
+        var tiers=document.querySelectorAll('.tier.tier-goal');
+        if(tiers.length===0) tiers=document.querySelectorAll('.tier:not(.tier-goal)');
+        // Hide tiers that don't match selected goal (when goal tabs visible, else show all).
+        if(goalEls.length>0 && selGoal){
+          document.querySelectorAll('.tier.tier-goal').forEach(function(t){ var id=(t.querySelector('[data-goal]')||t).getAttribute('data-goal'); var match = !id || id===selGoal; t.classList.toggle('tier-hidden', !match); });
+        }
+        // Phase filter: hide features/tasks not in selected phase. Server could filter but client keeps auto-refresh.
+        if(selPhase){
+          document.querySelectorAll('.feature').forEach(function(f){ var ph=f.getAttribute('data-phase')||''; if(ph && ph!==selPhase) f.classList.add('tier-hidden'); else f.classList.remove('tier-hidden'); });
+        }
+        // If only one goal, goal strip already hidden server-side — no tier-hidden by goal.
+      }
+      goalEls.forEach(function(el){ el.addEventListener('click', function(){ selGoal=el.getAttribute('data-goal'); write(GK, selGoal); apply(); }); });
+      phaseEls.forEach(function(el){ el.addEventListener('click', function(){ selPhase=el.getAttribute('data-phase'); write(PK, selPhase); apply(); }); });
+      apply();
+    } catch(e){}
+  }
+  tabBind();
   function refresh() {
     // A hidden tab is not being read; skip the work but keep the loop alive.
     if (document.hidden) { schedule(BASE); return; }
@@ -1169,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 ?? [];
@@ -1217,7 +1384,33 @@ export function renderDashboard(state: DashboardState): string {
   // Which feature/sprint/goal is currently being worked (for blinking).
   const activeTask = tasks.find((t) => t.status === "in_progress" || t.status === "rework") ?? tasks.find((t) => t.status === "pending") ?? null;
   const activeFeatureId = activeTask?.featureId ?? null;
-  const body = features.length
+  // — tabs: Goal(s) top row, Phase(s) second row. Default = active task's goal/phase, else current phase.
+  // On a project that has exactly one goal, the goal tab strip hides (requirement §3). The phase tab strip
+  // always shows so RESEARCH progress is isolated from BUILD progress — same plan-list, filtered view.
+  const activeGoalId = (() => {
+    if (!activeTask) return goals[0]?.id ?? null;
+    const f = features.find((ff) => ff.id === activeTask.featureId) ?? null;
+    const s = f?.sprintId ? sprints.find((ss) => ss.id === f!.sprintId) ?? null : null;
+    return (f?.goalId ?? s?.goalId ?? goals[0]?.id ?? null) as string | null;
+  })();
+  const currentPhase = state.phase ?? null;
+  const showGoalTabs = display.levels.goal && goals.length > 1;
+  const phaseTabs = getPhaseOrder(state.enabledPhases);
+  const goalTabsHtml = showGoalTabs
+    ? `<nav class="dash-tabs" aria-label="Goals">` +
+      goals.map((g) => {
+        const cur = g.id === activeGoalId ? ' is-current' : '';
+        return `<button type="button" class="dash-tab${cur}" data-goal="${esc(g.id)}">${esc(g.title ?? g.id)}</button>`;
+      }).join("") + `</nav>`
+    : "";
+  const phaseTabsHtml = `<nav class="dash-tabs" aria-label="Phases">` +
+    phaseTabs.map((p) => {
+      const cur = p === currentPhase ? ' is-current' : '';
+      return `<button type="button" class="dash-tab${cur}" data-phase="${esc(p)}">${esc(p.toUpperCase())}</button>`;
+    }).join("") + `</nav>`;
+  const tabStyle = `<style>.dash-tabs{display:flex;flex-wrap:wrap;gap:6px;margin:10px 0 6px}.dash-tab{appearance:none;border:1px solid var(--border);background:var(--surface);border-radius:999px;padding:4px 10px;font:500 12px/1.2 inherit;color:var(--muted);cursor:pointer}.dash-tab.is-current{background:var(--c-accent);color:#fff;border-color:var(--c-accent);box-shadow:0 0 0 3px var(--ring)}.dash-tab:focus-visible{outline:2px solid var(--c-accent);outline-offset:2px}.tier-hidden{display:none!important}</style>`;
+  // Tag every feature row with its effective phase so tabs can filter client-side without a round-trip.
+  const origBody = features.length
     ? groups
         .map((group) =>
           renderGoalGroup(
@@ -1234,6 +1427,16 @@ export function renderDashboard(state: DashboardState): string {
         )
         .join("")
     : renderEmptyPlan(state.phase);
+  const body = (() => {
+    if (!origBody) return origBody;
+    // Inject data-phase on each feature card using featurePhase list.
+    let idx = 0;
+    return origBody.replace(/<section class="card feature/g, () => {
+      const f = features[idx++] ?? null;
+      const ph = (f as { phase?: string } | null)?.phase ?? (flattenTasks(list).find((t) => t.featureId === f?.id)?.effectivePhase as string | undefined) ?? "build";
+      return `<section data-phase="${esc(ph)}" class="card feature`;
+    });
+  })();
 
   const titleBits: string[] = [];
   if (paused) titleBits.push("PAUSED");
@@ -1253,7 +1456,7 @@ export function renderDashboard(state: DashboardState): string {
 <!-- Empty data URI: suppresses the /favicon.ico request the harness server would 404. -->
 <link rel="icon" href="data:,">
 <title>${esc(title)}</title>
-<style>${STYLES}</style>
+<style>${STYLES}</style>${tabStyle}
 </head>
 <body>
 <div id="app">
@@ -1272,7 +1475,9 @@ ${
     : ""
 }
 ${display.progress ? renderProgress(counts, progress.tasksTotal, progress.featuresDone, progress.featuresTotal) : ""}
+${renderBackground(state.engine ?? null, state.workers ?? [], state.activity ?? [])}
 ${renderGate(gate)}
+${goalTabsHtml}${phaseTabsHtml}
 ${body}
 <footer class="foot">
   <span>state as of <span class="mono">${esc(formatTimestamp(state.timestamp))}</span></span>

package/src/ui/widget.ts

@@ -86,6 +86,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 +117,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 +419,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();
@@ -410,13 +523,16 @@ export function renderWidget(state: WidgetState, options: WidgetOptions = {}): s
   const headRight = phaseTag + revTag;
   const gapW = inner - width(headLeft) - width(headRight);
   push(headLeft + (gapW > 1 ? s.fg("rule", " " + g.rail.repeat(gapW - 2) + " ") : " ") + headRight);
-  // Dashboard URL near top, clickable (OSC 8) with meaningful host:port, not just numbers.
-  if (state.dashboardUrl) {
-    const url = state.dashboardUrl;
-    const label = s.fg("accent", url);
-    // OSC 8 hyperlink: terminals that support it make it clickable; others show the URL.
-    const link = `\u001b]8;;${url}\u0007${label}\u001b]8;;\u0007`;
-    push(truncate(s.fg("muted", "Dashboard: ") + link, inner));
+  // Dashboard URL: always visible (user never has to type /infinity:dashboard to discover it).
+  {
+    const url = state.dashboardUrl as string | null | undefined;
+    if (url) {
+      const label = s.fg("accent", url);
+      const link = `\u001b]8;;${url}\u0007${label}\u001b]8;;\u0007`;
+      push(truncate(s.fg("muted", "Dashboard: ") + link, inner));
+    } else {
+      push(truncate(s.fg("muted", "Dashboard: ") + s.fg("muted", "/infinity:dashboard → http://127.0.0.1:PORT"), inner));
+    }
   }
   if (state.handoffModelNote) {
     push(truncate(s.fg("muted", state.handoffModelNote), inner));
@@ -532,6 +648,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) -----------------------------------------