infinity-harness 2.6.5 → 2.7.0

package/src/core/gates.ts

@@ -336,8 +336,10 @@ async function checkNoEmptyDirs({ targetDir }: Ctx): Promise<CheckResult> {
 async function checkFeatureCriteria({ targetDir }: Ctx): Promise<CheckResult> {
   const { list } = loadFeatureList(targetDir);
   // Seeded starter features (phase-*) are scaffolding, not real features — ignore for criteria gate.
+  // Also: if no non-scaffold features exist yet, DEFINE has not been planned and must not PASS on a
+  // single phase-* dummy. Treat absent as FAIL with a distinct detail so callers seeding define know to act.
   const features = (list.features ?? []).filter((f) => !(f as { phase?: string }).phase);
-  if (features.length === 0) return fail("feature-criteria", "no features planned yet");
+  if (features.length === 0) return fail("feature-criteria", "no real features planned yet — run DEFINE");
   const missing = features.filter((f) => !(f.criteria ?? []).length).map((f) => f.id);
   return missing.length === 0
     ? pass("feature-criteria", `${features.length} feature(s) have criteria`)
@@ -381,10 +383,9 @@ type Check = (ctx: Ctx) => Promise<CheckResult>;
 
 const PHASE_CHECKS: Record<Phase, Check[]> = {
   init: [checkGitRepo, checkConfigExists],
-  // Generic: tasks + doc on every phase — RESEARCH no longer doc-only, DEFINE/PLAN no longer doc-only.
-  // tasksComplete is advisory on define/plan/research so seeded tasks stay visible without freezing
-  // the synthetic mkSatisfiableProject walk that never completes seeded tasks. The dashboard widget
-  // still shows ... subtasks and progress as the real signal; BUILD keeps tasksComplete blocking.
+  // tasksComplete is advisory on seeded-phase gates only when seeded work exists — otherwise the
+  // converge walk would freeze on the seeded define/plan tasks that test never completes. Once BUILD
+  // has tasksComplete remains blocking.
   research: [checkResearchDoc],
   define: [checkFeatureCriteria, checkSkillsLoad],
   plan: [checkFeatureCriteria, checkTasksPlanned],

package/src/core/phases.ts

@@ -217,6 +217,15 @@ function startersForPhase(dir: string, phase: string): StarterTask[] {
   return STARTER_TASKS_BY_DEPTH[DEFAULT_RESEARCH_DEPTH] ?? [];
 }
 
+export function ensurePhaseSeeded(dir: string, phase: import("./types.ts").Phase): boolean {
+  try {
+    const { list } = loadFeatureList(dir);
+    if (tasksForPhase(list, phase).length > 0) return false;
+    const r = seedPhaseIfEmpty(dir, phase);
+    return r.seeded;
+  } catch { return false; }
+}
+
 export function seedPhaseIfEmpty(dir: string, phase: import("./types.ts").Phase): { seeded: boolean; error: string | null } {
   const seeded = startersForPhase(dir, phase);
   if (seeded.length === 0) return { seeded: false, error: null };
@@ -224,12 +233,10 @@ export function seedPhaseIfEmpty(dir: string, phase: import("./types.ts").Phase)
     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])
-    );
+    // Each phase gets its own feature (phase-<name>) so per-phase tabs/groups isolate correctly.
+    // Never append a "define" task to a "research" feature — the feature.phase is the grouping key.
+    const match = list.features.find((f) => (f as { phase?: string }).phase === phase);
+    const feature: typeof list.features[number] = match ?? ({ 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);

package/src/core/settings.ts

@@ -375,20 +375,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.",
+    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: "Legacy engine only. The background engine runs one unit at a time, in its own session, at the level you chose for session handoff.",
         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: "Legacy engine only. The background engine runs one worker; parallel background workers are not wired up yet.",
         type: { kind: "number", min: 1, max: 16 },
       },
     ],

package/src/core/types.ts

@@ -168,12 +168,28 @@ 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;
 };
 
+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.