infinity-harness 2.6.6 → 2.8.0

package/src/core/modelRouter.ts

@@ -0,0 +1,149 @@
+/**
+ * infinity-harness — modelRouter: which model for which unit (Core, pi-free).
+ *
+ * Pure decision: difficulty + tiers + baseModel -> asked {provider,id}.
+ * Never verifies — tier preflight + servedModel + budget live in the Daemon.
+ *
+ * Tiers live in `config.tiers` (A/B/C/D/X). Legacy `harness/model-router.json`
+ * is still migrated on read for one release (byDifficulty Master ladder).
+ */
+
+import type { TierMap, TierSpec, HarnessConfig, FeatureList, Phase, Difficulty } from "./types.ts";
+
+export type ThinkingLevel = import("./types.ts").ThinkingLevel;
+export type TierId = import("./types.ts").TierId;
+
+const DIFF_TO_TIER: Record<Difficulty, import("./types.ts").TierId> = {
+  easy: "B",
+  moderate: "C",
+  difficult: "D",
+};
+
+function effectiveDifficultyForUnitFromTasks(tasks: Array<{ difficulty?: Difficulty }>): Difficulty | undefined {
+  const rank: Record<string, number> = { easy: 1, moderate: 2, difficult: 3 };
+  let best: Difficulty | undefined;
+  let bestRank = -1;
+  for (const t of tasks) {
+    const d = t.difficulty;
+    if (!d) continue;
+    const r = rank[d] ?? -1;
+    if (r > bestRank) { bestRank = r; best = d as Difficulty; }
+  }
+  return best;
+}
+
+function tiersOf(config: HarnessConfig): TierMap {
+  const t = (config as unknown as { tiers?: TierMap }).tiers;
+  if (t && typeof t === "object") return t;
+  return {};
+}
+
+function baseModelOf(runState: { baseModel?: { provider: string; id: string } | string | null } | null | undefined): { provider: string; id: string } | null {
+  if (!runState?.baseModel) return null;
+  const bm: unknown = runState.baseModel;
+  if (typeof bm === "string") {
+    const parts = String(bm).split("/");
+    if (parts.length >= 2) return { provider: parts[0]!, id: parts.slice(1).join("/") };
+    return { provider: "anthropic", id: String(bm) };
+  }
+  if (typeof bm === "object" && bm !== null && typeof (bm as { provider: unknown }).provider === "string" && typeof (bm as { id: unknown }).id === "string") {
+    return { provider: String((bm as { provider: unknown }).provider), id: String((bm as { id: unknown }).id) };
+  }
+  return null;
+}
+
+export type RouteInput = {
+  difficulty?: Difficulty | string;
+  tiers?: TierMap;
+  baseModel?: { provider: string; id: string } | string | null;
+  // Convenience: pass config + runState instead of tiers+baseModel
+  config?: HarnessConfig;
+  runState?: { baseModel?: { provider: string; id: string } | string | null } | null;
+};
+
+export type RouteResult = { provider: string; id: string; tier: TierId; askedTier: import("./types.ts").TierId | null };
+
+/**
+ * Resolve the asked model for one unit.
+ * Empty slot -> baseModel, never pi's default. Throws when no model can be resolved.
+ */
+export function routeModel(input: RouteInput): RouteResult {
+  const tiers: TierMap = input.tiers ?? (input.config ? tiersOf(input.config) : {});
+  const base = baseModelOf(input.runState ?? (input.baseModel ? { baseModel: input.baseModel } : null));
+  const diff = (input.difficulty as Difficulty | undefined) ?? undefined;
+  let tier: TierId | null = null;
+  if (diff && diff in DIFF_TO_TIER) tier = DIFF_TO_TIER[diff as Difficulty];
+  if (!tier) tier = "A"; // general work -> A
+  const spec: TierSpec | undefined = (tiers as Record<string, TierSpec | undefined>)[tier];
+  if (spec && spec.provider && spec.id) return { provider: spec.provider, id: spec.id, tier: tier!, askedTier: tier };
+  if (base) return { provider: base.provider, id: base.id, tier: tier!, askedTier: null };
+  throw new Error(`no model for tier ${tier}: tiers empty and no baseModel`);
+}
+
+/**
+ * Unit-level difficulty for handoff buckets.
+ * When handoff is coarser than `task`, the bucket's hardest difficulty wins.
+ */
+export function effectiveDifficultyForTask(
+  plan: FeatureList,
+  taskId: string | { id?: string; key?: string; compositeKey?: string },
+  handoff?: string,
+): Difficulty | undefined {
+  const needle = typeof taskId === "string" ? taskId : (taskId?.key ?? taskId?.compositeKey ?? taskId?.id ?? "");
+  const hh = (handoff ?? "task") as string;
+  // Find the task and its feature
+  let target: { task: import("./types.ts").Task; featureId: string; effectivePhase?: string } | null = null;
+  for (const f of plan.features ?? []) {
+    for (const t of f.tasks ?? []) {
+      const comp = t.key ?? `${f.id}/${t.id}`;
+      if (t.id === needle || t.key === needle || comp === needle) {
+        const featPhase = (f as { phase?: string }).phase as string | undefined;
+        const taskPhase = (t as { phase?: string }).phase as string | undefined;
+        const eff = taskPhase ?? featPhase ?? "build";
+        target = { task: t, featureId: f.id, effectivePhase: eff };
+        break;
+      }
+    }
+    if (target) break;
+  }
+  if (!target) {
+    // Fallback: global hardest when target not found and handoff is coarse
+    if (hh === "off") return effectiveDifficultyForUnitFromTasks((plan.features ?? []).flatMap(f => f.tasks ?? []) as Array<{ difficulty?: Difficulty }>);
+    return undefined;
+  }
+  const own = (target.task as { difficulty?: Difficulty }).difficulty;
+  if (hh === "task" || hh === "subtask" || hh === "off") {
+    if (hh === "off") {
+      const all = (plan.features ?? []).flatMap(f => f.tasks ?? []) as Array<{ difficulty?: Difficulty }>;
+      return effectiveDifficultyForUnitFromTasks(all) ?? own;
+    }
+    return own;
+  }
+  let bucket: Array<{ difficulty?: Difficulty }> = [];
+  const all = (plan.features ?? []).flatMap(f => f.tasks ?? []) as Array<{ difficulty?: Difficulty } & { effectivePhase?: string; featureId?: string }>;
+  if (hh === "phase") {
+    const phase = target.effectivePhase ?? "build";
+    for (const f of plan.features ?? []) {
+      const fp = (f as { phase?: string }).phase as string | undefined;
+      for (const t of f.tasks ?? []) {
+        const tp = (t as { phase?: string }).phase as string | undefined;
+        const eff = tp ?? fp ?? "build";
+        if (eff === phase) bucket.push(t as { difficulty?: Difficulty });
+      }
+    }
+  } else if (hh === "feature") {
+    const feat = plan.features.find(f => f.id === target!.featureId);
+    bucket = (feat?.tasks ?? []) as Array<{ difficulty?: Difficulty }>;
+  } else if (hh === "sprint") {
+    const feat = plan.features.find(f => f.id === target!.featureId) as { sprintId?: string } | undefined;
+    const sid = feat?.sprintId;
+    if (!sid) return own;
+    for (const f of plan.features ?? []) if ((f as { sprintId?: string }).sprintId === sid) bucket.push(...((f.tasks ?? []) as Array<{ difficulty?: Difficulty }>));
+  } else if (hh === "goal") {
+    // Simplify: goal = global hardest (goals span features via sprint)
+    const all2 = (plan.features ?? []).flatMap(f => f.tasks ?? []) as Array<{ difficulty?: Difficulty }>;
+    return effectiveDifficultyForUnitFromTasks(all2) ?? own;
+  }
+  return effectiveDifficultyForUnitFromTasks(bucket) ?? own;
+}
+

