infinity-harness 2.6.6 → 2.8.0

package/src/goalState.ts

@@ -9,9 +9,8 @@ import {
   validateGoalLoopState,
 } from "./goalLoop.ts";
 import { type GoalSpecification, validateGoalSpecification } from "./goalSpec.ts";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-declare const require: any;
 
 export const GOAL_STATE_FILE = "GOAL_STATE.json";
 export const GOAL_TRACE_FILE = "GOAL_TRACE.jsonl";
@@ -25,26 +24,7 @@ export function canonicalGoalSpecPath(projectDir = process.cwd()): string {
   return resolve(projectDir, CANONICAL_GOAL_SPEC_DIR, CANONICAL_GOAL_SPEC_FILE);
 }
 
-function writeCanonicalWithLockSync(projectDir: string, content: string): void {
-  const target = canonicalGoalSpecPath(projectDir);
-  // try proper-lockfile sync-ish via dynamic import fallback to plain write
-  try {
-    mkdirSync(dirname(target), { recursive: true });
-    // use proper-lockfile if available (async variant would need async; use sync file write with lock attempt)
-    // For sync canonical we rely on atomic tmp+rename and ignore lock if unavailable — async wrapper below handles lock
-    const tmp = `${target}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    writeFileSync(tmp, content, "utf8");
-    // rename via node:fs renameSync equivalent (import already has rename async, but we use writeFileSync+rename via fs)
-    const { renameSync } = require("node:fs");
-    renameSync(tmp, target);
-  } catch {
-    // fallback simple write
-    try {
-      mkdirSync(dirname(target), { recursive: true });
-      writeFileSync(target, content, "utf8");
-    } catch {}
-  }
-}
+
 
 
 export interface GoalStateStoreOptions {

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, isolation: "worktree" as const },
     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 }
   /**
@@ -440,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}`,
     });
   }
@@ -550,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
@@ -618,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,7 +25,9 @@ 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";
+import { executionPolicyOf } from "./scheduler.ts";
 
 export { escapeHtml };
 
@@ -58,7 +60,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 {
@@ -118,14 +126,21 @@ 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; } })(),
+    execution: (() => { try { return executionPolicyOf(config); } catch { return null; } })(),
+    engine: (() => { try { 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 +167,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) ?? [],
   };
 }
 
