infinity-harness 2.3.1 → 2.4.0

package/CHANGELOG.md

@@ -4,6 +4,70 @@ 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.4.0] — 2026-08-24
+
+Two settings that were one switch each, and one switch turned out to be the wrong shape for both
+questions.
+
+### Added
+
+- **A mode per phase, not a mode per run.** "copilot" and "autopilot" could not say "let it define
+  and plan on its own but show me the review", and that is a thing people want. Every phase now
+  carries its own mode: `autopilot` advances when the gate passes, `copilot` stops and waits for
+  your signature. The two familiar words survive as two named points in that space rather than the
+  only two points in it, and every phase except INIT can be a checkpoint — the three that decide
+  *what gets built* are the ones that usually pay for themselves, but that is a default rather than
+  a limit.
+
+- **Five workflows ship, and you can build your own.** `copilot`, `autopilot`, `spec and ship`
+  (you sign the scope going in and the release coming out), `research first`, and `every gate`.
+  Building one is its own short flow: pick the phases, then say for each whether it stops for you.
+  Name it and it is kept — in `~/.pi/agent/infinity-harness/`, with *you* rather than with the
+  project, because a workflow you designed is worth as much on the next one. It is then the first
+  thing offered there.
+
+  Built-ins are read-only, and their names cannot be taken. "copilot" has to mean the same thing in
+  every conversation about this tool; someone who wants a different copilot makes their own and
+  gives it their own name.
+
+- **`/infinity:workflow`** — choose one, build one, switch by name (`/infinity:workflow
+  spec-and-ship`), or `list` what is available and what you are on. `/infinity:config` →
+  **Workflow** edits one phase at a time. All of it changes at any time and takes effect at the next
+  gate: three phases into a run is exactly when someone realises they do want to see the review.
+
+- **Display templates.** Shipping all five plan levels to everyone was the wrong answer for the same
+  reason shipping two was: one person works in sprints and never opens a subtask, the next has no
+  sprints and lives in the subtask list. Four ship — `focus`, `everything`, `overview` (the shape,
+  no tasks), `worklist` (tasks only, no rail) — and anything else is chosen level by level: the
+  five plan levels, the `done/total` counts, the `← #3` dependency labels, the acceptance criteria,
+  the phase rail, the progress meter, the alert strip, and how many rows the terminal shows before
+  it scrolls. Name what you end up with and it is saved with you like a workflow.
+
+- **`/infinity:display`** — pick a template, choose level by level, switch by name, or `list`.
+  `/infinity:config` → **Display** edits the same things one at a time.
+
+- **The widget and the dashboard read the same setting.** Configure how you like to read a plan
+  once, not twice.
+
+### Changed
+
+- `harness/config.json` gains `phaseModes`, `workflow` and `display`. A 2.3 config is migrated on
+  read: its three-phase `approvals` becomes the equivalent modes and is labelled with the workflow
+  it amounts to, so a project mid-run keeps exactly the approvals it was configured with and nobody
+  has to edit JSON to upgrade. The legacy field is kept in step on write.
+- Hiding a plan level hides the row, never the work beneath it: turn off sprints on a plan organised
+  into sprints and the features move up one indent rather than vanishing, and task numbers do not
+  shift, so `← #3` still points at the same task. A task nobody can see is a task that gets stuck
+  forever.
+
+### Fixed
+
+- **`initHarness` ignored a caller that passed the old `approvals` shape** once `phaseModes`
+  existed, silently producing an autopilot run. It falls back to `approvals` when no modes are
+  given — the same rule `loadConfig` applies to an older file.
+
+---
+
 ## [2.3.1] — 2026-08-24
 
 *(2.3.0 was staged at the registry and never completed; 2.3.1 is that release plus the last two

package/README.md

@@ -100,11 +100,10 @@ It detects your stack and its lint/test/build commands, then asks you five quest
 
 | | |
 |---|---|
-| **How involved do you want to be?** | copilot — you approve the definition and the plan · autopilot — you choose what to approve, if anything |
-| **What are you building?** | One or two sentences. Asked in *both* modes, because a run with no goal has no business inventing one. |
-| **Research it first?** | Adds an optional RESEARCH phase before DEFINE: prior art, constraints, options with costs, a recommendation, and the questions only you can answer. |
-| **Which phases do you sign?** *(autopilot only)* | RESEARCH, DEFINE, PLAN — tick any, all or none. None is the walk-away setting. |
+| **Which workflow?** | A built-in, one you saved, or *build one* — pick the phases, then say for each whether it stops for you |
+| **What are you building?** | One or two sentences. Asked whatever the workflow, because a run with no goal has no business inventing one. |
 | **When should it start a fresh session?** | Every phase (default) · every task · never |
+| **How much of the plan on screen?** | A display template — `focus`, `everything`, `overview`, `worklist`, or level by level |
 
 Then it writes `harness/` — the config, an empty plan, the phase and role docs, and starters
 for the documents the review gate will demand — and hands the model its first brief. It never
@@ -134,14 +133,45 @@ the craft skills that match the work, and what to do next. Do the work, then:
 
 ## Who decides what
 
-The two words are about **who signs off**, not about how autonomous the agent is. Both modes
-run the same pipeline, the same gates and the same loop.
+"copilot" and "autopilot" used to be one switch, and one switch is the wrong shape for the
+question. What people actually want is per-phase: let the model define and plan on its own but
+show me the review; or grill me on the definition and then leave me alone until it ships. Two
+words cannot say that.
 
-| | copilot | autopilot |
-|---|---|---|
-| RESEARCH, DEFINE, PLAN | you approve each one | you pick which, if any |
-| Everything after PLAN | the gate decides | the gate decides |
-| When it is right | you care what gets built | you have said what you want and you are leaving |
+So the setting is a **mode per phase**, and the two familiar words are two named points in that
+space rather than the only two points in it.
+
+| Mode | When a phase's gate passes |
+|---|---|
+| `autopilot` | it advances |
+| `copilot` | it stops and waits for your signature |
+
+Five workflows ship with the package, and none of them can be edited — `copilot` has to mean the
+same thing in every conversation about this tool:
+
+| Workflow | Stops at |
+|---|---|
+| **copilot** | DEFINE, PLAN |
+| **autopilot** | nothing |
+| **spec and ship** | DEFINE, SHIP — you sign the scope going in and the release coming out |
+| **research first** | adds a RESEARCH phase, and stops on all three thinking phases |
+| **every gate** | every phase. Slowest, and the one you want on something that matters |
+
+Anything else you build yourself: pick the phases, then say for each whether it stops for you. Give
+it a name and it is saved with *you*, not with the project, so it is the first thing offered on your
+next one.
+
+```
+/infinity:workflow                 choose one, or build one
+/infinity:workflow spec-and-ship   switch to a named one, no menu
+/infinity:workflow list            what is available, and what you are on now
+```
+
+Any of it changes at any time and takes effect at the next gate — three phases into a run is
+exactly when someone realises they do want to see the review after all. `/infinity:config` →
+**Workflow** edits one phase at a time.
+
+### Signing a phase
 
 When a phase you signed up for passes its gate, the run **stops and asks you** rather than
 advancing. Approving continues it; answering with a sentence sends the phase back carrying your
@@ -152,9 +182,9 @@ words, so it is redone against your objection rather than redone identically:
 /infinity:approve the criteria say nothing about refunds
 ```
 
-A rejection is pinned to the state of the project when you made it, so the run will not ask you
-the same question again until the agent has actually changed something in response. If it never
-does, the run stops and says so instead of nagging forever.
+A rejection is pinned to the state of the project when you made it, so the run will not ask you the
+same question again until the agent has actually changed something in response. If it never does,
+the run stops and says so instead of nagging forever.
 
 ## One run, many sessions
 
@@ -224,7 +254,8 @@ valid; the menu is the same data with prompts and bounds checking attached.
 |---|---|
 | **Models** | Which model runs each difficulty tier, the master model, consultation budget |
 | **Pipeline** | Which phases run, copilot vs autopilot, role strictness, pause |
-| **Your approvals** | Which of RESEARCH / DEFINE / PLAN stop and wait for your signature |
+| **Workflow** | The mode for each phase — which of them stop and wait for your signature |
+| **Display** | Which plan levels and which chrome the widget and the dashboard draw |
 | **Sessions** | Fresh session per phase or per task, the context threshold, the carry note |
 | **Project commands** | lint / test / coverage / build — what the gate actually runs |
 | **Gates** | Enable, coverage threshold, placeholder rejection |
@@ -349,7 +380,7 @@ The agent edits it by submitting the **complete** task list through the `infinit
 
 ## Watching it work
 
-**In the terminal** — the widget above updates on every turn, showing all five levels of the plan:
+**In the terminal** — the widget updates on every turn, showing the plan as deep as you asked for:
 goal, sprint, feature, task, subtask. It is a *window*, not a truncation — the rows above and
 below are counted, and one keypress away:
 
@@ -362,14 +393,43 @@ below are counted, and one keypress away:
 It is responsive down to ~58 columns, degrades to ASCII when the locale isn't UTF-8, and drops
 colour under `NO_COLOR`.
 
-**In a browser** — `/infinity:dashboard` serves a live page on loopback: phase rail, stacked progress
-meters that show stuck work as colour rather than absence, the whole plan as a collapsible
-goal → sprint → feature → task → subtask tree with counts at every level, and the last gate
-verdict. It refreshes itself every 5 seconds and reconnects with backoff if the run ends.
+**In a browser** — `/infinity:dashboard` serves a live page on loopback: phase rail, stacked
+progress meters that show stuck work as colour rather than absence, the plan as a collapsible tree
+with counts at every level, and the last gate verdict. It refreshes itself every 5 seconds and
+reconnects with backoff if the run ends.
 
 The dashboard is strictly read-only and binds to `127.0.0.1`. It never writes, and never bumps
 `baseRevision` — opening it can't perturb the run you're watching.
 
+### What they show is yours to choose
+
+Two people watching the same run want different things on screen. One works in sprints and never
+opens a subtask; the next has no sprints and lives in the subtask list. So it is a setting, and
+**the widget and the dashboard read the same one** — configure how you like to read a plan once,
+not twice.
+
+| Template | |
+|---|---|
+| **focus** *(default)* | every level, with subtasks on the task being worked |
+| **everything** | all five levels, every subtask on every task, a taller window |
+| **overview** | goals, sprints and features with their counts. No tasks — the shape, not the work |
+| **worklist** | tasks only. No grouping rows, no rail — for when you already know the plan |
+
+```
+/infinity:display              pick a template, or choose level by level
+/infinity:display overview     switch straight to one
+/infinity:display list         what is available, and what you are on now
+```
+
+Choosing level by level also lets you turn off the phase rail, the progress meter, the alert strip,
+the `done/total` counts, the `← #3` dependency labels and the acceptance criteria, and set how many
+rows the terminal shows before it scrolls. Name what you end up with and it is saved with you,
+offered on your next project. `/infinity:config` → **Display** edits the same things one at a time.
+
+Hiding a level never hides what is under it: turn off sprints on a plan organised into sprints and
+the features move up one indent, they do not vanish. A task nobody can see is a task that gets
+stuck forever.
+
 ## Craft skills
 
 28 short documents on how to do the work well — how to write a test worth
@@ -447,10 +507,12 @@ infinity-harness/
 │   │                              · featureList (the SSOT) · lock · exec
 │   │                              · skills (match) · skillsAudit (guard)
 │   ├── ui/                        theme · planTree (the five levels, once)
+│   │                              · display (what to draw, and the templates)
 │   │                              · widget (terminal) · dashboard (web) · wizard · config
 │   ├── loop.ts                    the continuous-run driver and its stop conditions
 │   ├── runState.ts                is a run armed, and which run is it — on disk, across sessions
 │   ├── handoff.ts                 when to continue in a fresh session, and what to tell it
+│   ├── workflow.ts                a mode per phase, the built-ins, and the ones you save
 │   ├── approval.ts · intake.ts    human sign-off · what the start-up wizard's answers mean
 │   ├── escalate.ts                the ladder's actuator: chooses a rung and takes it
 │   ├── goal.ts                    the outer loop: is the thing asked for actually done?
@@ -467,7 +529,10 @@ infinity-harness/
 │   ├── model-router.json          optional routing
 │   ├── docs/                      architecture · decisions · phase and role docs
 │   └── skills/                    28 craft skills the brief points at
-├── tests/                         31 files, plain node:assert
+│
+│   ~/.pi/agent/infinity-harness/  the workflows and display templates you saved —
+│                                  they belong to you, not to a project
+├── tests/                         33 files, plain node:assert
 └── scripts/
     ├── run-tests.mjs
     ├── e2e.mjs                    16 scenarios, including one against a real pi process
@@ -482,7 +547,7 @@ there is one implementation, and the adapter calls it.
 ```bash
 npm install
 npm run check                    # tsc --noEmit, strict
-npm test                         # 31 test files
+npm test                         # 33 test files
 npm run e2e                      # 16 end-to-end scenarios
 npm run e2e -- --only realpi     # just the ones that drive a real pi process
 npm run e2e -- --list            # what the scenarios are

package/extensions/infinity-harness/index.ts

@@ -78,7 +78,29 @@ import {
   type HandoffReason,
 } from "../../src/handoff.ts";
 import { needsApproval, resolveApproval, approvedPhases } from "../../src/approval.ts";
-import { runIntakeWizard, unattendedIntake } from "../../src/ui/wizard.ts";
+import {
+  buildDisplay,
+  pickDisplay,
+  pickWorkflow,
+  runIntakeWizard,
+  unattendedIntake,
+} from "../../src/ui/wizard.ts";
+import {
+  applyWorkflow,
+  findWorkflow,
+  listWorkflows,
+  matchWorkflow,
+  renderWorkflow,
+  signedPhases,
+  summarizeWorkflow,
+} from "../../src/workflow.ts";
+import {
+  findDisplay,
+  listDisplays,
+  normalizeDisplay,
+  summarizeDisplay,
+} from "../../src/ui/display.ts";
+import type { DisplayPolicy } from "../../src/core/types.ts";
 import { defaultView, scrollView, SCROLL_STEP, TASK_WINDOW, EXPANDED_WINDOW, type WidgetView } from "../../src/ui/widget.ts";
 import { buildPlanRows } from "../../src/ui/planTree.ts";
 
@@ -165,6 +187,7 @@ export default function (pi: ExtensionAPI): void {
         sessions: run?.sessions ?? null,
         intake: typeof config.intake?.brief === "string" ? config.intake.brief : null,
         awaitingApproval: config.awaitingApproval ?? null,
+        display: normalizeDisplay(config.display),
         phase: config.currentPhase,
         enabledPhases: config.phases?.enabled,
         paused: Boolean(config.paused),
@@ -1246,7 +1269,7 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.registerCommand("infinity:init", {
-    description: "Set up a harness here — mode, goal, research, approvals, sessions",
+    description: "Set up a harness here — workflow, goal, sessions, display",
     handler: async (args: string, ctx: ExtensionContext) => {
       const dir = projectDir(ctx);
       const force = /\bforce\b/.test(args);
@@ -1262,57 +1285,36 @@ export default function (pi: ExtensionAPI): void {
       }
 
       const detected = detectStack(dir);
-      let phases: Phase[] | undefined;
 
-      // Two things used to be wrong here, and they compounded.
+      // Three things used to be wrong here, and they compounded.
       //
-      // First, the wizard never asked what was being built — so picking
-      // "autopilot" started a run with no idea and no scope, and the harness
-      // invented a project and began building it. Autopilot was being read as
-      // "you decide everything, including what I want".
+      // The wizard never asked what was being built — so picking "autopilot"
+      // started a run with no idea and no scope, and the harness invented a
+      // project and began building it.
       //
-      // Second, "mode" was the only question. There was no way to say "drive
-      // yourself, but show me the plan before you build it", which is what
-      // most people actually want from an unattended run.
+      // "mode" was the only question, and one switch cannot say "drive
+      // yourself, but show me the plan before you build it".
       //
-      // The wizard now asks for the goal in both modes, offers an optional
-      // research phase, and — in autopilot — lets the human pick exactly which
-      // of RESEARCH / DEFINE / PLAN they sign. `src/intake.ts` owns what the
-      // answers mean; `src/ui/wizard.ts` owns asking them.
+      // And even that switch only reached three phases. It is a mode per
+      // phase now, chosen from a workflow the human can build, name and reuse.
+      // `src/workflow.ts` owns what a workflow is, `src/intake.ts` what the
+      // answers mean, `src/ui/wizard.ts` how they are asked.
       if (ctx.hasUI) {
         const cmds = Object.entries(detected.commands).filter(([, v]) => Boolean(v));
         const summary = cmds.length ? cmds.map(([k, v]) => `${k}: ${v}`).join(", ") : "no commands detected";
-        const go = await ctx.ui.select(
-          `Create a harness here? ${detected.label} · ${summary}`,
-          ["yes", "yes, and let me choose the phases", "cancel"],
-        );
+        const go = await ctx.ui.select(`Create a harness here? ${detected.label} · ${summary}`, [
+          "yes",
+          "cancel",
+        ]);
         if (go === undefined || go === "cancel") {
           notify(ctx, "init cancelled — nothing was written.", "info");
           return;
         }
-
-        if (go.includes("phases")) {
-          const chosen = new Set<Phase>(DEFAULT_ENABLED_PHASES);
-          for (;;) {
-            const rows = SELECTABLE_PHASES.map((p) => `${chosen.has(p) ? "[x]" : "[ ]"} ${p}`);
-            const hit = await ctx.ui.select("Phases to run", [...rows, "✓ done"]);
-            if (hit === undefined || hit === "✓ done") break;
-            const key = SELECTABLE_PHASES[rows.indexOf(hit)];
-            if (!key) break;
-            if (chosen.has(key)) chosen.delete(key);
-            else chosen.add(key);
-          }
-          phases = [...chosen];
-        }
       }
 
       const wizard = ctx.hasUI
-        ? await runIntakeWizard({
-            prompt: prompterFor(ctx),
-            phases,
-            brief: goalFromArgs || null,
-          })
-        : ({ cancelled: false, plan: unattendedIntake(goalFromArgs || null, phases) } as const);
+        ? await runIntakeWizard({ prompt: prompterFor(ctx), brief: goalFromArgs || null })
+        : ({ cancelled: false, plan: unattendedIntake(goalFromArgs || null) } as const);
 
       if (wizard.cancelled) {
         notify(ctx, "init cancelled — nothing was written.", "info");
@@ -1324,6 +1326,9 @@ export default function (pi: ExtensionAPI): void {
         mode: plan.mode,
         phases: plan.phases,
         approvals: plan.approvals,
+        phaseModes: plan.phaseModes,
+        workflow: plan.workflow,
+        display: plan.display,
         session: plan.session,
         brief: plan.brief,
         force,
@@ -1353,6 +1358,143 @@ export default function (pi: ExtensionAPI): void {
     },
   });
 
+  /**
+   * Change the workflow mid-run.
+   *
+   * Any of this is editable at any time and takes effect on the next gate —
+   * a run three phases deep is exactly when someone realises they do want to
+   * see the review after all.
+   */
+  pi.registerCommand("infinity:workflow", {
+    description: "Choose or build the workflow — which phases run, and which stop for you",
+    handler: async (args: string, ctx: ExtensionContext) => {
+      const dir = projectDir(ctx);
+      if (!isHarnessProject(dir)) {
+        notify(ctx, NO_HARNESS, "warning");
+        return;
+      }
+
+      const { config } = loadConfig(dir);
+      const arg = args.trim();
+
+      if (arg === "" && !ctx.hasUI) {
+        notify(ctx, describeCurrentWorkflow(dir), "info");
+        return;
+      }
+      if (arg === "show" || arg === "list") {
+        const rows = listWorkflows().map((w) => `  ${w.builtIn ? " " : "*"} ${w.name} — ${w.description}`);
+        notify(
+          ctx,
+          `${describeCurrentWorkflow(dir)}\n\nAvailable (* = yours):\n${rows.join("\n")}`,
+          "info",
+        );
+        return;
+      }
+
+      // `/infinity:workflow <name>` switches without a menu, which is what a
+      // second run in the same terminal wants.
+      let chosen = arg ? findWorkflow(arg) : undefined;
+      if (arg && !chosen) {
+        notify(ctx, `No workflow called "${arg}". \`/infinity:workflow list\` shows them.`, "warning");
+        return;
+      }
+      if (!chosen) {
+        if (!ctx.hasUI) {
+          notify(ctx, "This mode has no dialogs — `/infinity:workflow <name>` switches directly.", "warning");
+          return;
+        }
+        chosen = (await pickWorkflow(prompterFor(ctx))) ?? undefined;
+        if (!chosen) {
+          notify(ctx, "Unchanged.", "info");
+          return;
+        }
+      }
+
+      const { value } = await withLock(configPath(dir), () => {
+        const fresh = loadConfig(dir);
+        if (!fresh.ok) return false;
+        applyWorkflow(fresh.config, chosen!);
+        // Keep the legacy field in step so a 2.3 tool reading this config
+        // still sees the same three answers it understands.
+        fresh.config.approvals = {
+          research: fresh.config.phaseModes?.research === "copilot",
+          define: fresh.config.phaseModes?.define === "copilot",
+          plan: fresh.config.phaseModes?.plan === "copilot",
+        };
+        fresh.config.mode = signedPhases(fresh.config).length > 0 ? "copilot" : "autopilot";
+        return saveConfig(dir, fresh.config).ok;
+      });
+
+      if (!value) {
+        notify(ctx, "Could not save the workflow — config unreadable.", "error");
+        return;
+      }
+      notify(ctx, `${renderWorkflow(chosen)}\n\nIt takes effect at the next gate.`, "info");
+      refreshWidget(ctx);
+      void config;
+    },
+  });
+
+  pi.registerCommand("infinity:display", {
+    description: "Choose what the widget and the dashboard show, level by level",
+    handler: async (args: string, ctx: ExtensionContext) => {
+      const dir = projectDir(ctx);
+      if (!isHarnessProject(dir)) {
+        notify(ctx, NO_HARNESS, "warning");
+        return;
+      }
+      const arg = args.trim();
+      const current = normalizeDisplay(loadConfig(dir).config.display);
+
+      if (arg === "show" || arg === "list") {
+        const rows = listDisplays().map((d) => `  ${d.builtIn ? " " : "*"} ${d.name} — ${d.description}`);
+        notify(
+          ctx,
+          `Now: ${summarizeDisplay(current)}\n\nTemplates (* = yours):\n${rows.join("\n")}`,
+          "info",
+        );
+        return;
+      }
+
+      let next: DisplayPolicy | undefined;
+      if (arg) {
+        const template = findDisplay(arg);
+        if (!template) {
+          notify(ctx, `No template called "${arg}". \`/infinity:display list\` shows them.`, "warning");
+          return;
+        }
+        next = template.policy;
+      } else {
+        if (!ctx.hasUI) {
+          notify(ctx, `Now: ${summarizeDisplay(current)}. \`/infinity:display <template>\` switches.`, "info");
+          return;
+        }
+        next = await pickDisplay(prompterFor(ctx));
+        if (!next) {
+          notify(ctx, "Unchanged.", "info");
+          return;
+        }
+      }
+
+      const { value } = await withLock(configPath(dir), () => {
+        const fresh = loadConfig(dir);
+        if (!fresh.ok) return false;
+        fresh.config.display = normalizeDisplay(next);
+        return saveConfig(dir, fresh.config).ok;
+      });
+
+      if (!value) {
+        notify(ctx, "Could not save the display settings — config unreadable.", "error");
+        return;
+      }
+      // The widget is the answer to "did that do what I wanted", so redraw it
+      // before saying anything about it.
+      view = defaultView();
+      refreshWidget(ctx);
+      notify(ctx, `Showing: ${summarizeDisplay(normalizeDisplay(next))}`, "info");
+    },
+  });
+
   /**
    * Continue the run in a replacement session.
    *
@@ -2295,6 +2437,20 @@ function errMsg(e: unknown): string {
   return e instanceof Error ? e.message : String(e);
 }
 
+/** The workflow this project is on, and whether it still matches a named one. */
+function describeCurrentWorkflow(dir: string): string {
+  const { config } = loadConfig(dir);
+  const named = matchWorkflow(config);
+  const head = `Workflow: ${summarizeWorkflow(config)}`;
+  const rail = (config.phases?.enabled ?? [])
+    .map((p) => (config.phaseModes?.[p] === "copilot" ? `[${p}]` : p))
+    .join(" → ");
+  const drift = named
+    ? ""
+    : "\n\nThese settings do not match any saved workflow. `/infinity:workflow` can save them as one.";
+  return `${head}\n  ${rail}\n  (a phase in [brackets] stops for you)${drift}`;
+}
+
 /**
  * The few sentences the run cannot afford to have summarised away.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinity-harness",
-  "version": "2.3.1",
+  "version": "2.4.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.",
   "type": "module",
   "keywords": [

package/src/approval.ts

@@ -19,8 +19,8 @@
  */
 
 import type { HarnessConfig, Phase } from "./core/types.ts";
