infinity-harness 2.8.0 → 2.8.2

package/CHANGELOG.md

@@ -4,6 +4,28 @@ 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.8.2] — 2026-08-30
+
+Republishes 2.8.1. The 2.8.1 tarball on disk and on the registry was built from 2.8.0 content while `package.json` already said 2.8.1, so `/infinity:init` still auto-started RESEARCH in your session and the wizard never asked `Start the run now?`. No code changes since `v2.8.1` (`81d16590`).
+
+### Fixed
+
+- **Stale 2.8.1 artifact.** Rebuilt from `HEAD` so the `launchNow` wizard step, the parked-by-default `NOT running — /infinity:run` opener, and the `controlPanelContract` are in the published package.
+
+## [2.8.1] — 2026-08-30
+
+Init no longer steals your session. The harness only runs when you say so.
+
+### Fixed
+
+- **"/infinity:init" auto-started research in your session.** After the wizard, the extension sent the RESEARCH brief as followUp, so FullAuto began doing RESEARCH in the same session that just created the harness — before you could decide to walk away. The harness is now parked after init. The opener says "harness is NOT running — /infinity:run starts it" and the agent is idle in control-panel mode, regardless of workflow or phase.
+
+- **No way to go straight from init to running.** The wizard now asks a final question "Start the run now?" ("yes — start the run now" / "no — I will run /infinity:run when ready"). Saying yes arms harness/run.json, captures baseModel for the daemon, and spawns the detached daemon (or the in-process supervisor fallback) — the same path as "/infinity:run". Saying no (or an unattended init or old scripted harness with no answer) stays parked.
+
+### Changed
+
+- Opener after init always names the next command. With a goal it shows the RESEARCH or DEFINE brief plus "NOT running — /infinity:run"; without a goal it asks for the goal first, then the same tagline.
+
 ## [2.8.0] — 2026-08-30
 
 The harness stops shipping its own run. The repo is the driver, not the project.

package/extensions/infinity-harness/index.ts

@@ -1826,15 +1826,73 @@ export default function (pi: ExtensionAPI): void {
       notify(ctx, lines.join("\n"), plan.warnings.length ? "warning" : "info");
       refreshWidget(ctx);
 
-      // Hand the model the brief straight away, so the session that created
-      // the harness is also the session that starts using it. Without a goal
-      // the first thing it must do is ask for one — never guess one.
-      const brief = await briefText(dir);
-      const opener = plan.brief
-        ? brief
-        : `The human has not said what they want built yet. Ask them, in one short question, ` +
-          `and do not start any work or invent a scope until they answer.\n\n${brief}`;
-      pi.sendUserMessage(opener, { deliverAs: "followUp" });
+      // Show the next step, but do NOT auto-start the run.
+      // After /infinity:init the harness is initialized and parked.
+      // The agent can answer questions in this session, but the pipeline
+      // only runs after the human says so: /infinity:run (or "yes" to the
+      // last wizard question). Auto-starting here is the bug that made
+      // full-auto research steal the session that just created the harness.
+      if ((wizard as { launchNow?: boolean }).launchNow) {
+        // Opt-in: wizard asked "Start the run now?" and the human said yes.
+        armRun(dir, sessionId);
+        // Capture baseModel for daemon (same as /infinity:run does)
+        try {
+          const bm = baseModelOf(ctx);
+          if (bm) {
+            const { loadRunState: _ld, saveRunState: _sv, runIdFor: _rf } = await import("../../src/core/runState.ts");
+            const rid = _rf(dir, sessionId);
+            const rs = _ld(dir);
+            const parts = bm.split("/");
+            const baseModel = parts.length >= 2 ? { provider: parts[0]!, id: parts.slice(1).join("/") } : { provider: "anthropic", id: bm };
+            if (rs) { (rs as unknown as { baseModel: unknown }).baseModel = baseModel; _sv(dir, rs); }
+            else { const { newRunState } = await import("../../src/core/runState.ts"); const ns = newRunState(rid); (ns as unknown as { baseModel: unknown }).baseModel = baseModel; _sv(dir, ns); }
+          }
+        } catch {}
+        // Try detached daemon, fall back to supervisor in this pi session.
+        const tryDaemonSpawn = async (): Promise<{ spawned: boolean }> => {
+          try {
+            const { spawn: _sp } = await import("node:child_process");
+            const { existsSync: _ex, openSync: _op, closeSync: _cl } = await import("node:fs");
+            const { resolve: _re } = await import("node:path");
+            const cands = [_re(dir, "dist/daemon/index.js"), _re(dir, "src/daemon/index.ts")];
+            let entry: string | null = null;
+            for (const c of cands) if (_ex(c)) { entry = c; break; }
+            if (!entry) return { spawned: false };
+            try { const { loadDaemon: _ld, isDaemonAlive: _al } = await import("../../src/daemon/guard.ts"); const live = _ld(dir); if (live && _al(live)) return { spawned: true }; } catch {}
+            const fd = _op(_re(dir, "harness/daemon.log"), "a");
+            const a: string[] = [];
+            if (entry.endsWith(".ts")) a.push("--experimental-strip-types", "--no-warnings=ExperimentalWarning");
+            a.push(entry, dir);
+            const ch = _sp(process.execPath, a, { detached: true, stdio: ["ignore", fd as unknown as number, fd as unknown as number], windowsHide: true, env: { ...process.env, INFINITY_HARNESS_WORKER: "1" } } as unknown as Parameters<typeof _sp>[2]);
+            try { ch.unref(); } catch {}
+            try { _cl(fd); } catch {}
+            for (let i = 0; i < 40; i++) { await new Promise(r=>setTimeout(r,250)); try { const { loadDaemon: l2, isDaemonAlive: a2 } = await import("../../src/daemon/guard.ts"); const v = l2(dir); if (v && a2(v)) return { spawned: true }; } catch {}
+            }
+            return { spawned: true };
+          } catch { return { spawned: false }; }
+        };
+        const dr = await tryDaemonSpawn();
+        if (!dr.spawned) await startEngine(ctx, dir);
+        notify(ctx, "infinity-harness: run armed — background run started. /infinity:halt stops it.", "info");
+      } else {
+        const brief = await briefText(dir);
+        if (!plan.brief) {
+          pi.sendUserMessage(
+            `The human has not said what they want built yet. Ask them, in one short question, and do not start any work or invent a scope until they answer. The harness is NOT running — "/infinity:run" starts it.\n\n${brief}`,
+            { deliverAs: "followUp" },
+          );
+        } else if (plan.phases[0] === "research") {
+          pi.sendUserMessage(
+            `${brief}\n\nThis is RESEARCH — survey constraints and options first, then validate (infinity_validate) to advance. The harness is NOT running yet. Run "/infinity:run" when you are ready, or answer "yes — start the run now" next time you init.`,
+            { deliverAs: "followUp" },
+          );
+        } else {
+          pi.sendUserMessage(
+            `${brief}\n\nThe harness is ready but NOT running. Run "/infinity:run" to start, or answer "yes — start the run now" in the wizard next time.`,
+            { deliverAs: "followUp" },
+          );
+        }
+      }
     },
   });
 

