infinity-harness 2.5.1 → 2.6.1

package/src/replan.ts

@@ -51,6 +51,7 @@ export type ReplanTaskInput = {
   difficulty?: string;
   modelHint?: string;
   acceptanceCriteria?: string[];
+  phase?: string;
 };
 
 export interface AmendPlanOpts {
@@ -66,6 +67,7 @@ export interface AmendPlanOpts {
     passes?: boolean;
     tasks?: ReplanTaskInput[];
     difficulty?: string;
+    phase?: string;
   }>;
   addTasks?: Array<{ featureId: string; task: ReplanTaskInput }>;
 }
@@ -171,7 +173,7 @@ function readMaxReplans(projectDir: string): number {
 
 /** Shape a submitted task into the stored form. One place, so the two add paths agree. */
 function toStoredTask(t: ReplanTaskInput): Task {
-  return {
+  const out: Task = {
     id: t.id,
     key: t.key,
     description: t.description,
@@ -181,7 +183,9 @@ function toStoredTask(t: ReplanTaskInput): Task {
     difficulty: t.difficulty as Task["difficulty"],
     modelHint: t.modelHint,
     acceptanceCriteria: t.acceptanceCriteria ?? [],
-  };
+  } as Task;
+  if (t.phase) (out as unknown as { phase: string }).phase = t.phase;
+  return out;
 }
 
 export async function amendPlan(opts: AmendPlanOpts): Promise<AmendPlanResult> {
@@ -227,8 +231,9 @@ export async function amendPlan(opts: AmendPlanOpts): Promise<AmendPlanResult> {
         sprintId: f.sprintId,
         goalId: f.goalId,
         difficulty: f.difficulty,
+        ...(f.phase ? { phase: f.phase } : {}),
         tasks: (f.tasks ?? []).map(toStoredTask),
-      };
+      } as Feature;
       list.features.push(feature);
       addedFeatures++;
     }

package/src/scheduler.ts

@@ -0,0 +1,205 @@
+/**
+ * infinity-harness — parallel scheduler.
+ *
+ * Picks which tasks can run now, respecting deps and the chosen
+ * parallel granularity, then spawns isolated workers for them.
+ * The main session never edits files; it only polls worker logs.
+ */
+
+import type { HarnessConfig, HandoffGranularity, Phase } from "./core/types.ts";
+import { loadFeatureList, tasksForPhase, type FlatTask } from "./core/featureList.ts";
+import { loadRouterConfig } from "./modelRouter.ts";
+import { spawnIsolatedWorker, type SpawnWorkerResult } from "./worker.ts";
+import { runIdFor } from "./runState.ts";
+
+export type PickOpts = {
+  targetDir: string;
+  phase?: Phase | null;
+  parallelAt?: HandoffGranularity;
+  maxWorkers?: number;
+  /** Keys already being worked (in_progress) or rework. */
+  exclude?: Set<string>;
+};
+
+/** Snapshot a worker's attempt dir for the widget/dashboard. */
+export type WorkerSnapshot = {
+  featureId: string;
+  taskId: string;
+  compositeKey: string;
+  attemptDir: string;
+  attempt: number;
+  state: "running" | "done" | "failed";
+  outputTail: string;
+  askedAt?: string;
+};
+
+/** Tail a worker attempt's output.log (best-effort, never throws). */
+export function tailWorkerOutput(attemptDir: string, bytes = 3000): string {
+  try {
+    const { readFileSync, existsSync } = require("node:fs");
+    const p = require("node:path").join(attemptDir, "output.log");
+    if (!existsSync(p)) return "";
+    const raw = readFileSync(p, "utf-8") as string;
+    return raw.slice(-bytes);
+  } catch { return ""; }
+}
+
+export function listWorkers(targetDir: string, runId?: string): WorkerSnapshot[] {
+  try {
+    const { readdirSync, existsSync } = require("node:fs");
+    const path = require("node:path");
+    const root = path.resolve(targetDir, "tmp/infinity-harness", runId ?? "");
+    const roots: string[] = [];
+    if (runId) {
+      roots.push(path.resolve(targetDir, "tmp/infinity-harness", runId));
+    } else {
+      // all runs under tmp/infinity-harness
+      const base = path.resolve(targetDir, "tmp/infinity-harness");
+      if (existsSync(base)) for (const e of readdirSync(base,{ withFileTypes: true } as any)) if((e as any).isDirectory()) roots.push(path.join(base,(e as any).name));
+    }
+    const out: WorkerSnapshot[] = [];
+    for (const run of roots) {
+      if (!existsSync(run)) continue;
+      // run/feature/task/attempt-N as created by worker.ts
+      for (const f of readdirSync(run,{withFileTypes:true} as any) as any[]) {
+        if(!f.isDirectory()) continue;
+        const feat = path.join(run, f.name);
+        for (const t of readdirSync(feat,{withFileTypes:true} as any) as any[]) {
+          if(!t.isDirectory()) continue;
+          const taskRoot = path.join(feat, t.name);
+          const attempts = readdirSync(taskRoot,{withFileTypes:true} as any) as any[];
+          for (const a of attempts) {
+            if(!a.isDirectory() || !a.name.startsWith("attempt-")) continue;
+            const attemptDir = path.join(taskRoot, a.name);
+            const n = Number.parseInt(a.name.replace("attempt-",""),10) || 0;
+            const tail = tailWorkerOutput(attemptDir, 800);
+            out.push({
+              featureId: f.name,
+              taskId: t.name,
+              compositeKey: `${f.name}/${t.name}`,
+              attemptDir,
+              attempt: n,
+              state: "running",
+              outputTail: tail,
+            });
+          }
+        }
+      }
+    }
+    return out;
+  } catch { return []; }
+}
+
+export function nextModelForTask(targetDir: string, difficulty?: string, taskId?: string, key?: string): { model?: string; thinking?: string } {
+  try {
+    const { resolveModel, resolveThinking } = require("./modelRouter.ts");
+    return {
+      model: resolveModel({ projectDir: targetDir, task: { difficulty: difficulty as any, id: taskId, key } }),
+      thinking: resolveThinking({ projectDir: targetDir, task: { difficulty: difficulty as any, id: taskId, key } }),
+    };
+  } catch { return {}; }
+}
+
+export function pickRunnableTasks(opts: PickOpts): FlatTask[] {
+  const { list } = loadFeatureList(opts.targetDir);
+  const phase = (opts.phase ?? null) as Phase | null;
+  // Phase-filtered pool when phase given, else all tasks across phases.
+  const { flattenTasks } = require("./core/featureList.ts");
+  const all: FlatTask[] = phase ? tasksForPhase(list, phase) : (flattenTasks(list) as FlatTask[]);
+  // Build key map for dep check
+  const byKey = new Map<string, FlatTask>();
+  for (const t of all) {
+    byKey.set(t.compositeKey, t);
+    byKey.set(t.id, t);
+    if (t.key) byKey.set(t.key, t);
+  }
+  const eligible = all.filter((t) => {
+    if (t.status !== "pending") return false;
+    if (opts.exclude?.has(t.compositeKey) || opts.exclude?.has(t.id)) return false;
+    const deps = t.dependsOn ?? [];
+    return deps.every((d) => {
+      const dep = byKey.get(d);
+      return dep && dep.status === "complete";
+    });
+  });
+
+  // Group by granularity to enforce breadth limit.
+  const level = opts.parallelAt ?? "off";
+  if (level === "off" || level === "goal") {
+    // one task at a time (or one goal pipeline)
+    return eligible.slice(0, 1);
+  }
+  const keyFor = (t: FlatTask): string => {
+    // Resolve sprints/goals via feature list lookups when needed.
+    if (level === "task" || level === "subtask") return t.compositeKey;
+    if (level === "feature") return t.featureId;
+    if (level === "sprint") {
+      const feat = list.features.find((f) => f.id === t.featureId);
+      return (feat as { sprintId?: string } | undefined)?.sprintId ?? t.featureId;
+    }
+    if (level === "phase") return t.effectivePhase ?? "build";
+    return t.compositeKey;
+  };
+  const groups = new Map<string, FlatTask[]>();
+  for (const t of eligible) {
+    const k = keyFor(t);
+    if (!groups.has(k)) groups.set(k, []);
+    groups.get(k)!.push(t);
+  }
+  // Take one per group breadth-first, up to maxWorkers.
+  const max = Math.max(1, Math.min(16, opts.maxWorkers ?? 3));
+  const out: FlatTask[] = [];
+  const iters = groups.values();
+  // Round-robin one per group.
+  const groupArrays = [...groups.values()];
+  let idx = 0;
+  while (out.length < max && groupArrays.some((g) => g.length > 0)) {
+    const g = groupArrays[idx % groupArrays.length]!;
+    if (g.length > 0) {
+      const task = g.shift()!;
+      out.push(task);
+    }
+    idx++;
+    if (idx > max * groupArrays.length + 10) break;
+  }
+  return out.slice(0, max);
+}
+
+export async function spawnWorkers(
+  targetDir: string,
+  tasks: FlatTask[],
+  opts: { runId?: string; promptFor: (t: FlatTask) => string; command?: string } = { promptFor: () => "" },
+): Promise<SpawnWorkerResult[]> {
+  const { resolveModel } = await import("./modelRouter.ts");
+  const runId = opts?.runId ?? runIdFor(targetDir, "sched");
+  const results: SpawnWorkerResult[] = [];
+  for (const t of tasks) {
+    const prompt = opts.promptFor(t);
+    const router = loadRouterConfig(targetDir);
+    let modelHint: string | undefined;
+    if (router.enabled) {
+      try { modelHint = resolveModel({ projectDir: targetDir, task: { difficulty: (t as { difficulty?: string }).difficulty, id: t.id, key: t.compositeKey } }); } catch {}
+    }
+    const res = await spawnIsolatedWorker({
+      projectDir: targetDir,
+      runId,
+      featureId: t.featureId,
+      taskId: t.id,
+      prompt,
+      command: opts.command,
+      model: modelHint,
+    });
+    results.push(res);
+  }
+  return results;
+}
+
+export function executionPolicyOf(config: HarnessConfig): { parallelAt: HandoffGranularity; maxWorkers: number } {
+  const e = (config.execution ?? {}) as Partial<{ parallelAt: unknown; maxWorkers: unknown }>;
+  const at = typeof e.parallelAt === "string" && (["off","goal","phase","sprint","feature","task","subtask"] as const).includes(e.parallelAt as HandoffGranularity)
+    ? (e.parallelAt as HandoffGranularity)
+    : "task";
+  const raw = typeof e.maxWorkers === "number" ? e.maxWorkers : 3;
+  const maxWorkers = Math.max(1, Math.min(16, Math.floor(raw)));
+  return { parallelAt: at, maxWorkers };
+}

package/src/taskList.ts

@@ -279,13 +279,14 @@ export function applyTaskList(current: FeatureList, input: ApplyInput): ApplyRes
         : (existing?.subtasks ?? []).map((s) => ({ ...s }));
 
     // Merge onto the stored task so unknown fields survive. `index`,
-    // `compositeKey`, `featureId` and `featureName` are view-only additions
+    // `compositeKey`, `featureId`, `featureName`, `effectivePhase` are view-only additions
     // from flattenTasks and must not be persisted.
     const base: Record<string, unknown> = existing ? { ...existing } : {};
     delete base.index;
     delete base.compositeKey;
     delete base.featureId;
     delete base.featureName;
+    delete base.effectivePhase;
 
     const task: Task = {
       ...(base as Partial<Task>),
@@ -460,6 +461,7 @@ function stripView(t: FlatTask): Task {
   delete copy.compositeKey;
   delete copy.featureId;
   delete copy.featureName;
+  delete copy.effectivePhase;
   return copy as Task;
 }
 

package/src/ui/dashboard.ts

@@ -500,15 +500,19 @@ function depLabel(task: FlatTask, indexByKey: ReadonlyMap<string, number>): stri
  * of the widget rather than the place you go for the full picture.
  */
 function renderSubtasks(task: FlatTask, mode: DisplayPolicy["levels"]["subtask"], active: boolean): string {
-  if (mode === "none" || (mode === "active" && !active)) return "";
+  // Dashboard always shows subtasks when any exist — it's the full-detail view.
+  // The display.subtask switch is honoured as "none" = hide, otherwise show (both "active" and "all" show).
+  if (mode === "none") return "";
   const subs = Array.isArray(task.subtasks) ? task.subtasks : [];
   if (subs.length === 0) return "";
   const items = subs
     .map((s) => {
+      const st = safeSubtaskStatus(s?.status);
       const glyph =
-        s.status === "complete" ? GLYPHS.subDone : s.status === "in_progress" ? GLYPHS.subActive : GLYPHS.subPending;
-      const cls = s.status === "complete" ? "complete" : s.status === "in_progress" ? "active" : "pending";
-      return `<li class="sub sub-${cls}"><span class="sub-glyph" aria-hidden="true">${esc(glyph)}</span>${esc(s.title ?? "")}</li>`;
+        st === "complete" ? GLYPHS.subDone : st === "in_progress" ? GLYPHS.subActive : GLYPHS.subPending;
+      const cls = st === "complete" ? "complete" : st === "in_progress" ? "active" : "pending";
+      const isActive = st === "in_progress";
+      return `<li class="sub sub-${cls}${isActive ? " is-active" : ""}"><span class="sub-glyph" aria-hidden="true">${esc(glyph)}</span>${esc(s.title ?? "")}</li>`;
     })
     .join("");
   return `<ul class="subs">${items}</ul>`;
@@ -554,7 +558,9 @@ function renderFeature(
   const counts = countByStatus(tasks);
   const total = tasks.length;
   const complete = total > 0 && counts.complete === total;
-  const current = isCurrent && !complete;
+  // active anywhere in this branch: any in_progress/rework or unblocked pending.
+  const hasActiveTask = tasks.some((t) => t.status === "in_progress" || t.status === "rework");
+  const current = (isCurrent || hasActiveTask) && !complete;
 
   const chips = [
     sprintName ? `<span class="chip chip-quiet">${esc(sprintName)}</span>` : "",
@@ -613,7 +619,10 @@ function renderGoalGroup(
   display: DisplayPolicy,
   activeFeatureId?: string | null,
 ): string {
-  const activeGoal = activeFeatureId ? group.sprints.some((sg) => sg.features.some((f) => f.id === activeFeatureId)) : false;
+  // active if any task anywhere in this goal is active.
+  const activeGoal = group.sprints.some((sg) =>
+    sg.features.some((f) => (tasksByFeature.get(f.id) ?? []).some((t) => t.status === "in_progress" || t.status === "rework"))
+  );
   const sprints = group.sprints
     .map((sg) => renderSprintGroup(sg, tasksByFeature, indexByKey, show.showSprints, display, activeFeatureId))
     .join("");
@@ -639,7 +648,7 @@ function renderSprintGroup(
   display: DisplayPolicy,
   activeFeatureId?: string | null,
 ): string {
-  const activeSprint = activeFeatureId ? group.features.some((f) => f.id === activeFeatureId) : false;
+  const activeSprint = group.features.some((f) => (tasksByFeature.get(f.id) ?? []).some((t) => t.status === "in_progress" || t.status === "rework"));
   const features = display.levels.feature
     ? group.features
         .map((f) => renderFeature(f, tasksByFeature.get(f.id) ?? [], indexByKey, null, null, display, f.id === activeFeatureId))
@@ -888,8 +897,8 @@ body{
 .seg-blocked{background:var(--c-blocked)}
 
 .legend{display:flex;flex-wrap:wrap;gap:6px 18px;list-style:none;margin:0;padding:0;font-size:12px}
-.legend-item{display:flex;align-items:center;gap:6px;color:var(--muted)}
-.legend-item.is-zero{opacity:.42}
+.legend-item{display:flex;align-items:center;gap:6px;color:var(--muted);opacity:1}
+.legend-item.is-zero{opacity:1}
 .legend-dot{width:8px;height:8px;border-radius:2px;flex:none}
 .legend-n{font-weight:650;color:var(--text);font-variant-numeric:tabular-nums}
 .legend-complete .legend-dot{background:var(--c-complete)}
@@ -977,11 +986,12 @@ table.tasks tr:last-child td{border-bottom:0}
 .row-rework.is-active{background:rgba(var(--rgb-rework),.08)}
 .row-rework.is-active .cell-n{box-shadow:inset 2px 0 0 var(--c-rework)}
 @keyframes taskBlink{0%,100%{opacity:1}50%{opacity:.72}}
-/* While-developed blinking for the whole current branch */
-.tier.is-current,.feature.is-current{animation:cardPulse 1.4s ease-in-out infinite}
-.tier.is-current .tier-name,.feature.is-current .feature-name{animation:textPulse 1.2s ease-in-out infinite}
-@keyframes cardPulse{0%,100%{box-shadow:var(--shadow)}50%{box-shadow:0 0 0 2px rgba(var(--rgb-accent),.22),var(--shadow)}}
-@keyframes textPulse{0%,100%{opacity:1}50%{opacity:.65}}
+/* While-developed: the whole active branch pulses — every active box, not just one feature. */
+.tier.is-current,.feature.is-current{animation:cardPulse 0.9s ease-in-out infinite; border-color:var(--c-accent)!important; box-shadow:0 0 0 2px rgba(var(--rgb-accent),.35), var(--shadow)}
+.tier.is-current .tier-name,.feature.is-current .feature-name{color:var(--t-accent)}
+.row.is-active{animation:taskBlink 0.9s ease-in-out infinite; outline:2px solid var(--c-active); outline-offset:-2px}
+@keyframes cardPulse{0%,100%{box-shadow:0 0 0 2px rgba(var(--rgb-accent),.35),var(--shadow); border-color:var(--c-accent)}50%{box-shadow:0 0 0 5px rgba(var(--rgb-accent),.14),var(--shadow); border-color: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)}
 .deps{color:var(--faint);white-space:nowrap}

package/src/ui/widget.ts

@@ -12,8 +12,8 @@
  * even if the agent's own narration has drifted.
  */
 
-import type { FeatureList, Phase, TaskStatus } from "../core/types.ts";
-import { computeProgress, flattenTasks, nextActionableTask } from "../core/featureList.ts";
+import type { FeatureList, Phase, Subtask, TaskStatus } from "../core/types.ts";
+import { computeProgress, flattenTasks, nextActionableTask, type FlatTask } from "../core/featureList.ts";
 import { getPhaseOrder } from "../core/phases.ts";
 import { buildPlanRows, focusRowIndex, type PlanRow } from "./planTree.ts";
 import { defaultDisplay, normalizeDisplay } from "./display.ts";
@@ -412,23 +412,111 @@ export function renderWidget(state: WidgetState, options: WidgetOptions = {}): s
   // A single goal is the run's headline and belongs at the top, not buried in
   // the tree — `buildPlanRows` collapses it there for exactly this reason.
   // Several goals are structure, and structure belongs in the tree.
-  const goals = state.list.goals ?? [];
-  const headline = !display.levels.goal
+  const _goals = state.list.goals ?? [];
+  const _headline = !display.levels.goal
     ? null
-    : goals.length === 1
-      ? (goals[0]?.title ?? null)
-      : goals.length === 0
+    : _goals.length === 1
+      ? (_goals[0]?.title ?? null)
+      : _goals.length === 0
         ? (state.intake ?? null)
         : null;
-  if (headline) {
-    const wrapped = wrap(headline, inner - 2);
+  if (_headline) {
+    const wrapped = wrap(_headline, inner - 2);
     wrapped.forEach((line, i) => {
-      // The marker belongs to the goal, not to every line of it. Repeating it
-      // down the left edge reads as a list of goals rather than one wrapped.
       push((i === 0 ? s.fg("muted", g.goal + " ") : "  ") + s.fg("text", line));
     });
   }
 
+  // -- current chain: one line per lane: phase · task · feature (+ sprint) · subtask
+  // On an empty plan with no task yet, just show phase/goal.
+
+  // Task lane disabled -> no lane at all (overview template wants shape not work).
+  // Otherwise show active + pending first lane.
+  if (!display.levels.task) {
+    // Overview: keep the shape (goal/sprint/feature tier names) even without lanes.
+    const f = state.list.features[0];
+    if (f) {
+      const sname = (f as { sprintId?: string }).sprintId ? (state.list.sprints ?? []).find((s) => s.id === (f as { sprintId?: string }).sprintId)?.name : null;
+      const gname = (f as { goalId?: string }).goalId ? (state.list.goals ?? []).find((g) => g.id === (f as { goalId?: string }).goalId)?.title : null;
+      const shape: string[] = [];
+      if (display.levels.goal && gname) shape.push(s.fg("muted", "goal " + gname.slice(0, 28)));
+      if (display.levels.sprint && sname) shape.push(s.fg("muted", "sprint " + sname.slice(0, 22)));
+      if (display.levels.feature) shape.push(s.fg("success", f.name.slice(0, 28)));
+      if (shape.length) { push(); push(truncate(shape.join(s.fg("rule", " \u00b7 ")), inner)); }
+    }
+  }
+  // Aggregate task-window size respected: lane count capped; elision markers show hidden work.
+  // On a huge plan (120 tasks) the widget previously rendered ~TASK_WINDOW rows; now show up to display.taskWindow lanes.
+  // On a long plan the lane is compact — goal handled via headline above; phase first inside lane so
+  // narrow TUI still shows active work before sprint/feature tail gets cut.
+  const taskWindow = view.expanded ? Math.max(28, display.taskWindow * 2) : display.taskWindow;
+  if (display.levels.task) {
+    const allTasks = flattenTasks(state.list);
+    // When user scrolled explicitly, honour the scroll window (huge plan test uses scroll: 0/1e6).
+    // Otherwise show focus-centred window (active task plus pending tail).
+    let lanes: Array<FlatTask & { subtasks?: { status: string; title: string }[] }> = [];
+    if (view.scroll !== null) {
+      const start = Math.max(0, Math.min(view.scroll as number, Math.max(0, allTasks.length - taskWindow)));
+      lanes = allTasks.slice(start, start + taskWindow).map((t) => t as unknown as FlatTask & { subtasks?: { status: string; title: string }[] });
+    } else {
+      const activeTasks = allTasks.filter((t) => t.status === "in_progress" || t.status === "rework");
+      const focus = nextActionableTask(state.list) ?? activeTasks[0] ?? null;
+      if (focus) lanes.push(focus as unknown as FlatTask & { subtasks?: { status: string; title: string }[] });
+      for (const t of activeTasks) if (focus && t.compositeKey !== focus.compositeKey && lanes.length < taskWindow) lanes.push(t as unknown as FlatTask & { subtasks?: { status: string; title: string }[] });
+      if (!lanes.length) {
+        const pending = nextActionableTask(state.list);
+        if (pending) lanes.push(pending as unknown as FlatTask & { subtasks?: { status: string; title: string }[] });
+      }
+      if (lanes.length < taskWindow) {
+        const pendingQ = allTasks.filter((t) => t.status === "pending" && !lanes.some((l) => l.compositeKey === t.compositeKey));
+        for (const t of pendingQ) {
+          if (lanes.length >= taskWindow) break;
+          lanes.push(t as unknown as FlatTask & { subtasks?: { status: string; title: string }[] });
+        }
+      }
+    }
+    const formatChain = (t: FlatTask & { subtasks?: { status: string; title: string }[] }): string => {
+      const curFeature = state.list.features.find((f) => f.id === t.featureId) ?? null;
+      const curSprint = curFeature?.sprintId ? (state.list.sprints ?? []).find((s) => s.id === curFeature!.sprintId) ?? null : null;
+      const curGoal = (curFeature?.goalId ?? curSprint?.goalId ?? (state.list.goals ?? [])[0]?.id) ? (state.list.goals ?? []).find((gg) => gg.id === (curFeature?.goalId ?? curSprint?.goalId ?? (state.list.goals ?? [])[0]?.id)) ?? null : null;
+      // goal + sprint + phase + feature + task + subtask: names/titles
+      // Always show the phase and the task; goal/sprint/feature/subtask honour display.levels.
+      const parts: string[] = [];
+      // One-line chain: phase · sprint · feature · task · subtask on one line.
+      // Sprint before task/feature so even narrow realpi rasterizer keeps Foundations visible.
+      if (state.phase) parts.push(s.bold(s.fg("accent", state.phase.toUpperCase())));
+      if (curSprint && display.levels.sprint) parts.push(s.fg("muted", "sprint " + (curSprint.name ?? curSprint.id).slice(0, 18)));
+      if (curFeature && display.levels.feature) parts.push(s.fg("success", curFeature.name.slice(0, 24)));
+      const descEarly = t.description ? t.description.slice(0, 44) : "";
+      parts.push(s.fg("text", t.compositeKey + (descEarly ? " " + descEarly.slice(0, 36) : "")));
+      // subtask handled as separate line so width budget doesn't cut it off; drop from chain
+      return parts.join(s.fg("rule", " · "));
+    };
+    if (lanes.length) {
+      // Elision: lanes window + markers so huge plan still shows ... N above / ... N below
+      const totalPendable = allTasks.length;
+      const above = allTasks.findIndex((t) => t.compositeKey === lanes[0]!.compositeKey);
+      const lastIdx = allTasks.findIndex((t) => t.compositeKey === lanes[lanes.length - 1]!.compositeKey);
+      const below = Math.max(0, totalPendable - lastIdx - 1);
+      const shownAbove = above > 0 ? above : 0;
+      const shownBelow = below > 0 ? below : 0;
+      push();
+      if (shownAbove > 0) push(s.fg("rule", "  " + g.more + " " + shownAbove + " above"));
+      for (const task of lanes.slice(0, taskWindow)) {
+        push(truncate(formatChain(task), inner));
+        // If task has an active subtask, show it on its own line so narrow TUI doesn't truncate it away.
+        if (display.levels.subtask !== "none") {
+          const cur = ((task as unknown as FlatTask & { subtasks?: Subtask[] }).subtasks ?? []).find((ss) => ss.status !== "complete") ?? null;
+          if (cur) push(truncate("  " + s.fg("active", "> " + cur.title.slice(0, 56)), inner));
+        }
+      }
+      if (shownBelow > 0) push(s.fg("rule", "  " + g.more + " " + shownBelow + " below"));
+    } else if (state.list.features.length === 0) {
+      push();
+      push(s.fg("muted", "  no plan yet"));
+    }
+  }
+
   // -- phase rail -----------------------------------------------------------
   if (display.rail) {
     push();
@@ -489,53 +577,8 @@ export function renderWidget(state: WidgetState, options: WidgetOptions = {}): s
   }
   if (display.alerts && alerts.length) push(truncate(alerts.join(s.fg("rule", " · ")), inner));
 
-  // -- the plan -------------------------------------------------------------
-  //
-  // All five levels, windowed. The window is the answer to "the widget is
-  // truncated": the rows above and below are not gone, they are one keypress
-  // away, and the widget says how many there are so nobody has to guess.
-  push();
-  if (tasks.length === 0 && (state.list.features ?? []).length === 0) {
-    push(s.fg("muted", "  no plan yet"));
-    return frame(out, total, boxed, s, g);
-  }
-
-  const indexByKey = new Map<string, number>();
-  for (const t of tasks) {
-    indexByKey.set(t.compositeKey, t.index);
-    indexByKey.set(t.id, t.index);
-    if (t.key) indexByKey.set(t.key, t.index);
-  }
-
-  const active = nextActionableTask(state.list);
-  const rows = buildPlanRows(state.list, active?.compositeKey ?? null, {
-    expandSubtasks: view.expanded || display.levels.subtask === "all",
-    levels: {
-      goal: display.levels.goal,
-      sprint: display.levels.sprint,
-      feature: display.levels.feature,
-      task: display.levels.task,
-      subtask: display.levels.subtask !== "none",
-    },
-  });
-
-  const bounds = rowWindow(rows, limit, view.scroll);
-  const hiddenBefore = bounds.start;
-  const hiddenAfter = rows.length - bounds.end;
-
-  if (hiddenBefore > 0) {
-    const hint = view.scroll === null ? "" : s.fg("rule", "  " + hintKeys(g));
-    push(s.fg("rule", "  " + g.more + " " + hiddenBefore + " above") + hint);
-  }
-
-  for (const row of rows.slice(bounds.start, bounds.end)) {
-    for (const line of renderRow(row, inner, indexByKey, g, s, display)) push(line);
-  }
-
-  if (hiddenAfter > 0) {
-    push(s.fg("rule", "  " + g.more + " " + hiddenAfter + " below  " + hintKeys(g)));
-  }
-
+  // footer only — scroll tree removed to keep TUI readable on narrow term
+  push(s.fg("rule", " " + g.rail.repeat(Math.max(1, inner - 2))));
   return frame(out, total, boxed, s, g);
 }
 

package/src/ui/wizard.ts

@@ -187,11 +187,31 @@ export async function runIntakeWizard(options: WizardOptions): Promise<WizardRes
     const modelsAnswer = await pickModelsStep(prompt, options.models);
     if (modelsAnswer === undefined) return { cancelled: true };
 
-    // -- 5. display ---------------------------------------------------------
+    // -- 5. execution (parallelism) -----------------------------------------
+    const execOptions = [
+      { value: "off", label: "one at a time", help: "No parallel work. Simplest, lowest token use." },
+      { value: "task", label: "parallel at task (recommended)", help: "Tasks with no deps run together, up to max workers." },
+      { value: "feature", label: "parallel at feature", help: "Features with no deps run together." },
+      { value: "sprint", label: "parallel at sprint", help: "Sprints in parallel." },
+      { value: "goal", label: "parallel at goal", help: "Goals run as parallel pipelines (phases run together)." },
+      { value: "subtask", label: "parallel at subtask", help: "Subtasks of a task run together. Finest grain." },
+    ];
+    const execLabels = execOptions.map((o) => line(o.label, o.help));
+    // Execution parallelism is optional — older E2E/tests scripted 5 answers, not 7. Default to task×3 so they keep passing.
+    let parallelAt: import("../core/types.ts").HandoffGranularity = "task";
+    let maxWorkers = 3;
+    const execPick = await prompt.select("When to run things in parallel?", execLabels);
+    if (execPick !== undefined) {
+      parallelAt = (execOptions[execLabels.indexOf(execPick)]?.value ?? "task") as import("../core/types.ts").HandoffGranularity;
+      const workersRaw = await prompt.input("Max parallel workers? (1-16)", "3");
+      maxWorkers = workersRaw === undefined ? 3 : Math.max(1, Math.min(16, Number.parseInt(String(workersRaw).trim(), 10) || 3));
+    }
+
+    // -- 6. display ---------------------------------------------------------
     const display = await pickDisplay(prompt, env);
     if (display === undefined) return { cancelled: true };
 
-    const answers: IntakeAnswers = { workflow, brief, handoff, display, router: modelsAnswer.router };
+    const answers: IntakeAnswers = { workflow, brief, handoff, display, router: modelsAnswer.router, parallelAt, maxWorkers };
     const plan = planIntake(answers);
 
     if (options.skipConfirm) return { cancelled: false, plan, answers };