package/src/core/paths.ts

@@ -46,6 +46,26 @@ export function featureListPath(targetDir: string): string {
   return resolve(harnessDir(targetDir), "features", "feature-list.json");
 }
 
+export function planPath(targetDir: string): string {
+  return resolve(harnessDir(targetDir), "plan.json");
+}
+
+export function daemonPath(targetDir: string): string {
+  return resolve(harnessDir(targetDir), "daemon.json");
+}
+
+export function supervisorPath(targetDir: string): string {
+  return resolve(harnessDir(targetDir), "supervisor.json");
+}
+
+export function activityPath(targetDir: string): string {
+  return resolve(harnessDir(targetDir), "activity.json");
+}
+
+export function sessionsDir(targetDir: string): string {
+  return resolve(harnessDir(targetDir), "sessions");
+}
+
 export function progressPath(targetDir: string): string {
   return resolve(harnessDir(targetDir), "progress.md");
 }
@@ -124,6 +144,15 @@ export function agentDocPath(targetDir: string, role: string): string {
   return resolve(docsDir(targetDir), "agents", `${role}.md`);
 }
 
+/** Per-worker worktree root; git worktree per concurrent worker when isolation=worktree. */
+export function worktreesDir(targetDir: string): string {
+  return resolve(harnessDir(targetDir), "worktrees");
+}
+
+export function worktreePath(targetDir: string, branch: string): string {
+  return resolve(worktreesDir(targetDir), branch.replace(/[^a-zA-Z0-9._-]/g, "-"));
+}
+
 /** Root for per-run worker isolation. Always inside the project, always ignorable. */
 export function runRoot(targetDir: string): string {
   return resolve(targetDir, "tmp", "infinity-harness");

package/src/core/plan.ts

@@ -0,0 +1,39 @@
+/**
+ * infinity-harness — plan.ts (canonical) — re-export / wrapper around featureList.ts.
+ *
+ * v3 canonical path is `harness/plan.json`. The module `featureList.ts` already
+ * implements the canonical load/save with legacy fallback and stub handling;
+ * this file is the name the architecture calls "plan.ts" — one file, one name,
+ * matching the 5-level hierarchy.
+ *
+ * Keeping `featureList.ts` as the real implementation avoids churning every
+ * import in one commit; this shim means `import { loadPlan } from "./plan.ts"`
+ * and `import { loadFeatureList } from "./featureList.ts"` both work and
+ * point at the same truth.
+ */
+
+export {
+  emptyFeatureList,
+  validateKey,
+  normalizeStatus,
+  normalizeSubtaskStatus,
+  isDone,
+  resolvePlanFile,
+  loadFeatureList,
+  loadFeatureList as loadPlan,
+  saveFeatureList,
+  saveFeatureList as savePlan,
+  flattenTasks,
+  findTask,
+  findFeature,
+  tasksForPhase,
+  featuresForPhase,
+  computeProgress,
+  nextActionableTask,
+  detectCycle,
+  MAX_TASKS,
+  MAX_DEPENDS_ON,
+  MAX_SUBJECT_LEN,
+  MAX_DESCRIPTION_LEN,
+} from "./featureList.ts";
+export type { LoadedFeatureList, FlatTask, Progress } from "./featureList.ts";

package/src/core/runState.ts

@@ -0,0 +1,151 @@
+/**
+ * infinity-harness — core/runState.ts (Core owns type + path, Daemon owns writes).
+ *
+ * v2.7's `src/runState.ts` had { armed, runId, startedAt, sessions, stoppedAt, stopReason }.
+ * v3 extends it with: baseModel, tiers (preflight results), budget (byTier UsageTotals + caps).
+ * Existing fields are kept; the file stays `harness/run.json`.
+ *
+ * Core owns the type, the path spelling, and the read helpers used by Interfaces.
+ * Daemon owns the writes (arm, heartbeat, budget, preflight) — but the types
+ * are here so Interfaces and Core can read the same truth without importing
+ * the Daemon.
+ */
+
+import { runStatePath } from "./paths.ts";
+import { readJsonSafe, writeJsonAtomic, removeFile } from "./fsx.ts";
+
+export type ProviderModel = { provider: string; id: string; thinkingLevel?: string };
+
+export type TierPreflight = { provider: string; id: string; preflight: "ok" | "fail"; servedModel?: string; reason?: string };
+
+export type TierResults = Partial<Record<"A" | "B" | "C" | "D" | "X", TierPreflight>>;
+
+export type UsageTotals = { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number; calls: number };
+
+export function createUsageTotals(): UsageTotals {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, calls: 0 };
+}
+
+export type Budget = {
+  byTier: Partial<Record<"A" | "B" | "C" | "D" | "X", UsageTotals>>;
+  cap: { totalTokens?: number | null; costUsd?: number | null; wallClockMs?: number | null };
+  stopOnExhaustion?: boolean;
+};
+
+export type RunState = {
+  armed: boolean;
+  runId: string;
+  startedAt: string;
+  sessions: number;
+  stoppedAt: string | null;
+  stopReason: string | null;
+  /** Captured from ctx.model at arm time. The detached Daemon has no ctx. */
+  baseModel: ProviderModel | null;
+  /** Preflight outcome per tier. A failing tier blocks arming. */
+  tiers: TierResults;
+  /** Per-tier spend and caps. X outside consultation is a defect signal, not a budget. */
+  budget: Budget;
+  wallClockMs?: number;
+  escalation?: { level: string | null; since: string | null };
+};
+
+export function newRunState(runId: string, now = new Date()): RunState {
+  return {
+    armed: true,
+    runId,
+    startedAt: now.toISOString(),
+    sessions: 1,
+    stoppedAt: null,
+    stopReason: null,
+    baseModel: null,
+    tiers: {},
+    budget: { byTier: {}, cap: {}, stopOnExhaustion: true },
+  };
+}
+
+export function loadRunState(targetDir: string): RunState | null {
+  const raw = readJsonSafe<Record<string, unknown> | null>(runStatePath(targetDir), null);
+  if (!raw || typeof raw.runId !== "string" || !raw.runId) return null;
+  const sessions = typeof raw.sessions === "number" && (raw.sessions as number) > 0 ? (raw.sessions as number) : 1;
+  // Back-compat: older file had no baseModel/tiers/budget — treat as null/empty.
+  const baseModel = (() => {
+    const bm = (raw as Record<string, unknown>).baseModel;
+    if (!bm || typeof bm !== "object" || Array.isArray(bm)) return null;
+    const b = bm as Record<string, unknown>;
+    if (typeof b.provider === "string" && typeof b.id === "string") return { provider: String(b.provider), id: String(b.id), ...(typeof b.thinkingLevel === "string" ? { thinkingLevel: b.thinkingLevel } : {}) } as ProviderModel;
+    // legacy: baseModel was a string "provider/id"
+    if (typeof raw.baseModel === "string" && String(raw.baseModel).trim()) {
+      const s = String(raw.baseModel).trim();
+      const parts = s.split("/");
+      if (parts.length >= 2) return { provider: parts[0]!, id: parts.slice(1).join("/") };
+      return { provider: "anthropic", id: s };
+    }
+    return null;
+  })();
+  const tiersRaw = (raw as Record<string, unknown>).tiers;
+  const tiers: TierResults = (tiersRaw && typeof tiersRaw === "object" && !Array.isArray(tiersRaw) ? tiersRaw : {}) as TierResults;
+  const budgetRaw = (raw as Record<string, unknown>).budget;
+  const budget: Budget = (budgetRaw && typeof budgetRaw === "object" && !Array.isArray(budgetRaw)
+    ? budgetRaw as Budget
+    : { byTier: {}, cap: {}, stopOnExhaustion: true });
+  if (!budget.byTier || typeof budget.byTier !== "object") budget.byTier = {};
+  if (!budget.cap || typeof budget.cap !== "object") budget.cap = {};
+  return {
+    armed: raw.armed === true,
+    runId: raw.runId as string,
+    startedAt: typeof raw.startedAt === "string" ? (raw.startedAt as string) : new Date(0).toISOString(),
+    sessions,
+    stoppedAt: typeof raw.stoppedAt === "string" ? (raw.stoppedAt as string) : null,
+    stopReason: typeof raw.stopReason === "string" ? (raw.stopReason as string) : null,
+    baseModel,
+    tiers,
+    budget,
+    ...(typeof (raw as Record<string, unknown>).wallClockMs === "number" ? { wallClockMs: (raw as Record<string, unknown>).wallClockMs as number } : {}),
+    ...(typeof (raw as Record<string, unknown>).escalation === "object" ? { escalation: (raw as Record<string, unknown>).escalation as RunState["escalation"] } : {}),
+  };
+}
+
+export function saveRunState(targetDir: string, state: RunState): void {
+  try { writeJsonAtomic(runStatePath(targetDir), state); } catch { /* run bookkeeping must not kill the session */ }
+}
+
+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;
+}
+
+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 */ }
+}
+
+export function runIdFor(targetDir: string, fallback: string): string {
+  const state = loadRunState(targetDir);
+  return state && state.armed ? state.runId : fallback;
+}
+
+/** Parse a legacy baseModel string "provider/id" into a ProviderModel. */
+export function parseBaseModelString(s: string | null | undefined): ProviderModel | null {
+  if (!s || !String(s).trim()) return null;
+  const str = String(s).trim();
+  const parts = str.split("/");
+  if (parts.length >= 2) return { provider: parts[0]!, id: parts.slice(1).join("/") };
+  return { provider: "anthropic", id: str };
+}

