infinity-harness 2.6.2 → 2.6.4

package/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to this project are documented here.
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.6.4] — 2026-08-25
+
+`feature-criteria` now ignores seeded `phase-*` scaffolding so `DEFINE` does not pass on the
+research seed alone. Same `phase` field, same `seedPhaseIfEmpty`, same worker path — just the gate.
+
+## [2.6.3] — 2026-08-25
+
+Research was shallow because it had no tasks — one search, doc, PASS. Now it follows the same
+mechanism as every other phase: three starter tasks `research/r1-3` with subtasks, same `seedPhaseIfEmpty`
+trigger on loop entry (0 tasks \& gate fails), same phase-scoped progress and same worker pickup
+(`scheduler` scoped to `research`). No special code for research. Synthetic `convergence` walk stays clean
+by only seeding when gate fails, so empty `DEFINE` test projects don't dirty.
+
 ## [2.6.2] — 2026-08-25
 
 Publish 2.6.1 left the tarball staged on the registry awaiting an attestation that never arrived; npm

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinity-harness",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "description": "A pi agent extension that runs a gated build pipeline unattended \u2014 enforces phases, validates with deterministic gates, and keeps working for hours or days without losing the plan.",
   "type": "module",
   "keywords": [

package/src/core/gates.ts

@@ -328,7 +328,8 @@ async function checkNoEmptyDirs({ targetDir }: Ctx): Promise<CheckResult> {
 /** Every feature must declare acceptance criteria before BUILD starts. */
 async function checkFeatureCriteria({ targetDir }: Ctx): Promise<CheckResult> {
   const { list } = loadFeatureList(targetDir);
-  const features = list.features ?? [];
+  // Seeded starter features (phase-*) are scaffolding, not real features — ignore for criteria gate.
+  const features = (list.features ?? []).filter((f) => !(f as { phase?: string }).phase);
   if (features.length === 0) return fail("feature-criteria", "no features planned yet");
   const missing = features.filter((f) => !(f.criteria ?? []).length).map((f) => f.id);
   return missing.length === 0
@@ -373,6 +374,10 @@ 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.
   research: [checkResearchDoc],
   define: [checkFeatureCriteria, checkSkillsLoad],
   plan: [checkFeatureCriteria, checkTasksPlanned],

package/src/core/phases.ts

@@ -129,18 +129,65 @@ export async function transitionPhase(targetDir: string, toPhase: Phase): Promis
 
 /** 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.
+ * Generic: every phase that is enabled and enters with 0 tasks gets starters —
+ * same code path, same trigger, no special case for research. BUILD/VERIFY
+ * already have tasks from PLAN so they are not seeded; RESEARCH was shallow
+ * because it had no tasks — now it does.
  */
-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.
+export type StarterTask = {
+  id: string;
+  description: string;
+  difficulty: "easy" | "moderate" | "difficult";
+  subtasks?: string[];
+};
+export const STARTER_TASKS: Record<string, StarterTask[]> = {
+  research: [
+    {
+      id: "research/r1",
+      description: "Collect prior art — 3 sources, what exists, where it stops",
+      difficulty: "moderate",
+      subtasks: ["source 1 + summary", "source 2 + summary", "source 3 + summary"],
+    },
+    {
+      id: "research/r2",
+      description: "Name constraints (given vs inferred) and lay out 2+ options with costs",
+      difficulty: "moderate",
+      subtasks: ["constraints given vs inferred", "option A cost/benefit", "option B cost/benefit"],
+    },
+    {
+      id: "research/r3",
+      description: "Recommend one option, falsification condition, and open questions for DEFINE",
+      difficulty: "moderate",
+      subtasks: ["recommendation + falsification", "open questions list"],
+    },
+  ],
   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" },
+    {
+      id: "define/d1",
+      description: "Interview scope and write bounded PRD + acceptance criteria",
+      difficulty: "moderate",
+      subtasks: ["scope interview", "PRD draft", "acceptance criteria per feature"],
+    },
+    {
+      id: "define/d2",
+      description: "Record sprint contract and branch (not main)",
+      difficulty: "easy",
+      subtasks: ["sprint contract", "feature branch"],
+    },
   ],
   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" },
+    {
+      id: "plan/p1",
+      description: "Break each feature into ordered, dependency-aware tasks",
+      difficulty: "moderate",
+      subtasks: ["vertical slices", "dependency graph", "difficulty + subtasks"],
+    },
+    {
+      id: "plan/p2",
+      description: "Commit plan (feature-list) and validate",
+      difficulty: "easy",
+      subtasks: ["feature-list.json commit", "validate gate"],
+    },
   ],
 };
 
@@ -175,8 +222,13 @@ export function seedPhaseIfEmpty(dir: string, phase: import("./types.ts").Phase)
         status: "pending" as const,
         phase,
         difficulty: t.difficulty,
+        subtasks: (t.subtasks ?? []).map((title: string) => ({ title, status: "pending" as const })),
       } as any);
     }
+    // Newly created phase-features default to criteria so DEFINE gate doesn't fail on 'phase-define missing criteria'.
+    if (Array.isArray(feature.criteria) && feature.criteria.length === 0) {
+      feature.criteria = [`${phase} ready for review`];
+    }
     list.baseRevision = (list.baseRevision ?? 0) + 1;
     saveFeatureList(dir, list);
     return { seeded: true, error: null };

package/src/loop.ts

@@ -275,19 +275,13 @@ 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.
+  // 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.
   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);
       }