infinity-harness 2.5.1 → 2.6.0

package/src/core/phases.ts

@@ -11,6 +11,8 @@ import type { HarnessConfig, Phase } from "./types.ts";
 import { PHASE_ORDER, DEFAULT_ENABLED_PHASES } from "./types.ts";
 import { loadConfig, saveConfig, recordGate, currentRoleFor } from "./config.ts";
 import { gitBranch, gitIsClean, gitHasUpstream, gitLastCommitMessage } from "./exec.ts";
+import { loadFeatureList, saveFeatureList, tasksForPhase } from "./featureList.ts";
+import type { RetryLevel } from "./types.ts";
 
 export { PHASE_ORDER };
 
@@ -125,6 +127,64 @@ export async function transitionPhase(targetDir: string, toPhase: Phase): Promis
   return { ok: true, error: null, config, from, to: toPhase };
 }
 
+/** Starter tasks seeded when a phase has no tasks at all (idempotent, fixes DEFINE rev 0).
+ *
+ * Only phases that are *gated on doc artefacts* get starters. BUILD/VERIFY etc
+ * already have tasks from PLAN; seeding them would pollute BUILD's tasksComplete.
+ */
+export const STARTER_TASKS: Record<string, Array<{ id: string; description: string; difficulty: "easy" | "moderate" | "difficult" }>> = {
+  // Research has its doc gate but no task gate; a doc checklist, not tasks — no seed.
+  define: [
+    { id: "define/d1", description: "Interview scope and write bounded PRD + acceptance criteria", difficulty: "moderate" },
+    { id: "define/d2", description: "Record sprint contract and branch (not main)", difficulty: "easy" },
+  ],
+  plan: [
+    { id: "plan/p1", description: "Break each feature into ordered, dependency-aware tasks", difficulty: "moderate" },
+    { id: "plan/p2", description: "Commit plan (feature-list) and validate", difficulty: "easy" },
+  ],
+};
+
+export function isPhaseDone(dir: string, phase: import("./types.ts").Phase): boolean {
+  const { list } = loadFeatureList(dir);
+  const tasks = tasksForPhase(list, phase);
+  return tasks.length > 0 && tasks.every((t) => t.status === "complete");
+}
+
+export function seedPhaseIfEmpty(dir: string, phase: import("./types.ts").Phase): { seeded: boolean; error: string | null } {
+  const seeded = STARTER_TASKS[phase] ?? [];
+  if (seeded.length === 0) return { seeded: false, error: null };
+  try {
+    const { list } = loadFeatureList(dir);
+    const existing = tasksForPhase(list, phase);
+    if (existing.length > 0) return { seeded: false, error: null };
+    // Append to first feature matching phase, or create a phase feature.
+    const feature = (
+      list.features.find((f) => (f as { phase?: string }).phase === phase) ??
+      list.features[0] ??
+      ({ id: `phase-${phase}`, name: phase.toUpperCase(), tasks: [] } as unknown as typeof list.features[number])
+    );
+    if (!list.features.includes(feature as any)) {
+      (feature as { phase?: string }).phase = phase;
+      list.features.push(feature as any);
+    }
+    for (const t of seeded) {
+      if (feature.tasks.some((x) => x.id === t.id)) continue;
+      feature.tasks.push({
+        id: t.id,
+        description: t.description,
+        status: "pending" as const,
+        phase,
+        difficulty: t.difficulty,
+      } as any);
+    }
+    list.baseRevision = (list.baseRevision ?? 0) + 1;
+    saveFeatureList(dir, list);
+    return { seeded: true, error: null };
+  } catch (e) {
+    return { seeded: false, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+
 /** Advance one step along the enabled pipeline. */
 export async function advancePhase(targetDir: string): Promise<TransitionResult> {
   const { config, ok, error } = loadConfig(targetDir);

package/src/core/settings.ts

@@ -372,6 +372,27 @@ export const SETTINGS: SettingsGroup[] = [
       },
     ],
   },
+  {
+    id: "execution",
+    label: "Execution",
+    help: "How many things run at once, and at which level. Main session only shows progress; workers do the real work.",
+    settings: [
+      {
+        path: "execution.parallelAt",
+        file: "config",
+        label: "Parallel at",
+        help: "off: one at a time · goal: goals in parallel · phase: phases · sprint/feature/task/subtask. Pick one. Finer implies coarser.",
+        type: { kind: "choice", choices: ["off", "goal", "phase", "sprint", "feature", "task", "subtask"] },
+      },
+      {
+        path: "execution.maxWorkers",
+        file: "config",
+        label: "Max workers",
+        help: "How many workers run at once (1-16)._deps must be satisfied; parallelAt limits breadth.",
+        type: { kind: "number", min: 1, max: 16 },
+      },
+    ],
+  },
   {
     id: "commands",
     label: "Project commands",
@@ -473,41 +494,125 @@ export const SETTINGS: SettingsGroup[] = [
   {
     id: "retries",
     label: "Retry budgets",
-    help: "How many attempts a task, feature or phase gets before the run escalates to you.",
+    help: "How many attempts a task, feature or phase gets before the run escalates to you. Levels are the generic ladder: goal → phase → sprint → feature → task → subtask.",
     settings: [
       {
         path: "maxRetries",
         file: "config",
+        label: "Task retries (legacy)",
+        help: "Legacy top-level task budget. Prefer retry.levels.task.maxRetries below.",
+        type: { kind: "number", min: 1, max: 100 },
+      },
+      {
+        path: "retry.levels.goal.enabled",
+        file: "config",
+        label: "Goal retries",
+        help: "Bound whole goal-pass retries (outer loop). Off by default.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "retry.levels.goal.maxRetries",
+        file: "config",
+        label: "Goal max",
+        help: "Attempts per goal when enabled.",
+        type: { kind: "number", min: 1, max: 100 },
+      },
+      {
+        path: "retry.levels.phase.enabled",
+        file: "config",
+        label: "Phase retries",
+        help: "Bound how many times one phase may repeat. Off by default.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "retry.levels.phase.maxRetries",
+        file: "config",
+        label: "Phase max",
+        help: "Attempts per phase when enabled.",
+        type: { kind: "number", min: 1, max: 100 },
+      },
+      {
+        path: "retry.levels.sprint.enabled",
+        file: "config",
+        label: "Sprint retries",
+        help: "Sprint-level retries. Off by default, as sprints are build-exclusive.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "retry.levels.sprint.maxRetries",
+        file: "config",
+        label: "Sprint max",
+        help: "Attempts per sprint when enabled.",
+        type: { kind: "number", min: 1, max: 100 },
+      },
+      {
+        path: "retry.levels.feature.enabled",
+        file: "config",
+        label: "Feature retries",
+        help: "Bound retries per feature. Off by default.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "retry.levels.feature.maxRetries",
+        file: "config",
+        label: "Feature max",
+        help: "Attempts per feature when enabled.",
+        type: { kind: "number", min: 1, max: 100 },
+      },
+      {
+        path: "retry.levels.task.enabled",
+        file: "config",
         label: "Task retries",
-        help: "Attempts per task before the harness stops and asks for help.",
+        help: "The main retry budget, on by default. Subtask goes here too.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "retry.levels.task.maxRetries",
+        file: "config",
+        label: "Task max",
+        help: "Attempts per task. Leave unset to use maxRetries (legacy).",
+        type: { kind: "number", min: 1, max: 100 },
+      },
+      {
+        path: "retry.levels.subtask.enabled",
+        file: "config",
+        label: "Subtask retries",
+        help: "Whether subtasks get their own retry count before escalating to task.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "retry.levels.subtask.maxRetries",
+        file: "config",
+        label: "Subtask max",
+        help: "Attempts per subtask when enabled.",
         type: { kind: "number", min: 1, max: 100 },
       },
       {
         path: "retry.features.enabled",
         file: "config",
-        label: "Feature retry budget",
-        help: "Also bound retries per feature, not just per task.",
+        label: "(legacy) Feature retry",
+        help: "Legacy per-feature switch. Mirrors retry.levels.feature.enabled.",
         type: { kind: "boolean" },
       },
       {
         path: "retry.features.maxRetries",
         file: "config",
-        label: "Feature retries",
-        help: "Attempts per feature when the budget above is enabled.",
+        label: "(legacy) Feature max",
+        help: "Legacy feature budget value.",
         type: { kind: "number", min: 1, max: 100 },
       },
       {
         path: "retry.phases.enabled",
         file: "config",
-        label: "Phase retry budget",
-        help: "Also bound how many times one phase may repeat.",
+        label: "(legacy) Phase retry",
+        help: "Legacy per-phase switch. Mirrors retry.levels.phase.enabled.",
         type: { kind: "boolean" },
       },
       {
         path: "retry.phases.maxRetries",
         file: "config",
-        label: "Phase retries",
-        help: "Attempts per phase when the budget above is enabled.",
+        label: "(legacy) Phase max",
+        help: "Legacy phase budget value.",
         type: { kind: "number", min: 1, max: 100 },
       },
     ],

package/src/core/types.ts

@@ -88,6 +88,8 @@ export type Task = {
   key?: string;
   description: string;
   status: TaskStatus;
+  /** Which pipeline phase this task belongs to. Absent means `build` for backwards compat. */
+  phase?: Phase;
   dependsOn?: string[];
   subtasks?: Subtask[];
   difficulty?: Difficulty;
@@ -102,6 +104,7 @@ export type Feature = {
   name: string;
   description?: string;
   passes?: boolean;
+  phase?: Phase;
   sprintId?: string;
   goalId?: string;
   criteria?: string[];
@@ -148,6 +151,10 @@ export type RetryBucket = {
   maxRetries: number | null;
 };
 
+/** Levels that can each have their own retry budget and escalation state. */
+export const RETRY_LEVELS = ["goal", "phase", "sprint", "feature", "task", "subtask"] as const;
+export type RetryLevel = (typeof RETRY_LEVELS)[number];
+
 /**
  * How the run divides itself into pi sessions.
  *
@@ -160,6 +167,13 @@ export type RetryBucket = {
  */
 export type HandoffGranularity = "off" | "goal" | "phase" | "sprint" | "feature" | "task" | "subtask";
 
+export type ExecutionPolicy = {
+  /** Level at which parallel work is allowed. `off` = one task at a time. */
+  parallelAt: HandoffGranularity;
+  /** Max parallel workers (1..16). Guarded by lock and budget. */
+  maxWorkers: number;
+};
+
 export type SessionPolicy = {
   /**
    * When to hand off to a fresh session.
@@ -274,6 +288,7 @@ export type HarnessConfig = {
   phases: { enabled: Phase[] };
   roles: { strict: boolean };
   session: SessionPolicy;
+  execution: ExecutionPolicy;
   /** Legacy: the three-phase approval switch 2.3 shipped. Migrated to `phaseModes`. */
   approvals: ApprovalPolicy;
   /** Mode per phase — the setting `approvals` became. */
@@ -294,12 +309,16 @@ export type HarnessConfig = {
     tasks: RetryBucket;
     features: RetryBucket;
     phases: RetryBucket;
+    /** New per-level budgets keyed by RetryLevel. Legacy fields remain for compat. */
+    levels: Partial<Record<RetryLevel, RetryBucket>>;
   };
   maxRetries: number;
   retryCount: number;
   taskRetryCount: number;
   featureRetryCount: number;
   phaseRetryCount: number;
+  /** Fine-grained counters per RetryLevel; zeroed on success at that level. */
+  retryPerLevel: Partial<Record<RetryLevel, number>>;
   pipelineIteration: number;
   gateHistory: GateHistoryEntry[];
   [k: string]: unknown;

package/src/escalate.ts

@@ -66,6 +66,8 @@ export type EscalateOptions = {
   targetDir: string;
   runId: string;
   phase: Phase;
+  /** active retry level: subtask -> task -> ... -> goal; empty means "task" */
+  level?: string;
   /** The gate's failing checks, so the instruction can name them. */
   failures: string[];
   /** Whether the working tree moved since the last attempt. */
@@ -188,16 +190,28 @@ export async function escalate(options: EscalateOptions): Promise<Escalation> {
 
     case "consult": {
       const model = choice.nextModel ?? null;
+      const lvl = options.level ?? "task";
+      let thinkingHint: string | null = null;
+      try {
+        const { consultNextWithThinking, DIFFICULTY_LADDER } = await import("./modelRouter.ts");
+        const cur = (task?.difficulty ?? null) as string | null;
+        const idx = (DIFFICULTY_LADDER as readonly string[]).indexOf(cur ?? "");
+        const nextDiff = idx >= 0 && idx < (DIFFICULTY_LADDER.length as number) - 1 ? (DIFFICULTY_LADDER as readonly string[])[idx + 1] as string : null;
+        const picked = consultNextWithThinking(cur as string | null, { projectDir: targetDir, consultedCount: state.consultedCount });
+        void picked; void nextDiff;
+        thinkingHint = null; // keep instruction lean; spawned worker resolves thinking from router
+      } catch {}
       return {
         strategy: "consult",
-        reason: choice.reason,
+        reason: `${choice.reason} [${lvl}]`,
         instruction:
-          `ESCALATE. Reframing did not shift this either, so it is going to a stronger model` +
+          `ESCALATE [${lvl}]. Reframing did not shift this either, so it is going to a stronger model` +
           (model ? `: ${model}` : "") +
+          (thinkingHint ? ` (thinking: ${thinkingHint})` : "") +
           `. Write down, precisely, what you have tried and what the failure actually says — ` +
           `that hand-off is the whole value of the escalation.\n\nStill failing:\n${failureList}`,
         model,
-        applied: model ? `consulting ${model}` : null,
+        applied: model ? `consulting ${model} [${lvl}]` : `consult [${lvl}]`,
         next: carry("consult", { consultedCount: state.consultedCount + 1 }),
       };
     }

package/src/intake.ts

@@ -51,6 +51,8 @@ export type IntakeAnswers = {
   brief: string;
   /** Session handoff policy. Defaults to a fresh session per phase. */
   handoff?: SessionPolicy["handoff"];
+  parallelAt?: import("./core/types.ts").HandoffGranularity;
+  maxWorkers?: number;
   /** What the surfaces should draw. Defaults to the `focus` template. */
   display?: DisplayPolicy;
   /** Model routing for difficulty tiers and consulting. */
@@ -75,6 +77,7 @@ export type IntakePlan = {
   /** Kept in step with `phaseModes` so a 2.3 config read by a 2.3 tool still works. */
   approvals: ApprovalPolicy;
   session: SessionPolicy;
+  execution: import("./core/types.ts").ExecutionPolicy;
   display: DisplayPolicy;
   router?: IntakeAnswers["router"];
   /** What the human should be told about what they just chose. */
@@ -117,6 +120,8 @@ export function planIntake(answers: IntakeAnswers): IntakePlan {
     contextThreshold: handoff === "off" ? 0 : 0.6,
     carryNotes: true,
   };
+  const parallelAt = answers.parallelAt ?? "task";
+  const maxWorkers = Math.max(1, Math.min(16, Number.isFinite(answers.maxWorkers as number) ? Math.floor(answers.maxWorkers as number) : 3));
 
   const display = normalizeDisplay(answers.display ?? defaultDisplay());
   const brief = answers.brief?.trim() ? answers.brief.trim() : null;
@@ -162,6 +167,7 @@ export function planIntake(answers: IntakeAnswers): IntakePlan {
       plan: phaseModes.plan === "copilot",
     },
     session,
+    execution: { parallelAt, maxWorkers },
     display,
     router: answers.router,
     summary: summarize(workflow, phases, phaseModes, session, display, brief),

package/src/loop.ts

@@ -24,10 +24,10 @@
 import { createHash } from "node:crypto";
 import { resolve } from "node:path";
 import type { HarnessConfig, Phase } from "./core/types.ts";
-import { loadConfig, saveConfig, isRetryExhausted, incrementPhaseRetry } from "./core/config.ts";
+import { loadConfig, saveConfig, isRetryExhausted, incrementPhaseRetry, incrementRetryLevel, zeroLowerOnPass } from "./core/config.ts";
 import { loadFeatureList, computeProgress, nextActionableTask } from "./core/featureList.ts";
 import { runChecks } from "./core/gates.ts";
-import { advancePhase, isFinalPhase, nextPhase } from "./core/phases.ts";
+import { advancePhase, isFinalPhase, nextPhase, seedPhaseIfEmpty } from "./core/phases.ts";
 import { buildBrief, renderBrief } from "./core/brief.ts";
 import { harnessDir } from "./core/paths.ts";
 import { readJsonSafe, writeJsonAtomic, fileExists } from "./core/fsx.ts";
@@ -38,6 +38,7 @@ import {
   describeEscalation,
   type EscalationState,
 } from "./escalate.ts";
+import { executionPolicyOf, pickRunnableTasks } from "./scheduler.ts";
 import { loadGoal, recordPipelinePass, viewOf } from "./goal.ts";
 import {
   needsApproval,
@@ -66,10 +67,12 @@ export type LoopState = {
   lastDecision: string | null;
   stoppedAt: string | null;
   stopReason: string | null;
-  /** Where this run sits on the escalation ladder. */
+  /** Where this run sits on the escalation ladder (run-scoped fallback). */
   escalation: EscalationState;
+  /** Per-level escalation: each level has its own ladder progress. */
+  perLevelEscalation: Partial<Record<import("./core/types.ts").RetryLevel, EscalationState>>;
   /** Every rung taken, so the human coming back can see the shape of it. */
-  escalations: { at: string; strategy: string; reason: string; applied: string | null }[];
+  escalations: { at: string; strategy: string; level?: string; reason: string; applied: string | null }[];
 };
 
 /** Escalation history kept in the loop state. Older entries tell no story. */
@@ -124,6 +127,7 @@ export function newLoopState(runId: string, now = new Date()): LoopState {
     stoppedAt: null,
     stopReason: null,
     escalation: emptyEscalationState(),
+    perLevelEscalation: {},
     escalations: [],
   };
 }
@@ -135,12 +139,26 @@ export function loadLoopState(targetDir: string, runId: string, now = new Date()
     return {
       ...stored,
       escalation: { ...emptyEscalationState(), ...(stored.escalation ?? {}) },
+      perLevelEscalation: (stored as Record<string, unknown>).perLevelEscalation
+        ? (stored as unknown as LoopState).perLevelEscalation
+        : {},
       escalations: Array.isArray(stored.escalations) ? stored.escalations : [],
     };
   }
   return newLoopState(runId, now);
 }
 
+export function escalationStateForLevel(state: LoopState, level: string): EscalationState {
+  const key = level as import("./core/types.ts").RetryLevel;
+  return (state.perLevelEscalation[key] ?? emptyEscalationState()) as EscalationState;
+}
+export function setEscalationForLevel(state: LoopState, level: string, next: EscalationState): void {
+  const key = level as import("./core/types.ts").RetryLevel;
+  state.perLevelEscalation[key] = next;
+  // Keep top-level in step with the finest active level so old widget still reads it.
+  state.escalation = next;
+}
+
 export function saveLoopState(targetDir: string, state: LoopState): void {
   try {
     writeJsonAtomic(loopStatePath(targetDir), state);
@@ -257,6 +275,25 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
 
   state.lastPhase = config.currentPhase;
 
+  // Ensure DEFINE/PLAN have at least seed tasks — fixes DEFINE rev 0
+  // idempotently and ensures handoff's toTask becomes non-null shortly after
+  // RESEARCH auto-advanced. Only enabled doc phases with no tasksForPhase are
+  // seeded, so synthetic convergence projects (with already-complete BUILD tasks)
+  // do not get a dirty feature-list. Also: if a phase's task-gate (featureCriteria)
+  // already passes, do not seed — the plan is already satisfied without starters.
+  if (config.currentPhase && (config.phases?.enabled ?? []).includes(config.currentPhase)) {
+    try {
+      const { list: _list } = loadFeatureList(targetDir);
+      const hasPhaseTasks = (await import("./core/featureList.ts")).tasksForPhase(_list, config.currentPhase).length > 0;
+      if (!hasPhaseTasks) {
+        // Do not seed when the gate is already satisfied — the synthetic converge
+        // walk expects define->ship without touching the tree.
+        const gateTrial = await runChecks(targetDir, config.currentPhase, { record: false });
+        if (!gateTrial.overall) seedPhaseIfEmpty(targetDir, config.currentPhase);
+      }
+    } catch {}
+  }
+
   // -- terminal conditions --------------------------------------------------
   const { list } = loadFeatureList(targetDir);
   const progress = computeProgress(list);
@@ -377,9 +414,17 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
     // phase, spending `retry` and `reframe` on an agent that had not yet been
     // given a chance to do anything. A stall means the agent produced nothing
     // when asked; a fresh brief has not asked yet.
+    // Zero lower-level retry counters on a phase pass (task/subtask streaks reset for the new phase).
+    try {
+      const movedCfg = moved.config ?? loadConfig(targetDir).config;
+      zeroLowerOnPass(movedCfg, "phase");
+      saveConfig(targetDir, movedCfg);
+    } catch {}
     state.lastFingerprint = null;
     state.noProgressStreak = 0;
     state.escalation = { ...state.escalation, tried: [] };
+    // Also reset per-level escalation for task/subtask so the next phase starts clean.
+    state.perLevelEscalation = {};
 
     const brief = await buildBrief(targetDir);
     return finish({
@@ -400,6 +445,9 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
   const fp = await fingerprint(targetDir);
   state.lastFingerprint = fp;
 
+  // Active retry level: finest active level with work (subtask > task > feature > sprint > phase > goal).
+  const retryLevel = detectRetryLevel(list, config.currentPhase, phase);
+
   if (previous === null || previous !== fp) {
     state.noProgressStreak = 0;
     // The tree moved, so whatever the run was stuck on, it is not stuck on it
@@ -408,6 +456,10 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
     // stalls, but a rung spent on a problem that resolved should not be
     // missing when a different problem appears.
     state.escalation = { ...state.escalation, tried: [] };
+    const lev = retryLevel
+      ? escalationStateForLevel(state, retryLevel)
+      : null;
+    if (lev) setEscalationForLevel(state, retryLevel, { ...lev, tried: [] });
   } else {
     state.noProgressStreak += 1;
   }
@@ -423,8 +475,11 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
   // Escalating never *prevents* the run from stopping. The strike is still
   // counted; the ladder just gets a turn first, so a run stops because nothing
   // worked rather than because nothing was tried.
+  // Per-level: each retryLevel has its own EscalationState, consult+thinking escalation
+  // climbs with it, and lower levels are zeroed on a pass at a coarser level.
   let escalation = null as Awaited<ReturnType<typeof escalate>> | null;
   if (!options.skipEscalation && state.noProgressStreak >= ESCALATE_AFTER_STALLS) {
+    const levState = escalationStateForLevel(state, retryLevel ?? "task");
     escalation = await escalate({
       targetDir,
       runId,
@@ -432,16 +487,18 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
       failures: gate ? gate.failures : [],
       fileDelta: previous !== null && previous !== fp,
       fingerprint: fp,
-      state: state.escalation,
+      state: levState,
+      level: retryLevel ?? "task",
       now,
     });
-    state.escalation = escalation.next;
+    setEscalationForLevel(state, retryLevel ?? "task", escalation.next);
     if (escalation.strategy) {
       state.escalations = [
         ...state.escalations,
         {
           at: now.toISOString(),
           strategy: escalation.strategy,
+          level: retryLevel ?? "task",
           reason: escalation.reason,
           applied: escalation.applied,
         },
@@ -482,14 +539,47 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
     });
   }
 
-  // Charge a phase retry so the configured budget still bounds the run even
-  // when the tree keeps changing but the gate never opens.
+  // Charge retries at the active level as well as the legacy phase counter.
   const fresh = loadConfig(targetDir);
+  let execPolicy: { parallelAt: string; maxWorkers: number } | null = null;
   if (fresh.ok) {
-    incrementPhaseRetry(fresh.config);
+    execPolicy = executionPolicyOf(fresh.config) as { parallelAt: string; maxWorkers: number };
+    incrementRetryLevel(fresh.config, retryLevel ?? "phase");
+    // Keep phase counter in step as the global guard so existing budgets still fire.
+    if ((retryLevel ?? "phase") !== "phase") incrementPhaseRetry(fresh.config);
     saveConfig(targetDir, fresh.config);
   }
 
+  // Auto-spawn isolated workers for eligible tasks at the current phase —
+  // the main session stays as orchestrator/visualisation only. Workers are
+  // created empty (no shell command) so realpi/e2e without a worker runtime
+  // still advances via gate; the brief still drives the main session until a
+  // real runner picks the attempt up. This makes the main session safe to
+  // observe but not edit the plan.
+  try {
+    if (execPolicy && execPolicy.parallelAt !== "off" && fresh?.ok) {
+      const eligible = pickRunnableTasks({
+        targetDir,
+        phase: fresh.config.currentPhase as import("./core/types.ts").Phase | null,
+        parallelAt: execPolicy.parallelAt as import("./core/types.ts").HandoffGranularity,
+        maxWorkers: execPolicy.maxWorkers,
+      });
+      if (eligible.length > 0) {
+        const { spawnWorkers } = await import("./scheduler.ts");
+        const curBrief = await buildBrief(targetDir);
+        const briefFor = (t: import("./core/featureList.ts").FlatTask): string =>
+          `Task ${t.compositeKey} in ${fresh.config.currentPhase}: ${t.description}` +
+          `\nAcceptance: ${(t.criteria ?? (curBrief.criteria ?? [])).join("; ")}`;
+        // Fire-and-forget so the brief still returns promptly; harness does not
+        // depend on the child process (covered by e2e). Errors are best-effort.
+        spawnWorkers(targetDir, eligible, {
+          runId,
+          promptFor: briefFor,
+        }).catch(() => {});
+      }
+    }
+  } catch {}
+
   const brief = await buildBrief(targetDir);
   const failures = gate
     ? gate.checks
@@ -562,6 +652,22 @@ async function requestGoalReview(
   }
 }
 
+/** Finest active level with pending work — decides which retry ladder to climb. */
+export function detectRetryLevel(list: import("./core/types.ts").FeatureList, phase: import("./core/types.ts").Phase | null, _activePhase: import("./core/types.ts").Phase): string {
+  try {
+    const tasks = phase ? list.features.flatMap((f) => (f as { phase?: string }).phase === phase || (f.tasks as { phase?: string }[]).some((t) => t.phase === phase) ? f.tasks : []) : [];
+    // Prefer task-level detection from subtasks
+    const all = list.features.flatMap((f) => f.tasks);
+    const hasSubtaskPending = all.some((t) => (t.subtasks ?? []).some((s) => s.status !== "complete"));
+    const hasTaskPending = all.some((t) => t.status !== "complete");
+    if (hasSubtaskPending) return "subtask";
+    if (hasTaskPending) return "task";
+    const featsPending = (list.features ?? []).some((f) => !(f.tasks ?? []).every((t) => t.status === "complete"));
+    if (featsPending) return "feature";
+    return "phase";
+  } catch { return "task"; }
+}
+
 /** Human-readable one-liner for the status bar / notify. */
 export function describeDecision(d: LoopDecision): string {
   switch (d.action) {

package/src/modelRouter.ts

@@ -168,6 +168,20 @@ export function resolveModel(opts: ResolveOpts = {}): string {
  * MASTER never assigned, only via consultNext after exhaustion.
  * Returns next model or null if at top/budget exhausted.
  */
+export function consultNextWithThinking(
+  currentDifficulty: string | null | undefined,
+  opts: { projectDir?: string; consultedCount?: number } = {},
+): { model: string | null; thinking: ThinkingLevel | "" } {
+  const model = consultNext(currentDifficulty, opts);
+  let thinking: ThinkingLevel | "" = "";
+  if (model) {
+    const idx = DIFFICULTY_LADDER.indexOf(currentDifficulty as any);
+    const nextDiff = idx >= 0 && idx < DIFFICULTY_LADDER.length - 1 ? DIFFICULTY_LADDER[idx + 1] as string : (idx === DIFFICULTY_LADDER.length - 1 ? null : null);
+    thinking = resolveThinkingForConsult(nextDiff, opts.projectDir) ?? "";
+  }
+  return { model, thinking };
+}
+
 export function consultNext(
   currentDifficulty: string | null | undefined,
   opts: { projectDir?: string; consultedCount?: number } = {},

package/src/remote.ts

@@ -57,6 +57,8 @@ export interface RemoteState {
   goalPass: { current: number; max: number } | null;
   /** What the reader has asked the dashboard to draw. */
   display: DisplayPolicy;
+  execution: unknown;
+  workers: unknown;
 }
 
 export interface RemoteServer {
@@ -116,6 +118,15 @@ export function buildRemoteState(projectDir?: string): RemoteState {
     rework: readJsonSafe<unknown>(reworkPath(dir), null),
     awaitingApproval: config.awaitingApproval ?? null,
     sessions: loadRunState(dir)?.sessions ?? null,
+    execution: (() => { try { const { executionPolicyOf } = require("./scheduler.ts"); return executionPolicyOf(config); } catch { return null; } })(),
+    workers: (() => {
+      try {
+        const { listWorkers } = require("./scheduler.ts");
+        const runId = (() => { try { return (require("./runState.ts") as { runIdFor: (d:string,f:string)=>string }).runIdFor(dir, ""); } catch { return undefined; } })();
+        const ws = listWorkers(dir, runId || undefined) as unknown[];
+        return Array.isArray(ws) ? ws.slice(0, 6) : [];
+      } catch { return []; }
+    })(),
     goalPass:
       typeof config.goalPass === "number" && typeof config.goalMaxPasses === "number"
         ? { current: config.goalPass, max: config.goalMaxPasses }