infinity-harness 2.6.6 → 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;
@@ -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/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();
@@ -535,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) -----------------------------------------