package/src/core/settings.ts

@@ -188,6 +188,125 @@ export const SETTINGS: SettingsGroup[] = [
         help: "A paused pipeline refuses to advance and stops the continuous run.",
         type: { kind: "boolean" },
       },
+      {
+        path: "pilot",
+        file: "config",
+        label: "Pilot",
+        help: "Run-level preset over per-phase modes. copilot every phase stops, autopilot builds without you, full is hands-off intake->SHIP.",
+        type: { kind: "choice", choices: ["copilot", "autopilot", "full"] },
+      },
+      {
+        path: "tiers.A.provider",
+        file: "config",
+        label: "Tier A provider",
+        help: "Provider for general harness work (orchestration, short-lived A workers).",
+        type: { kind: "text", placeholder: "anthropic", allowEmpty: true },
+      },
+      {
+        path: "tiers.A.id",
+        file: "config",
+        label: "Tier A model",
+        help: "Model id for tier A general work.",
+        type: { kind: "text", placeholder: "claude-sonnet-4-5", allowEmpty: true },
+      },
+      {
+        path: "tiers.B.provider",
+        file: "config",
+        label: "Tier B provider",
+        help: "Provider for easy tasks.",
+        type: { kind: "text", placeholder: "anthropic", allowEmpty: true },
+      },
+      {
+        path: "tiers.B.id",
+        file: "config",
+        label: "Tier B model",
+        help: "Model id for B (easy). Empty means use baseModel X.",
+        type: { kind: "text", placeholder: "claude-sonnet-4-5", allowEmpty: true },
+      },
+      {
+        path: "tiers.C.provider",
+        file: "config",
+        label: "Tier C provider",
+        help: "Provider for moderate tasks.",
+        type: { kind: "text", placeholder: "anthropic", allowEmpty: true },
+      },
+      {
+        path: "tiers.C.id",
+        file: "config",
+        label: "Tier C model",
+        help: "Model id for C (moderate).",
+        type: { kind: "text", placeholder: "claude-opus-4-5", allowEmpty: true },
+      },
+      {
+        path: "tiers.D.provider",
+        file: "config",
+        label: "Tier D provider",
+        help: "Provider for difficult tasks.",
+        type: { kind: "text", placeholder: "anthropic", allowEmpty: true },
+      },
+      {
+        path: "tiers.D.id",
+        file: "config",
+        label: "Tier D model",
+        help: "Model id for D (difficult).",
+        type: { kind: "text", placeholder: "claude-opus-4-5", allowEmpty: true },
+      },
+      {
+        path: "tiers.X.provider",
+        file: "config",
+        label: "Tier X provider",
+        help: "Provider for consultation / escalation (strongest).",
+        type: { kind: "text", placeholder: "anthropic", allowEmpty: true },
+      },
+      {
+        path: "tiers.X.id",
+        file: "config",
+        label: "Tier X model",
+        help: "Model id for X (consultation).",
+        type: { kind: "text", placeholder: "claude-opus-4-5", allowEmpty: true },
+      },
+      {
+        path: "limits.unitWallClockMs",
+        file: "config",
+        label: "Unit wall-clock ms",
+        help: "How long one worker may run before abort + dispose. Default 30m.",
+        type: { kind: "number", min: 60000, max: 7200000, unit: "ms" },
+      },
+      {
+        path: "limits.maxRecycles",
+        file: "config",
+        label: "Max recycles",
+        help: "How many compaction recycles one unit tolerates before stopping. Default 2.",
+        type: { kind: "number", min: 0, max: 10 },
+      },
+      {
+        path: "limits.maxReworkPerUnit",
+        file: "config",
+        label: "Max rework per unit",
+        help: "How many times a unit may go back to rework. Default 2.",
+        type: { kind: "number", min: 0, max: 10 },
+      },
+      {
+        path: "limits.maxReplansPerPhase",
+        file: "config",
+        label: "Max replans per phase",
+        help: "How many plan mutations a phase may have. Default 3.",
+        type: { kind: "number", min: 0, max: 10 },
+      },
+      {
+        path: "limits.tokenCap",
+        file: "config",
+        label: "Token cap",
+        help: "Total tokens before the run stops. Null means unconstrained.",
+        type: { kind: "number", min: 1000, max: 100000000 },
+      },
+      {
+        path: "limits.costCap",
+        file: "config",
+        label: "Cost cap USD",
+        help: "Spend ceiling across A/B/C/D/X. Null means unconstrained.",
+        type: { kind: "number", min: 0, max: 100000 },
+      },
     ],
   },
   {
@@ -375,22 +494,36 @@ 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.",
+    help: "Who does the work, how many at once, and at which level. The session you are typing in is a control panel; background workers do the real work.",
     settings: [
+      {
+        path: "execution.engine",
+        file: "config",
+        label: "Where work runs",
+        help: "background: every unit of work runs in its own pi session with its own model, and this session spends no tokens on it (recommended) · main-session: the old behaviour, everything runs here on your model.",
+        type: { kind: "choice", choices: ["background", "main-session"] },
+      },
       {
         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.",
+        help: "The plan-phase for parallel work. The background engine runs one worker until worktrees land, so this is only the future parallelism knob.",
         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.",
+        help: "Hard cap on concurrent workers (1..16). Guarded by lock and budget; 1 until worktrees exist. Effective from Daemon.",
         type: { kind: "number", min: 1, max: 16 },
       },
+      {
+        path: "execution.isolation",
+        file: "config",
+        label: "Isolation",
+        help: "How concurrent workers stay out of each others way. none forces maxWorkers=1 and no worktree.",
+        type: { kind: "choice", choices: ["worktree", "none"] },
+      },
     ],
   },
   {
@@ -458,7 +591,7 @@ export const SETTINGS: SettingsGroup[] = [
         path: "gates.antiPlaceholder.enabled",
         file: "config",
         label: "Reject placeholders",
-        help: "Fail the gate on TODO-implement, FIXME, 'not implemented' and friends in source.",
+        help: "Fail the gate when source still has unfinished markers.",
         type: { kind: "boolean" },
       },
     ],