package/harness/docs/DECISIONS.md

@@ -1,110 +1,110 @@
-# Decisions
-
-Architectural decisions and the reasoning behind them. Outcomes without reasons are useless to the
-next person — record why, and what it cost.
-
----
-
-## 1. The gate is the only referee
-
-**Context.** An agent asked whether its work is finished will say yes. Repeatedly, and wrongly, over
-a long run.
-
-**Decision.** Completion is decided by deterministic checks that are a pure function of the project
-on disk. The agent cannot mark its own work complete, and the extension blocks hand-edits to
-`currentPhase` while the gate is failing.
-
-**Cost.** Gates must be cheap enough to run every iteration, and must never fail for a reason the
-agent cannot fix — a gate that deadlocks the loop is worse than no gate. Hence advisory checks:
-an unconfigured lint command is reported, not enforced.
-
----
-
-## 2. Phases move forward, one step at a time
-
-**Decision.** `isValidTransition` permits only the next enabled phase, or re-running the current one.
-Backward movement exists only as an explicit, budgeted rework that records why it happened.
-
-**Why.** It removes a decision the model is bad at. Without it, a struggling agent reorders the
-pipeline to reach a phase whose gate it can pass.
-
----
-
-## 3. The plan is submitted whole; omission means deletion
-
-**Decision.** `infinity_plan` takes the complete task list, not a patch.
-
-**Why.** Incremental edits require the model to track what exists. Over hours it stops being able to:
-it re-adds deleted tasks, forgets others, and the file diverges from reality. A full submission is
-self-correcting, and one unambiguous rule beats a set of merge semantics nobody can predict.
-
-**Cost.** Every write carries the whole plan. Capped at 200 tasks, which is far beyond a sensible
-sprint.
-
----
-
-## 4. `baseRevision` is not a compare-and-swap
-
-**Context.** The original write did read → check `baseRevision` → write, with no mutual exclusion,
-and the docs claimed this protected parallel workers. It does not. Two processes that both read
-revision N both pass the check and both write N+1. Measured: 2 lost updates in a 6-way fan-out.
-
-**Decision.** `writeTaskList` holds an exclusive lock across the whole read-apply-write and fails
-closed — a write that cannot take the lock is refused, not raced.
-
-**Cost.** Plan writes serialise. The critical section is milliseconds, so this is not felt; a
-`LockTimeoutError` is retryable and names the stuck lock.
-
-**Also.** The sync lock uses `<path>.ilock`. `proper-lockfile` owns `<path>.lock` and it is a
-directory there too, so sharing the name made a nested async+sync lock deadlock against itself.
-
----
-
-## 5. One implementation, in `src/`
-
-**Context.** The extension carried inlined copies of the plan engine and the widget. The tests
-exercised `src/`; the shipped code path never called it. The two drifted, and the drift was
-invisible because the suite was green. The same pattern later reappeared in `rework.ts` and
-`replan.ts`, which kept private plan loaders — and one of them mishandled status aliases, rejecting
-every amendment to a plan that used `"done"`.
-
-**Decision.** `src/` is the single implementation. The extension owns pi's lifecycle and nothing
-else. A private `loadFeatureList` is a bug, not a shortcut.
-
----
-
-## 6. Knowing when to stop is the product
-
-**Decision.** The loop halts on no-progress, wall clock, iteration count, retry budgets, or a human
-brake — and every stop names its reason.
-
-**Why.** Continuing is trivial. The default failure mode of an autonomous loop with a weak model is
-re-running a failing gate against an unchanged tree until the budget is gone. The no-progress
-detector compares a fingerprint of the working tree and the plan; the first failing iteration is a
-baseline and never counts as a stall.
-
----
-
-## 7. Ship vendor-neutral defaults
-
-**Context.** The router shipped enabled, with one third-party vendor's model ids hardcoded in every
-slot.
-
-**Decision.** Routing is disabled by default and every slot is empty, meaning "use whatever model pi
-is already configured with". Installing an extension must never silently redirect someone's work to
-a model they did not choose.
-
----
-
-## 8. The dashboard cannot perturb the run
-
-**Decision.** Read-only, loopback-only, and it does not run the gate — it reports the last recorded
-verdict instead.
-
-**Why.** Running lint and the test suite because someone opened a web page is a surprising and
-expensive side effect. And a page rendering model output on a public interface leaks the project;
-binding elsewhere requires an explicit opt-in, and the CSP is tight enough that an escaping slip
-cannot become script execution.
+# Decisions
+
+Architectural decisions and the reasoning behind them. Outcomes without reasons are useless to the
+next person — record why, and what it cost.
+
+---
+
+## 1. The gate is the only referee
+
+**Context.** An agent asked whether its work is finished will say yes. Repeatedly, and wrongly, over
+a long run.
+
+**Decision.** Completion is decided by deterministic checks that are a pure function of the project
+on disk. The agent cannot mark its own work complete, and the extension blocks hand-edits to
+`currentPhase` while the gate is failing.
+
+**Cost.** Gates must be cheap enough to run every iteration, and must never fail for a reason the
+agent cannot fix — a gate that deadlocks the loop is worse than no gate. Hence advisory checks:
+an unconfigured lint command is reported, not enforced.
+
+---
+
+## 2. Phases move forward, one step at a time
+
+**Decision.** `isValidTransition` permits only the next enabled phase, or re-running the current one.
+Backward movement exists only as an explicit, budgeted rework that records why it happened.
+
+**Why.** It removes a decision the model is bad at. Without it, a struggling agent reorders the
+pipeline to reach a phase whose gate it can pass.
+
+---
+
+## 3. The plan is submitted whole; omission means deletion
+
+**Decision.** `infinity_plan` takes the complete task list, not a patch.
+
+**Why.** Incremental edits require the model to track what exists. Over hours it stops being able to:
+it re-adds deleted tasks, forgets others, and the file diverges from reality. A full submission is
+self-correcting, and one unambiguous rule beats a set of merge semantics nobody can predict.
+
+**Cost.** Every write carries the whole plan. Capped at 200 tasks, which is far beyond a sensible
+sprint.
+
+---
+
+## 4. `baseRevision` is not a compare-and-swap
+
+**Context.** The original write did read → check `baseRevision` → write, with no mutual exclusion,
+and the docs claimed this protected parallel workers. It does not. Two processes that both read
+revision N both pass the check and both write N+1. Measured: 2 lost updates in a 6-way fan-out.
+
+**Decision.** `writeTaskList` holds an exclusive lock across the whole read-apply-write and fails
+closed — a write that cannot take the lock is refused, not raced.
+
+**Cost.** Plan writes serialise. The critical section is milliseconds, so this is not felt; a
+`LockTimeoutError` is retryable and names the stuck lock.
+
+**Also.** The sync lock uses `<path>.ilock`. `proper-lockfile` owns `<path>.lock` and it is a
+directory there too, so sharing the name made a nested async+sync lock deadlock against itself.
+
+---
+
+## 5. One implementation, in `src/`
+
+**Context.** The extension carried inlined copies of the plan engine and the widget. The tests
+exercised `src/`; the shipped code path never called it. The two drifted, and the drift was
+invisible because the suite was green. The same pattern later reappeared in `rework.ts` and
+`replan.ts`, which kept private plan loaders — and one of them mishandled status aliases, rejecting
+every amendment to a plan that used `"done"`.
+
+**Decision.** `src/` is the single implementation. The extension owns pi's lifecycle and nothing
+else. A private `loadFeatureList` is a bug, not a shortcut.
+
+---
+
+## 6. Knowing when to stop is the product
+
+**Decision.** The loop halts on no-progress, wall clock, iteration count, retry budgets, or a human
+brake — and every stop names its reason.
+
+**Why.** Continuing is trivial. The default failure mode of an autonomous loop with a weak model is
+re-running a failing gate against an unchanged tree until the budget is gone. The no-progress
+detector compares a fingerprint of the working tree and the plan; the first failing iteration is a
+baseline and never counts as a stall.
+
+---
+
+## 7. Ship vendor-neutral defaults
+
+**Context.** The router shipped enabled, with one third-party vendor's model ids hardcoded in every
+slot.
+
+**Decision.** Routing is disabled by default and every slot is empty, meaning "use whatever model pi
+is already configured with". Installing an extension must never silently redirect someone's work to
+a model they did not choose.
+
+---
+
+## 8. The dashboard cannot perturb the run
+
+**Decision.** Read-only, loopback-only, and it does not run the gate — it reports the last recorded
+verdict instead.
+
+**Why.** Running lint and the test suite because someone opened a web page is a surprising and
+expensive side effect. And a page rendering model output on a public interface leaks the project;
+binding elsewhere requires an explicit opt-in, and the CSP is tight enough that an escaping slip
+cannot become script execution.
 
 ---
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infinity-harness",
-  "version": "2.8.0",
-  "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.",
+  "version": "2.8.2",
+  "description": "A pi agent extension that runs a gated build pipeline unattended — enforces phases, validates with deterministic gates, and keeps working for hours or days without losing the plan.",
   "type": "module",
   "keywords": [
     "pi-package",

package/src/ui/wizard.ts

@@ -66,7 +66,7 @@ export type WizardOptions = {
 
 export type WizardResult =
   | { cancelled: true }
-  | { cancelled: false; plan: IntakePlan; answers: IntakeAnswers };
+  | { cancelled: false; plan: IntakePlan; answers: IntakeAnswers; launchNow?: boolean };
 
 const CONFIRM = "start with these settings";
 const RESTART = "change something";
@@ -267,7 +267,7 @@ export async function runIntakeWizard(options: WizardOptions): Promise<WizardRes
     const answers: IntakeAnswers = { workflow, researchDepth, brief, handoff, display, router: modelsAnswer.router, parallelAt, maxWorkers };
     const plan = planIntake(answers);
 
-    if (options.skipConfirm) return { cancelled: false, plan, answers };
+    if (options.skipConfirm) return { cancelled: false, plan, answers, launchNow: false };
 
     const body = [plan.summary, ...(plan.warnings.length ? ["", ...plan.warnings.map((w) => `! ${w}`)] : [])].join(
       "\n",
@@ -277,7 +277,16 @@ export async function runIntakeWizard(options: WizardOptions): Promise<WizardRes
     const confirm = await prompt.select("Ready?", [CONFIRM, RESTART, CANCEL]);
     if (confirm === undefined || confirm === CANCEL) return { cancelled: true };
     if (confirm === RESTART) continue;
-    return { cancelled: false, plan, answers };
+    // Last step: ask whether to arm and start immediately (opt-in).
+    // After init the harness is never auto-started — only /infinity:run (or
+    // "yes" here) arms it. Older tests/E2E scripts that do not answer this
+    // are treated as "later" so they keep passing.
+    const LAUNCH_NOW = "yes — start the run now";
+    const LAUNCH_LATER = "no — I'll run /infinity:run when ready";
+    const launchPick = await prompt.select("Start the run now?", [LAUNCH_NOW, LAUNCH_LATER]);
+    let launchNow = false;
+    if (launchPick !== undefined) launchNow = launchPick === LAUNCH_NOW;
+    return { cancelled: false, plan, answers, launchNow };
   }
 }