infinity-harness 2.6.5 → 2.7.0

package/src/intake.ts

@@ -56,6 +56,8 @@ export type IntakeAnswers = {
   /** Session handoff policy. Defaults to a fresh session per phase. */
   handoff?: SessionPolicy["handoff"];
   parallelAt?: import("./core/types.ts").HandoffGranularity;
+  /** Where the work runs. Defaults to background — its own pi session per unit. */
+  engine?: import("./core/types.ts").ExecutionEngine;
   maxWorkers?: number;
   /** What the surfaces should draw. Defaults to the `focus` template. */
   display?: DisplayPolicy;
@@ -126,6 +128,7 @@ export function planIntake(answers: IntakeAnswers): IntakePlan {
     carryNotes: true,
   };
   const parallelAt = answers.parallelAt ?? "task";
+  const engine = answers.engine ?? "background";
   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());
@@ -174,7 +177,7 @@ export function planIntake(answers: IntakeAnswers): IntakePlan {
       plan: phaseModes.plan === "copilot",
     },
     session,
-    execution: { parallelAt, maxWorkers },
+    execution: { engine, parallelAt, maxWorkers },
     display,
     router: answers.router,
     summary: summarize(workflow, phases, phaseModes, session, display, brief, _researchDepth),

package/src/loop.ts

@@ -38,7 +38,6 @@ import {
   describeEscalation,
   type EscalationState,
 } from "./escalate.ts";
-import { executionPolicyOf, pickRunnableTasks } from "./scheduler.ts";
 import { loadGoal, recordPipelinePass, viewOf } from "./goal.ts";
 import {
   needsApproval,
@@ -95,9 +94,29 @@ export type LoopBudget = {
   noProgressLimit: number;
 };
 
+/**
+ * What the supervisor needs to know about an escalation, without re-deriving
+ * it. A rung that names a stronger model is a model switch, and a model
+ * switch is a new worker session — the supervisor cannot act on `reason`.
+ */
+export type DecisionEscalation = { strategy: string; model: string | null; level: string | null };
+
 export type LoopDecision =
-  | { action: "continue"; message: string; reason: string }
-  | { action: "advanced"; toPhase: Phase; message: string; reason: string }
+  | {
+      action: "continue";
+      message: string;
+      reason: string;
+      /**
+       * The instruction on its own, without the brief appended.
+       *
+       * A worker that is already on this unit has the brief in its context
+       * from the turn before; re-sending several kilobytes of it every cycle
+       * is the single largest avoidable cost in a long run.
+       */
+      headline?: string;
+      escalation?: DecisionEscalation | null;
+    }
+  | { action: "advanced"; toPhase: Phase; message: string; reason: string; headline?: string }
   | { action: "stop"; reason: string; detail: string }
   | { action: "wait"; reason: string; detail: string }
   /**
@@ -275,17 +294,32 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
 
   state.lastPhase = config.currentPhase;
 
-  // Generic: current phase with 0 tasks gets starters (research → deep, define/plan → fix rev 0).
-  // Same code for every phase, same trigger: 0 tasks && gate fails. Never dirties a converged walk.
+  // Every enabled phase owns tracked work. Visible breakdown (requirement 1) says RESEARCH must
+  // show its tasks even when its doc gate already PASSed — progress is the real signal.
+  // On a copilot approval project with real features, never inject scaffolding on a PASSing DEFINE.
+  // On synthetic mkSatisfiableProject (define→ship already complete, first tick PASS) also skip.
+  // All other empty phases (bakr_test define/plan after autopilot research) seed on FAIL.
   if (config.currentPhase && (config.phases?.enabled ?? []).includes(config.currentPhase)) {
+    const maybeRejected = Boolean((config as { approvalRejection?: unknown }).approvalRejection);
+    if (!maybeRejected) {
     try {
       const { list: _list } = loadFeatureList(targetDir);
       const hasPhaseTasks = (await import("./core/featureList.ts")).tasksForPhase(_list, config.currentPhase).length > 0;
       if (!hasPhaseTasks) {
-        const gateTrial = await runChecks(targetDir, config.currentPhase, { record: false });
-        if (!gateTrial.overall) seedPhaseIfEmpty(targetDir, config.currentPhase);
+        const curPhase = config.currentPhase;
+        if (curPhase === "research") {
+          // Research is doc + tracked tasks: always show the breakdown (5 tasks for deep). 
+          seedPhaseIfEmpty(targetDir, curPhase);
+        } else {
+          const curState = state;
+          const probe = await runChecks(targetDir, curPhase, { record: false });
+          if (!probe.overall) {
+            seedPhaseIfEmpty(targetDir, curPhase);
+          }
+        }
       }
     } catch {}
+    }
   }
 
   // -- terminal conditions --------------------------------------------------
@@ -425,6 +459,9 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
       action: "advanced",
       toPhase: upcoming,
       message: renderBrief(brief, moved.config ?? undefined),
+      headline:
+        `The ${phase.toUpperCase()} gate passed and the run has advanced to ` +
+        `${upcoming.toUpperCase()}. Work the new phase now.`,
       reason: `gate passed on ${phase}`,
     });
   }
@@ -535,44 +572,19 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
 
   // 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) {
-    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 {}
+  // There used to be a fire-and-forget `spawnWorkers` here. It spawned
+  // workers with no command, so all it ever did was create an empty
+  // `tmp/infinity-harness/<run>/<feature>/<task>/attempt-N/` on every failing
+  // gate — litter in the user's tree, an unawaited promise that outlived the
+  // call, and no work. Background execution is the supervisor's job now
+  // (`src/supervisor.ts`), which spawns a real pi session and waits for it.
 
   const brief = await buildBrief(targetDir);
   const failures = gate
@@ -603,6 +615,10 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
       : escalation?.strategy
         ? `escalated: ${describeEscalation(escalation)}`
         : "gate failed",
+    headline: head,
+    escalation: escalation?.strategy
+      ? { strategy: escalation.strategy, model: escalation.model ?? null, level: retryLevel ?? null }
+      : null,
     message: `${head}\n${renderBrief(brief, fresh.ok ? fresh.config : undefined)}`,
   });
 }

package/src/remote.ts

@@ -25,6 +25,7 @@ import { modelRouterPath, reworkPath } from "./core/paths.ts";
 import { readJsonSafe } from "./core/fsx.ts";
 import { loadRunState } from "./runState.ts";
 import { normalizeDisplay } from "./ui/display.ts";
+import { supervisorStatePath, activityPath } from "./supervisor.ts";
 import { renderDashboard, escapeHtml, type DashboardState } from "./ui/dashboard.ts";
 
 export { escapeHtml };
@@ -58,7 +59,13 @@ export interface RemoteState {
   /** What the reader has asked the dashboard to draw. */
   display: DisplayPolicy;
   execution: unknown;
+  /** Where the work runs: background pi sessions, or this session. */
+  engine: "background" | "main-session" | null;
+  /** The supervisor's state file, verbatim. Opaque here. */
+  supervisor: unknown;
   workers: unknown;
+  /** Tail of the background log. */
+  activity: unknown;
 }
 
 export interface RemoteServer {
@@ -119,13 +126,20 @@ export function buildRemoteState(projectDir?: string): RemoteState {
     awaitingApproval: config.awaitingApproval ?? null,
     sessions: loadRunState(dir)?.sessions ?? null,
     execution: (() => { try { const { executionPolicyOf } = require("./scheduler.ts"); return executionPolicyOf(config); } catch { return null; } })(),
+    engine: (() => { try { const { executionPolicyOf } = require("./scheduler.ts"); return executionPolicyOf(config).engine as "background" | "main-session"; } catch { return null; } })(),
+    // The supervisor's own state is the truth about what is running. This used
+    // to scan the attempt-directory tree, which reported every attempt ever
+    // made as a live worker.
+    supervisor: readJsonSafe<unknown>(supervisorStatePath(dir), 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 []; }
+      const sup = readJsonSafe<{ worker?: unknown; history?: unknown[] } | null>(supervisorStatePath(dir), null);
+      const live = sup?.worker ? [sup.worker] : [];
+      const past = Array.isArray(sup?.history) ? sup!.history!.slice(-3).reverse() : [];
+      return [...live, ...past];
+    })(),
+    activity: (() => {
+      const raw = readJsonSafe<{ lines?: unknown[] } | null>(activityPath(dir), null);
+      return Array.isArray(raw?.lines) ? raw!.lines!.slice(-60) : [];
     })(),
     goalPass:
       typeof config.goalPass === "number" && typeof config.goalMaxPasses === "number"
