infinity-harness 2.3.0 → 2.4.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";
 
@@ -117,6 +139,17 @@ export default function (pi: ExtensionAPI): void {
   let remoteDir: string | null = null;
   let view: WidgetView = defaultView();
 
+  /**
+   * Is this instance's session still the live one?
+   *
+   * After `ctx.newSession()` pi tears the old runtime down and rebinds
+   * extensions, but this closure and its registered handlers still exist. Any
+   * of them that touches `pi` or a captured `ctx` afterwards gets
+   * "This extension ctx is stale after session replacement" — which is what a
+   * handoff produced on every single turn until this flag existed.
+   */
+  let sessionLive = true;
+
   /**
    * Is a continuous run armed?
    *
@@ -154,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),
@@ -307,6 +341,10 @@ export default function (pi: ExtensionAPI): void {
     // this session stops driving and the replacement never arrives. One
     // attempt, then carry on here — a run that continues in a fat session is
     // far better than a run that stops.
+    // A one-shot `pi -p` run has no next turn to hand anything to: replacing
+    // its session mid-flight produces a stale-context error and nothing else.
+    if (ctx.mode !== "tui" && ctx.mode !== "rpc") return false;
+
     if (handingOff) {
       if (hasPendingHandoff(dir)) {
         notify(ctx, "infinity-harness: the new session never started — continuing here.", "warning");
@@ -531,6 +569,7 @@ export default function (pi: ExtensionAPI): void {
    * summarised. Anything the run cannot afford to forget belongs here.
    */
   pi.on("before_agent_start", async (event, ctx) => {
+    if (!sessionLive) return;
     const dir = projectDir(ctx);
     if (!isHarnessProject(dir)) return;
     try {
@@ -544,6 +583,7 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.on("session_tree", async (_event, ctx) => {
+    if (!sessionLive) return;
     refreshWidget(ctx);
   });
 
@@ -553,6 +593,7 @@ export default function (pi: ExtensionAPI): void {
    * few calls costs little and keeps the plan honest.
    */
   pi.on("context", async (event, ctx) => {
+    if (!sessionLive) return;
     const dir = projectDir(ctx);
     if (!isHarnessProject(dir)) return;
 
@@ -630,6 +671,7 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.on("session_compact", async (event, ctx) => {
+    if (!sessionLive) return;
     const dir = projectDir(ctx);
     if (!isHarnessProject(dir)) return;
     try {
@@ -658,6 +700,7 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.on("turn_end", async (_event, ctx) => {
+    if (!sessionLive) return;
     refreshWidget(ctx);
   });
 
@@ -670,6 +713,7 @@ export default function (pi: ExtensionAPI): void {
    * `/reload`, `/resume`, and pi being restarted.
    */
   pi.on("agent_settled", async (_event, ctx) => {
+    if (!sessionLive) return;
     const dir = projectDir(ctx);
     if (!isHarnessProject(dir)) return;
     if (loopBusy || handingOff) return;
@@ -749,6 +793,7 @@ export default function (pi: ExtensionAPI): void {
    * touch of the config would stop the harness configuring itself.
    */
   pi.on("tool_call", async (event, ctx) => {
+    if (!sessionLive) return;
     const dir = projectDir(ctx);
     if (!isHarnessProject(dir)) return;
 
@@ -791,6 +836,7 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.on("session_shutdown", async () => {
+    sessionLive = false;
     if (remoteServer) {
       try {
         await remoteServer.close();
@@ -1223,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);
@@ -1239,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");
@@ -1301,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,
@@ -1330,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.
    *
@@ -1392,7 +1557,12 @@ export default function (pi: ExtensionAPI): void {
       } catch (e) {
         // A handoff that cannot happen must never end the run: fall back to
         // carrying on in this session, which is the pre-2.3 behaviour.
+        //
+        // Unless the session is already gone — `newSession` can fail *after*
+        // replacing the runtime, and reaching for the old `pi` then is the
+        // "stale ctx" error rather than a recovery.
         clearHandoff(dir);
+        if (!sessionLive) return;
         notify(ctx, `infinity-harness: could not start a new session — ${errMsg(e)}`, "warning");
         pi.sendUserMessage(pending.kickoff, { deliverAs: "followUp" });
       }
@@ -2267,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,7 +1,7 @@
 {
   "name": "infinity-harness",
-  "version": "2.3.0",
-  "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.",
+  "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": [
     "pi-package",

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";
 
@@ -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);
 }