infinity-harness 2.3.1 → 2.5.0

package/src/intake.ts

@@ -7,109 +7,121 @@
  * "you decide everything, including what I want", which is not a mode anybody
  * asked for.
  *
- * The fix is to separate two questions that were tangled together:
+ * The fix was to separate two questions that were tangled together:
  *
- *   1. What are we building?      — always asked, in both modes
- *   2. Who signs off on what?     — the mode's actual meaning
+ *   1. What are we building?      — always asked
+ *   2. Who signs off on what?     — the workflow
  *
- * copilot     the human is in the loop. DEFINE and PLAN are theirs to approve
- *             (and RESEARCH too, when it is on). Not negotiable — that is what
- *             the word means.
- * autopilot   the human is *optionally* in the loop. They pick which of
- *             RESEARCH / DEFINE / PLAN they want to sign and which they hand
- *             to the model. Forfeiting all three is the "give it a goal and
- *             walk away" mode; keeping DEFINE is the common middle.
- *
- * RESEARCH is a separate, optional phase that runs before DEFINE: the human
- * gives an idea, the model goes and finds out what it actually has to be.
+ * And the second of those turned out to be tangled too. "copilot" and
+ * "autopilot" are one switch, and one switch cannot say "let it define and
+ * plan on its own but show me the review". So the answer is a **workflow**: a
+ * mode per phase, with the two familiar words as two named points in that
+ * space rather than the only two points in it. `src/workflow.ts` owns what a
+ * workflow is and where saved ones live.
  *
  * Nothing here talks to pi. It takes answers and returns a plan of record, so
  * the flow can be unit-tested without a terminal and driven from the adapter,
  * from a test, or from a config file.
  */
 
-import type { ApprovalPolicy, Phase, SessionPolicy } from "./core/types.ts";
+import type { ApprovalPolicy, DisplayPolicy, Phase, SessionPolicy } from "./core/types.ts";
 import { DEFAULT_ENABLED_PHASES, PHASE_ORDER } from "./core/types.ts";
+import {
+  BUILTIN_WORKFLOWS,
+  describeModes,
+  normalizeModes,
+  normalizePhases,
+  signedPhases as signedIn,
+  type PhaseMode,
+  type PhaseModes,
+  type Workflow,
+} from "./workflow.ts";
+import { defaultDisplay, normalizeDisplay } from "./ui/display.ts";
 
 export type Mode = "copilot" | "autopilot";
 
 /** The wizard's questions, in the order they are asked. */
-export const INTAKE_STEPS = ["mode", "brief", "research", "approvals", "handoff"] as const;
+export const INTAKE_STEPS = ["workflow", "brief", "handoff", "display"] as const;
 export type IntakeStep = (typeof INTAKE_STEPS)[number];
 
 export type IntakeAnswers = {
-  mode: Mode;
+  /** The chosen workflow: a built-in, one they saved, or one they just built. */
+  workflow: Workflow;
   /** What the human wants built, in their words. Empty is allowed but warned about. */
   brief: string;
-  /** Run the optional RESEARCH phase before DEFINE. */
-  research: boolean;
-  /**
-   * Which phases the human wants to sign, for autopilot only.
-   * Ignored in copilot, where all three are always signed.
-   */
-  approvals?: Partial<ApprovalPolicy>;
   /** Session handoff policy. Defaults to a fresh session per phase. */
   handoff?: SessionPolicy["handoff"];
-  /** Phases the human explicitly chose. Overrides the research toggle. */
-  phases?: Phase[];
+  /** What the surfaces should draw. Defaults to the `focus` template. */
+  display?: DisplayPolicy;
+  /** Model routing for difficulty tiers and consulting. */
+  router?: {
+    enabled: boolean;
+    byDifficulty: Record<string, string>;
+    thinkingByDifficulty?: Partial<Record<string, string>>;
+    master?: string;
+    thinkingMaster?: string;
+    default?: string;
+    thinkingDefault?: string;
+  };
 };
 
 export type IntakePlan = {
+  /** Derived: "copilot" when the run stops for the human anywhere, else "autopilot". */
   mode: Mode;
+  workflow: { id: string; name: string };
   brief: string | null;
   phases: Phase[];
+  phaseModes: PhaseModes;
+  /** Kept in step with `phaseModes` so a 2.3 config read by a 2.3 tool still works. */
   approvals: ApprovalPolicy;
   session: SessionPolicy;
+  display: DisplayPolicy;
+  router?: IntakeAnswers["router"];
   /** What the human should be told about what they just chose. */
   summary: string;
   /** Things that will bite later if left as they are. */
   warnings: string[];
 };
 