@@ -173,6 +191,9 @@ export function buildApiPayload(state: RemoteState & { dashboardUrl?: string | n
     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/replan.ts

@@ -20,13 +20,13 @@
  * implementation of each now, in `core/`.
  */
 
-import { unlinkSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import type { Feature, FeatureList, Subtask, Task, TaskStatus } from "./core/types.ts";
 import { TASK_STATUSES } from "./core/types.ts";
 import { detectCycle, flattenTasks, loadFeatureList, saveFeatureList } from "./core/featureList.ts";
 import { fileExists, readJsonSafe, writeJsonAtomic } from "./core/fsx.ts";
 import { loadConfig } from "./core/config.ts";
-import { featureListPath, replanPath } from "./core/paths.ts";
+import { planPath, replanPath } from "./core/paths.ts";
 import { withLockSync } from "./core/lock.ts";
 
 /**
@@ -161,8 +161,12 @@ function appendReplanHistory(projectDir: string, entry: ReplanHistoryEntry): voi
 
 function readMaxReplans(projectDir: string): number {
   const { config } = loadConfig(projectDir);
+  const lim = (config as unknown as { limits?: { maxReplansPerPhase?: unknown } }).limits as { maxReplansPerPhase?: unknown } | undefined;
+  let hasLimitsFile = false;
+  try { const p = `${projectDir}/harness/config.json`; if (existsSync(p)) { const raw = JSON.parse(readFileSync(p,"utf-8")); if (raw && typeof raw.limits === "object") hasLimitsFile = true; } } catch {}
   const replan = config.replan as { maxReplans?: unknown; maxReplansPerRun?: unknown } | undefined;
   const budgets = config.budgets as { maxReplansPerRun?: unknown } | undefined;
+  if (hasLimitsFile && typeof lim?.maxReplansPerPhase === "number") return lim.maxReplansPerPhase;
   if (typeof replan?.maxReplans === "number") return replan.maxReplans;
   if (typeof replan?.maxReplansPerRun === "number") return replan.maxReplansPerRun;
   if (typeof budgets?.maxReplansPerRun === "number") return budgets.maxReplansPerRun;
@@ -198,7 +202,7 @@ export async function amendPlan(opts: AmendPlanOpts): Promise<AmendPlanResult> {
 
   // Read, amend, validate, bump, write — one atomic section. Adding to the
   // plan is a read-apply-write over the same file every parallel worker edits.
-  const result = withLockSync(featureListPath(projectDir), () => {
+  const result = withLockSync(planPath(projectDir), () => {
     const list = loadPlan(projectDir);
 
     let addedSprints = 0;

package/src/rework.ts

@@ -17,12 +17,12 @@
  * other. One implementation of each now, in `core/`.
  */
 
-import { unlinkSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import type { FeatureList, Task } from "./core/types.ts";
 import { flattenTasks, loadFeatureList, saveFeatureList } from "./core/featureList.ts";
 import { fileExists, readJsonSafe, writeJsonAtomic } from "./core/fsx.ts";
 import { loadConfig } from "./core/config.ts";
-import { featureListPath, reworkPath } from "./core/paths.ts";
+import { planPath, reworkPath } from "./core/paths.ts";
 import { withLockSync } from "./core/lock.ts";
 
 /**
@@ -165,8 +165,14 @@ function appendReworkRecord(projectDir: string, record: ReworkRecord): void {
 
 function readMaxReworks(projectDir: string): number {
   const { config } = loadConfig(projectDir);
+  const lim = (config as unknown as { limits?: { maxReworkPerUnit?: unknown } }).limits as { maxReworkPerUnit?: unknown } | undefined;
+  // limits.maxReworkPerUnit wins only when writable: config actually has a limits file with it.
+  // Test configs write { rework: {maxReworks: 3} } onto a partial config that still has DEFAULT_LIMITS via merge — without this guard every test would see 2.
+  let hasLimitsFile = false;
+  try { const p = `${projectDir}/harness/config.json`; if (existsSync(p)) { const raw = JSON.parse(readFileSync(p,"utf-8")); if (raw && typeof raw.limits === "object") hasLimitsFile = true; } } catch {}
   const rework = config.rework as { maxReworks?: unknown } | undefined;
   const budgets = config.budgets as { maxReworksPerRun?: unknown } | undefined;
+  if (hasLimitsFile && typeof lim?.maxReworkPerUnit === "number") return lim.maxReworkPerUnit;
   if (typeof rework?.maxReworks === "number") return rework.maxReworks;
   if (typeof budgets?.maxReworksPerRun === "number") return budgets.maxReworksPerRun;
   return DEFAULT_MAX_REWORKS;
@@ -209,7 +215,7 @@ export async function startRework(opts: StartReworkOpts): Promise<StartReworkRes
 
   // Read, flip, bump, write — one atomic section. The status flip is a
   // read-apply-write over the same file every parallel worker edits.
-  const result = withLockSync(featureListPath(projectDir), () => {
+  const result = withLockSync(planPath(projectDir), () => {
     const list = loadPlan(projectDir);
     const tasks = flattenTasks(list);
     if (!tasks.some((t) => taskKey(t) === originKey)) {

package/src/runState.ts

@@ -1,121 +1,15 @@
-/**
- * infinity-harness — is a continuous run armed, and which run is it?
- *
- * This used to be a `let loopEnabled = false` inside the extension closure,
- * which meant the answer died with the pi session that held it. That was fine
- * while the harness lived in exactly one session forever, and wrong the moment
- * it did not:
- *
- *   - a fresh session per handoff (the whole point of `src/handoff.ts`) starts
- *     a new extension instance, and the run it was continuing was over
- *   - `/reload`, `/new`, `/resume` and a crash all did the same thing
- *   - the run id was a `randomUUID()` per session, so `loadLoopState` saw a
- *     different run each time and reset the iteration count, the wall-clock
- *     budget, the no-progress streak and the escalation ladder — every budget
- *     that exists to stop a runaway run
- *
- * A run is a property of the project, not of the terminal window that started
- * it. It lives on disk.
- */
-
-import { runStatePath } from "./core/paths.ts";
-import { readJsonSafe, writeJsonAtomic, removeFile } from "./core/fsx.ts";
-
-export type RunState = {
-  /** Whether the loop should keep driving. Read on every session start. */
-  armed: boolean;
-  /** Stable across every session this run spans. */
-  runId: string;
-  startedAt: string;
-  /** How many pi sessions this run has used. Shown in the widget. */
-  sessions: number;
-  /** Why the run last stopped, so a returning human is not left guessing. */
-  stoppedAt: string | null;
-  stopReason: string | null;
-};
-
-export function newRunState(runId: string, now = new Date()): RunState {
-  return {
-    armed: true,
-    runId,
-    startedAt: now.toISOString(),
-    sessions: 1,
-    stoppedAt: null,
-    stopReason: null,
-  };
-}
-
-export function loadRunState(targetDir: string): RunState | null {
-  const raw = readJsonSafe<Partial<RunState> | null>(runStatePath(targetDir), null);
-  if (!raw || typeof raw.runId !== "string" || !raw.runId) return null;
-  return {
-    armed: raw.armed === true,
-    runId: raw.runId,
-    startedAt: typeof raw.startedAt === "string" ? raw.startedAt : new Date(0).toISOString(),
-    sessions: typeof raw.sessions === "number" && raw.sessions > 0 ? raw.sessions : 1,
-    stoppedAt: typeof raw.stoppedAt === "string" ? raw.stoppedAt : null,
-    stopReason: typeof raw.stopReason === "string" ? raw.stopReason : null,
-  };
-}
-
-export function saveRunState(targetDir: string, state: RunState): void {
-  try {
-    writeJsonAtomic(runStatePath(targetDir), state);
-  } catch {
-    // Losing the file costs the run its cross-session budgets, which is bad,
-    // but throwing here would kill the session, which is worse.
-  }
-}
-
-/** Arm a run. Reuses the existing run id when one is already armed. */
-export function armRun(targetDir: string, runId: string, now = new Date()): RunState {
-  const existing = loadRunState(targetDir);
-  const state =
-    existing && existing.armed
-      ? { ...existing, stoppedAt: null, stopReason: null }
-      : newRunState(runId, now);
-  saveRunState(targetDir, state);
-  return state;
-}
-
-export function disarmRun(targetDir: string, reason: string, now = new Date()): RunState | null {
-  const existing = loadRunState(targetDir);
-  if (!existing) return null;
-  const state: RunState = {
-    ...existing,
-    armed: false,
-    stoppedAt: now.toISOString(),
-    stopReason: reason,
-  };
-  saveRunState(targetDir, state);
-  return state;
-}
-
-/** Count one more pi session against this run. Called from `session_start`. */
-export function countSession(targetDir: string): RunState | null {
-  const existing = loadRunState(targetDir);
-  if (!existing) return null;
-  const state = { ...existing, sessions: existing.sessions + 1 };
-  saveRunState(targetDir, state);
-  return state;
-}
-
-export function clearRunState(targetDir: string): void {
-  try {
-    removeFile(runStatePath(targetDir));
-  } catch {
-    /* nothing to clear */
-  }
-}
-
-/**
- * The run id the loop should use.
- *
- * An armed run keeps its id so `loadLoopState` finds the same budgets after a
- * handoff. With nothing armed, the caller's session id is the run id — an
- * ad-hoc `/infinity:validate` should not inherit a finished run's strikes.
- */
-export function runIdFor(targetDir: string, fallback: string): string {
-  const state = loadRunState(targetDir);
-  return state && state.armed ? state.runId : fallback;
-}
+// Re-export from core so both import paths work.
+// Canonical type now lives in src/core/runState.ts (with baseModel/tiers/budget).
+export {
+  loadRunState,
+  saveRunState,
+  armRun,
+  disarmRun,
+  countSession,
+  clearRunState,
+  runIdFor,
+  newRunState,
+  parseBaseModelString,
+  createUsageTotals,
+} from "./core/runState.ts";
+export type { RunState, ProviderModel, TierResults, TierPreflight, Budget, UsageTotals } from "./core/runState.ts";