infinity-harness 2.3.1 → 2.4.0

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";
 
@@ -51,6 +52,9 @@ export function defaultConfig(): HarnessConfig {
     roles: { strict: false },
     session: { handoff: "phase", contextThreshold: 0.7, 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 };

package/src/core/init.ts

@@ -29,6 +29,7 @@ import { DEFAULT_ENABLED_PHASES, PHASE_ORDER, PHASE_ROLE } from "./types.ts";
 import { defaultConfig, saveConfig } from "./config.ts";
 import { emptyFeatureList, saveFeatureList } from "./featureList.ts";
 import * as P from "./paths.ts";
+import { normalizeDisplay } from "../ui/display.ts";
 
 export type StackId = "node" | "python" | "rust" | "go" | "unknown";
 
@@ -149,8 +150,14 @@ export type InitOptions = {
   commands?: Partial<ProjectCommands>;
   /** Re-scaffold missing files in a project that already has a config. */
   force?: boolean;
-  /** Which phases stop for a human signature. See SessionPolicy / ApprovalPolicy. */
+  /** Legacy three-phase approval switch, kept in step with `phaseModes`. */
   approvals?: Partial<HarnessConfig["approvals"]>;
+  /** Mode per phase — which of them stop for a human signature. */
+  phaseModes?: HarnessConfig["phaseModes"];
+  /** Which named workflow those modes came from. */
+  workflow?: HarnessConfig["workflow"];
+  /** What the widget and the dashboard draw. */
+  display?: HarnessConfig["display"];
   /** Session-handoff policy. Defaults to a fresh session per phase. */
   session?: Partial<HarnessConfig["session"]>;
   /** What the human said they want built. Recorded, and read by the first brief. */
@@ -210,6 +217,20 @@ export function initHarness(targetDir: string, options: InitOptions = {}): InitR
   config.commands = { ...stack.commands, ...stripUndefined(options.commands ?? {}) };
   config.approvals = { ...config.approvals, ...stripUndefined(options.approvals ?? {}) };
   config.session = { ...config.session, ...stripUndefined(options.session ?? {}) };
+  // Every enabled phase gets a mode, so a phase list and a mode map cannot
+  // disagree about which phases exist. A caller that still passes the 2.3
+  // `approvals` shape and no modes gets what it asked for rather than silently
+  // getting autopilot — the same rule `loadConfig` applies to an older file.
+  const legacy = (options.approvals ?? {}) as Record<string, unknown>;
+  const hasModes = options.phaseModes && Object.keys(options.phaseModes).length > 0;
+  config.phaseModes = Object.fromEntries(
+    phases.map((p) => [
+      p,
+      (hasModes ? options.phaseModes?.[p] === "copilot" : legacy[p] === true) ? "copilot" : "autopilot",
+    ]),
+  );
+  if (options.workflow) config.workflow = options.workflow;
+  if (options.display) config.display = normalizeDisplay(options.display);
   if (options.brief !== undefined) {
     config.intake = {
       completed: true,

package/src/core/paths.ts

@@ -5,10 +5,35 @@
  * Nothing outside this module hardcodes a harness path.
  */
 
+import { homedir } from "node:os";
 import { resolve } from "node:path";
 
 export const HARNESS_DIRNAME = "harness";
 
+/**
+ * Where things that belong to the *person* live, rather than to a project.
+ *
+ * A workflow someone designed and named is worth exactly as much on their next
+ * project as on this one, so it cannot live under `harness/`. This follows
+ * pi's own config directory, honouring the same override pi honours, so a
+ * sandboxed or rebranded install keeps everything in one place.
+ */
+export function userDir(env: NodeJS.ProcessEnv = process.env): string {
+  const override = env.PI_CODING_AGENT_DIR;
+  if (override && override.trim()) return resolve(override.trim(), "infinity-harness");
+  return resolve(homedir(), ".pi", "agent", "infinity-harness");
+}
+
+/** The workflows this person has saved, reusable across every project. */
+export function userWorkflowsPath(env?: NodeJS.ProcessEnv): string {
+  return resolve(userDir(env), "workflows.json");
+}
+
+/** The display templates this person has saved. */
+export function userDisplayPath(env?: NodeJS.ProcessEnv): string {
+  return resolve(userDir(env), "displays.json");
+}
+
 export function harnessDir(targetDir: string): string {
   return resolve(targetDir, HARNESS_DIRNAME);
 }

package/src/core/settings.ts

@@ -49,6 +49,9 @@ export type SettingsGroup = {
 
 // ── The schema ──────────────────────────────────────────────────────────────
 
+/** The two things a phase can do when its gate passes. */
+const PHASE_MODE_CHOICES = ["autopilot", "copilot"] as const;
+
 const DIFFICULTY_HELP =
   "Tasks the planner marked at this difficulty run on this model. Empty means: use whatever model pi is already on.";
 
@@ -152,31 +155,157 @@ export const SETTINGS: SettingsGroup[] = [
     ],
   },
   {
-    id: "approvals",
-    label: "Your approvals",
-    help: "Which phases stop and wait for your signature. These are the three that decide WHAT gets built — after PLAN, a wrong turn fails a gate and retries.",
+    id: "workflow",
+    label: "Workflow",
+    help: "Which phases stop and wait for your signature, one phase at a time. `/infinity:workflow` picks a named one or builds a new one.",
     settings: [
       {
-        path: "approvals.research",
+        path: "phaseModes.research",
         file: "config",
-        label: "Sign off RESEARCH",
-        help: "You read harness/docs/RESEARCH.md and say whether it is looking at the right problem. Only applies when the RESEARCH phase is enabled.",
-        type: { kind: "boolean" },
+        label: "RESEARCH",
+        help: "copilot stops so you can read harness/docs/RESEARCH.md before anything is specified.",
+        type: { kind: "choice", choices: PHASE_MODE_CHOICES },
       },
       {
-        path: "approvals.define",
+        path: "phaseModes.define",
         file: "config",
-        label: "Sign off DEFINE",
+        label: "DEFINE",
         help: "The highest-leverage signature: a wrong definition is a weekend building the wrong thing perfectly.",
+        type: { kind: "choice", choices: PHASE_MODE_CHOICES },
+      },
+      {
+        path: "phaseModes.plan",
+        file: "config",
+        label: "PLAN",
+        help: "copilot shows you the whole task list before a line of it is built.",
+        type: { kind: "choice", choices: PHASE_MODE_CHOICES },
+      },
+      {
+        path: "phaseModes.build",
+        file: "config",
+        label: "BUILD",
+        help: "copilot stops once the code passes its gate, so you can read the diff.",
+        type: { kind: "choice", choices: PHASE_MODE_CHOICES },
+      },
+      {
+        path: "phaseModes.verify",
+        file: "config",
+        label: "VERIFY",
+        help: "copilot asks whether the tests prove the thing works or only that it runs.",
+        type: { kind: "choice", choices: PHASE_MODE_CHOICES },
+      },
+      {
+        path: "phaseModes.simplify",
+        file: "config",
+        label: "SIMPLIFY",
+        help: "copilot shows you what was deleted before it moves on.",
+        type: { kind: "choice", choices: PHASE_MODE_CHOICES },
+      },
+      {
+        path: "phaseModes.review",
+        file: "config",
+        label: "REVIEW",
+        help: "copilot asks whether you would approve this if someone else had written it.",
+        type: { kind: "choice", choices: PHASE_MODE_CHOICES },
+      },
+      {
+        path: "phaseModes.ship",
+        file: "config",
+        label: "SHIP",
+        help: "copilot stops before the tag goes on. The last chance to say no.",
+        type: { kind: "choice", choices: PHASE_MODE_CHOICES },
+      },
+    ],
+  },
+  {
+    id: "display",
+    label: "Display",
+    help: "What the terminal widget and the web dashboard draw. `/infinity:display` picks a template or edits this level by level.",
+    settings: [
+      {
+        path: "display.levels.goal",
+        file: "config",
+        label: "Goals",
+        help: "The outermost level. Off on a plan with one goal costs you nothing.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "display.levels.sprint",
+        file: "config",
+        label: "Sprints",
+        help: "Off hides the sprint rows; the features under them still show, one level shallower.",
         type: { kind: "boolean" },
       },
       {
-        path: "approvals.plan",
+        path: "display.levels.feature",
         file: "config",
-        label: "Sign off PLAN",
-        help: "You see the whole task list before a line of it is built, and can send it back with a note.",
+        label: "Features",
+        help: "Off hides the feature rows; their tasks still show.",
         type: { kind: "boolean" },
       },
+      {
+        path: "display.levels.task",
+        file: "config",
+        label: "Tasks",
+        help: "Off leaves the shape of the run without the work — see the `overview` template.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "display.levels.subtask",
+        file: "config",
+        label: "Subtasks",
+        help: "active shows them only on the task being worked, which is what fits in a widget.",
+        type: { kind: "choice", choices: ["none", "active", "all"] },
+      },
+      {
+        path: "display.counts",
+        file: "config",
+        label: "Counts",
+        help: "The done/total figure on goals, sprints and features.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "display.dependencies",
+        file: "config",
+        label: "Dependency labels",
+        help: "The `← #3` markers that say which task a task is waiting on.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "display.criteria",
+        file: "config",
+        label: "Acceptance criteria",
+        help: "Shown under each feature on the dashboard. No room for them in a terminal widget.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "display.rail",
+        file: "config",
+        label: "Phase rail",
+        help: "The `define ─ plan ─ BUILD ─ …` strip.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "display.progress",
+        file: "config",
+        label: "Progress meter",
+        help: "The bar and the task/feature counts beside it.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "display.alerts",
+        file: "config",
+        label: "Alert strip",
+        help: "Blocked and rework counts, retries, sessions, and any phase waiting for you.",
+        type: { kind: "boolean" },
+      },
+      {
+        path: "display.taskWindow",
+        file: "config",
+        label: "Widget rows",
+        help: "How many rows of plan the terminal shows before it starts scrolling.",
+        type: { kind: "number", min: 3, max: 60 },
+      },
     ],
   },
   {

package/src/core/types.ts

@@ -176,13 +176,55 @@ export type SessionPolicy = {
   carryNotes: boolean;
 };
 
-/** Which phases stop and wait for a human signature before the run continues. */
+/**
+ * Which phases stop and wait for a human signature before the run continues.
+ *
+ * Superseded by `HarnessConfig.phaseModes`, which says the same thing for
+ * *every* phase rather than only these three. Kept because configs written by
+ * 2.3 have it, and `loadConfig` migrates them on read.
+ */
 export type ApprovalPolicy = {
   research: boolean;
   define: boolean;
   plan: boolean;
 };
 
+/** What happens when a phase's gate passes: stop for the human, or advance. */
+export type PhaseMode = "copilot" | "autopilot";
+
+/**
+ * Which parts of the plan a surface draws.
+ *
+ * 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 at all and
+ * lives in the subtask list. Rather than pick a winner, the levels are a
+ * setting, and the widget and the dashboard read the same one.
+ */
+export type DisplayPolicy = {
+  /** Name of the template this came from, or "custom" once it is edited. */
+  preset: string;
+  levels: {
+    goal: boolean;
+    sprint: boolean;
+    feature: boolean;
+    task: boolean;
+    /** "active" shows them only on the task being worked. */
+    subtask: "none" | "active" | "all";
+  };
+  /** `2/5` counts on the grouping rows. */
+  counts: boolean;
+  /** `← #3` dependency labels on tasks. */
+  dependencies: boolean;
+  /** The phase rail, the progress meter and the alert strip. */
+  rail: boolean;
+  progress: boolean;
+  alerts: boolean;
+  /** Acceptance criteria under each feature. Dashboard only — no room in a widget. */
+  criteria: boolean;
+  /** Rows of plan in the terminal widget before it starts scrolling. */
+  taskWindow: number;
+};
+
 /** What the start-up wizard settled, so it is never asked twice. */
 export type IntakeState = {
   /** True once the wizard has run to completion for this project. */
@@ -227,7 +269,13 @@ export type HarnessConfig = {
   phases: { enabled: Phase[] };
   roles: { strict: boolean };
   session: SessionPolicy;
+  /** Legacy: the three-phase approval switch 2.3 shipped. Migrated to `phaseModes`. */
   approvals: ApprovalPolicy;
+  /** Mode per phase — the setting `approvals` became. */
+  phaseModes: Partial<Record<Phase, PhaseMode>>;
+  /** Which named workflow the modes above came from, before any hand-editing. */
+  workflow: { id: string; name: string } | null;
+  display: DisplayPolicy;
   intake: IntakeState;
   /** Set when a gate passed but the phase needs a human signature first. */
   awaitingApproval: Phase | null;