-/**
- * In copilot the human is in the loop by definition, so every approvable
- * phase that is enabled is theirs. Making this configurable would make
- * "copilot" mean nothing.
- */
-export function copilotApprovals(phases: Phase[]): ApprovalPolicy {
-  return {
-    research: phases.includes("research"),
-    define: true,
-    plan: true,
-  };
+export function builtInByName(name: string): Workflow | null {
+  return BUILTIN_WORKFLOWS.find((w) => w.id === name || w.name === name) ?? null;
 }
 
-function normalizePhases(base: Phase[], research: boolean): Phase[] {
-  const wanted = new Set<Phase>(base.filter((p) => (PHASE_ORDER as readonly string[]).includes(p)));
-  wanted.delete("init");
-  if (research) wanted.add("research");
-  else wanted.delete("research");
-  const ordered = PHASE_ORDER.filter((p) => wanted.has(p));
-  return ordered.length ? [...ordered] : [...DEFAULT_ENABLED_PHASES];
+/** Build an ad-hoc workflow from a phase list and a mode per phase. */
+export function customWorkflow(
+  phases: Phase[],
+  modes: PhaseModes,
+  name = "custom",
+): Workflow {
+  const ordered = normalizePhases(phases);
+  const normalized = normalizeModes(modes, ordered);
+  return {
+    id: "custom",
+    name,
+    description: describeModes(ordered, normalized),
+    builtIn: false,
+    phases: ordered,
+    modes: normalized,
+  };
 }
 
 /** Turn the wizard's answers into everything `initHarness` needs. */
 export function planIntake(answers: IntakeAnswers): IntakePlan {
-  const research = answers.research === true;
-  const phases = normalizePhases(answers.phases ?? [...DEFAULT_ENABLED_PHASES], research);
-
-  const approvals: ApprovalPolicy =
-    answers.mode === "copilot"
-      ? copilotApprovals(phases)
-      : {
-          research: phases.includes("research") && answers.approvals?.research === true,
-          define: answers.approvals?.define === true,
-          plan: answers.approvals?.plan === true,
-        };
+  const workflow = answers.workflow;
+  const phases = normalizePhases(workflow.phases);
+  const phaseModes = normalizeModes(workflow.modes, phases);
 
-  const handoff = answers.handoff ?? "phase";
+  const handoff = answers.handoff ?? "task";
   const session: SessionPolicy = {
     handoff,
-    contextThreshold: handoff === "off" ? 0 : 0.7,
+    contextThreshold: handoff === "off" ? 0 : 0.6,
     carryNotes: true,
   };
 
+  const display = normalizeDisplay(answers.display ?? defaultDisplay());
   const brief = answers.brief?.trim() ? answers.brief.trim() : null;
+  const signed = PHASE_ORDER.filter((p) => phaseModes[p] === "copilot");
+  const mode: Mode = signed.length > 0 ? "copilot" : "autopilot";
 
   const warnings: string[] = [];
   if (!brief) {
@@ -118,13 +130,19 @@ export function planIntake(answers: IntakeAnswers): IntakePlan {
         "It will not guess a project.",
     );
   }
-  if (answers.mode === "autopilot" && !approvals.define && !approvals.plan && !approvals.research) {
+  if (signed.length === 0) {
     warnings.push(
       "Nothing is being approved by you. The model decides what to build and how, " +
         "and you see it when it is done. This is the right setting for a run you " +
         "want to walk away from — and the wrong one if the goal is vague.",
     );
   }
+  if (signed.length === phases.length) {
+    warnings.push(
+      "Every phase stops for you. Nothing moves while you are away, which is the " +
+        "point — just do not expect to start this and go to bed.",
+    );
+  }
   if (handoff === "off") {
     warnings.push(
       "Session handoff is off, so the whole run shares one context window. " +
@@ -132,20 +150,37 @@ export function planIntake(answers: IntakeAnswers): IntakePlan {
     );
   }
 
-  return { mode: answers.mode, brief, phases, approvals, session, summary: summarize(answers.mode, phases, approvals, session, brief), warnings };
+  return {
+    mode,
+    workflow: { id: workflow.id, name: workflow.name },
+    brief,
+    phases,
+    phaseModes,
+    approvals: {
+      research: phaseModes.research === "copilot",
+      define: phaseModes.define === "copilot",
+      plan: phaseModes.plan === "copilot",
+    },
+    session,
+    display,
+    router: answers.router,
+    summary: summarize(workflow, phases, phaseModes, session, display, brief),
+    warnings,
+  };
 }
 
 function summarize(
-  mode: Mode,
+  workflow: Workflow,
   phases: Phase[],
-  approvals: ApprovalPolicy,
+  modes: PhaseModes,
   session: SessionPolicy,
+  display: DisplayPolicy,
   brief: string | null,
 ): string {
-  const signed = (["research", "define", "plan"] as const).filter((p) => approvals[p]);
+  const signed = phases.filter((p) => modes[p] === "copilot");
   const L: string[] = [];
-  L.push(`Mode      ${mode}`);
-  L.push(`Pipeline  ${phases.join(" → ")}`);
+  L.push(`Workflow  ${workflow.name}`);
+  L.push(`Pipeline  ${phases.map((p) => (modes[p] === "copilot" ? `[${p}]` : p)).join(" → ")}`);
   L.push(
     `You sign  ${signed.length ? signed.map((s) => s.toUpperCase()).join(", ") : "nothing — the model decides and runs"}`,
   );
@@ -158,6 +193,7 @@ function summarize(
           : "fresh session per phase"
     }`,
   );
+  L.push(`Display   ${display.preset}`);
   L.push(`Goal      ${brief ?? "(none yet — you will be asked first thing)"}`);
   return L.join("\n");
 }
@@ -177,21 +213,9 @@ export type Question = {
   placeholder?: string;
 };
 
-export const MODE_QUESTION: Question = {
-  id: "mode",
-  title: "How much do you want to be involved?",
-  options: [
-    {
-      value: "copilot",
-      label: "copilot — I approve the definition and the plan",
-      help: "The run stops and shows you its work before it starts building. You can send any phase back with a note.",
-    },
-    {
-      value: "autopilot",
-      label: "autopilot — I choose what to approve, if anything",
-      help: "You pick which of research, definition and plan you sign. Approve none of them and the run is yours to walk away from.",
-    },
-  ],
+export const WORKFLOW_QUESTION: Question = {
+  id: "workflow",
+  title: "How should this run — which phases, and which of them stop for you?",
 };
 
 export const BRIEF_QUESTION: Question = {
@@ -200,64 +224,81 @@ export const BRIEF_QUESTION: Question = {
   placeholder: "e.g. a CLI that reconciles Stripe payouts against our ledger",
 };
 
-export const RESEARCH_QUESTION: Question = {
-  id: "research",
-  title: "Research the idea first?",
-  options: [
-    {
-      value: "no",
-      label: "no — go straight to defining it",
-      help: "Right when you already know what has to be built.",
-    },
-    {
-      value: "yes",
-      label: "yes — find out what it has to be first",
-      help: "Adds a RESEARCH phase before DEFINE: prior art, constraints, options with costs, a recommendation, and the questions only you can answer.",
-    },
-  ],
-};
-
 export const HANDOFF_QUESTION: Question = {
   id: "handoff",
   title: "When should the run start a fresh session?",
   options: [
+    {
+      value: "goal",
+      label: "per goal — one session for the whole run",
+      help: "The old single-session run. Every task accumulates context until compaction.",
+    },
     {
       value: "phase",
-      label: "every phase (recommended)",
-      help: "Each phase starts clean, working from the brief. Keeps the context small on long runs.",
+      label: "every phase",
+      help: "Old default. Each phase starts clean from the brief.",
+    },
+    {
+      value: "sprint",
+      label: "every sprint",
+      help: "New session whenever the active sprint changes (or phase).",
+    },
+    {
+      value: "feature",
+      label: "every feature",
+      help: "New session on each feature boundary (and sprint/phase).",
     },
     {
       value: "task",
-      label: "every task",
-      help: "The cleanest context per unit of work. Best with small models; costs one extra brief per task.",
+      label: "every task (recommended)",
+      help: "Each task gets a clean session. Best isolation; one extra brief per task.",
+    },
+    {
+      value: "subtask",
+      label: "every subtask",
+      help: "Finest grain — each subtask gets a fresh session. Most isolation, most churn.",
     },
     {
       value: "off",
-      label: "never — one long session",
-      help: "The old behaviour. The context grows for the whole run and compaction takes over.",
+      label: "never — alias for per goal",
+      help: "Same as per goal — one long session without fresh starts.",
     },
   ],
 };
 
-/** The approval checklist, offered only in autopilot. */
-export function approvalOptions(research: boolean): { value: keyof ApprovalPolicy; label: string; help: string }[] {
-  const out: { value: keyof ApprovalPolicy; label: string; help: string }[] = [];
-  if (research) {
-    out.push({
-      value: "research",
-      label: "RESEARCH — what it found before anything is specified",
-      help: "You read harness/docs/RESEARCH.md and say whether it is looking at the right problem.",
-    });
-  }
-  out.push({
-    value: "define",
-    label: "DEFINE — the scope and the acceptance criteria",
-    help: "The single highest-leverage signature: a wrong definition is a weekend building the wrong thing perfectly.",
-  });
-  out.push({
-    value: "plan",
-    label: "PLAN — the task list before any code is written",
-    help: "You see the whole decomposition and can send it back before it is built.",
-  });
-  return out;
-}
+export const DISPLAY_QUESTION: Question = {
+  id: "display",
+  title: "How much of the plan do you want on screen?",
+};
+
+/** The two modes, as a question about one phase. */
+export const PHASE_MODE_OPTIONS: { value: PhaseMode; label: string; help: string }[] = [
+  {
+    value: "autopilot",
+    label: "autopilot — it passes the gate and moves on",
+    help: "The deterministic gate is the only referee for this phase.",
+  },
+  {
+    value: "copilot",
+    label: "copilot — it stops and waits for you",
+    help: "When the gate passes, the run parks and asks you to sign it off before advancing.",
+  },
+];
+
+/** What each phase is for, one line, shown while picking modes. */
+export const PHASE_PURPOSE: Record<Phase, string> = {
+  init: "set the project up",
+  research: "find out what it actually has to be",
+  define: "write down what is being built, and the criteria",
+  plan: "break it into ordered, dependency-aware tasks",
+  build: "implement it, one task at a time",
+  verify: "prove it behaves; hunt what the tests miss",
+  simplify: "delete more than you add",
+  review: "judge it as if someone else wrote it",
+  ship: "tag, changelog, leave the tree clean",
+};
+
+/** Phases someone can put in a pipeline. INIT is not one of them. */
+export const SELECTABLE_PHASES: Phase[] = PHASE_ORDER.filter((p) => p !== "init");
+
+export { DEFAULT_ENABLED_PHASES, signedIn as signedPhases };

package/src/modelRouter.ts

@@ -11,6 +11,14 @@ import { writeJsonAtomic, stripBom } from "./core/fsx.ts";
 export const ROUTER_FILE = "harness/model-router.json";
 export const ROUTER_VERSION = 1;
 
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+
+export const THINKING_LEVELS: readonly ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+
+export function isThinkingLevel(v: unknown): v is ThinkingLevel {
+  return typeof v === "string" && (THINKING_LEVELS as readonly string[]).includes(v);
+}
+
 export interface RouterConfig {
   version: number;
   enabled: boolean;
@@ -24,6 +32,10 @@ export interface RouterConfig {
   byTask?: Record<string, string>;
   consultation?: { enabled: boolean; maxPerTask: number; oneStepOnly: boolean; requireExhaustion: boolean };
   budgets?: { maxReworksPerRun: number; maxReplansPerRun: number; maxReviewBounces: number };
+  /** Thinking level per tier, and for master/default. Empty means inherit pi's current level. */
+  thinkingByDifficulty?: Partial<Record<string, ThinkingLevel | "">>;
+  thinkingMaster?: ThinkingLevel | "";
+  thinkingDefault?: ThinkingLevel | "";
 }
 
 /**
@@ -52,6 +64,9 @@ export const DEFAULT_ROUTER: RouterConfig = {
   byTask: {},
   consultation: { enabled: true, maxPerTask: 1, oneStepOnly: true, requireExhaustion: true },
   budgets: { maxReworksPerRun: 3, maxReplansPerRun: 2, maxReviewBounces: 2 },
+  thinkingByDifficulty: { easy: "" as ThinkingLevel | "", moderate: "" as ThinkingLevel | "", difficult: "" as ThinkingLevel | "" } as Partial<Record<string, ThinkingLevel | "">>,
+  thinkingMaster: "" as ThinkingLevel | "",
+  thinkingDefault: "" as ThinkingLevel | "",
 };
 
 export const DIFFICULTY_LADDER: Array<"easy" | "moderate" | "difficult"> = ["easy", "moderate", "difficult"];
@@ -68,9 +83,13 @@ export function saveRouterConfig(projectDir: string, cfg: RouterConfig): void {
   writeJsonAtomic(routerPath(projectDir), cfg);
 }
 
+function normalizeThinking(v: unknown): ThinkingLevel | "" {
+  return typeof v === "string" && (THINKING_LEVELS as readonly string[]).includes(v) ? (v as ThinkingLevel) : "";
+}
+
 export function loadRouterConfig(projectDir?: string): RouterConfig {
   const p = routerPath(projectDir);
-  if (!existsSync(p)) return { ...DEFAULT_ROUTER, byDifficulty: { ...DEFAULT_ROUTER.byDifficulty! }, byPhase: {}, byRole: {}, byFeature: {}, bySprint: {}, byTask: {}, consultation: { ...DEFAULT_ROUTER.consultation! }, budgets: { ...DEFAULT_ROUTER.budgets! } };
+  if (!existsSync(p)) return { ...DEFAULT_ROUTER, byDifficulty: { ...DEFAULT_ROUTER.byDifficulty! }, byPhase: {}, byRole: {}, byFeature: {}, bySprint: {}, byTask: {}, consultation: { ...DEFAULT_ROUTER.consultation! }, budgets: { ...DEFAULT_ROUTER.budgets! }, thinkingByDifficulty: { ...(DEFAULT_ROUTER.thinkingByDifficulty as Record<string, ThinkingLevel | "">) }, thinkingMaster: DEFAULT_ROUTER.thinkingMaster, thinkingDefault: DEFAULT_ROUTER.thinkingDefault };
   try {
     const raw = JSON.parse(stripBom(readFileSync(p, "utf-8")));
     // merge with defaults to ensure fields
@@ -87,8 +106,18 @@ export function loadRouterConfig(projectDir?: string): RouterConfig {
       byTask: raw.byTask ?? {},
       consultation: raw.consultation ?? { ...DEFAULT_ROUTER.consultation! },
       budgets: raw.budgets ?? { ...DEFAULT_ROUTER.budgets! },
+      thinkingByDifficulty: (() => {
+        const cur = raw.thinkingByDifficulty;
+        if (!cur || typeof cur !== "object") return { ...(DEFAULT_ROUTER.thinkingByDifficulty as Record<string, ThinkingLevel | "">) };
+        const out: Record<string, ThinkingLevel | ""> = {};
+        for (const k of DIFFICULTY_LADDER) out[k] = normalizeThinking((cur as Record<string, unknown>)[k]);
+        return out;
+      })(),
+      thinkingMaster: normalizeThinking(raw.thinkingMaster),
+      thinkingDefault: normalizeThinking(raw.thinkingDefault),
     };
     if (!cfg.byDifficulty) cfg.byDifficulty = { ...DEFAULT_ROUTER.byDifficulty! };
+    if (!cfg.thinkingByDifficulty) cfg.thinkingByDifficulty = { ...(DEFAULT_ROUTER.thinkingByDifficulty as Record<string, ThinkingLevel | "">) };
     return cfg;
   } catch {
     return { ...DEFAULT_ROUTER };
@@ -170,14 +199,38 @@ export function consultNext(
   return null;
 }
 
+export function resolveThinking(opts: ResolveOpts = {}): ThinkingLevel | "" {
+  const cfg = loadRouterConfig(opts.projectDir);
+  // Thinking is orthogonal to routing-enabled; when disabled, fall through to default/inherit.
+  const difficulty = opts.difficulty ?? opts.task?.difficulty ?? opts.feature?.difficulty ?? opts.sprint?.difficulty;
+  if (difficulty && cfg.thinkingByDifficulty && (cfg.thinkingByDifficulty as Record<string, ThinkingLevel | "">)[difficulty]) {
+    const v = (cfg.thinkingByDifficulty as Record<string, ThinkingLevel | "">)[difficulty];
+    if (v) return v;
+  }
+  // Master thinking only via consultation path; here just check difficulty default fallback
+  if (cfg.thinkingDefault) return cfg.thinkingDefault;
+  return "";
+}
+
+export function resolveThinkingForConsult(nextDifficulty: string | null, projectDir?: string): ThinkingLevel | "" {
+  const cfg = loadRouterConfig(projectDir);
+  if (!nextDifficulty) return cfg.thinkingMaster ?? "";
+  const v = cfg.thinkingByDifficulty?.[nextDifficulty as string] as ThinkingLevel | "" | undefined;
+  if (v) return v;
+  return "";
+}
+
 /** For widget/remote read-only exposure */
-export function routerSummary(projectDir?: string): { enabled: boolean; default: string; byDifficulty: Record<string, string>; master: string; budgets: RouterConfig["budgets"]; consultation: RouterConfig["consultation"] } {
+export function routerSummary(projectDir?: string): { enabled: boolean; default: string; byDifficulty: Record<string, string>; thinkingByDifficulty: Record<string, ThinkingLevel | "">; master: string; thinkingMaster: ThinkingLevel | ""; thinkingDefault: ThinkingLevel | ""; budgets: RouterConfig["budgets"]; consultation: RouterConfig["consultation"] } {
   const cfg = loadRouterConfig(projectDir);
   return {
     enabled: cfg.enabled,
     default: cfg.default,
     byDifficulty: { ...(cfg.byDifficulty ?? {}) } as Record<string, string>,
+    thinkingByDifficulty: { ...(cfg.thinkingByDifficulty ?? {}) } as Record<string, ThinkingLevel | "">,
     master: cfg.master ?? DEFAULT_ROUTER.master!,
+    thinkingMaster: (cfg.thinkingMaster ?? "") as ThinkingLevel | "",
+    thinkingDefault: (cfg.thinkingDefault ?? "") as ThinkingLevel | "",
     budgets: cfg.budgets,
     consultation: cfg.consultation,
   };

package/src/remote.ts

@@ -18,12 +18,13 @@ import { createServer, type Server } from "node:http";
 import type { AddressInfo } from "node:net";
 import { resolve } from "node:path";
 
-import type { FeatureList, Feature, Goal, GateResult, Phase, Sprint } from "./core/types.ts";
+import type { DisplayPolicy, FeatureList, Feature, Goal, GateResult, Phase, Sprint } from "./core/types.ts";
 import { loadFeatureList, computeProgress } from "./core/featureList.ts";
 import { loadConfig } from "./core/config.ts";
 import { modelRouterPath, reworkPath } from "./core/paths.ts";
 import { readJsonSafe } from "./core/fsx.ts";
 import { loadRunState } from "./runState.ts";
+import { normalizeDisplay } from "./ui/display.ts";
 import { renderDashboard, escapeHtml, type DashboardState } from "./ui/dashboard.ts";
 
 export { escapeHtml };
@@ -54,6 +55,8 @@ export interface RemoteState {
   /** pi sessions this run has spent — proof the handoff is doing its job. */
   sessions: number | null;
   goalPass: { current: number; max: number } | null;
+  /** What the reader has asked the dashboard to draw. */
+  display: DisplayPolicy;
 }
 
 export interface RemoteServer {
@@ -118,6 +121,7 @@ export function buildRemoteState(projectDir?: string): RemoteState {
         ? { current: config.goalPass, max: config.goalMaxPasses }
         : null,
     sprints: list.sprints ?? [],
+    display: normalizeDisplay(config.display),
   };
 }
 
@@ -136,6 +140,7 @@ function toDashboardState(s: RemoteState): DashboardState {
     awaitingApproval: s.awaitingApproval,
     sessions: s.sessions,
     goalPass: s.goalPass,
+    display: s.display,
   };
 }
 
@@ -159,6 +164,7 @@ export function buildApiPayload(state: RemoteState): Record<string, unknown> {
     sessions: state.sessions,
     goalPass: state.goalPass,
     sprints: state.sprints,
+    display: state.display,
     features: state.features.map((f) => ({
       id: f.id,
       name: f.name,

package/src/ui/config.ts

@@ -15,6 +15,8 @@
  */
 
 import type { Setting, SettingsGroup } from "../core/settings.ts";
+import { summarizeWorkflow } from "../workflow.ts";
+import { normalizeDisplay, summarizeDisplay } from "./display.ts";
 import {
   SETTINGS,
   coerce,
@@ -92,6 +94,10 @@ function summarize(group: SettingsGroup, io: ReturnType<typeof readAll>): string
     }
     case "pipeline":
       return (io.config.phases?.enabled ?? []).join(" → ") || "(none)";
+    case "workflow":
+      return summarizeWorkflow(io.config);
+    case "display":
+      return summarizeDisplay(normalizeDisplay(io.config.display));
     case "commands": {
       const set = Object.entries(io.config.commands ?? {}).filter(([, v]) => Boolean(v));
       return set.length ? set.map(([k]) => k).join(", ") : "none set";
@@ -160,6 +166,13 @@ async function editSetting(setting: Setting, options: ConfigMenuOptions): Promis
       raw = picked;
       break;
     }
+    case "thinking": {
+      const choices = ["(inherit)", "off", "minimal", "low", "medium", "high", "xhigh", "max"];
+      const picked = await prompt.select(`${setting.label} — ${setting.help}`, [...choices, BACK]);
+      if (picked === undefined || picked === BACK) return false;
+      raw = picked;
+      break;
+    }
     case "model": {
       raw = await pickModel(setting, options, typeof current === "string" ? current : "");
       if (raw === undefined) return false;