infinity-harness 2.3.1 → 2.5.0

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),
@@ -274,15 +297,33 @@ export default function (pi: ExtensionAPI): void {
 
   // -- session handoff ------------------------------------------------------
 
-  /** The task the pipeline is on right now, or null. */
-  const activeTaskKey = (dir: string): string | null => {
+  /** The task/feature/sprint/goal/subtask the pipeline is on right now, or null. */
+  const activePlanKeys = (dir: string): { task: string | null; feature: string | null; sprint: string | null; goal: string | null; subtask: string | null; } => {
     try {
       const { list } = loadFeatureList(dir);
-      return nextActionableTask(list)?.compositeKey ?? null;
+      const task = nextActionableTask(list);
+      const flat = task ? loadFeatureList(dir).list.features?.find((f) => f.id === task.featureId) ?? null : null;
+      // Resolve sprint/goal via list, and active subtask of the focused task.
+      const taskKey = task?.compositeKey ?? null;
+      const featureId = task?.featureId ?? null;
+      const feature = featureId ? (list.features ?? []).find((f) => f.id === featureId) ?? null : null;
+      const sprintId = feature?.sprintId ?? null;
+      const goalId = feature?.goalId ?? (sprintId ? (list.sprints ?? []).find((s) => s.id === sprintId)?.goalId ?? null : null) ?? (list.goals?.[0]?.id ?? null);
+      const sprint = sprintId ? sprintId : null;
+      const goal = goalId ? goalId : null;
+      // First non-complete subtask of the active task.
+      let subtask: string | null = null;
+      const rawTask = feature && task ? feature.tasks.find((t) => t.id === task.id || t.key === task.key) ?? null : null;
+      if (rawTask?.subtasks?.length) {
+        const cur = rawTask.subtasks.find((s) => s.status !== "complete") ?? null;
+        if (cur) subtask = `${taskKey}#${cur.id ?? cur.title}`;
+      }
+      return { task: taskKey, feature: featureId, sprint, goal, subtask };
     } catch {
-      return null;
+      return { task: null, feature: null, sprint: null, goal: null, subtask: null };
     }
   };
+  const activeTaskKey = (dir: string): string | null => activePlanKeys(dir).task;
 
   /** How full this session's context is, 0..1, or null when pi cannot say. */
   const contextRatio = (ctx: ExtensionContext): number | null => {
@@ -332,12 +373,41 @@ export default function (pi: ExtensionAPI): void {
     }
     try {
       const { config } = loadConfig(dir);
+      const toKeys = activePlanKeys(dir);
+      // Map caller's fromTask (a compositeKey) back to its feature/sprint etc for the "from" side.
+      // We derive them from the plan so goal/sprint/feature boundaries are comparable.
+      let fromGoal: string | null = null;
+      let fromSprint: string | null = null;
+      let fromFeature: string | null = null;
+      try {
+        const { list } = loadFeatureList(dir);
+        if (fromTask) {
+          const ft = ((): { featureId: string } | null => {
+            for (const f of list.features ?? []) for (const t of f.tasks ?? []) if (t.key === fromTask || `${f.id}/${t.id}` === fromTask || t.id === fromTask) return { featureId: f.id };
+            return null;
+          })();
+          if (ft) {
+            fromFeature = ft.featureId;
+            const feat = list.features.find((f) => f.id === ft.featureId) ?? null;
+            fromSprint = feat?.sprintId ?? null;
+            fromGoal = feat?.goalId ?? (fromSprint ? (list.sprints ?? []).find((s) => s.id === fromSprint)?.goalId ?? null : null) ?? null;
+          }
+        }
+      } catch {}
       const decision = shouldHandoff({
         config,
         fromPhase,
         toPhase,
         fromTask,
-        toTask: activeTaskKey(dir),
+        toTask: toKeys.task,
+        fromGoal,
+        toGoal: toKeys.goal,
+        fromSprint,
+        toSprint: toKeys.sprint,
+        fromFeature,
+        toFeature: toKeys.feature,
+        fromSubtask: null, // subtask delta is derived from task payload; tracked via fromTask composite + activePlanKeys
+        toSubtask: toKeys.subtask,
         contextRatio: contextRatio(ctx),
       });
       if (!decision.handoff) return false;
@@ -473,6 +543,7 @@ export default function (pi: ExtensionAPI): void {
 
     view = defaultView();
     refreshWidget(ctx);
+    installTerminalShortcuts(ctx);
     const { config } = loadConfig(dir);
     lastBriefPhase = config.currentPhase;
 
@@ -1019,6 +1090,34 @@ export default function (pi: ExtensionAPI): void {
       const lines = gate.checks
         .map((c) => `${c.advisory ? "·" : c.pass ? "+" : "x"} ${c.name}: ${c.detail}`)
         .join("\n");
+      // On a passing gate in autopilot, the tool itself advances the phase
+      // so a run without the continuous loop armed still moves forward when
+      // the agent calls infinity_validate — that's what the brief says will
+      // happen ("PASS → the harness advances") and what stopped research
+      // from ever reaching DEFINE until someone typed "continue".
+      if (gate.overall && !params?.feature && !params?.task) {
+        try {
+          const { needsApproval } = await import("../../src/approval.ts");
+          const fresh = loadConfig(dir).config;
+          if (!needsApproval(fresh, fresh.currentPhase)) {
+            const { advancePhase } = await import("../../src/core/phases.ts");
+            const moved = await advancePhase(dir);
+            if (moved.ok && moved.to) {
+              refreshWidget(ctx as ExtensionContext);
+              const brief = await briefText(dir);
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Gate PASS on ${gate.phase} → advanced ${moved.from} → ${moved.to}\n${lines}\n\n${brief}`,
+                  },
+                ],
+                details: { ...gate, advanced: moved } as unknown as typeof gate,
+              };
+            }
+          }
+        } catch {}
+      }
       return {
         content: [
           {
@@ -1246,7 +1345,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 +1361,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, models: () => availableModels(ctx) })
+        : ({ cancelled: false, plan: unattendedIntake(goalFromArgs || null) } as const);
 
       if (wizard.cancelled) {
         notify(ctx, "init cancelled — nothing was written.", "info");
@@ -1324,8 +1402,22 @@ 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,
+        router: plan.router
+          ? ({
+              enabled: !!plan.router.enabled,
+              byDifficulty: plan.router.byDifficulty as unknown as Record<string, string>,
+              thinkingByDifficulty: plan.router.thinkingByDifficulty as unknown as Record<string, string>,
+              master: plan.router.master ?? "",
+              thinkingMaster: plan.router.thinkingMaster as unknown as string,
+              default: plan.router.default ?? "",
+              thinkingDefault: plan.router.thinkingDefault as unknown as string,
+            } as Partial<import("../../src/modelRouter.ts").RouterConfig>)
+          : undefined,
         force,
       });
       if (!result.ok) {
@@ -1353,6 +1445,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.
    *
@@ -2210,24 +2439,58 @@ export default function (pi: ExtensionAPI): void {
   // `alt+` and not `ctrl+`: pi already binds ctrl+j (newline), ctrl+k (delete
   // to line end) and ctrl+o (expand tool output). Shadowing an editor key to
   // scroll a widget would be a worse bug than the one being fixed.
+  //
+  // Shortcuts are editor-focused via registerShortcut, but also handled as a
+  // raw terminal fallback so they work when an overlay or selector has focus
+  // or when the terminal sends the legacy ESC+j sequence that the editor
+  // otherwise swallows as text.
+
+  const scrollDown = async (ctx: ExtensionContext): Promise<void> => moveView(ctx, SCROLL_STEP);
+  const scrollUp = async (ctx: ExtensionContext): Promise<void> => moveView(ctx, -SCROLL_STEP);
+  const toggleExpand = async (ctx: ExtensionContext): Promise<void> => {
+    view = { ...view, expanded: !view.expanded };
+    refreshWidget(ctx);
+  };
 
-  pi.registerShortcut("alt+j", {
-    description: "infinity-harness: scroll the plan down",
-    handler: async (ctx: ExtensionContext) => moveView(ctx, SCROLL_STEP),
-  });
-
-  pi.registerShortcut("alt+k", {
-    description: "infinity-harness: scroll the plan up",
-    handler: async (ctx: ExtensionContext) => moveView(ctx, -SCROLL_STEP),
-  });
-
-  pi.registerShortcut("alt+o", {
-    description: "infinity-harness: expand or collapse the plan widget",
-    handler: async (ctx: ExtensionContext) => {
-      view = { ...view, expanded: !view.expanded };
-      refreshWidget(ctx);
-    },
-  });
+  pi.registerShortcut("alt+j", { description: "infinity-harness: scroll the plan down", handler: scrollDown });
+  pi.registerShortcut("alt+k", { description: "infinity-harness: scroll the plan up", handler: scrollUp });
+  pi.registerShortcut("alt+o", { description: "infinity-harness: expand or collapse the plan widget", handler: toggleExpand });
+  // Uppercase handling covered by the raw terminal fallback below which
+  // lowercases data before matching; KeyId type only allows lowercase.
+
+  // Fallback raw input handler — runs even when the editor is not the
+  // focused component (e.g. a selector is open). Must be installed per-
+  // session because onTerminalInput is a UI session thing, not a global.
+  let removeTerminalShortcut: (() => void) | null = null;
+  const installTerminalShortcuts = (ctx: ExtensionContext): void => {
+    try {
+      removeTerminalShortcut?.();
+    } catch {}
+    try {
+      // matchesKey lives in pi-tui but re-exported by pi; use the extension
+      // input raw matcher via string compare for ESC-prefixed alt.
+      removeTerminalShortcut = ctx.ui.onTerminalInput((data: string) => {
+        // Legacy alt+letter is ESC + lower letter. Kitty may send CSI-u; both
+        // are handled by normalising to lookahead then matching via the same
+        // strings registerShortcut uses.
+        const lower = data.toLowerCase();
+        // Fast path: alt+j/k/o as ESC + letter (\x1bj) or higher-plane.
+        if (data === "\x1bj" || data === "\x1bJ" || lower === "\x1bj") {
+          void scrollDown(ctx);
+          return { consume: true };
+        }
+        if (data === "\x1bk" || data === "\x1bK" || lower === "\x1bk") {
+          void scrollUp(ctx);
+          return { consume: true };
+        }
+        if (data === "\x1bo" || data === "\x1bO" || lower === "\x1bo") {
+          void toggleExpand(ctx);
+          return { consume: true };
+        }
+        return undefined;
+      });
+    } catch {}
+  };
 
   pi.registerCommand("infinity:scroll", {
     description: "Move the plan widget — up, down, top, bottom, expand, follow",
@@ -2295,6 +2558,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.5.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 {

package/src/core/config.ts

@@ -9,6 +9,7 @@
 
 import type { HarnessConfig, GateHistoryEntry, Phase, Role } from "./types.ts";
 import { DEFAULT_ENABLED_PHASES, PHASE_ROLE } from "./types.ts";
+import { defaultDisplay, normalizeDisplay } from "../ui/display.ts";
 import { configPath } from "./paths.ts";
 import { readJson, writeJsonAtomic, backupOnce, fileExists } from "./fsx.ts";
 
@@ -49,8 +50,11 @@ export function defaultConfig(): HarnessConfig {
     },
     phases: { enabled: [...DEFAULT_ENABLED_PHASES] },
     roles: { strict: false },
-    session: { handoff: "phase", contextThreshold: 0.7, carryNotes: true },
+    session: { handoff: "task", contextThreshold: 0.6, carryNotes: true },
     approvals: { research: false, define: false, plan: false },
+    phaseModes: Object.fromEntries(DEFAULT_ENABLED_PHASES.map((p) => [p, "autopilot"])),
+    workflow: { id: "autopilot", name: "autopilot" },
+    display: defaultDisplay(),
     intake: { completed: false, brief: null, at: null },
     awaitingApproval: null,
     loop: {
@@ -89,6 +93,45 @@ function deepMerge<T>(defaults: T, partial: unknown): T {
   return out as T;
 }
 
+/**
+ * Bring an older config forward on read.
+ *
+ * 2.3 had a three-phase `approvals` switch; 2.4 has a mode for every phase.
+ * A project mid-run must not lose the approvals it was configured with just
+ * because the shape moved, and nobody should have to edit JSON to upgrade.
+ * The migration is read-only — it takes effect on the next save like any other
+ * change — so a downgrade still finds the old field where it left it.
+ */
+function migrate(config: HarnessConfig, stored: Partial<HarnessConfig>): HarnessConfig {
+  const out = config as Record<string, unknown>;
+  const phases = Array.isArray(config.phases?.enabled) ? config.phases.enabled : [...DEFAULT_ENABLED_PHASES];
+
+  // The signal is what the *file* had, not what the merge produced: defaults
+  // supply a `phaseModes` for every phase, so a merged config always looks
+  // migrated and the old approvals would be silently dropped.
+  const hadModes =
+    typeof stored.phaseModes === "object" &&
+    stored.phaseModes !== null &&
+    Object.keys(stored.phaseModes).length > 0;
+
+  if (!hadModes) {
+    const approvals = (stored.approvals ?? {}) as Record<string, unknown>;
+    const next: Record<string, string> = {};
+    for (const p of phases) next[p] = approvals[p] === true ? "copilot" : "autopilot";
+    out.phaseModes = next;
+    if (!stored.workflow) {
+      const signed = phases.filter((p) => next[p] === "copilot");
+      out.workflow =
+        signed.length === 0
+          ? { id: "autopilot", name: "autopilot" }
+          : { id: "copilot", name: "copilot" };
+    }
+  }
+
+  config.display = normalizeDisplay(config.display);
+  return config;
+}
+
 export type LoadResult = {
   ok: boolean;
   config: HarnessConfig;
@@ -114,7 +157,7 @@ export function loadConfig(targetDir: string): LoadResult {
     if (raw === null) {
       return { ok: false, config: defaultConfig(), error: "harness/config.json is empty", seeded: true };
     }
-    return { ok: true, config: deepMerge(defaultConfig(), raw), error: null, seeded: false };
+    return { ok: true, config: migrate(deepMerge(defaultConfig(), raw), raw), error: null, seeded: false };
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     return { ok: false, config: defaultConfig(), error: msg, seeded: false };