@@ -152,6 +166,9 @@ function toDashboardState(s: RemoteState): DashboardState {
     sessions: s.sessions,
     goalPass: s.goalPass,
     display: s.display,
+    engine: s.engine,
+    workers: (s.workers as import("./ui/dashboard.ts").DashWorker[] | null) ?? [],
+    activity: (s.activity as import("./ui/dashboard.ts").DashActivity[] | null) ?? [],
   };
 }
 
@@ -160,7 +177,7 @@ export function buildHtml(state: RemoteState): string {
 }
 
 /** JSON payload for `/api/harness`. Excludes the full list to stay compact. */
-export function buildApiPayload(state: RemoteState): Record<string, unknown> {
+export function buildApiPayload(state: RemoteState & { dashboardUrl?: string | null; handoffModelNote?: string | null }): Record<string, unknown> {
   return {
     baseRevision: state.baseRevision,
     phase: state.phase,
@@ -173,6 +190,9 @@ export function buildApiPayload(state: RemoteState): Record<string, unknown> {
     rework: state.rework,
     awaitingApproval: state.awaitingApproval,
     sessions: state.sessions,
+    engine: state.engine,
+    workers: state.workers,
+    activity: state.activity,
     goalPass: state.goalPass,
     sprints: state.sprints,
     display: state.display,

package/src/scheduler.ts

@@ -297,12 +297,19 @@ export async function spawnWorkers(
   return results;
 }
 
-export function executionPolicyOf(config: HarnessConfig): { parallelAt: HandoffGranularity; maxWorkers: number } {
-  const e = (config.execution ?? {}) as Partial<{ parallelAt: unknown; maxWorkers: unknown }>;
+export function executionPolicyOf(config: HarnessConfig): {
+  engine: import("./core/types.ts").ExecutionEngine;
+  parallelAt: HandoffGranularity;
+  maxWorkers: number;
+} {
+  const e = (config.execution ?? {}) as Partial<{ engine: unknown; parallelAt: unknown; maxWorkers: unknown }>;
+  // Anything but the explicit legacy value means background: a config written
+  // before this setting existed should get the new behaviour, not the bug.
+  const engine: import("./core/types.ts").ExecutionEngine = e.engine === "main-session" ? "main-session" : "background";
   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 };
+  return { engine, parallelAt: at, maxWorkers };
 }