-import { APPROVABLE_PHASES } from "./core/types.ts";
 import { loadConfig, saveConfig } from "./core/config.ts";
+import { modeFor, signedPhases, SIGNABLE_PHASES } from "./workflow.ts";
 
 export type ApprovalRequest = {
   phase: Phase;
@@ -29,26 +29,31 @@ export type ApprovalRequest = {
   prompt: string;
 };
 
+/** Every phase except INIT, which is plumbing rather than work. */
 export function isApprovable(phase: Phase | null): boolean {
-  return phase !== null && (APPROVABLE_PHASES as readonly string[]).includes(phase);
+  return phase !== null && SIGNABLE_PHASES.includes(phase);
 }
 
 /** Does `phase` need a signature before the pipeline may leave it? */
 export function needsApproval(config: HarnessConfig, phase: Phase | null): boolean {
   if (!isApprovable(phase)) return false;
-  const approvals = (config.approvals ?? {}) as Record<string, unknown>;
-  return approvals[phase as string] === true;
+  return modeFor(config, phase) === "copilot";
 }
 
 /** Which phases the human has asked to sign, in pipeline order. */
 export function approvedPhases(config: HarnessConfig): Phase[] {
-  return APPROVABLE_PHASES.filter((p) => needsApproval(config, p)) as Phase[];
+  return signedPhases(config);
 }
 
 const ARTIFACTS: Record<string, string[]> = {
   research: ["harness/docs/RESEARCH.md"],
   define: ["specs/prd.md", "harness/sprint-contract.md", "the acceptance criteria in the plan"],
   plan: ["the task list in the widget, or `/infinity:dashboard`"],
+  build: ["the diff since the last phase — `git diff`", "the tasks marked complete in the plan"],
+  verify: ["the test output", "what the tests still do not cover"],
+  simplify: ["what was deleted — `git diff --stat`"],
+  review: ["harness/evaluator-rubric.md and the score against it", "README.md and harness/docs/"],
+  ship: ["CHANGELOG.md", "the tag, and `git log` since the last one"],
 };
 
 const ASKS: Record<string, string> = {
@@ -57,6 +62,11 @@ const ASKS: Record<string, string> = {
   define:
     "Is this the thing you want built, and would meeting these criteria convince you it works?",
   plan: "Does this plan build that thing, in an order that makes sense, with nothing important missing?",
+  build: "Is this the code you wanted written, and would you be happy to own it?",
+  verify: "Do these tests actually prove the thing works, or only that it runs?",
+  simplify: "Is what is left simpler, and is anything missing that should not be?",
+  review: "Would you approve this if someone else had written it?",
+  ship: "Is this ready to go out, under this version, with this changelog?",
 };
 
 export function describeApproval(phase: Phase): ApprovalRequest {