@@ -674,6 +807,7 @@ export function writeSetting(targetDir: string, setting: Setting, value: unknown
 
 /** How a value is shown in the menu. Empty model slots read as inherited. */
 export function formatValue(setting: Setting, value: unknown): string {
+  if (setting.path === "execution.isolation") return typeof value === "string" && value.trim() ? value : "worktree";
   switch (setting.type.kind) {
     case "boolean":
       return value ? "on" : "off";

package/src/core/types.ts

@@ -74,6 +74,22 @@ export type SubtaskStatus = (typeof SUBTASK_STATUSES)[number];
 
 export type Difficulty = "easy" | "moderate" | "difficult";
 
+export type PilotMode = "copilot" | "autopilot" | "full";
+
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+
+export type TierSpec = {
+  provider: string;
+  id: string;
+  thinkingLevel?: ThinkingLevel | "";
+};
+
+export type TierId = "A" | "B" | "C" | "D" | "X";
+
+export type TierMap = Partial<Record<TierId, TierSpec>>;
+
+export type ExecutionIsolation = "worktree" | "none";
+
 // ── Feature list (the SSOT on disk) ─────────────────────────────────────────
 
 export type Subtask = {
@@ -95,6 +111,8 @@ export type Task = {
   difficulty?: Difficulty;
   modelHint?: string;
   criteria?: string[];
+  /** When true this task must run alone — whole-tree isolation (lockfile regen, codemod). */
+  serialize?: boolean;
   /** Free-form extras are preserved verbatim on round-trip. */
   [k: string]: unknown;
 };
@@ -168,12 +186,30 @@ export type RetryLevel = (typeof RETRY_LEVELS)[number];
 export type HandoffGranularity = "off" | "goal" | "phase" | "sprint" | "feature" | "task" | "subtask";
 
 export type ExecutionPolicy = {
+  /**
+   * Who actually does the work.
+   *
+   * `background` — the default, and the reason this harness exists. Each unit
+   * of work runs in its own `pi` process with its own model and its own
+   * context window; the session the human is typing into stays a control
+   * panel and spends no tokens on the run.
+   *
+   * `main-session` — the pre-2.7 behaviour, kept because a run on a machine
+   * that cannot spawn a second pi still has to be able to work. Everything
+   * happens in the human's session, on the human's model.
+   */
+  engine: ExecutionEngine;
   /** 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;
+  /** How concurrent workers stay out of each other's way. */
+  isolation: ExecutionIsolation;
 };
 
+export type ExecutionEngine = "background" | "main-session";
+export const EXECUTION_ENGINES: readonly ExecutionEngine[] = ["background", "main-session"] as const;
+
 export type SessionPolicy = {
   /**
    * When to hand off to a fresh session.
@@ -303,6 +339,19 @@ export type HarnessConfig = {
   workflow: { id: string; name: string } | null;
   display: DisplayPolicy;
   intake: IntakeState;
+  /** Run-level pilot preset over per-phase modes. `full` = hands-off intake→SHIP. */
+  pilot: PilotMode;
+  /** Tier definitions A/B/C/D/X. Each is provider+id+thinking. Empty means use baseModel. */
+  tiers: TierMap;
+  /** Global caps that bound a run. */
+  limits: {
+    unitWallClockMs: number;
+    maxRecycles: number;
+    maxReworkPerUnit: number;
+    maxReplansPerPhase: number;
+    tokenCap: number | null;
+    costCap: number | null;
+  };
   /** Set when a gate passed but the phase needs a human signature first. */
   awaitingApproval: Phase | null;
   /** Budgets that bound an unattended continuous run. See src/loop.ts. */