@ilya-lesikov/pi-pi 0.5.0 → 0.7.0

package/extensions/orchestrator/pp-menu.ts

@@ -1,27 +1,53 @@
 import { existsSync, readdirSync, writeFileSync } from "fs";
-import { join, relative } from "path";
-import { askUser } from "../../3p/pi-ask-user/index.js";
+import { join, relative, basename } from "path";
+import { isDeepStrictEqual } from "util";
+import { askUser, isCancel, type CancelReason } from "../../3p/pi-ask-user/index.js";
 import { unregisterAgentDefinitions } from "./agents/registry.js";
-import { loadConfig, type PiPiConfig } from "./config.js";
+import {
+  type AfterEditCommandConfig,
+  type AfterImplementCommandConfig,
+  GLOBAL_CONFIG_PATH,
+  getDefaultConfig,
+  loadConfig,
+  mergeConfigLayers,
+  parseDuration,
+  readRawConfig,
+  removeConfigValue,
+  resolvePreset,
+  writeConfigValue,
+  type PiPiConfig,
+  type PresetGroup,
+  type OrchestratorRole,
+  type VariantConfig,
+} from "./config.js";
 import {
   loadBrainstormReviewOutputs,
   loadCodeReviewOutputs,
   loadPlanReviewOutputs,
 } from "./context.js";
 import { detectDefaultBranch, enterReviewCycle, finalizeReviewCycle } from "./event-handlers.js";
-import { Orchestrator, deepReviewConfig } from "./orchestrator.js";
+import { Orchestrator } from "./orchestrator.js";
 import { cancelPendingPlannotatorWait } from "./plannotator.js";
 import { spawnPlanners, spawnPlanReviewers } from "./phases/planning.js";
 import { spawnCodeReviewers } from "./phases/review.js";
 import { spawnBrainstormReviewers } from "./phases/brainstorm.js";
+import { nextPhase } from "./phases/machine.js";
+import { getAllAliases, getModelFamilies, getModelInfo, resolveModel, updateRegistryFromAvailableModels } from "./model-registry.js";
+import { compareModelVersion } from "./model-version.js";
 
 import {
   listTasks,
+  getEffectiveMode,
+  getEffectivePhaseMode,
   loadTask,
   lockTask,
   saveTask,
   taskAge,
   taskName,
+  taskNameFromState,
+  taskShortId,
+  type AutonomousConfig,
+  type TaskMode,
   type TaskInfo,
   type TaskType,
 } from "./state.js";
@@ -29,19 +55,55 @@ import {
   clearFlantGeneratedConfig,
   getFlantGeneratedConfig,
   loadFlantSettings,
+  readClaudeOAuthToken,
+  readGatewayApiKey,
   saveFlantSettings,
   unregisterFlantProviders,
   updateFlantInfra,
   type FlantSettings,
 } from "./flant-infra.js";
+import { runDoctor } from "./doctor.js";
+import { normalizeRepoPath, type RepoInfo } from "./repo-utils.js";
+import { getLogger, addTaskDestination, setLogLevel } from "./log.js";
+import { handleSpawnResult } from "./spawn-cleanup.js";
 
 type MenuMode = "command" | "tool";
 
 const BACK = "back" as const;
 
+// Sentinel returned by showActiveTaskMenu when the user dismissed the top-level
+// menu with a deliberate ESC (cancelReason "user"), as opposed to selecting the
+// "Back" option or a programmatic dismissal. Callers (pp_phase_complete) use it
+// to stop the turn cleanly instead of returning reminder text that starts a new
+// LLM turn. It is intentionally distinct from the empty-string "Back" return.
+export const USER_CANCELLED = "\u0000user-cancelled" as const;
+
 type OptionInput = string | { title: string; description?: string };
 
+type TimeoutKey =
+  | "performance.commands.afterEdit"
+  | "performance.commands.afterImplement"
+  | "performance.internals.subagentStale"
+  | "performance.internals.taskLockStale"
+  | "performance.internals.taskLockRefresh";
+
+function isEnabled(value: { enabled?: boolean } | undefined): boolean {
+  return value?.enabled !== false;
+}
+
 async function selectOption(ctx: any, question: string, options: OptionInput[]): Promise<string | undefined> {
+  return (await selectOptionCancelable(ctx, question, options)).choice;
+}
+
+// Like selectOption but also surfaces the cancel reason so callers can tell a
+// deliberate user ESC (reason "user") apart from a normal non-selection. Used by
+// showActiveTaskMenu so pp_phase_complete can stop the turn cleanly on ESC
+// (mirroring ask_user) while keeping the "Back" navigation reminder.
+async function selectOptionCancelable(
+  ctx: any,
+  question: string,
+  options: OptionInput[],
+): Promise<{ choice?: string; cancelReason?: CancelReason }> {
   const result = await askUser(ctx, {
     question,
     options,
@@ -49,8 +111,124 @@ async function selectOption(ctx: any, question: string, options: OptionInput[]):
     allowComment: false,
     allowMultiple: false,
   });
-  if (!result || result.kind !== "selection") return undefined;
-  return result.selections[0];
+  if (result && isCancel(result)) return { cancelReason: result.reason };
+  if (!result || result.kind !== "selection") return {};
+  return { choice: result.selections[0] };
+}
+
+function opt(title: string, description: string): OptionInput {
+  return { title, description };
+}
+
+function getRegisteredRepos(orchestrator: Orchestrator): RepoInfo[] {
+  const repos = orchestrator.active?.state.repos ?? [];
+  if (repos.length > 0) return repos;
+  return [{ path: normalizeRepoPath(orchestrator.cwd), isRoot: true }];
+}
+
+function validateRepos(repos: RepoInfo[]): RepoInfo[] {
+  return repos.filter((repo) => {
+    try {
+      if (!existsSync(repo.path)) return false;
+      return existsSync(join(repo.path, ".git"));
+    } catch {
+      return false;
+    }
+  });
+}
+
+function formatRepoLabel(repo: RepoInfo): string {
+  return `${repo.path}${repo.isRoot ? " (root)" : ""}`;
+}
+
+function formatRepoList(repos: RepoInfo[]): string {
+  return repos
+    .map((repo) => {
+      const base = repo.baseBranch ? `, base: ${repo.baseBranch}` : "";
+      return `- ${formatRepoLabel(repo)}${base}`;
+    })
+    .join("\n");
+}
+
+function appendSection(content: string, heading: string, body: string): string {
+  const normalized = content.trimEnd();
+  if (normalized.includes(`${heading}\n`)) return normalized + "\n";
+  return `${normalized}\n\n${heading}\n${body}\n`;
+}
+
+function appendToSection(content: string, heading: string, body: string): string {
+  const normalized = content.trimEnd();
+  if (normalized.includes(body)) return normalized + "\n";
+
+  const lines = normalized.split("\n");
+  const sectionIndex = lines.findIndex((line) => line.trim() === heading);
+  if (sectionIndex === -1) {
+    return appendSection(normalized, heading, body);
+  }
+
+  let insertIndex = lines.length;
+  for (let i = sectionIndex + 1; i < lines.length; i += 1) {
+    if (lines[i]?.startsWith("## ")) {
+      insertIndex = i;
+      break;
+    }
+  }
+
+  const insertLines = body.split("\n");
+  if (insertIndex > sectionIndex + 1 && lines[insertIndex - 1]?.trim() !== "") {
+    insertLines.unshift("");
+  }
+  lines.splice(insertIndex, 0, ...insertLines);
+  return lines.join("\n") + "\n";
+}
+
+function appendRepoContext(content: string, repos: RepoInfo[]): string {
+  if (repos.length === 0) return content;
+  const lines = repos.map((repo) => `- ${formatRepoLabel(repo)}${repo.baseBranch ? ` (base: ${repo.baseBranch})` : ""}`);
+  return appendToSection(content, "## Constraints", `Registered repositories:\n${lines.join("\n")}`);
+}
+
+function appendResearchOpenQuestions(content: string, text: string): string {
+  const normalized = content.trimEnd();
+  if (normalized.includes("## Open Questions\n")) {
+    return `${normalized}\n${text}\n`;
+  }
+  return `${normalized}\n\n## Open Questions\n${text}\n`;
+}
+
+async function pickCommitForRepo(orchestrator: Orchestrator, ctx: any, repo: RepoInfo): Promise<string | null> {
+  let commits: Array<{ hash: string; message: string; age: string }> = [];
+  try {
+    const logResult = await orchestrator.pi.exec(
+      "git", ["log", "--oneline", "--format=%h\t%s\t%cr", "-30"],
+      { cwd: repo.path, timeout: 5000 },
+    );
+    if (logResult.code === 0 && logResult.stdout.trim()) {
+      commits = logResult.stdout.trim().split("\n").map((line) => {
+        const [hash, message, age] = line.split("\t");
+        return { hash: hash || "", message: message || "", age: age || "" };
+      }).filter((c) => c.hash);
+    }
+  } catch {}
+  if (commits.length === 0) {
+    ctx.ui.notify(`No commits found in ${repo.path}.`, "info");
+    return null;
+  }
+  const commitOptions: OptionInput[] = commits.map((c) => ({
+    title: `${c.hash} ${c.message}`,
+    description: c.age,
+  }));
+  commitOptions.push({ title: "Back", description: "Return to the previous menu" });
+  const picked = await selectOption(ctx, `Review changes since (${repo.path}):`, commitOptions);
+  if (!picked || picked === "Back") return null;
+  const pickedHash = picked.split(" ")[0];
+  return pickedHash || null;
+}
+
+interface RepoPrContext {
+  repoPath: string;
+  prUrl: string | null;
+  prContext: string | null;
 }
 
 function setStep(orchestrator: Orchestrator, step: string): void {
@@ -75,7 +253,7 @@ function showStatus(orchestrator: Orchestrator, ctx: any): void {
 
 async function abortCurrentWork(orchestrator: Orchestrator, ctx: any): Promise<void> {
   orchestrator.abortAllSubagents();
-  ctx.abort?.();
+  orchestrator.transitionController.abortMainAgent(ctx.abort?.bind(ctx));
   await ctx.waitForIdle?.();
   const taskStore = (globalThis as any)[Symbol.for("pi-tasks:store")];
   taskStore?.clearAll?.();
@@ -87,11 +265,13 @@ async function pauseTask(orchestrator: Orchestrator, ctx: any): Promise<string>
 
   cancelPendingPlannotatorWait(orchestrator);
   orchestrator.abortAllSubagents();
-  ctx.abort?.();
+  orchestrator.transitionController.abortMainAgent(ctx.abort?.bind(ctx));
   await ctx.waitForIdle?.();
 
   const name = orchestrator.active.description;
+  const type = orchestrator.active.type;
 
+  orchestrator.active.state.reviewCycle = null;
   saveTask(orchestrator.active.dir, orchestrator.active.state);
   unregisterAgentDefinitions(orchestrator.pi);
   await orchestrator.cleanupActive();
@@ -100,7 +280,15 @@ async function pauseTask(orchestrator: Orchestrator, ctx: any): Promise<string>
   taskStore?.clearAll?.();
   taskStore?.refreshWidget?.(ctx.ui);
 
+  orchestrator.lastCtx = ctx;
   orchestrator.updateStatus(ctx);
+  // Route through the controller as a "done" target (same coordinator as every
+  // other compaction). The agent was aborted above, so this compacts via the
+  // already-idle path; the awaitable resolves at every terminus.
+  await orchestrator.transitionController.requestTransition({
+    kind: "done",
+    summary: `Task "${name}" (${type}) paused.`,
+  });
   ctx.ui.notify(`Task "${name}" paused. Use /pp → Resume to continue.`, "info");
   return `Task "${name}" paused.`;
 }
@@ -110,17 +298,17 @@ async function finishTask(orchestrator: Orchestrator, ctx: any): Promise<string>
 
   cancelPendingPlannotatorWait(orchestrator);
   orchestrator.abortAllSubagents();
-  ctx.abort?.();
+  orchestrator.transitionController.abortMainAgent(ctx.abort?.bind(ctx));
   await ctx.waitForIdle?.();
 
   const name = orchestrator.active.description;
   const type = orchestrator.active.type;
   const dir = orchestrator.active.dir;
 
-  orchestrator.taskDoneCompactionPending = true;
-  orchestrator.taskDoneCompactionSummary = `Task "${name}" (${type}) completed.`;
+  orchestrator.lastCtx = ctx;
 
   orchestrator.active.state.phase = "done";
+  orchestrator.active.state.reviewCycle = null;
   saveTask(orchestrator.active.dir, orchestrator.active.state);
   unregisterAgentDefinitions(orchestrator.pi);
   await orchestrator.cleanupActive();
@@ -130,7 +318,12 @@ async function finishTask(orchestrator: Orchestrator, ctx: any): Promise<string>
   taskStore?.refreshWidget?.(ctx.ui);
 
   orchestrator.updateStatus(ctx);
-  ctx.compact?.();
+  // Route through the controller as a "done" target (fire-and-forget: the task
+  // is over, nothing awaits this compaction).
+  void orchestrator.transitionController.requestTransition({
+    kind: "done",
+    summary: `Task "${name}" (${type}) completed.`,
+  });
 
   const urExists = existsSync(join(dir, "USER_REQUEST.md"));
   const resExists = existsSync(join(dir, "RESEARCH.md"));
@@ -150,10 +343,59 @@ async function finishTask(orchestrator: Orchestrator, ctx: any): Promise<string>
 
 function loadPhaseReviewOutputs(taskDir: string, phase: string, pass: number): { name: string; content: string }[] {
   if (phase === "brainstorm") return loadBrainstormReviewOutputs(taskDir, pass);
-  if (phase === "plan") return loadPlanReviewOutputs(taskDir);
+  if (phase === "plan") return loadPlanReviewOutputs(taskDir, pass);
   return loadCodeReviewOutputs(taskDir, pass);
 }
 
+function getDefaultReviewPresetName(config: PiPiConfig, phase: string): string {
+  if (phase === "brainstorm") return config.agents.subagents.presetGroups.brainstormReviewers.default;
+  if (phase === "plan") return config.agents.subagents.presetGroups.planReviewers.default;
+  return config.agents.subagents.presetGroups.codeReviewers.default;
+}
+
+function isPresetEnabled(preset: { enabled?: boolean } | undefined): boolean {
+  return preset?.enabled !== false;
+}
+
+function getReviewPresetGroup(phase: string): PresetGroup {
+  if (phase === "brainstorm") return "brainstormReviewers";
+  if (phase === "plan") return "planReviewers";
+  return "codeReviewers";
+}
+
+export async function pickPreset(
+  ctx: any,
+  orchestrator: Orchestrator,
+  group: PresetGroup,
+  title: string,
+): Promise<string | null> {
+  const presets = orchestrator.config.agents.subagents.presetGroups[group].presets ?? {};
+  const defaultPresetName = orchestrator.config.agents.subagents.presetGroups[group].default;
+
+  const options: OptionInput[] = [];
+  const byTitle = new Map<string, string>();
+
+  for (const [presetName, preset] of Object.entries(presets)) {
+    if (!isPresetEnabled(preset)) continue;
+    const enabledModels = Object.values(preset.agents)
+      .filter((variant) => isEnabled(variant))
+      .map((variant) => {
+        const info = getModelInfo(variant.model);
+        return `${info.vendor}/${info.family} (${variant.thinking})`;
+      });
+    const description = enabledModels.length > 0 ? enabledModels.join(", ") : "No enabled models";
+    const optionTitle = presetName === defaultPresetName ? `${presetName} [default]` : presetName;
+    byTitle.set(optionTitle, presetName);
+    options.push({ title: optionTitle, description });
+  }
+
+  options.push({ title: "Back", description: "Return to the previous menu" });
+
+  const choice = await selectOption(ctx, title, options);
+  if (!choice || choice === "Back") return null;
+  return byTitle.get(choice) ?? null;
+}
+
 export async function resumeTask(
   orchestrator: Orchestrator,
   ctx: any,
@@ -171,9 +413,9 @@ export async function resumeTask(
 
   let release: (() => Promise<void>) | null = null;
   try {
-    release = await lockTask(task.dir, orchestrator.config.timeouts);
+    release = await lockTask(task.dir, orchestrator.config.performance.internals);
   } catch {
-    const staleSeconds = Math.round(orchestrator.config.timeouts.lockStale / 1000);
+    const staleSeconds = Math.round(orchestrator.config.performance.internals.taskLockStale / 1000);
     const message =
       `Cannot resume: task is locked by another pi session (or a session that crashed less than ${staleSeconds}s ago). ` +
       `Wait ${staleSeconds}s for the lock to expire, or kill the other session first.`;
@@ -184,6 +426,39 @@ export async function resumeTask(
   orchestrator.resetTaskScopedState();
   orchestrator.activeTaskToken++;
 
+  const normalizedRoot = normalizeRepoPath(orchestrator.cwd);
+  if (!task.state.repos || task.state.repos.length === 0) {
+    task.state.repos = [{ path: normalizedRoot, isRoot: true }];
+    saveTask(task.dir, task.state);
+  }
+
+  if (!task.state.repos.some((repo) => repo.isRoot)) {
+    const rootByPath = task.state.repos.find((repo) => repo.path === normalizedRoot);
+    if (rootByPath) {
+      rootByPath.isRoot = true;
+    } else if (task.state.repos.length > 0) {
+      task.state.repos[0]!.isRoot = true;
+    } else {
+      task.state.repos = [{ path: normalizedRoot, isRoot: true }];
+    }
+    saveTask(task.dir, task.state);
+  }
+
+  const validRepos = validateRepos(task.state.repos ?? []);
+  if ((task.state.repos?.length ?? 0) !== validRepos.length) {
+    const pruned = (task.state.repos?.length ?? 0) - validRepos.length;
+    task.state.repos = validRepos;
+    saveTask(task.dir, task.state);
+    ctx.ui.notify(`Pruned ${pruned} stale repo(s) that no longer exist.`, "warning");
+  }
+
+  if (!task.state.repos || task.state.repos.length === 0) {
+    task.state.repos = [{ path: normalizedRoot, isRoot: true }];
+    saveTask(task.dir, task.state);
+  }
+
+  const needsRepoRegistrationPrompt = task.state.repos.some((repo) => !repo.baseBranch);
+
   orchestrator.active = {
     dir: task.dir,
     type: task.type,
@@ -195,7 +470,11 @@ export async function resumeTask(
     description: task.state.description,
   };
 
-  const modelConfig = orchestrator.config.mainModel[
+  addTaskDestination(task.dir);
+  setLogLevel(orchestrator.config.general.logLevel);
+  getLogger().info({ s: "task", dir: task.dir, type: task.type, phase: task.state.phase }, "task resumed");
+
+  const modelConfig = orchestrator.config.agents.orchestrators[
     task.type === "debug" ? "debug"
     : task.type === "brainstorm" ? "brainstorm"
     : task.type === "review" ? "review"
@@ -215,32 +494,52 @@ export async function resumeTask(
 
   if (orchestrator.active.state.phase === "plan" && orchestrator.active.state.step === "await_planners") {
     const plansDir = join(orchestrator.active.dir, "plans");
-    const enabledVariants = Object.entries(orchestrator.config.planners).filter(([, v]) => v.enabled);
+    const requestedPlannerPresetName = orchestrator.active.state.activePlannerPreset ?? orchestrator.config.agents.subagents.presetGroups.planners.default;
+    const plannerPresetExists = Object.prototype.hasOwnProperty.call(orchestrator.config.agents.subagents.presetGroups.planners.presets ?? {}, requestedPlannerPresetName);
+    const plannerPresetName = plannerPresetExists
+      ? requestedPlannerPresetName
+      : (Object.keys(orchestrator.config.agents.subagents.presetGroups.planners.presets ?? {})[0] ?? requestedPlannerPresetName);
+    if (orchestrator.active.state.activePlannerPreset !== plannerPresetName) {
+      orchestrator.active.state.activePlannerPreset = plannerPresetName;
+      saveTask(orchestrator.active.dir, orchestrator.active.state);
+    }
+    if (!plannerPresetExists && plannerPresetName !== requestedPlannerPresetName) {
+      ctx.ui.notify(
+        `Planner preset "${requestedPlannerPresetName}" not found. Falling back to "${plannerPresetName}".`,
+        "warning",
+      );
+    }
+    const plannerVariants = resolvePreset(orchestrator.config, "planners", plannerPresetName);
+    const enabledVariants = Object.entries(plannerVariants).filter(([, v]) => isEnabled(v));
     const planFiles = existsSync(plansDir)
       ? readdirSync(plansDir).filter((f) => f.endsWith(".md") && !f.includes("synthesized") && !f.includes("review_"))
       : [];
-    if (planFiles.length >= enabledVariants.length) {
+    const completedVariants = new Set(planFiles.map((f) => f.replace(/^\d+_/, "").replace(/\.md$/, "")));
+    const hasAllEnabledVariants = enabledVariants.every(([name]) => completedVariants.has(name));
+    if (hasAllEnabledVariants) {
       orchestrator.active.state.step = "synthesize";
       saveTask(orchestrator.active.dir, orchestrator.active.state);
     } else {
-      const completedVariants = new Set(planFiles.map((f) => f.replace(/^\d+_/, "").replace(/\.md$/, "")));
       const missingVariants = enabledVariants.filter(([name]) => !completedVariants.has(name));
       if (missingVariants.length > 0) {
-        const missingConfig: Record<string, any> = {};
+        const missingConfig: typeof plannerVariants = {};
         for (const [name, cfg] of missingVariants) missingConfig[name] = cfg;
-        const partialConfig = { ...orchestrator.config, planners: missingConfig };
         orchestrator.pendingSubagentSpawns = missingVariants.length;
         orchestrator.failedPlannerVariants = [];
-        spawnPlanners(pi, orchestrator.cwd, orchestrator.active.dir, orchestrator.active.taskId, partialConfig).then((result) => {
-          orchestrator.failedPlannerVariants = result.failedVariants;
-          if (result.spawned === 0) orchestrator.pendingSubagentSpawns = 0;
-          for (const id of result.agentIds ?? []) {
-            orchestrator.spawnedAgentIds.delete(id);
-          }
-          orchestrator.pendingSubagentSpawns = 0;
-        }).catch((err: any) => {
-          orchestrator.pendingSubagentSpawns = 0;
-          console.error(`[pi-pi] spawnPlanners failed: ${err.message}`);
+        const plannerSpawn = spawnPlanners(
+          pi,
+          orchestrator.cwd,
+          orchestrator.active.dir,
+          orchestrator.active.taskId,
+          orchestrator.config,
+          orchestrator.transitionController.phaseSend,
+          missingConfig,
+          orchestrator.active?.state.repos ?? [],
+        );
+        handleSpawnResult(orchestrator, plannerSpawn, {
+          kind: "planner",
+          logScope: "planner",
+          logMessage: "spawnPlanners failed",
         });
       } else {
         orchestrator.active.state.step = "synthesize";
@@ -251,35 +550,56 @@ export async function resumeTask(
 
   if (orchestrator.active.state.reviewCycle) {
     const cycle = orchestrator.active.state.reviewCycle;
-    const reviewConfig = cycle.kind === "auto-deep" ? deepReviewConfig(orchestrator.config) : orchestrator.config;
     const phase = orchestrator.active.state.phase;
+    const requestedReviewPresetName = orchestrator.active.state.activeReviewPreset
+      ?? getDefaultReviewPresetName(orchestrator.config, phase);
+    const group = getReviewPresetGroup(phase);
+    const reviewPresetExists = Object.prototype.hasOwnProperty.call(orchestrator.config.agents.subagents.presetGroups[group].presets ?? {}, requestedReviewPresetName);
+    const presetName = reviewPresetExists
+      ? requestedReviewPresetName
+      : (Object.keys(orchestrator.config.agents.subagents.presetGroups[group].presets ?? {})[0] ?? requestedReviewPresetName);
+    if (orchestrator.active.state.activeReviewPreset !== presetName) {
+      orchestrator.active.state.activeReviewPreset = presetName;
+      saveTask(orchestrator.active.dir, orchestrator.active.state);
+    }
+    if (!reviewPresetExists && presetName !== requestedReviewPresetName) {
+      ctx.ui.notify(
+        `Review preset "${requestedReviewPresetName}" not found. Falling back to "${presetName}".`,
+        "warning",
+      );
+    }
     const reviewers = phase === "brainstorm"
-      ? reviewConfig.brainstormReviewers
+      ? resolvePreset(orchestrator.config, "brainstormReviewers", presetName)
       : phase === "plan"
-      ? reviewConfig.planReviewers
-      : reviewConfig.codeReviewers;
-    const reviewerCount = Object.values(reviewers).filter((v) => v.enabled).length;
+      ? resolvePreset(orchestrator.config, "planReviewers", presetName)
+      : resolvePreset(orchestrator.config, "codeReviewers", presetName);
+    const reviewerCount = Object.values(reviewers).filter((v) => isEnabled(v)).length;
 
-    if ((cycle.kind === "auto" || cycle.kind === "auto-deep") && (cycle.step === "spawn_reviewers" || cycle.step === "await_reviewers")) {
+    if (cycle.kind === "auto" && (cycle.step === "spawn_reviewers" || cycle.step === "await_reviewers")) {
       const outputs = loadPhaseReviewOutputs(orchestrator.active.dir, phase, cycle.pass);
-      if (outputs.length >= reviewerCount) {
+      if (reviewerCount === 0) {
+        orchestrator.active.state.reviewCycle = null;
+        orchestrator.active.state.step = "llm_work";
+        saveTask(orchestrator.active.dir, orchestrator.active.state);
+        orchestrator.safeSendUserMessage("[PI-PI] No reviewers configured — nothing to review. Continue working.");
+      } else if (outputs.length >= reviewerCount) {
         cycle.step = "apply_feedback";
         orchestrator.active.state.step = "apply_feedback";
         saveTask(orchestrator.active.dir, orchestrator.active.state);
         const rendered = outputs.map((o) => `=== ${o.name} ===\n${o.content}`).join("\n\n");
-        pi.sendMessage(
+        orchestrator.transitionController.sendCustom(
           {
             customType: "pp-review-ready",
             content: `[PI-PI] Reviewer outputs are ready.\n\n${rendered}`,
             display: false,
           },
-          { deliverAs: "steer" },
+          "context",
         );
       } else {
         const completedVariants = new Set(
           outputs.map((o) => o.name.replace(/^\d+_/, "").replace(/_round-\d+\.md$/, "").replace(/\.md$/, "")),
         );
-        const enabledVariants = Object.entries(reviewers).filter(([, v]) => v.enabled);
+        const enabledVariants = Object.entries(reviewers).filter(([, v]) => isEnabled(v));
         const missingVariants = enabledVariants.filter(([name]) => !completedVariants.has(name));
 
         if (missingVariants.length === 0) {
@@ -287,39 +607,69 @@ export async function resumeTask(
           orchestrator.active.state.step = "apply_feedback";
           saveTask(orchestrator.active.dir, orchestrator.active.state);
           const rendered = outputs.map((o) => `=== ${o.name} ===\n${o.content}`).join("\n\n");
-          pi.sendMessage(
+          orchestrator.transitionController.sendCustom(
             {
               customType: "pp-review-ready",
               content: `[PI-PI] Reviewer outputs are ready.\n\n${rendered}`,
               display: false,
             },
-            { deliverAs: "steer" },
+            "context",
           );
         } else {
-          const missingReviewerConfig: Record<string, any> = {};
+          const missingReviewerConfig: typeof reviewers = {};
           for (const [name, cfg] of missingVariants) missingReviewerConfig[name] = cfg;
-          const partialConfig = phase === "brainstorm"
-            ? { ...reviewConfig, brainstormReviewers: missingReviewerConfig }
-            : phase === "plan"
-            ? { ...reviewConfig, planReviewers: missingReviewerConfig }
-            : { ...reviewConfig, codeReviewers: missingReviewerConfig };
+          orchestrator.active.state.activeReviewPreset = presetName;
+          saveTask(orchestrator.active.dir, orchestrator.active.state);
           orchestrator.pendingSubagentSpawns = missingVariants.length;
           const spawnFn = phase === "brainstorm"
-            ? () => spawnBrainstormReviewers(pi, orchestrator.cwd, orchestrator.active!.dir, orchestrator.active!.taskId, partialConfig, cycle.pass)
+            ? () => spawnBrainstormReviewers(
+              pi,
+              orchestrator.cwd,
+              orchestrator.active!.dir,
+              orchestrator.active!.taskId,
+              orchestrator.config,
+              cycle.pass,
+              orchestrator.transitionController.phaseSend,
+              missingReviewerConfig,
+              orchestrator.active?.state.repos ?? [],
+            )
             : phase === "plan"
-            ? () => spawnPlanReviewers(pi, orchestrator.cwd, orchestrator.active!.dir, orchestrator.active!.taskId, partialConfig)
-            : () => spawnCodeReviewers(pi, orchestrator.cwd, orchestrator.active!.dir, orchestrator.active!.taskId, partialConfig, cycle.pass);
+            ? () => spawnPlanReviewers(
+              pi,
+              orchestrator.cwd,
+              orchestrator.active!.dir,
+              orchestrator.active!.taskId,
+              orchestrator.config,
+              cycle.pass,
+              orchestrator.transitionController.phaseSend,
+              missingReviewerConfig,
+              orchestrator.active?.state.repos ?? [],
+            )
+            : () => spawnCodeReviewers(
+              pi,
+              orchestrator.cwd,
+              orchestrator.active!.dir,
+              orchestrator.active!.taskId,
+              orchestrator.config,
+              cycle.pass,
+              phase,
+              orchestrator.transitionController.phaseSend,
+              missingReviewerConfig,
+              orchestrator.active?.state.repos ?? [],
+            );
           orchestrator.failedReviewerVariants = [];
-          spawnFn().then((result) => {
-            orchestrator.failedReviewerVariants = result.failedVariants;
-            if (result.spawned === 0) orchestrator.pendingSubagentSpawns = 0;
-            for (const id of result.agentIds ?? []) {
-              orchestrator.spawnedAgentIds.delete(id);
-            }
-            orchestrator.pendingSubagentSpawns = 0;
-          }).catch((err: any) => {
-            orchestrator.pendingSubagentSpawns = 0;
-            console.error(`[pi-pi] spawn reviewers failed: ${err.message}`);
+          handleSpawnResult(orchestrator, spawnFn(), {
+            kind: "reviewer",
+            logScope: "review",
+            logMessage: "spawn reviewers failed",
+            onSettled: (result) => {
+              if (result?.spawned === 0 && orchestrator.active?.state.reviewCycle?.step === "await_reviewers") {
+                orchestrator.active.state.reviewCycle = null;
+                orchestrator.active.state.step = "llm_work";
+                saveTask(orchestrator.active.dir, orchestrator.active.state);
+                orchestrator.safeSendUserMessage("[PI-PI] No reviewer outputs were produced — nothing to review. Continue working.");
+              }
+            },
           });
           cycle.step = "await_reviewers";
           orchestrator.active.state.step = "await_reviewers";
@@ -329,13 +679,13 @@ export async function resumeTask(
     } else if (cycle.step === "apply_feedback") {
       const outputs = loadPhaseReviewOutputs(orchestrator.active.dir, phase, cycle.pass);
       const rendered = outputs.map((o) => `=== ${o.name} ===\n${o.content}`).join("\n\n");
-      pi.sendMessage(
+      orchestrator.transitionController.sendCustom(
         {
           customType: "pp-review-ready",
           content: `[PI-PI] Review cycle is in apply_feedback step.\n\n${rendered}`,
           display: false,
         },
-        { deliverAs: "steer" },
+        "context",
       );
     }
   }
@@ -349,6 +699,12 @@ export async function resumeTask(
     orchestrator.safeSendUserMessage(`[PI-PI] Resumed ${orchestrator.active.state.phase} phase. Continue working.`);
   }
 
+  if (needsRepoRegistrationPrompt) {
+    orchestrator.safeSendUserMessage(
+      "[PI-PI] Register your repos using pp_register_repo (including the root) before continuing.",
+    );
+  }
+
   return { ok: true };
 }
 
@@ -356,10 +712,11 @@ function listCompletedFromTasks(cwd: string): TaskInfo[] {
   const paused = new Set<string>([
     ...listTasks(cwd, "brainstorm").map((t) => t.dir),
     ...listTasks(cwd, "debug").map((t) => t.dir),
+    ...listTasks(cwd, "review").map((t) => t.dir),
   ]);
   const results: TaskInfo[] = [];
 
-  for (const type of ["brainstorm", "debug"] as TaskType[]) {
+  for (const type of ["brainstorm", "debug", "review"] as TaskType[]) {
     const typeDir = join(cwd, ".pp", "state", type);
     if (!existsSync(typeDir)) continue;
     for (const entry of readdirSync(typeDir, { withFileTypes: true })) {
@@ -395,34 +752,6 @@ async function showSubagentsMenu(ctx: any): Promise<void> {
   await api.showMenu(ctx);
 }
 
-async function showLspMenu(ctx: any): Promise<typeof BACK> {
-  while (true) {
-    const choice = await selectOption(ctx, "LSP", [
-      { title: "Status", description: "Show detected language servers and their state" },
-      { title: "Restart", description: "Stop all servers. They reinitialize on next use" },
-      { title: "Back", description: "Return to the previous menu" },
-    ]);
-    if (!choice || choice === "Back") return BACK;
-
-    const api = (globalThis as any)[Symbol.for("pi-lsp:api")] as {
-      status?: (menuCtx: any) => Promise<void>;
-      restart?: (menuCtx: any) => Promise<void>;
-    } | undefined;
-
-    if (!api?.status || !api?.restart) {
-      ctx.ui.notify("LSP API is not available.", "warning");
-      continue;
-    }
-
-    if (choice === "Status") {
-      await api.status(ctx);
-      continue;
-    }
-
-    await api.restart(ctx);
-  }
-}
-
 function countFlantProviders(settings: FlantSettings): { anthropic: number; openai: number } {
   const models = settings.cachedFlantModels ?? [];
   const anthropic = models.filter((m) => m.startsWith("claude-")).length;
@@ -436,27 +765,36 @@ function collectRoleAssignments(config: Partial<PiPiConfig> | null): string[] {
     if (typeof value === "string" && value.length > 0) out.push(`${key} = ${value}`);
   };
 
-  add("mainModel.implement", config.mainModel?.implement?.model);
-  add("mainModel.debug", config.mainModel?.debug?.model);
-  add("mainModel.brainstorm", config.mainModel?.brainstorm?.model);
-  add("mainModel.review", config.mainModel?.review?.model);
+  add("agents.orchestrators.implement", config.agents?.orchestrators?.implement?.model);
+  add("agents.orchestrators.plan", config.agents?.orchestrators?.plan?.model);
+  add("agents.orchestrators.debug", config.agents?.orchestrators?.debug?.model);
+  add("agents.orchestrators.brainstorm", config.agents?.orchestrators?.brainstorm?.model);
+  add("agents.orchestrators.review", config.agents?.orchestrators?.review?.model);
+
+  const addPresetAssignments = (group: "planners" | "planReviewers" | "codeReviewers" | "brainstormReviewers") => {
+    const presets = config.agents?.subagents?.presetGroups?.[group]?.presets;
+    if (!presets || typeof presets !== "object") return;
+    for (const [presetName, preset] of Object.entries(presets)) {
+      if (!preset || typeof preset !== "object") continue;
+      const agents = (preset as any).agents;
+      if (!agents || typeof agents !== "object") continue;
+      if ((preset as any).enabled === false) continue;
+      for (const [name, variant] of Object.entries(agents as Record<string, any>)) {
+        if (variant?.enabled !== false) {
+          add(`agents.subagents.presetGroups.${group}.presets.${presetName}.agents.${name}`, variant.model);
+        }
+      }
+    }
+  };
 
-  for (const [name, variant] of Object.entries(config.planners ?? {})) {
-    if (variant.enabled) add(`planners.${name}`, variant.model);
-  }
-  for (const [name, variant] of Object.entries(config.planReviewers ?? {})) {
-    if (variant.enabled) add(`planReviewers.${name}`, variant.model);
-  }
-  for (const [name, variant] of Object.entries(config.codeReviewers ?? {})) {
-    if (variant.enabled) add(`codeReviewers.${name}`, variant.model);
-  }
-  for (const [name, variant] of Object.entries(config.brainstormReviewers ?? {})) {
-    if (variant.enabled) add(`brainstormReviewers.${name}`, variant.model);
-  }
+  addPresetAssignments("planners");
+  addPresetAssignments("planReviewers");
+  addPresetAssignments("codeReviewers");
+  addPresetAssignments("brainstormReviewers");
 
-  add("agents.explore", config.agents?.explore?.model);
-  add("agents.librarian", config.agents?.librarian?.model);
-  add("agents.task", config.agents?.task?.model);
+  add("agents.subagents.simple.explore", config.agents?.subagents?.simple?.explore?.model);
+  add("agents.subagents.simple.librarian", config.agents?.subagents?.simple?.librarian?.model);
+  add("agents.subagents.simple.task", config.agents?.subagents?.simple?.task?.model);
   return out;
 }
 
@@ -469,6 +807,20 @@ function flantStatusText(settings: FlantSettings): string {
     `Last updated: ${settings.lastUpdated ?? "never"}`,
     `Providers: pp-flant-anthropic (${providers.anthropic} models), pp-flant-openai (${providers.openai} models)`,
   ];
+  if (settings.subscription) {
+    const hasOAuth = !!readClaudeOAuthToken();
+    const hasGatewayKey = !!readGatewayApiKey();
+    const subActive = hasOAuth && hasGatewayKey;
+    lines.push(
+      `Personal subscription: on (${subActive ? `active — pp-flant-anthropic-sub, ${providers.anthropic} models` : "inactive"})`,
+    );
+    if (!subActive) {
+      if (!hasOAuth) lines.push("  - missing Claude OAuth token (run pi /login for Anthropic)");
+      if (!hasGatewayKey) lines.push("  - missing gateway key (set LLM_API_KEY or FLANT_API_KEY)");
+    }
+  } else {
+    lines.push("Personal subscription: off");
+  }
   if (assignments.length === 0) {
     lines.push("Role assignments: none");
   } else {
@@ -498,10 +850,12 @@ async function showFlantInfraMenu(orchestrator: Orchestrator, ctx: any): Promise
     const settings = loadFlantSettings();
     const enableLabel = `Enable: ${settings.enabled ? "ON" : "OFF"}`;
     const options: OptionInput[] = [enableLabel];
+    const subscriptionLabel = `Personal Claude subscription: ${settings.subscription ? "ON" : "OFF"}`;
     if (settings.enabled) {
       options.push(
         `Auto-update on startup: ${settings.autoUpdate ? "ON" : "OFF"}`,
         `Cache period: ${settings.cacheTTLDays} ${settings.cacheTTLDays === 1 ? "day" : "days"}`,
+        subscriptionLabel,
         "Update now",
         "Current status",
       );
@@ -538,6 +892,34 @@ async function showFlantInfraMenu(orchestrator: Orchestrator, ctx: any): Promise
       continue;
     }
 
+    if (choice === subscriptionLabel) {
+      const turningOn = !settings.subscription;
+      if (turningOn) {
+        if (!readClaudeOAuthToken()) {
+          ctx.ui.notify("No Claude OAuth token found. Log in to your personal Claude subscription in pi first (/login → Anthropic), then retry.", "warning");
+          continue;
+        }
+        if (!readGatewayApiKey()) {
+          ctx.ui.notify("Set LLM_API_KEY (or FLANT_API_KEY) for the gateway first.", "warning");
+          continue;
+        }
+      }
+      const next = { ...settings, subscription: turningOn };
+      saveFlantSettings(next);
+      const result = await updateFlantInfra(orchestrator.pi);
+      if (!result.ok) {
+        ctx.ui.notify(`Personal subscription ${turningOn ? "enable" : "disable"} failed: ${result.error ?? "unknown error"}`, "error");
+      } else {
+        ctx.ui.notify(
+          turningOn
+            ? "Personal Claude subscription ON — Claude roles now route through sub/claude-* (billed to your subscription); non-Claude roles stay on llm-api.flant.ru."
+            : "Personal Claude subscription OFF — Claude roles reverted to pp-flant-anthropic.",
+          "info",
+        );
+      }
+      continue;
+    }
+
     if (choice.startsWith("Cache period:")) {
       const selected = await selectOption(ctx, "Cache period", [
         { title: "1 day", description: "Refresh model metadata daily" },
@@ -574,7 +956,7 @@ function formatTokenCount(count: number): string {
   return `${Math.round(count / 1000000)}M`;
 }
 
-function formatDuration(ms: number): string {
+function formatElapsedDuration(ms: number): string {
   const sec = Math.floor(ms / 1000);
   if (sec < 60) return `${sec}s`;
   const min = Math.floor(sec / 60);
@@ -585,17 +967,18 @@ function formatDuration(ms: number): string {
   return remMin > 0 ? `${hr}h ${remMin}m` : `${hr}h`;
 }
 
-function showUsage(ctx: any): void {
+export function showUsage(ctx: any): void {
   const tracker = (globalThis as any)[Symbol.for("pi-pi:usage-tracker")] as
     | {
         getTotalInputTokens(): number; getTotalOutputTokens(): number;
         getTotalCacheReadTokens(): number; getTotalCacheWriteTokens(): number;
+        getTotalProcessedInputTokens(): number;
         getTotalCost(): number; getCacheHitRate(): number;
         getMainInputTokens(): number; getMainOutputTokens(): number;
         getMainCacheReadTokens(): number; getMainCacheWriteTokens(): number;
         getMainCost(): number;
-        getPerModelUsage(): Record<string, { inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; turns: number }>;
-        getSubagentList(): Array<{ description: string; agentType: string; modelId: string; inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; cost: number; durationMs: number; toolUses: number }>;
+        getPerModelUsage(): Record<string, { inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; cacheSupported: boolean; turns: number; subscription: boolean }>;
+        getSubagentList(): Array<{ description: string; agentType: string; modelId: string; inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; cacheSupported: boolean; cost: number; durationMs: number; toolUses: number; subscription: boolean }>;
       }
     | undefined;
 
@@ -604,30 +987,52 @@ function showUsage(ctx: any): void {
     return;
   }
 
-  const totalInput = tracker.getTotalInputTokens();
+  // Token-weighted cache hit rate: cache reads over all processed input
+  // (uncached + cache read + cache write). Same formula everywhere so the
+  // total, per-model, and per-agent percentages are directly comparable.
+  const hitRate = (uncached: number, cacheRead: number, cacheWrite: number): number => {
+    const processed = uncached + cacheRead + cacheWrite;
+    return processed > 0 ? cacheRead / processed : 0;
+  };
+
+  // Compact one-line input part: total processed input with an inline
+  // uncached / cache read / cache write breakdown, e.g. "↑1.3k (u84 r1.0k w200)".
+  const inputPart = (uncached: number, cacheRead: number, cacheWrite: number, cacheSupported: boolean): string => {
+    const processed = uncached + cacheRead + cacheWrite;
+    const head = `↑${formatTokenCount(processed)}`;
+    if (!cacheSupported) return head;
+    return `${head} (u${formatTokenCount(uncached)} r${formatTokenCount(cacheRead)} w${formatTokenCount(cacheWrite)})`;
+  };
+
+  const totalUncachedInput = tracker.getTotalInputTokens();
   const totalOutput = tracker.getTotalOutputTokens();
   const totalCacheRead = tracker.getTotalCacheReadTokens();
+  const totalCacheWrite = tracker.getTotalCacheWriteTokens();
+  const totalProcessedInput = tracker.getTotalProcessedInputTokens();
   const totalCost = tracker.getTotalCost();
-  const totalCacheRate = (totalCacheRead + totalInput) > 0
-    ? totalCacheRead / (totalCacheRead + totalInput)
-    : 0;
+  const totalCacheRate = tracker.getCacheHitRate();
 
   const mainInput = tracker.getMainInputTokens();
   const mainOutput = tracker.getMainOutputTokens();
   const mainCacheRead = tracker.getMainCacheReadTokens();
+  const mainCacheWrite = tracker.getMainCacheWriteTokens();
   const mainCost = tracker.getMainCost();
   const models = tracker.getPerModelUsage();
   const subagents = tracker.getSubagentList();
 
-  const byModel = new Map<string, { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number }>();
+  const byModel = new Map<string, { input: number; output: number; cacheRead: number; cacheWrite: number; cacheSupported: boolean; cost: number; subscription: boolean }>();
   const mainModelEntries = Object.entries(models);
-  const mainTotalTokens = mainModelEntries.reduce((s, [, u]) => s + u.inputTokens + u.outputTokens, 0);
+  // Subscription (flat-rate) models contribute no dollars, so exclude their
+  // tokens from the proportional-share denominator or paid rows would be
+  // inflated and the sub/ rows would receive a spurious share.
+  const mainTotalTokens = mainModelEntries.reduce((s, [, u]) => s + (u.subscription ? 0 : u.inputTokens + u.outputTokens), 0);
   for (const [modelId, usage] of mainModelEntries) {
     const modelTokens = usage.inputTokens + usage.outputTokens;
-    const modelCostShare = mainTotalTokens > 0 ? mainCost * (modelTokens / mainTotalTokens) : 0;
+    const modelCostShare = usage.subscription || mainTotalTokens <= 0 ? 0 : mainCost * (modelTokens / mainTotalTokens);
     byModel.set(modelId, {
       input: usage.inputTokens, output: usage.outputTokens,
-      cacheRead: usage.cacheReadTokens, cacheWrite: usage.cacheWriteTokens, cost: modelCostShare,
+      cacheRead: usage.cacheReadTokens, cacheWrite: usage.cacheWriteTokens, cacheSupported: usage.cacheSupported, cost: modelCostShare,
+      subscription: usage.subscription,
     });
   }
   for (const sa of subagents) {
@@ -638,29 +1043,39 @@ function showUsage(ctx: any): void {
       existing.output += sa.outputTokens;
       existing.cacheRead += sa.cacheReadTokens;
       existing.cacheWrite += sa.cacheWriteTokens;
+      if (sa.cacheSupported) existing.cacheSupported = true;
       existing.cost += sa.cost;
+      if (sa.subscription) existing.subscription = true;
     } else {
       byModel.set(key, {
         input: sa.inputTokens, output: sa.outputTokens,
-        cacheRead: sa.cacheReadTokens, cacheWrite: sa.cacheWriteTokens, cost: sa.cost,
+        cacheRead: sa.cacheReadTokens, cacheWrite: sa.cacheWriteTokens, cacheSupported: sa.cacheSupported, cost: sa.cost,
+        subscription: sa.subscription,
       });
     }
   }
 
+  // Total input the model processed = uncached + cache read + cache write.
+  // Shown as an explicit breakdown so the (often tiny) uncached sliver no
+  // longer masquerades as the whole "Input" figure.
   const lines: string[] = ["Session usage (total):"];
-  lines.push(`  Input: ${formatTokenCount(totalInput)} tokens`);
+  lines.push(`  Input: ${formatTokenCount(totalProcessedInput)} tokens`);
+  lines.push(`    • uncached:    ${formatTokenCount(totalUncachedInput)}`);
+  lines.push(`    • cache read:  ${formatTokenCount(totalCacheRead)}`);
+  lines.push(`    • cache write: ${formatTokenCount(totalCacheWrite)}`);
   lines.push(`  Output: ${formatTokenCount(totalOutput)} tokens`);
   if (totalCacheRead > 0) lines.push(`  Cache: ⚡${Math.round(totalCacheRate * 100)}% hit rate`);
-  if (totalCost > 0) lines.push(`  Cost: $${totalCost.toFixed(2)}`);
+  lines.push(`  Cost: $${totalCost.toFixed(2)}`);
 
   if (byModel.size > 0) {
     lines.push("");
     lines.push("By model:");
     for (const [modelId, m] of byModel) {
-      const cr = (m.cacheRead + m.input) > 0 ? Math.round(m.cacheRead / (m.cacheRead + m.input) * 100) : 0;
-      const parts = [`↑${formatTokenCount(m.input)}`, `↓${formatTokenCount(m.output)}`];
-      if (cr > 0) parts.push(`⚡${cr}%`);
-      if (m.cost > 0) parts.push(`$${m.cost.toFixed(2)}`);
+      const cr = Math.round(hitRate(m.input, m.cacheRead, m.cacheWrite) * 100);
+      const parts = [inputPart(m.input, m.cacheRead, m.cacheWrite, m.cacheSupported), `↓${formatTokenCount(m.output)}`];
+      if (m.cacheSupported) parts.push(`⚡${cr}%`);
+      if (m.subscription) parts.push("subscription");
+      else if (m.cost > 0) parts.push(`$${m.cost.toFixed(2)}`);
       lines.push(`  ${modelId}: ${parts.join("  ")}`);
     }
   }
@@ -669,13 +1084,16 @@ function showUsage(ctx: any): void {
   lines.push("By agent:");
   const agentModelNames = Object.keys(models);
   if (agentModelNames.length > 0) {
-    const mainParts = [`↑${formatTokenCount(mainInput)}`, `↓${formatTokenCount(mainOutput)}`];
-    const mainCR = (mainCacheRead + mainInput) > 0 ? Math.round(mainCacheRead / (mainCacheRead + mainInput) * 100) : 0;
-    if (mainCR > 0) mainParts.push(`⚡${mainCR}%`);
-    if (mainCost > 0) mainParts.push(`$${mainCost.toFixed(2)}`);
+    const mainCacheSupported = mainModelEntries.some(([, u]) => u.cacheSupported);
+    const mainAllSubscription = mainModelEntries.every(([, u]) => u.subscription);
+    const mainParts = [inputPart(mainInput, mainCacheRead, mainCacheWrite, mainCacheSupported), `↓${formatTokenCount(mainOutput)}`];
+    const mainCR = Math.round(hitRate(mainInput, mainCacheRead, mainCacheWrite) * 100);
+    if (mainCacheSupported) mainParts.push(`⚡${mainCR}%`);
+    if (mainAllSubscription) mainParts.push("subscription");
+    else if (mainCost > 0) mainParts.push(`$${mainCost.toFixed(2)}`);
     lines.push(`  Main (${agentModelNames.join(", ")}): ${mainParts.join("  ")}`);
   }
-  const byAgentType = new Map<string, { input: number; output: number; cacheRead: number; cost: number; durationMs: number; toolUses: number; count: number }>();
+  const byAgentType = new Map<string, { input: number; output: number; cacheRead: number; cacheWrite: number; cacheSupported: boolean; cost: number; durationMs: number; toolUses: number; count: number; subscriptionRuns: number }>();
   for (const sa of subagents) {
     const key = sa.agentType || sa.description;
     const existing = byAgentType.get(key);
@@ -683,24 +1101,30 @@ function showUsage(ctx: any): void {
       existing.input += sa.inputTokens;
       existing.output += sa.outputTokens;
       existing.cacheRead += sa.cacheReadTokens;
+      existing.cacheWrite += sa.cacheWriteTokens;
+      if (sa.cacheSupported) existing.cacheSupported = true;
       existing.cost += sa.cost;
       existing.durationMs += sa.durationMs;
       existing.toolUses += sa.toolUses;
       existing.count += 1;
+      if (sa.subscription) existing.subscriptionRuns += 1;
     } else {
       byAgentType.set(key, {
-        input: sa.inputTokens, output: sa.outputTokens, cacheRead: sa.cacheReadTokens,
-        cost: sa.cost, durationMs: sa.durationMs, toolUses: sa.toolUses, count: 1,
+        input: sa.inputTokens, output: sa.outputTokens, cacheRead: sa.cacheReadTokens, cacheWrite: sa.cacheWriteTokens,
+        cacheSupported: sa.cacheSupported, cost: sa.cost, durationMs: sa.durationMs, toolUses: sa.toolUses, count: 1,
+        subscriptionRuns: sa.subscription ? 1 : 0,
       });
     }
   }
   for (const [agentType, agg] of byAgentType) {
-    const saCR = (agg.cacheRead + agg.input) > 0
-      ? Math.round(agg.cacheRead / (agg.cacheRead + agg.input) * 100) : 0;
-    const parts = [`↑${formatTokenCount(agg.input)}`, `↓${formatTokenCount(agg.output)}`];
-    if (saCR > 0) parts.push(`⚡${saCR}%`);
-    if (agg.cost > 0) parts.push(`$${agg.cost.toFixed(2)}`);
-    if (agg.durationMs > 0) parts.push(formatDuration(agg.durationMs));
+    const saCR = Math.round(hitRate(agg.input, agg.cacheRead, agg.cacheWrite) * 100);
+    const parts = [inputPart(agg.input, agg.cacheRead, agg.cacheWrite, agg.cacheSupported), `↓${formatTokenCount(agg.output)}`];
+    if (agg.cacheSupported) parts.push(`⚡${saCR}%`);
+    // All runs subscription-routed → flat-rate label; otherwise show the
+    // paid-only summed cost (subscription runs already contribute $0).
+    if (agg.subscriptionRuns === agg.count) parts.push("subscription");
+    else if (agg.cost > 0) parts.push(`$${agg.cost.toFixed(2)}`);
+    if (agg.durationMs > 0) parts.push(formatElapsedDuration(agg.durationMs));
     if (agg.toolUses > 0) parts.push(`${agg.toolUses} tools`);
     const countSuffix = agg.count > 1 ? ` (×${agg.count})` : "";
     lines.push(`  ${agentType}${countSuffix}: ${parts.join("  ")}`);
@@ -713,10 +1137,11 @@ async function showInfoMenu(orchestrator: Orchestrator, ctx: any): Promise<typeo
   while (true) {
     const options: OptionInput[] = [];
     options.push({ title: "Subagents", description: "Manage running agents" });
-    options.push({ title: "LSP", description: "Language server status and controls" });
     options.push({ title: "Usage", description: "Show session token usage and cost breakdown" });
+    options.push({ title: "Doctor", description: "Run diagnostic checks" });
     if (orchestrator.active) {
       options.push({ title: "Task status", description: "Show current task phase, step, and timing" });
+      options.push({ title: "Repos", description: "Registered repositories and base branches" });
     }
     options.push({ title: "Back", description: "Return to the previous menu" });
 
@@ -726,147 +1151,1856 @@ async function showInfoMenu(orchestrator: Orchestrator, ctx: any): Promise<typeo
       await showSubagentsMenu(ctx);
       continue;
     }
-    if (choice === "LSP") {
-      await showLspMenu(ctx);
-      continue;
-    }
     if (choice === "Usage") {
       showUsage(ctx);
       continue;
     }
+    if (choice === "Doctor") {
+      await runDoctor(orchestrator, ctx);
+      continue;
+    }
     if (choice === "Task status") {
       showStatus(orchestrator, ctx);
       continue;
     }
+    if (choice === "Repos") {
+      await showReposSettings(orchestrator, ctx);
+      continue;
+    }
   }
 }
 
-async function showSettingsMenu(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
-  while (true) {
-    const options: OptionInput[] = [];
-    options.push({ title: "Flant AI Infrastructure", description: "Configure corporate AI model provider" });
-    options.push({ title: "Back", description: "Return to the previous menu" });
+type Scope = "global" | "project";
+type MainModelRole = keyof PiPiConfig["agents"]["orchestrators"];
+type AgentRole = keyof PiPiConfig["agents"]["subagents"]["simple"];
+type TimeoutGroup = "commands" | "internals";
+type CommandListKey = keyof PiPiConfig["commands"];
+type TimeoutEntry = { key: TimeoutKey; path: string[]; value: number };
+
+export interface ConfigSourceInfo {
+  activeValue: any;
+  defaultValue: any;
+  flantValue: any | undefined;
+  globalValue: any | undefined;
+  projectValue: any | undefined;
+  source: "default" | "flant" | "global" | "project";
+}
 
-    const choice = await selectOption(ctx, "Settings", options);
-    if (!choice || choice === "Back") return BACK;
-    await showFlantInfraMenu(orchestrator, ctx);
+const ORCHESTRATOR_ROLES: Array<{ role: MainModelRole; label: string; description: string }> = [
+  { role: "brainstorm", label: "Brainstormer", description: "agents.orchestrators.brainstorm" },
+  { role: "implement", label: "Implementer", description: "agents.orchestrators.implement" },
+  { role: "plan", label: "Planner", description: "agents.orchestrators.plan" },
+  { role: "debug", label: "Debugger", description: "agents.orchestrators.debug" },
+  { role: "review", label: "Reviewer", description: "agents.orchestrators.review" },
+  { role: "quick", label: "Quick", description: "agents.orchestrators.quick" },
+];
+
+const SUBAGENT_ROLES: Array<{ role: AgentRole; label: string; description: string }> = [
+  { role: "explore", label: "Explore", description: "agents.subagents.simple.explore" },
+  { role: "librarian", label: "Librarian", description: "agents.subagents.simple.librarian" },
+  { role: "task", label: "Task", description: "agents.subagents.simple.task" },
+];
+
+const PRESET_GROUP_ITEMS: Array<{ group: PresetGroup; label: string }> = [
+  { group: "brainstormReviewers", label: "Brainstorm reviewers" },
+  { group: "planners", label: "Planners" },
+  { group: "planReviewers", label: "Plan reviewers" },
+  { group: "codeReviewers", label: "Code reviewers" },
+];
+
+const TIMEOUT_LABELS: Record<TimeoutKey, string> = {
+  "performance.commands.afterEdit": "Command after file edit",
+  "performance.commands.afterImplement": "Command after implementation",
+  "performance.internals.subagentStale": "Subagent stale",
+  "performance.internals.taskLockStale": "Lock stale",
+  "performance.internals.taskLockRefresh": "Lock update",
+};
+
+const VALID_NAME_RE = /^[A-Za-z0-9-]+$/;
+
+function getProjectConfigPath(cwd: string): string {
+  return join(cwd, ".pp", "config.json");
+}
+
+function getScopeConfigPath(orchestrator: Orchestrator, scope: Scope): string {
+  return scope === "global" ? GLOBAL_CONFIG_PATH : getProjectConfigPath(orchestrator.cwd);
+}
+
+function hasNestedKey(obj: unknown, keyPath: string[]): boolean {
+  let cursor: any = obj;
+  for (const key of keyPath) {
+    if (!cursor || typeof cursor !== "object") return false;
+    if (!Object.prototype.hasOwnProperty.call(cursor, key)) return false;
+    cursor = cursor[key];
   }
+  return true;
 }
 
-async function promptDescription(ctx: any, prompt: string, fallback: string): Promise<string | undefined> {
-  const value = await ctx.ui.input(prompt);
-  if (value === undefined || value === null) return undefined;
-  const trimmed = String(value).trim();
-  return trimmed || fallback;
+function getNestedValue(obj: unknown, keyPath: string[]): any {
+  let cursor: any = obj;
+  for (const key of keyPath) {
+    if (!cursor || typeof cursor !== "object") return undefined;
+    if (!Object.prototype.hasOwnProperty.call(cursor, key)) return undefined;
+    cursor = cursor[key];
+  }
+  return cursor;
 }
 
-function resumeOptionTitle(t: TaskInfo): string {
-  return taskName(t.dir);
+function setNestedValue(obj: Record<string, any>, keyPath: string[], value: any): void {
+  if (keyPath.length === 0) return;
+  let cursor: Record<string, any> = obj;
+  for (let i = 0; i < keyPath.length - 1; i += 1) {
+    const key = keyPath[i]!;
+    const current = cursor[key];
+    if (!current || typeof current !== "object" || Array.isArray(current)) cursor[key] = {};
+    cursor = cursor[key] as Record<string, any>;
+  }
+  cursor[keyPath[keyPath.length - 1]!] = value;
 }
 
-function resumeOptionDescription(t: TaskInfo): string {
-  const age = taskAge(t.state);
-  const phase = t.state.phase === t.type ? t.type : `${t.type}/${t.state.phase}`;
-  return `${phase}, ${age}`;
+function deleteNestedValue(obj: Record<string, any>, keyPath: string[]): void {
+  if (keyPath.length === 0) return;
+  let cursor: Record<string, any> = obj;
+  for (let i = 0; i < keyPath.length - 1; i += 1) {
+    const key = keyPath[i]!;
+    const current = cursor[key];
+    if (!current || typeof current !== "object" || Array.isArray(current)) return;
+    cursor = current;
+  }
+  delete cursor[keyPath[keyPath.length - 1]!];
 }
 
-async function showResumeMenu(
-  orchestrator: Orchestrator,
-  ctx: any,
-  type: TaskType | undefined,
-  emptyMessage: string,
-): Promise<typeof BACK | "started"> {
-  while (true) {
-    const tasks = listTasks(orchestrator.cwd, type);
-    if (tasks.length === 0) {
-      ctx.ui.notify(emptyMessage, "info");
-      return BACK;
-    }
+function formatInlineValue(value: any): string {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean" || value === null) return String(value);
+  if (value === undefined) return "undefined";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
 
-    const options: OptionInput[] = tasks.map((t) => ({
-      title: resumeOptionTitle(t),
-      description: resumeOptionDescription(t),
-    }));
-    options.push({ title: "Back", description: "Return to the previous menu" });
+function tagsString(tags: string[]): string {
+  return tags.length > 0 ? `(${tags.join(", ")})` : "";
+}
 
-    const choice = await selectOption(ctx, "Resume", options);
-    if (!choice || choice === "Back") return BACK;
+function withTags(label: string, tags: string): string {
+  return tags ? `${label} ${tags}` : label;
+}
 
-    const task = tasks.find((t) => resumeOptionTitle(t) === choice);
-    if (!task) continue;
-    const result = await resumeTask(orchestrator, ctx, task);
-    if (result.ok) return "started";
-  }
+function getRawScopeValue(orchestrator: Orchestrator, scope: Scope, keyPath: string[]): any {
+  const raw = readRawConfig(getScopeConfigPath(orchestrator, scope));
+  return getNestedValue(raw, keyPath);
 }
 
-function fromOptionTitle(t: TaskInfo): string {
-  return taskName(t.dir);
+function getRawScopeConfigs(orchestrator: Orchestrator): { globalConfig: Record<string, any>; projectConfig: Record<string, any> } {
+  return {
+    globalConfig: readRawConfig(GLOBAL_CONFIG_PATH),
+    projectConfig: readRawConfig(getProjectConfigPath(orchestrator.cwd)),
+  };
 }
 
-function fromOptionDescription(t: TaskInfo, cwd: string): string {
-  const age = taskAge(t.state);
-  const rel = relative(join(cwd, ".pp", "state"), t.dir);
-  return `${t.type}, ${age} — ${rel}`;
+function isEmptyOverride(value: unknown): boolean {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value as object).length === 0;
 }
 
-async function showFromMenu(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK | "started"> {
-  while (true) {
-    const tasks = listCompletedFromTasks(orchestrator.cwd);
-    if (tasks.length === 0) {
-      ctx.ui.notify("No completed brainstorm/debug tasks with artifacts found.", "info");
-      return BACK;
-    }
+function hasLayerOverride(orchestrator: Orchestrator, scope: Scope, keyPath: string[]): boolean {
+  const raw = readRawConfig(getScopeConfigPath(orchestrator, scope));
+  if (!hasNestedKey(raw, keyPath)) return false;
+  return !isEmptyOverride(getNestedValue(raw, keyPath));
+}
 
-    const options: OptionInput[] = tasks.map((t) => ({
-      title: fromOptionTitle(t),
-      description: fromOptionDescription(t, orchestrator.cwd),
-    }));
-    options.push({ title: "Back", description: "Return to the previous menu" });
+function getLayerOverrideValue(orchestrator: Orchestrator, scope: Scope, keyPath: string[]): any {
+  const raw = readRawConfig(getScopeConfigPath(orchestrator, scope));
+  return getNestedValue(raw, keyPath);
+}
 
-    const choice = await selectOption(ctx, "From", options);
-    if (!choice || choice === "Back") return BACK;
+function getOwnedScopes(orchestrator: Orchestrator, keyPath: string[]): Scope[] {
+  const out: Scope[] = [];
+  if (hasLayerOverride(orchestrator, "global", keyPath)) out.push("global");
+  if (hasLayerOverride(orchestrator, "project", keyPath)) out.push("project");
+  return out;
+}
 
-    const selected = tasks.find((t) => fromOptionTitle(t) === choice);
-    if (!selected) continue;
+export function getConfigSourceInfo(orchestrator: Orchestrator, keyPath: string[]): ConfigSourceInfo {
+  const { globalConfig, projectConfig } = getRawScopeConfigs(orchestrator);
+  const flantConfig = getFlantGeneratedConfig() as Record<string, any> | null;
+  const activeValue = getNestedValue(orchestrator.config as Record<string, any>, keyPath);
+  const defaultValue = getNestedValue(getDefaultConfig() as Record<string, any>, keyPath);
+  const flantValue = flantConfig ? getNestedValue(flantConfig, keyPath) : undefined;
+  const globalValue = hasNestedKey(globalConfig, keyPath) ? getNestedValue(globalConfig, keyPath) : undefined;
+  const projectValue = hasNestedKey(projectConfig, keyPath) ? getNestedValue(projectConfig, keyPath) : undefined;
+  const source = hasNestedKey(projectConfig, keyPath)
+    ? "project"
+    : hasNestedKey(globalConfig, keyPath)
+    ? "global"
+    : flantConfig && hasNestedKey(flantConfig, keyPath)
+    ? "flant"
+    : "default";
+  return {
+    activeValue,
+    defaultValue,
+    flantValue,
+    globalValue,
+    projectValue,
+    source,
+  };
+}
 
-    const description = await promptDescription(ctx, "Describe the task", "implement");
-    if (!description) continue;
+export function formatSourceTags(currentValue: any, info: ConfigSourceInfo): string {
+  const tags: string[] = [];
+  if (isDeepStrictEqual(currentValue, info.activeValue)) tags.push("active");
+  if (isDeepStrictEqual(currentValue, info.defaultValue)) tags.push("default");
+  if (info.flantValue !== undefined && isDeepStrictEqual(currentValue, info.flantValue)) tags.push("flant");
+  if (info.globalValue !== undefined && isDeepStrictEqual(currentValue, info.globalValue)) tags.push("global");
+  if (info.projectValue !== undefined && isDeepStrictEqual(currentValue, info.projectValue)) tags.push("project");
+  return tagsString(tags);
+}
 
-    await orchestrator.startTask(ctx, "implement", description, selected.dir, true);
-    return "started";
+export function buildResetOptions(orchestrator: Orchestrator, keyPath: string[]): OptionInput[] {
+  const options: OptionInput[] = [];
+  const globalValue = getLayerOverrideValue(orchestrator, "global", keyPath);
+  if (hasLayerOverride(orchestrator, "global", keyPath) && !isEmptyOverride(globalValue)) {
+    options.push(opt("Reset global setting", formatInlineValue(globalValue)));
   }
+  const projectValue = getLayerOverrideValue(orchestrator, "project", keyPath);
+  if (hasLayerOverride(orchestrator, "project", keyPath) && !isEmptyOverride(projectValue)) {
+    options.push(opt("Reset project setting", formatInlineValue(projectValue)));
+  }
+  return options;
 }
 
-async function showImplementMenu(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK | "started"> {
-  while (true) {
-    const choice = await selectOption(ctx, "Implement", [
-      { title: "New", description: "Start a new implementation from scratch" },
-      { title: "From", description: "Continue from a completed brainstorm or debug task" },
-      { title: "Resume", description: "Resume a paused implementation" },
-      { title: "Back", description: "Return to the previous menu" },
-    ]);
-    if (!choice || choice === "Back") return BACK;
-
-    if (choice === "New") {
-      const description = await promptDescription(ctx, "Describe the task", "implement");
-      if (!description) continue;
-      await orchestrator.startTask(ctx, "implement", description);
-      return "started";
-    }
+export function formatDuration(ms: number): string {
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  if (ms < 60000) return `${Math.round(ms / 1000)}s`;
+  if (ms < 3600000) return `${Math.round(ms / 60000)}m`;
+  return `${Math.round(ms / 3600000)}h`;
+}
 
-    if (choice === "From") {
-      const result = await showFromMenu(orchestrator, ctx);
-      if (result === "started") return result;
-      continue;
-    }
+export function slugify(text: string, maxLen = 40): string {
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  const safe = collapsed.replace(/[^A-Za-z0-9 _./:-]/g, "").trim();
+  const base = safe || collapsed || "(empty)";
+  if (base.length <= maxLen) return base;
+  return `${base.slice(0, Math.max(1, maxLen - 1)).trimEnd()}…`;
+}
 
-    const result = await showResumeMenu(orchestrator, ctx, "implement", "No paused implement tasks found.");
-    if (result === "started") return result;
+function tryApplyConfigChange(orchestrator: Orchestrator, scope: Scope, keyPath: string[], value: any): { ok: boolean; error?: string } {
+  try {
+    const nextGlobal = structuredClone(readRawConfig(GLOBAL_CONFIG_PATH));
+    const nextProject = structuredClone(readRawConfig(getProjectConfigPath(orchestrator.cwd)));
+    const target = scope === "global" ? nextGlobal : nextProject;
+    setNestedValue(target, keyPath, value);
+    mergeConfigLayers(nextGlobal, nextProject);
+    writeConfigValue(getScopeConfigPath(orchestrator, scope), keyPath, value);
+    orchestrator.config = loadConfig(orchestrator.cwd);
+    return { ok: true };
+  } catch (err: any) {
+    return { ok: false, error: err?.message ?? String(err) };
   }
 }
 
-function buildPrContext(parsed: any): { prUrl: string | null; prContext: string | null } {
-  const title = typeof parsed?.title === "string" ? parsed.title.trim() : "";
+function tryClearConfigOverride(orchestrator: Orchestrator, scope: Scope, keyPath: string[]): { ok: boolean; error?: string } {
+  try {
+    const nextGlobal = structuredClone(readRawConfig(GLOBAL_CONFIG_PATH));
+    const nextProject = structuredClone(readRawConfig(getProjectConfigPath(orchestrator.cwd)));
+    const target = scope === "global" ? nextGlobal : nextProject;
+    deleteNestedValue(target, keyPath);
+    mergeConfigLayers(nextGlobal, nextProject);
+    removeConfigValue(getScopeConfigPath(orchestrator, scope), keyPath);
+    orchestrator.config = loadConfig(orchestrator.cwd);
+    return { ok: true };
+  } catch (err: any) {
+    return { ok: false, error: err?.message ?? String(err) };
+  }
+}
+
+function parseCommaSeparated(input: string): string[] {
+  return input
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function makeUniqueTitle(base: string, used: Set<string>): string {
+  if (!used.has(base)) {
+    used.add(base);
+    return base;
+  }
+  let index = 2;
+  while (true) {
+    const candidate = `${base} (${index})`;
+    if (!used.has(candidate)) {
+      used.add(candidate);
+      return candidate;
+    }
+    index += 1;
+  }
+}
+
+function normalizeProviderLabel(provider: string): string {
+  if (provider === "anthropic") return "Anthropic";
+  if (provider === "openai") return "OpenAI";
+  if (provider === "google") return "Google";
+  if (provider === "deepseek") return "DeepSeek";
+  if (provider === "x-ai") return "xAI";
+  if (provider === "qwen") return "Qwen";
+  if (provider === "pp-flant-anthropic") return "Flant Anthropic";
+  if (provider === "pp-flant-openai") return "Flant OpenAI";
+  return provider;
+}
+
+function providerOrder(provider: string): number {
+  if (provider === "pp-flant-anthropic") return 0;
+  if (provider === "pp-flant-openai") return 1;
+  if (provider === "anthropic") return 2;
+  if (provider === "openai") return 3;
+  if (provider === "google") return 4;
+  if (provider === "deepseek") return 5;
+  if (provider === "x-ai") return 6;
+  if (provider === "qwen") return 7;
+  return 99;
+}
+
+function listAvailableModels(ctx: any): Array<{ provider: string; id: string; spec: string }> {
+  const available = ctx?.modelRegistry?.getAvailable?.();
+  if (!Array.isArray(available)) return [];
+
+  const seen = new Set<string>();
+  const models: Array<{ provider: string; id: string; spec: string }> = [];
+  for (const model of available) {
+    const provider = typeof model?.provider === "string" ? model.provider.trim() : "";
+    const id = typeof model?.id === "string" ? model.id.trim() : "";
+    if (!provider || !id) continue;
+    const spec = `${provider}/${id}`;
+    const key = spec.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    models.push({ provider, id, spec });
+  }
+
+  models.sort((a, b) => {
+    const byProviderOrder = providerOrder(a.provider) - providerOrder(b.provider);
+    if (byProviderOrder !== 0) return byProviderOrder;
+    const byProviderName = a.provider.localeCompare(b.provider);
+    if (byProviderName !== 0) return byProviderName;
+    return compareModelVersion(b.id, a.id);
+  });
+
+  return models;
+}
+
+async function pickScope(ctx: any, orchestrator: Orchestrator): Promise<Scope | null> {
+  const choice = await selectOption(ctx, "Scope", [
+    opt("Set globally", GLOBAL_CONFIG_PATH),
+    opt("Set for project", getProjectConfigPath(orchestrator.cwd)),
+    opt("Back", "Return to the previous menu"),
+  ]);
+  if (!choice || choice === "Back") return null;
+  if (choice === "Set globally") return "global";
+  if (choice === "Set for project") return "project";
+  return null;
+}
+
+async function pickScopeFromOwned(ctx: any, orchestrator: Orchestrator, keyPath: string[]): Promise<Scope | null> {
+  const scopes = getOwnedScopes(orchestrator, keyPath);
+  if (scopes.length === 0) return null;
+  if (scopes.length === 1) return scopes[0]!;
+  const options: OptionInput[] = [
+    opt("Global override", GLOBAL_CONFIG_PATH),
+    opt("Project override", getProjectConfigPath(orchestrator.cwd)),
+    opt("Back", "Return to the previous menu"),
+  ];
+  const choice = await selectOption(ctx, "Choose override scope", options);
+  if (!choice || choice === "Back") return null;
+  return choice === "Global override" ? "global" : "project";
+}
+
+async function pickModel(ctx: any, currentModel?: string): Promise<string | null> {
+  const aliasMap = getAllAliases();
+  const families = getModelFamilies();
+  const availableModels = listAvailableModels(ctx);
+  const availableSpecs = new Set(availableModels.map((m) => m.spec));
+  const currentResolved = currentModel ? resolveModel(currentModel) : null;
+  const currentAvailable = currentResolved ? availableSpecs.has(currentResolved) : false;
+  const visibleAliases = new Set(
+    Object.entries(aliasMap)
+      .filter(([, resolved]) => availableSpecs.has(resolved))
+      .map(([alias]) => alias),
+  );
+  const options: OptionInput[] = [];
+  const selectionToModel = new Map<string, string>();
+  const usedTitles = new Set<string>();
+
+  if (currentModel && !visibleAliases.has(currentModel)) {
+    const tags = ["active"];
+    if (!currentAvailable) tags.push("unavailable");
+    const title = makeUniqueTitle(withTags(currentModel, tagsString(tags)), usedTitles);
+    options.push(opt(title, "Current model"));
+    selectionToModel.set(title, currentModel);
+  }
+
+  const aliasEntries: Array<{ provider: string; displayName: string; alias: string }> = [];
+  for (const family of families) {
+    for (const alias of family.aliases) {
+      if (!visibleAliases.has(alias)) continue;
+      aliasEntries.push({
+        provider: alias.split("/")[0] ?? "",
+        displayName: family.displayName,
+        alias,
+      });
+    }
+  }
+
+  aliasEntries.sort((a, b) => {
+    const byProviderOrder = providerOrder(a.provider) - providerOrder(b.provider);
+    if (byProviderOrder !== 0) return byProviderOrder;
+    const byProviderName = a.provider.localeCompare(b.provider);
+    if (byProviderName !== 0) return byProviderName;
+    return a.displayName.localeCompare(b.displayName);
+  });
+
+  for (const entry of aliasEntries) {
+    const providerLabel = normalizeProviderLabel(entry.provider);
+    const tags = entry.alias === currentModel ? tagsString(["active"]) : "";
+    const title = makeUniqueTitle(withTags(`${providerLabel} — ${entry.displayName} (latest)`, tags), usedTitles);
+    options.push(opt(title, entry.alias));
+    selectionToModel.set(title, entry.alias);
+  }
+
+  if (availableModels.length > 0) {
+    for (const model of availableModels) {
+      if (currentModel && model.spec === currentModel) continue;
+      const providerLabel = normalizeProviderLabel(model.provider);
+      const title = makeUniqueTitle(`${providerLabel} — ${model.id}`, usedTitles);
+      options.push(opt(title, model.spec));
+      selectionToModel.set(title, model.spec);
+    }
+  }
+
+  options.push(opt("Back", "Return to the previous menu"));
+
+  while (true) {
+    const choice = await selectOption(ctx, "Model", options);
+    if (!choice || choice === "Back") return null;
+    const selected = selectionToModel.get(choice);
+    if (selected) return selected;
+  }
+}
+
+async function pickThinking(
+  ctx: any,
+  allowXhigh: boolean,
+  orchestrator?: Orchestrator,
+  keyPath?: string[],
+): Promise<string | null> {
+  const options: OptionInput[] = [];
+  const byTitle = new Map<string, string>();
+  const usedTitles = new Set<string>();
+  const values = allowXhigh ? ["xhigh", "high", "medium", "low", "off"] : ["high", "medium", "low", "off"];
+  const info = orchestrator && keyPath ? getConfigSourceInfo(orchestrator, keyPath) : null;
+  for (const value of values) {
+    const label = thinkingLabel(value);
+    const title = makeUniqueTitle(withTags(label, info ? formatSourceTags(value, info) : ""), usedTitles);
+    options.push(title);
+    byTitle.set(title, value);
+  }
+  options.push(opt("Back", "Return to the previous menu"));
+  const choice = await selectOption(ctx, "Thinking level", options);
+  if (!choice || choice === "Back") return null;
+  return byTitle.get(choice) ?? null;
+}
+
+function refreshSubagentDefinitions(orchestrator: Orchestrator, keyPath: string[]): void {
+  if (keyPath[0] !== "agents") return;
+  unregisterAgentDefinitions(orchestrator.pi);
+  orchestrator.registerAgents();
+}
+
+function applyConfigChange(orchestrator: Orchestrator, scope: Scope, keyPath: string[], value: any): void {
+  const result = tryApplyConfigChange(orchestrator, scope, keyPath, value);
+  if (!result.ok) {
+    orchestrator.lastCtx?.ui?.notify(`Config update rejected: ${result.error}`, "error");
+    return;
+  }
+  const available = (orchestrator.lastCtx as any)?.modelRegistry?.getAvailable?.();
+  if (Array.isArray(available)) {
+    const modelIds = available
+      .map((m: any) => {
+        const provider = typeof m?.provider === "string" ? m.provider.trim() : "";
+        const id = typeof m?.id === "string" ? m.id.trim() : "";
+        return provider && id ? `${provider}/${id}` : "";
+      })
+      .filter((id: string) => id.length > 0);
+    updateRegistryFromAvailableModels(modelIds);
+  }
+  refreshSubagentDefinitions(orchestrator, keyPath);
+}
+
+function clearConfigOverride(orchestrator: Orchestrator, scope: Scope, keyPath: string[]): void {
+  const result = tryClearConfigOverride(orchestrator, scope, keyPath);
+  if (!result.ok) {
+    orchestrator.lastCtx?.ui?.notify(`Config update rejected: ${result.error}`, "error");
+    return;
+  }
+  refreshSubagentDefinitions(orchestrator, keyPath);
+}
+
+function thinkingLabel(value: string): string {
+  if (value === "off") return "Off";
+  if (value === "low") return "Low";
+  if (value === "medium") return "Medium";
+  if (value === "high") return "High";
+  if (value === "xhigh") return "Extra High";
+  return value;
+}
+
+function logLevelLabel(value: string): string {
+  if (value === "debug") return "Debug";
+  if (value === "info") return "Info";
+  if (value === "warn") return "Warning";
+  if (value === "error") return "Error";
+  return value;
+}
+
+function applyScopeChoice(orchestrator: Orchestrator, keyPath: string[], value: any, scope: Scope | null): void {
+  if (!scope) return;
+  try {
+    const globalConfig = structuredClone(readRawConfig(GLOBAL_CONFIG_PATH));
+    const projectConfig = structuredClone(readRawConfig(getProjectConfigPath(orchestrator.cwd)));
+    const mergedWithoutScope = scope === "global"
+      ? (() => {
+        deleteNestedValue(globalConfig, keyPath);
+        return mergeConfigLayers(globalConfig, null);
+      })()
+      : (() => {
+        deleteNestedValue(projectConfig, keyPath);
+        return mergeConfigLayers(globalConfig, projectConfig);
+      })();
+    const defaultForScope = getNestedValue(mergedWithoutScope, keyPath);
+    if (isDeepStrictEqual(value, defaultForScope)) {
+      if (scope === "global") {
+        clearConfigOverride(orchestrator, "global", keyPath);
+        return;
+      }
+      if (!hasLayerOverride(orchestrator, "global", keyPath)) {
+        clearConfigOverride(orchestrator, "project", keyPath);
+        return;
+      }
+    }
+  } catch {}
+  applyConfigChange(orchestrator, scope, keyPath, value);
+}
+
+function enabledPresetSummary(variants: Record<string, VariantConfig>): string {
+  const enabled = Object.entries(variants)
+    .filter(([, variant]) => isEnabled(variant))
+    .map(([name, variant]) => {
+      const info = getModelInfo(variant.model);
+      return `${name}: ${info.vendor}/${info.family} (${variant.thinking})`;
+    });
+  return enabled.length > 0 ? enabled.join(", ") : "No enabled models";
+}
+
+async function promptRequiredInput(ctx: any, label: string): Promise<string | null> {
+  const value = await ctx.ui.input(label);
+  if (value === undefined || value === null) return null;
+  const trimmed = String(value).trim();
+  if (!trimmed) return null;
+  return trimmed;
+}
+
+async function promptSafeName(ctx: any, label: string): Promise<string | null> {
+  const value = await promptRequiredInput(ctx, label);
+  if (!value) return null;
+  if (!VALID_NAME_RE.test(value)) {
+    ctx.ui.notify("Use only letters, numbers, and '-'.", "warning");
+    return null;
+  }
+  return value;
+}
+
+async function maybeHandleResetChoice(orchestrator: Orchestrator, ctx: any, choice: string, keyPath: string[]): Promise<boolean> {
+  if (choice === "Reset global setting") {
+    const confirm = await selectOption(ctx, "Confirm reset?", [
+      opt("Yes, reset", `Reset global override ${formatInlineValue(getLayerOverrideValue(orchestrator, "global", keyPath))}`),
+      opt("Back", "Cancel"),
+    ]);
+    if (confirm !== "Yes, reset") return true;
+    clearConfigOverride(orchestrator, "global", keyPath);
+    return true;
+  }
+  if (choice === "Reset project setting") {
+    const confirm = await selectOption(ctx, "Confirm reset?", [
+      opt("Yes, reset", `Reset project override ${formatInlineValue(getLayerOverrideValue(orchestrator, "project", keyPath))}`),
+      opt("Back", "Cancel"),
+    ]);
+    if (confirm !== "Yes, reset") return true;
+    clearConfigOverride(orchestrator, "project", keyPath);
+    return true;
+  }
+  return false;
+}
+
+async function showOrchestratorEditor(
+  orchestrator: Orchestrator,
+  ctx: any,
+  role: MainModelRole,
+  label: string,
+): Promise<typeof BACK> {
+  while (true) {
+    const current = orchestrator.config.agents.orchestrators[role];
+    const basePath = ["agents", "orchestrators", role];
+    const choice = await selectOption(ctx, label, [
+      opt(`Model: ${current.model}`, "Select model"),
+      opt(`Thinking: ${thinkingLabel(current.thinking)}`, "Select thinking level"),
+      ...buildResetOptions(orchestrator, basePath),
+      opt("Back", "Return to the previous menu"),
+    ]);
+    if (!choice || choice === "Back") return BACK;
+    if (choice.startsWith("Model:")) {
+      const model = await pickModel(ctx, current.model);
+      if (!model) continue;
+      applyScopeChoice(orchestrator, [...basePath, "model"], model, await pickScope(ctx, orchestrator));
+      continue;
+    }
+    if (choice.startsWith("Thinking:")) {
+      const thinking = await pickThinking(ctx, false, orchestrator, [...basePath, "thinking"]);
+      if (!thinking) continue;
+      applyScopeChoice(orchestrator, [...basePath, "thinking"], thinking, await pickScope(ctx, orchestrator));
+      continue;
+    }
+    await maybeHandleResetChoice(orchestrator, ctx, choice, basePath);
+  }
+}
+
+async function showOrchestratorsSettings(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
+  while (true) {
+    const options: OptionInput[] = ORCHESTRATOR_ROLES.map(({ role, label, description }) => {
+      const current = orchestrator.config.agents.orchestrators[role];
+      return opt(label, `${current.model} / ${thinkingLabel(current.thinking)} — ${description}`);
+    });
+    options.push(opt("Back", "Return to the previous menu"));
+    const choice = await selectOption(ctx, "Orchestrators", options);
+    if (!choice || choice === "Back") return BACK;
+    const picked = ORCHESTRATOR_ROLES.find((item) => item.label === choice);
+    if (!picked) continue;
+    await showOrchestratorEditor(orchestrator, ctx, picked.role, picked.label);
+  }
+}
+
+async function showSimpleSubagentEditor(
+  orchestrator: Orchestrator,
+  ctx: any,
+  role: AgentRole,
+  label: string,
+): Promise<typeof BACK> {
+  while (true) {
+    const current = orchestrator.config.agents.subagents.simple[role];
+    const basePath = ["agents", "subagents", "simple", role];
+    const choice = await selectOption(ctx, label, [
+      opt(`Model: ${current.model}`, "Select model"),
+      opt(`Thinking: ${thinkingLabel(current.thinking)}`, "Select thinking level"),
+      ...buildResetOptions(orchestrator, basePath),
+      opt("Back", "Return to the previous menu"),
+    ]);
+    if (!choice || choice === "Back") return BACK;
+    if (choice.startsWith("Model:")) {
+      const model = await pickModel(ctx, current.model);
+      if (!model) continue;
+      applyScopeChoice(orchestrator, [...basePath, "model"], model, await pickScope(ctx, orchestrator));
+      continue;
+    }
+    if (choice.startsWith("Thinking:")) {
+      const thinking = await pickThinking(ctx, true, orchestrator, [...basePath, "thinking"]);
+      if (!thinking) continue;
+      applyScopeChoice(orchestrator, [...basePath, "thinking"], thinking, await pickScope(ctx, orchestrator));
+      continue;
+    }
+    await maybeHandleResetChoice(orchestrator, ctx, choice, basePath);
+  }
+}
+
+async function addPresetVariant(
+  orchestrator: Orchestrator,
+  ctx: any,
+  group: PresetGroup,
+  presetName: string,
+): Promise<void> {
+  const variantName = await promptSafeName(ctx, "Agent name");
+  if (!variantName) return;
+  if (orchestrator.config.agents.subagents.presetGroups[group].presets?.[presetName]?.agents?.[variantName]) {
+    ctx.ui.notify(`Agent '${variantName}' already exists.`, "warning");
+    return;
+  }
+  const model = await pickModel(ctx);
+  if (!model) return;
+  const thinking = await pickThinking(ctx, true);
+  if (!thinking) return;
+  const scope = await pickScope(ctx, orchestrator);
+  if (!scope) return;
+  applyConfigChange(orchestrator, scope, ["agents", "subagents", "presetGroups", group, "presets", presetName, "agents", variantName], {
+    enabled: true,
+    model,
+    thinking,
+  });
+}
+
+async function removePresetVariant(
+  orchestrator: Orchestrator,
+  ctx: any,
+  group: PresetGroup,
+  presetName: string,
+  variantName: string,
+): Promise<void> {
+  const variantPath = ["agents", "subagents", "presetGroups", group, "presets", presetName, "agents", variantName];
+  const presetAgentsPath = ["agents", "subagents", "presetGroups", group, "presets", presetName, "agents"];
+  const scopes = getOwnedScopes(orchestrator, variantPath);
+  if (scopes.length === 0) return;
+  const scope = scopes.length === 1 ? scopes[0]! : await pickScopeFromOwned(ctx, orchestrator, variantPath);
+  if (!scope) return;
+  const rawPresetValue = getRawScopeValue(orchestrator, scope, presetAgentsPath);
+  if (!rawPresetValue || typeof rawPresetValue !== "object" || Array.isArray(rawPresetValue)) {
+    ctx.ui.notify("No override in selected scope.", "info");
+    return;
+  }
+  const rawPreset = rawPresetValue as Record<string, VariantConfig>;
+  if (!Object.prototype.hasOwnProperty.call(rawPreset, variantName)) {
+    ctx.ui.notify("Agent is inherited and cannot be removed in selected scope.", "info");
+    return;
+  }
+  if (Object.keys(rawPreset).length <= 1) {
+    try {
+      const nextGlobal = structuredClone(readRawConfig(GLOBAL_CONFIG_PATH));
+      const nextProject = structuredClone(readRawConfig(getProjectConfigPath(orchestrator.cwd)));
+      const target = scope === "global" ? nextGlobal : nextProject;
+      deleteNestedValue(target, presetAgentsPath);
+      mergeConfigLayers(nextGlobal, nextProject);
+    } catch {
+      ctx.ui.notify("Cannot delete the last agent in this preset.", "warning");
+      return;
+    }
+    clearConfigOverride(orchestrator, scope, presetAgentsPath);
+    return;
+  }
+  const nextPreset = structuredClone(rawPreset);
+  delete nextPreset[variantName];
+  applyConfigChange(orchestrator, scope, presetAgentsPath, nextPreset);
+}
+
+async function showPresetVariantEditor(
+  orchestrator: Orchestrator,
+  ctx: any,
+  group: PresetGroup,
+  presetName: string,
+  variantName: string,
+): Promise<typeof BACK> {
+  while (true) {
+    const variant = orchestrator.config.agents.subagents.presetGroups[group].presets?.[presetName]?.agents?.[variantName];
+    if (!variant) return BACK;
+    const variantPath = ["agents", "subagents", "presetGroups", group, "presets", presetName, "agents", variantName];
+    const options: OptionInput[] = [
+      opt(`Enabled: ${isEnabled(variant) ? "Yes" : "No"}`, "Toggle enabled state"),
+      opt(`Model: ${variant.model}`, "Select model"),
+      opt(`Thinking: ${thinkingLabel(variant.thinking)}`, "Select thinking level"),
+    ];
+    if (getOwnedScopes(orchestrator, variantPath).length > 0) {
+      options.push(opt("Delete", "Delete this agent override"));
+    }
+    options.push(opt("Back", "Return to the previous menu"));
+    const choice = await selectOption(ctx, `Agent "${variantName}"`, options);
+    if (!choice || choice === "Back") return BACK;
+    if (choice.startsWith("Model:")) {
+      const model = await pickModel(ctx, variant.model);
+      if (!model) continue;
+      applyScopeChoice(orchestrator, [...variantPath, "model"], model, await pickScope(ctx, orchestrator));
+      continue;
+    }
+    if (choice.startsWith("Thinking:")) {
+      const thinking = await pickThinking(ctx, true, orchestrator, [...variantPath, "thinking"]);
+      if (!thinking) continue;
+      applyScopeChoice(orchestrator, [...variantPath, "thinking"], thinking, await pickScope(ctx, orchestrator));
+      continue;
+    }
+    if (choice.startsWith("Enabled:")) {
+      await showBooleanSetting(orchestrator, ctx, "Enabled", [...variantPath, "enabled"]);
+      continue;
+    }
+    const confirm = await selectOption(ctx, "Confirm delete?", [
+      opt("Yes, delete", "This cannot be undone"),
+      opt("Back", "Cancel"),
+    ]);
+    if (confirm !== "Yes, delete") continue;
+    await removePresetVariant(orchestrator, ctx, group, presetName, variantName);
+    return BACK;
+  }
+}
+
+async function showPresetAgentsMenu(
+  orchestrator: Orchestrator,
+  ctx: any,
+  group: PresetGroup,
+  presetName: string,
+): Promise<typeof BACK> {
+  while (true) {
+    const preset = orchestrator.config.agents.subagents.presetGroups[group].presets?.[presetName];
+    if (!preset) return BACK;
+    const agents = preset.agents ?? {};
+    const options: OptionInput[] = [];
+    const byTitle = new Map<string, string>();
+    for (const [variantName, variant] of Object.entries(agents)) {
+      const tag = isEnabled(variant) ? "" : " (disabled)";
+      const title = `Agent "${variantName}"${tag}`;
+      options.push(opt(title, `${variant.model} / ${thinkingLabel(variant.thinking)}`));
+      byTitle.set(title, variantName);
+    }
+    options.push(opt("New agent", "Add a new agent"));
+    options.push(opt("Back", "Return to the previous menu"));
+    const choice = await selectOption(ctx, "Agents", options);
+    if (!choice || choice === "Back") return BACK;
+    if (choice === "New agent") {
+      await addPresetVariant(orchestrator, ctx, group, presetName);
+      continue;
+    }
+    const variantName = byTitle.get(choice);
+    if (!variantName) continue;
+    await showPresetVariantEditor(orchestrator, ctx, group, presetName, variantName);
+  }
+}
+
+function deletePresetFromScope(orchestrator: Orchestrator, scope: Scope, group: PresetGroup, presetName: string): void {
+  const groupPath = ["agents", "subagents", "presetGroups", group, "presets"];
+  const rawGroup = getRawScopeValue(orchestrator, scope, groupPath);
+  if (!rawGroup || typeof rawGroup !== "object" || Array.isArray(rawGroup)) return;
+  const nextGroup = structuredClone(rawGroup as Record<string, { enabled?: boolean; agents: Record<string, VariantConfig> }>);
+  delete nextGroup[presetName];
+  if (Object.keys(nextGroup).length === 0) {
+    clearConfigOverride(orchestrator, scope, groupPath);
+  } else {
+    applyConfigChange(orchestrator, scope, groupPath, nextGroup);
+  }
+}
+
+function isPresetDisabled(orchestrator: Orchestrator, group: PresetGroup, presetName: string): boolean {
+  const preset = orchestrator.config.agents.subagents.presetGroups[group].presets[presetName];
+  return preset?.enabled === false;
+}
+
+function setPresetDisabled(orchestrator: Orchestrator, group: PresetGroup, presetName: string, disabled: boolean, scope: Scope): void {
+  applyConfigChange(
+    orchestrator,
+    scope,
+    ["agents", "subagents", "presetGroups", group, "presets", presetName, "enabled"],
+    !disabled,
+  );
+}
+
+async function showPresetEditor(
+  orchestrator: Orchestrator,
+  ctx: any,
+  group: PresetGroup,
+  presetName: string,
+): Promise<typeof BACK> {
+  while (true) {
+    const preset = orchestrator.config.agents.subagents.presetGroups[group].presets?.[presetName];
+    if (!preset) return BACK;
+    const isDefault = orchestrator.config.agents.subagents.presetGroups[group].default === presetName;
+    const disabled = isPresetDisabled(orchestrator, group, presetName);
+    const presetPath = ["agents", "subagents", "presetGroups", group, "presets", presetName];
+    const defaultPath = ["agents", "subagents", "presetGroups", group, "default"];
+    const options: OptionInput[] = [
+      opt(`Enabled: ${disabled ? "No" : "Yes"}`, "Enable or disable this preset"),
+      opt("Agents", `${Object.keys(preset.agents ?? {}).length} agents`),
+    ];
+    if (!isDefault) {
+      options.push(opt("Use as default", "Set as default preset"));
+    }
+    options.push(...buildResetOptions(orchestrator, presetPath));
+    if (getOwnedScopes(orchestrator, presetPath).length > 0) {
+      options.push(opt("Delete", "Delete this preset override"));
+    }
+    options.push(opt("Back", "Return to the previous menu"));
+    const choice = await selectOption(ctx, `Preset "${presetName}"${isDefault ? " (default)" : ""}`, options);
+    if (!choice || choice === "Back") return BACK;
+    if (choice.startsWith("Enabled:")) {
+      await showPresetEnabledSetting(orchestrator, ctx, group, presetName);
+      continue;
+    }
+    if (choice === "Use as default") {
+      applyScopeChoice(orchestrator, defaultPath, presetName, await pickScope(ctx, orchestrator));
+      continue;
+    }
+    if (choice === "Agents") {
+      await showPresetAgentsMenu(orchestrator, ctx, group, presetName);
+      continue;
+    }
+    if (choice === "Delete") {
+      if (isDefault) {
+        ctx.ui.notify("Cannot delete the default preset. Change the default first.", "warning");
+        continue;
+      }
+      const confirm = await selectOption(ctx, "Confirm delete?", [
+        opt("Yes, delete", "This cannot be undone"),
+        opt("Back", "Cancel"),
+      ]);
+      if (confirm !== "Yes, delete") continue;
+      const scope = await pickScopeFromOwned(ctx, orchestrator, presetPath);
+      if (!scope) continue;
+      deletePresetFromScope(orchestrator, scope, group, presetName);
+      return BACK;
+    }
+    await maybeHandleResetChoice(orchestrator, ctx, choice, presetPath);
+  }
+}
+
+async function showPresetEnabledSetting(
+  orchestrator: Orchestrator,
+  ctx: any,
+  group: PresetGroup,
+  presetName: string,
+): Promise<void> {
+  const enabledPath = ["agents", "subagents", "presetGroups", group, "presets", presetName, "enabled"];
+  const info = getConfigSourceInfo(orchestrator, enabledPath);
+  const yesTitle = withTags("Yes", formatSourceTags(true, info));
+  const noTitle = withTags("No", formatSourceTags(false, info));
+  const choice = await selectOption(ctx, "Enabled", [
+    yesTitle,
+    noTitle,
+    opt("Back", "Return to the previous menu"),
+  ]);
+  if (!choice || choice === "Back") return;
+  if (choice === yesTitle) {
+    const scope = await pickScope(ctx, orchestrator);
+    if (!scope) return;
+    setPresetDisabled(orchestrator, group, presetName, false, scope);
+  } else if (choice === noTitle) {
+    const scope = await pickScope(ctx, orchestrator);
+    if (!scope) return;
+    setPresetDisabled(orchestrator, group, presetName, true, scope);
+  }
+}
+
+async function addNewPreset(orchestrator: Orchestrator, ctx: any, group: PresetGroup): Promise<void> {
+  const name = await promptSafeName(ctx, "Preset name");
+  if (!name) return;
+  if (orchestrator.config.agents.subagents.presetGroups[group].presets?.[name]) {
+    ctx.ui.notify(`Preset '${name}' already exists.`, "warning");
+    return;
+  }
+  const variantName = await promptSafeName(ctx, "Initial agent name");
+  if (!variantName) return;
+  const model = await pickModel(ctx);
+  if (!model) return;
+  const thinking = await pickThinking(ctx, true);
+  if (!thinking) return;
+  const scope = await pickScope(ctx, orchestrator);
+  if (!scope) return;
+  applyConfigChange(orchestrator, scope, ["agents", "subagents", "presetGroups", group, "presets", name], {
+    enabled: true,
+    agents: {
+      [variantName]: { enabled: true, model, thinking },
+    },
+  });
+}
+
+async function showPresetSettings(
+  orchestrator: Orchestrator,
+  ctx: any,
+  group: PresetGroup,
+  title: string,
+): Promise<typeof BACK> {
+  while (true) {
+    const presets = orchestrator.config.agents.subagents.presetGroups[group].presets ?? {};
+    const defaultName = orchestrator.config.agents.subagents.presetGroups[group].default;
+    const options: OptionInput[] = [];
+    const byTitle = new Map<string, string>();
+    for (const [presetName, preset] of Object.entries(presets)) {
+      const tags: string[] = [];
+      if (presetName === defaultName) tags.push("default");
+      if (isPresetDisabled(orchestrator, group, presetName)) tags.push("disabled");
+      const tagStr = tags.length > 0 ? ` (${tags.join(", ")})` : "";
+      const optionTitle = `Preset "${presetName}"${tagStr}`;
+      options.push(opt(optionTitle, enabledPresetSummary(preset.agents)));
+      byTitle.set(optionTitle, presetName);
+    }
+    options.push(opt("New preset", "Create preset"));
+    options.push(opt("Back", "Return to the previous menu"));
+    const choice = await selectOption(ctx, title, options);
+    if (!choice || choice === "Back") return BACK;
+    if (choice === "New preset") {
+      await addNewPreset(orchestrator, ctx, group);
+      continue;
+    }
+    const presetName = byTitle.get(choice);
+    if (!presetName) continue;
+    await showPresetEditor(orchestrator, ctx, group, presetName);
+  }
+}
+
+async function showSubagentSettings(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
+  while (true) {
+    const options: OptionInput[] = SUBAGENT_ROLES.map(({ role, label, description }) => {
+      const current = orchestrator.config.agents.subagents.simple[role];
+      return opt(label, `${current.model} / ${thinkingLabel(current.thinking)} — ${description}`);
+    });
+    for (const item of PRESET_GROUP_ITEMS) {
+      options.push(opt(item.label, `${Object.keys(orchestrator.config.agents.subagents.presetGroups[item.group].presets ?? {}).length} presets`));
+    }
+    options.push(opt("Back", "Return to the previous menu"));
+    const choice = await selectOption(ctx, "Subagents", options);
+    if (!choice || choice === "Back") return BACK;
+    const simple = SUBAGENT_ROLES.find((item) => item.label === choice);
+    if (simple) {
+      await showSimpleSubagentEditor(orchestrator, ctx, simple.role, simple.label);
+      continue;
+    }
+    const group = PRESET_GROUP_ITEMS.find((item) => item.label === choice);
+    if (!group) continue;
+    await showPresetSettings(orchestrator, ctx, group.group, group.label);
+  }
+}
+
+function getCommandScope(orchestrator: Orchestrator, keyPath: string[]): Scope {
+  const info = getConfigSourceInfo(orchestrator, keyPath);
+  if (info.source === "project") return "project";
+  if (info.source === "global") return "global";
+  return "project";
+}
+
+function ensureUniqueCommandId(existing: Record<string, unknown>, base: string): string {
+  if (!Object.prototype.hasOwnProperty.call(existing, base)) return base;
+  let i = 2;
+  while (Object.prototype.hasOwnProperty.call(existing, `${base}-${i}`)) i += 1;
+  return `${base}-${i}`;
+}
+
+function commandIdFromRun(run: string): string {
+  const base = run
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 48);
+  return base || "command";
+}
+
+async function showAfterEditCommands(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
+  while (true) {
+    const commands = orchestrator.config.commands.afterEdit;
+    const entries = Object.entries(commands);
+    const options: OptionInput[] = [];
+    const byTitle = new Map<string, string>();
+    const usedTitles = new Set<string>();
+    for (const [id, cmd] of entries) {
+      const title = makeUniqueTitle(`Command "${id}"`, usedTitles);
+      const globsCount = (cmd.globs ?? []).length;
+      const enabledTag = isEnabled(cmd) ? "" : " [disabled]";
+      options.push(opt(`${title}${enabledTag}`, `${globsCount} patterns — ${cmd.run}`));
+      byTitle.set(`${title}${enabledTag}`, id);
+    }
+    options.push(opt("New command", "Add command"));
+    options.push(...buildResetOptions(orchestrator, ["commands", "afterEdit"]));
+    options.push(opt("Back", "Return to the previous menu"));
+    const choice = await selectOption(ctx, `After file edit: ${entries.length} commands`, options);
+    if (!choice || choice === "Back") return BACK;
+    if (choice === "New command") {
+      const run = await promptRequiredInput(ctx, "Command to run");
+      if (!run) continue;
+      const globInput = await promptRequiredInput(ctx, "Glob patterns (comma-separated)");
+      if (!globInput) {
+        ctx.ui.notify("At least one file pattern is required.", "warning");
+        continue;
+      }
+      const patterns = parseCommaSeparated(globInput);
+      if (patterns.length === 0) {
+        ctx.ui.notify("At least one file pattern is required.", "warning");
+        continue;
+      }
+      const scope = await pickScope(ctx, orchestrator);
+      if (!scope) continue;
+      const baseId = commandIdFromRun(run);
+      const id = ensureUniqueCommandId(commands, baseId);
+      applyConfigChange(orchestrator, scope, ["commands", "afterEdit", id], { run, globs: patterns, enabled: true });
+      continue;
+    }
+    if (await maybeHandleResetChoice(orchestrator, ctx, choice, ["commands", "afterEdit"])) continue;
+    const id = byTitle.get(choice);
+    if (!id) continue;
+    const commandPath = ["commands", "afterEdit", id];
+    while (true) {
+      const command = orchestrator.config.commands.afterEdit[id];
+      if (!command) break;
+      const commandChoice = await selectOption(ctx, `Command "${id}"`, [
+        opt("Edit command", command.run),
+        opt("Triggers", `${(command.globs ?? []).length} patterns`),
+        opt(`Enabled: ${isEnabled(command) ? "Yes" : "No"}`, "Toggle command"),
+        opt("Delete command", "Remove this command"),
+        opt("Back", "Return to previous menu"),
+      ]);
+      if (!commandChoice || commandChoice === "Back") break;
+      if (commandChoice === "Edit command") {
+        const run = await promptRequiredInput(ctx, `Command (current: ${command.run})`);
+        if (!run) continue;
+        const scope = await pickScope(ctx, orchestrator);
+        if (!scope) continue;
+        applyConfigChange(orchestrator, scope, [...commandPath, "run"], run);
+        continue;
+      }
+      if (commandChoice.startsWith("Enabled:")) {
+        await showBooleanSetting(orchestrator, ctx, "Enabled", [...commandPath, "enabled"]);
+        continue;
+      }
+      if (commandChoice === "Triggers") {
+        while (true) {
+          const current = orchestrator.config.commands.afterEdit[id];
+          if (!current) break;
+          const currentGlobs = current.globs ?? [];
+          const patternUsed = new Set<string>();
+          const patternOptions: OptionInput[] = currentGlobs.map((glob) => {
+            const title = makeUniqueTitle(`Pattern "${slugify(glob, 50)}"`, patternUsed);
+            return opt(title, glob);
+          });
+          patternOptions.push(opt("New pattern", "Add trigger pattern"));
+          patternOptions.push(opt("Back", "Return to previous menu"));
+          const patternChoice = await selectOption(ctx, "File patterns", patternOptions);
+          if (!patternChoice || patternChoice === "Back") break;
+          if (patternChoice === "New pattern") {
+            const value = await promptRequiredInput(ctx, "Pattern");
+            if (!value) continue;
+            const scope = await pickScope(ctx, orchestrator);
+            if (!scope) continue;
+            applyConfigChange(orchestrator, scope, [...commandPath, "globs"], [...currentGlobs, value]);
+            continue;
+          }
+          const patternGlob = patternOptions.find((o) => (typeof o === "string" ? o : o.title) === patternChoice);
+          const actualGlob = patternGlob && typeof patternGlob !== "string" ? patternGlob.description : undefined;
+          const patternIndex = actualGlob ? currentGlobs.indexOf(actualGlob) : -1;
+          if (patternIndex < 0) continue;
+          const action = await selectOption(ctx, `Pattern "${slugify(currentGlobs[patternIndex]!, 50)}"`, [
+            opt("Edit", currentGlobs[patternIndex]!),
+            opt("Delete", "Remove this pattern"),
+            opt("Back", "Return to previous menu"),
+          ]);
+          if (!action || action === "Back") continue;
+          const nextGlob = [...currentGlobs];
+          if (action === "Delete") {
+            const confirm = await selectOption(ctx, "Confirm delete?", [
+              opt("Yes, delete", "This cannot be undone"),
+              opt("Back", "Cancel"),
+            ]);
+            if (confirm !== "Yes, delete") continue;
+            nextGlob.splice(patternIndex, 1);
+          } else {
+            const value = await promptRequiredInput(ctx, `Pattern (current: ${currentGlobs[patternIndex]})`);
+            if (!value) continue;
+            nextGlob[patternIndex] = value;
+          }
+          const scope = await pickScope(ctx, orchestrator);
+          if (!scope) continue;
+          applyConfigChange(orchestrator, scope, [...commandPath, "globs"], nextGlob);
+        }
+        continue;
+      }
+      const confirm = await selectOption(ctx, "Confirm delete?", [
+        opt("Yes, delete", "This cannot be undone"),
+        opt("Back", "Cancel"),
+      ]);
+      if (confirm !== "Yes, delete") continue;
+      const scope = await pickScope(ctx, orchestrator);
+      if (!scope) continue;
+      clearConfigOverride(orchestrator, scope, commandPath);
+      break;
+    }
+  }
+}
+
+async function showAfterImplementCommands(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
+  while (true) {
+    const commands = orchestrator.config.commands.afterImplement;
+    const entries = Object.entries(commands);
+    const options: OptionInput[] = [];
+    const byTitle = new Map<string, string>();
+    const usedTitles = new Set<string>();
+    for (const [id, cmd] of entries) {
+      const enabledTag = isEnabled(cmd) ? "" : " [disabled]";
+      const title = makeUniqueTitle(`Command "${id}"${enabledTag}`, usedTitles);
+      options.push(opt(title, cmd.run));
+      byTitle.set(title, id);
+    }
+    options.push(opt("New command", "Add command"));
+    options.push(...buildResetOptions(orchestrator, ["commands", "afterImplement"]));
+    options.push(opt("Back", "Return to the previous menu"));
+    const choice = await selectOption(ctx, `After implementation: ${entries.length} commands`, options);
+    if (!choice || choice === "Back") return BACK;
+    if (choice === "New command") {
+      const run = await promptRequiredInput(ctx, "Command to run");
+      if (!run) continue;
+      const scope = await pickScope(ctx, orchestrator);
+      if (!scope) continue;
+      const id = ensureUniqueCommandId(commands, commandIdFromRun(run));
+      applyConfigChange(orchestrator, scope, ["commands", "afterImplement", id], { run, enabled: true });
+      continue;
+    }
+    if (await maybeHandleResetChoice(orchestrator, ctx, choice, ["commands", "afterImplement"])) continue;
+    const id = byTitle.get(choice);
+    if (!id) continue;
+    const commandPath = ["commands", "afterImplement", id];
+    while (true) {
+      const command = orchestrator.config.commands.afterImplement[id];
+      if (!command) break;
+      const commandChoice = await selectOption(ctx, `Command "${id}"`, [
+        opt("Edit command", command.run),
+        opt(`Enabled: ${isEnabled(command) ? "Yes" : "No"}`, "Toggle command"),
+        opt("Delete command", "Remove this command"),
+        opt("Back", "Return to previous menu"),
+      ]);
+      if (!commandChoice || commandChoice === "Back") break;
+      if (commandChoice === "Edit command") {
+        const run = await promptRequiredInput(ctx, `Command (current: ${command.run})`);
+        if (!run) continue;
+        const scope = await pickScope(ctx, orchestrator);
+        if (!scope) continue;
+        applyConfigChange(orchestrator, scope, [...commandPath, "run"], run);
+        continue;
+      }
+      if (commandChoice.startsWith("Enabled:")) {
+        await showBooleanSetting(orchestrator, ctx, "Enabled", [...commandPath, "enabled"]);
+        continue;
+      }
+      const confirm = await selectOption(ctx, "Confirm delete?", [
+        opt("Yes, delete", "This cannot be undone"),
+        opt("Back", "Cancel"),
+      ]);
+      if (confirm !== "Yes, delete") continue;
+      const scope = await pickScope(ctx, orchestrator);
+      if (!scope) continue;
+      clearConfigOverride(orchestrator, scope, commandPath);
+      break;
+    }
+  }
+}
+
+async function showCommandsSettings(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
+  while (true) {
+    const afterEditCount = Object.keys(orchestrator.config.commands.afterEdit).length;
+    const afterImplementCount = Object.keys(orchestrator.config.commands.afterImplement).length;
+    const choice = await selectOption(ctx, "Commands", [
+      opt(
+        `After file edit: ${afterEditCount} commands`,
+        `${afterEditCount} commands`,
+      ),
+      opt(
+        `After implementation: ${afterImplementCount} commands`,
+        `${afterImplementCount} commands`,
+      ),
+      opt("Back", "Return to the previous menu"),
+    ]);
+    if (!choice || choice === "Back") return BACK;
+    if (choice.startsWith("After file edit:")) {
+      await showAfterEditCommands(orchestrator, ctx);
+      continue;
+    }
+    await showAfterImplementCommands(orchestrator, ctx);
+  }
+}
+
+async function showTimeoutsSettings(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
+  while (true) {
+    const timeoutEntries: TimeoutEntry[] = [
+      {
+        key: "performance.commands.afterEdit",
+        path: ["performance", "commands", "afterEdit"],
+        value: orchestrator.config.performance.commands.afterEdit,
+      },
+      {
+        key: "performance.commands.afterImplement",
+        path: ["performance", "commands", "afterImplement"],
+        value: orchestrator.config.performance.commands.afterImplement,
+      },
+      {
+        key: "performance.internals.subagentStale",
+        path: ["performance", "internals", "subagentStale"],
+        value: orchestrator.config.performance.internals.subagentStale,
+      },
+      {
+        key: "performance.internals.taskLockStale",
+        path: ["performance", "internals", "taskLockStale"],
+        value: orchestrator.config.performance.internals.taskLockStale,
+      },
+      {
+        key: "performance.internals.taskLockRefresh",
+        path: ["performance", "internals", "taskLockRefresh"],
+        value: orchestrator.config.performance.internals.taskLockRefresh,
+      },
+    ];
+    const options: OptionInput[] = timeoutEntries.map((entry) => {
+      const value = entry.value;
+      const key = entry.key;
+      return opt(`${TIMEOUT_LABELS[key]}: ${formatDuration(value)}`, "Edit timeout");
+    });
+    options.push(opt("Back", "Return to the previous menu"));
+    const choice = await selectOption(ctx, "Timeouts", options);
+    if (!choice || choice === "Back") return BACK;
+    const entry = timeoutEntries.find((item) => choice.startsWith(`${TIMEOUT_LABELS[item.key]}:`));
+    if (!entry) continue;
+    while (true) {
+      const current = getNestedValue(orchestrator.config, entry.path);
+      if (typeof current !== "number") break;
+      const action = await selectOption(ctx, `${TIMEOUT_LABELS[entry.key]}: ${formatDuration(current)}`, [
+        opt("Edit", "Set timeout value"),
+        ...buildResetOptions(orchestrator, entry.path),
+        opt("Back", "Return to the previous menu"),
+      ]);
+      if (!action || action === "Back") break;
+      if (action === "Edit") {
+        const input = await promptRequiredInput(
+          ctx,
+          `New value (current: ${formatDuration(current)}, e.g. 30s, 5m, 1h, or milliseconds)`,
+        );
+        if (!input) continue;
+        const parsed = parseDuration(input);
+        if (parsed === null) {
+          ctx.ui.notify("Invalid duration format.", "warning");
+          continue;
+        }
+        applyScopeChoice(orchestrator, entry.path, parsed, await pickScope(ctx, orchestrator));
+        continue;
+      }
+      await maybeHandleResetChoice(orchestrator, ctx, action, entry.path);
+    }
+  }
+}
+
+async function showPerformanceSettings(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
+  while (true) {
+    const choice = await selectOption(ctx, "Performance", [
+      opt("Timeouts", "Timeout configuration"),
+      opt("Back", "Return to the previous menu"),
+    ]);
+    if (!choice || choice === "Back") return BACK;
+    await showTimeoutsSettings(orchestrator, ctx);
+  }
+}
+
+async function showBooleanSetting(
+  orchestrator: Orchestrator,
+  ctx: any,
+  title: string,
+  keyPath: string[],
+): Promise<void> {
+  while (true) {
+    const info = getConfigSourceInfo(orchestrator, keyPath);
+    const yesTitle = withTags("Yes", formatSourceTags(true, info));
+    const noTitle = withTags("No", formatSourceTags(false, info));
+    const choice = await selectOption(ctx, title, [
+      yesTitle,
+      noTitle,
+      ...buildResetOptions(orchestrator, keyPath),
+      opt("Back", "Return to the previous menu"),
+    ]);
+    if (!choice || choice === "Back") return;
+    if (choice === yesTitle) {
+      applyScopeChoice(orchestrator, keyPath, true, await pickScope(ctx, orchestrator));
+      continue;
+    }
+    if (choice === noTitle) {
+      applyScopeChoice(orchestrator, keyPath, false, await pickScope(ctx, orchestrator));
+      continue;
+    }
+    await maybeHandleResetChoice(orchestrator, ctx, choice, keyPath);
+  }
+}
+
+async function showInvertedBooleanSetting(
+  orchestrator: Orchestrator,
+  ctx: any,
+  title: string,
+  keyPath: string[],
+): Promise<void> {
+  while (true) {
+    const info = getConfigSourceInfo(orchestrator, keyPath);
+    const yesTitle = withTags("Yes", formatSourceTags(false, info));
+    const noTitle = withTags("No", formatSourceTags(true, info));
+    const choice = await selectOption(ctx, title, [
+      yesTitle,
+      noTitle,
+      ...buildResetOptions(orchestrator, keyPath),
+      opt("Back", "Return to the previous menu"),
+    ]);
+    if (!choice || choice === "Back") return;
+    if (choice === yesTitle) {
+      applyScopeChoice(orchestrator, keyPath, false, await pickScope(ctx, orchestrator));
+      continue;
+    }
+    if (choice === noTitle) {
+      applyScopeChoice(orchestrator, keyPath, true, await pickScope(ctx, orchestrator));
+      continue;
+    }
+    await maybeHandleResetChoice(orchestrator, ctx, choice, keyPath);
+  }
+}
+
+async function showLogLevelSetting(orchestrator: Orchestrator, ctx: any): Promise<void> {
+  const levels: Array<{ value: PiPiConfig["general"]["logLevel"]; label: string }> = [
+    { value: "debug", label: "Debug" },
+    { value: "info", label: "Info" },
+    { value: "warn", label: "Warning" },
+    { value: "error", label: "Error" },
+  ];
+  while (true) {
+    const info = getConfigSourceInfo(orchestrator, ["general", "logLevel"]);
+    const options: OptionInput[] = levels.map((entry) => withTags(entry.label, formatSourceTags(entry.value, info)));
+    options.push(...buildResetOptions(orchestrator, ["general", "logLevel"]));
+    options.push(opt("Back", "Return to the previous menu"));
+    const choice = await selectOption(ctx, "Log level", options);
+    if (!choice || choice === "Back") return;
+    const picked = levels.find((entry) => choice.startsWith(entry.label));
+    if (picked) {
+      const scope = await pickScope(ctx, orchestrator);
+      if (!scope) continue;
+      applyConfigChange(orchestrator, scope, ["general", "logLevel"], picked.value);
+      setLogLevel(orchestrator.config.general.logLevel);
+      continue;
+    }
+    await maybeHandleResetChoice(orchestrator, ctx, choice, ["general", "logLevel"]);
+    setLogLevel(orchestrator.config.general.logLevel);
+  }
+}
+
+async function showGeneralSettings(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
+  while (true) {
+    const choice = await selectOption(ctx, "General", [
+      opt(`Commit automatically: ${orchestrator.config.general.autoCommit ? "Yes" : "No"}`, "Enable or disable auto commits"),
+      opt(`Ignore configs from other repos: ${orchestrator.config.general.loadExtraRepoConfigs ? "No" : "Yes"}`, "Load only root repo config"),
+      opt(`Log level: ${logLevelLabel(orchestrator.config.general.logLevel)}`, "Logging verbosity"),
+      opt(`Tracing: ${orchestrator.config.general.tracing ? "Yes" : "No"}`, "Capture full session traces to .pp/logs/traces/"),
+      opt("Flant AI Infrastructure", "Configure corporate AI model provider"),
+      opt("Back", "Return to the previous menu"),
+    ]);
+    if (!choice || choice === "Back") return BACK;
+    if (choice.startsWith("Commit automatically:")) {
+      await showBooleanSetting(orchestrator, ctx, "Commit automatically", ["general", "autoCommit"]);
+      continue;
+    }
+    if (choice.startsWith("Ignore configs from other repos:")) {
+      await showInvertedBooleanSetting(orchestrator, ctx, "Ignore configs from other repos", ["general", "loadExtraRepoConfigs"]);
+      continue;
+    }
+    if (choice.startsWith("Log level:")) {
+      await showLogLevelSetting(orchestrator, ctx);
+      continue;
+    }
+    if (choice.startsWith("Tracing:")) {
+      await showBooleanSetting(orchestrator, ctx, "Tracing", ["general", "tracing"]);
+      continue;
+    }
+    await showFlantInfraMenu(orchestrator, ctx);
+  }
+}
+
+async function showAgentsSettings(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
+  while (true) {
+    const choice = await selectOption(ctx, "Agents", [
+      opt("Orchestrators", "Orchestrator and subagent configuration"),
+      opt("Subagents", "Simple subagents and preset groups"),
+      opt("Back", "Return to the previous menu"),
+    ]);
+    if (!choice || choice === "Back") return BACK;
+    if (choice === "Orchestrators") {
+      await showOrchestratorsSettings(orchestrator, ctx);
+      continue;
+    }
+    await showSubagentSettings(orchestrator, ctx);
+  }
+}
+
+async function showReposSettings(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
+  while (true) {
+    const repos = orchestrator.active?.state.repos ?? [];
+    if (repos.length === 0) {
+      await selectOption(ctx, "No repos registered yet. The agent will register repos when it starts working.", [
+        opt("Back", "Return to the previous menu"),
+      ]);
+      return BACK;
+    }
+
+    const options: OptionInput[] = repos.map((repo) => ({
+      title: repo.path,
+      description: `base: ${repo.baseBranch ?? "(not set)"}${repo.isRoot ? " (root)" : ""}`,
+    }));
+    options.push(opt("Back", "Return to the previous menu"));
+
+    const choice = await selectOption(ctx, "Repos", options);
+    if (!choice || choice === "Back") return BACK;
+
+    const repo = repos.find((item) => item.path === choice);
+    if (!repo) continue;
+
+    const repoOptions: OptionInput[] = [
+      opt("Change base branch", `currently: ${repo.baseBranch ?? "(not set)"}`),
+      opt("Back", "Return to repo list"),
+    ];
+    const repoChoice = await selectOption(ctx, `${repo.path}${repo.isRoot ? " (root)" : ""}`, repoOptions);
+    if (!repoChoice || repoChoice === "Back") continue;
+
+    if (repoChoice === "Change base branch") {
+      const value = await ctx.ui.input("Base branch (e.g. origin/main):");
+      if (value === undefined || value === null) continue;
+      repo.baseBranch = String(value).trim() || undefined;
+      saveTask(orchestrator.active!.dir, orchestrator.active!.state);
+      unregisterAgentDefinitions(orchestrator.pi);
+      orchestrator.registerAgents();
+      ctx.ui.notify(`Base branch set to: ${repo.baseBranch ?? "(cleared)"}`, "info");
+    }
+  }
+}
+
+async function showLspSettings(ctx: any): Promise<typeof BACK> {
+  while (true) {
+    const choice = await selectOption(ctx, "LSP", [
+      opt("Restart all servers", "Stop all servers. They reinitialize on next use"),
+      opt("Back", "Return to the previous menu"),
+    ]);
+    if (!choice || choice === "Back") return BACK;
+
+    const api = (globalThis as any)[Symbol.for("pi-lsp:api")] as {
+      restart?: (menuCtx: any) => Promise<void>;
+    } | undefined;
+    if (!api?.restart) {
+      ctx.ui.notify("LSP API is not available.", "warning");
+      continue;
+    }
+    try {
+      await api.restart(ctx);
+    } catch (error: any) {
+      const message = error instanceof Error ? error.message : String(error);
+      ctx.ui.notify(`Failed to restart LSP servers: ${message}`, "error");
+    }
+  }
+}
+
+async function showSettingsMenu(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
+  while (true) {
+    const options: OptionInput[] = [
+      opt("General", "Commit, log level, Flant AI, repos"),
+      opt("Agents", "Orchestrator and subagent configuration"),
+      opt("Commands", "After file edit and after implementation"),
+      opt("Performance", "Timeout configuration"),
+      opt("LSP", "Language server controls"),
+      opt("Back", "Return to the previous menu"),
+    ];
+
+    const choice = await selectOption(ctx, "Settings", options);
+    if (!choice || choice === "Back") return BACK;
+
+    if (choice === "General") await showGeneralSettings(orchestrator, ctx);
+    else if (choice === "Agents") await showAgentsSettings(orchestrator, ctx);
+    else if (choice === "Commands") await showCommandsSettings(orchestrator, ctx);
+    else if (choice === "Performance") await showPerformanceSettings(orchestrator, ctx);
+    else if (choice === "LSP") await showLspSettings(ctx);
+  }
+}
+
+// First phases (brainstorm/debug/review) are always interactive and can never run
+// autonomously — autonomous configs only ever cover plan/implement.
+function autonomousPhasesForTask(type: TaskType): string[] {
+  if (type === "implement" || type === "debug" || type === "review") return ["plan", "implement"];
+  return [];
+}
+
+function defaultAutonomousReviewPreset(type: TaskType, phase: string): string {
+  if (type === "review" && phase === "review") return "deep";
+  return "regular";
+}
+
+function buildDefaultAutonomousConfig(type: TaskType): AutonomousConfig {
+  const phases = autonomousPhasesForTask(type);
+  const out: AutonomousConfig = { phases: {} };
+  for (const phase of phases) {
+    out.phases[phase] = {
+      reviewPreset: defaultAutonomousReviewPreset(type, phase),
+      maxReviewPasses: 3,
+      ...(phase === "plan" ? { plannerPreset: "regular" } : {}),
+    };
+  }
+  return out;
+}
+
+async function showTaskModePicker(ctx: any): Promise<TaskMode | "back"> {
+  const mode = await selectOption(ctx, "Mode", [
+    opt("Guided", "User gates at every phase transition"),
+    opt("Autonomous", "Full pipeline with automatic phase transitions"),
+    opt("Back", "Return to the previous menu"),
+  ]);
+  if (!mode || mode === "Back") return "back";
+  return mode === "Autonomous" ? "autonomous" : "guided";
+}
+
+export async function pickMaxReviewPasses(ctx: any, current: number): Promise<number | null> {
+  const currentLabel = current >= 999 ? "-" : String(current);
+  while (true) {
+    const input = await ctx.ui.input(
+      `Max review passes (enter a positive integer, or "-" for unlimited) [${currentLabel}]`,
+    );
+    if (input === undefined || input === null) return null;
+    const trimmed = String(input).trim();
+    if (trimmed === "") return null;
+    if (trimmed === "-") return 999;
+    if (!/^\d+$/.test(trimmed)) {
+      ctx.ui.notify('Please enter a positive integer, or "-" for unlimited.', "warning");
+      continue;
+    }
+    const parsed = Number.parseInt(trimmed, 10);
+    if (parsed <= 0) {
+      ctx.ui.notify('Please enter a positive integer, or "-" for unlimited.', "warning");
+      continue;
+    }
+    return parsed;
+  }
+}
+
+async function showAutonomousPhaseSettings(
+  orchestrator: Orchestrator,
+  ctx: any,
+  type: TaskType,
+  phase: string,
+  config: AutonomousConfig,
+): Promise<void> {
+  const phaseConfig = config.phases[phase] ?? {
+    reviewPreset: defaultAutonomousReviewPreset(type, phase),
+    maxReviewPasses: 3,
+    ...(phase === "plan" ? { plannerPreset: "regular" } : {}),
+  };
+  config.phases[phase] = phaseConfig;
+
+  while (true) {
+    const reviewPreset = phaseConfig.reviewPreset ?? defaultAutonomousReviewPreset(type, phase);
+    const maxReview = phaseConfig.maxReviewPasses >= 999 ? "No limit" : String(phaseConfig.maxReviewPasses);
+    const options: OptionInput[] = [
+      opt(`Review preset: ${reviewPreset}`, "Select review preset"),
+    ];
+    if (phase === "plan") {
+      options.push(opt(`Planner preset: ${phaseConfig.plannerPreset ?? "regular"}`, "Select planner preset"));
+    }
+    options.push(opt(`Max review passes: ${maxReview}`, "Safety cap for autonomous review loops"));
+    options.push(opt("Back", "Return to autonomous settings"));
+
+    const choice = await selectOption(ctx, `${phase.charAt(0).toUpperCase()}${phase.slice(1)} phase`, options);
+    if (!choice || choice === "Back") return;
+
+    if (choice.startsWith("Review preset:")) {
+      const group = getReviewPresetGroup(phase);
+      const picked = await pickPreset(ctx, orchestrator, group, "Review preset");
+      if (picked) phaseConfig.reviewPreset = picked;
+      continue;
+    }
+
+    if (choice.startsWith("Planner preset:")) {
+      const picked = await pickPreset(ctx, orchestrator, "planners", "Planner preset");
+      if (picked) phaseConfig.plannerPreset = picked;
+      continue;
+    }
+
+    const pickedMax = await pickMaxReviewPasses(ctx, phaseConfig.maxReviewPasses);
+    if (pickedMax !== null) phaseConfig.maxReviewPasses = pickedMax;
+  }
+}
+
+async function showAutonomousSettings(
+  orchestrator: Orchestrator,
+  ctx: any,
+  type: TaskType,
+): Promise<AutonomousConfig | null> {
+  const config = buildDefaultAutonomousConfig(type);
+  const phases = autonomousPhasesForTask(type);
+
+  while (true) {
+    const options: OptionInput[] = [
+      opt("Start", "Begin with current autonomous settings"),
+      ...phases.map((phase) => opt(`${phase.charAt(0).toUpperCase()}${phase.slice(1)} phase`, "Configure presets and review passes")),
+      opt("Back", "Return to mode selection"),
+    ];
+    const choice = await selectOption(ctx, "Autonomous", options);
+    if (!choice || choice === "Back") return null;
+    if (choice === "Start") return config;
+
+    const phase = choice.replace(/ phase$/, "").toLowerCase();
+    if (!phases.includes(phase)) continue;
+    await showAutonomousPhaseSettings(orchestrator, ctx, type, phase, config);
+  }
+}
+
+async function pickModeForTaskStart(
+  orchestrator: Orchestrator,
+  ctx: any,
+  type: TaskType,
+): Promise<{ mode: TaskMode; autonomousConfig?: AutonomousConfig } | null> {
+  while (true) {
+    const mode = await showTaskModePicker(ctx);
+    if (mode === "back") return null;
+    if (mode === "guided") return { mode: "guided" };
+    const autonomousConfig = await showAutonomousSettings(orchestrator, ctx, type);
+    if (!autonomousConfig) continue;
+    return { mode: "autonomous", autonomousConfig };
+  }
+}
+
+// Title: scannable human-readable intent + age. Callers must guarantee
+// uniqueness across the menu (see buildResumeOptions) so the option->task
+// mapping stays stable.
+function resumeOptionTitle(t: TaskInfo): string {
+  return `${taskNameFromState(t.dir, t.state)} — ${taskAge(t.state)}`;
+}
+
+// Description: rich per-entry detail sourced entirely from the already-loaded
+// TaskState (no extra disk reads). Empty/irrelevant fields are omitted.
+function resumeOptionDescription(t: TaskInfo, cwd: string): string {
+  const s = t.state;
+  const parts: string[] = [];
+
+  const phaseStep = s.step ? `${s.phase}/${s.step}` : s.phase;
+  parts.push(`${t.type} · ${phaseStep}`);
+
+  const mode = s.effectiveMode ?? s.mode;
+  if (mode) parts.push(mode);
+
+  if (s.reviewCycle && s.reviewCycle.pass > 0) parts.push(`review pass ${s.reviewCycle.pass}`);
+
+  const fileCount = s.modifiedFiles?.length ?? 0;
+  if (fileCount > 0) parts.push(`${fileCount} file${fileCount === 1 ? "" : "s"}`);
+
+  // Only surface the repo when it is informative: a multi-repo task, or a root
+  // repo that differs from the current project directory.
+  const rootRepo = s.repos?.find((r) => r.isRoot) ?? s.repos?.[0];
+  if (rootRepo && ((s.repos?.length ?? 0) > 1 || basename(rootRepo.path) !== basename(cwd))) {
+    parts.push(`repo: ${basename(rootRepo.path)}`);
+  }
+
+  parts.push(`id ${taskShortId(t.dir)}`);
+  return parts.join(" · ");
+}
+
+// Build menu options with a stable option->task index. Titles are made unique
+// (short id appended on collision) so selection maps back deterministically even
+// if two tasks share an intent, and the age component can't break the mapping
+// after the picker returns.
+function buildResumeOptions(tasks: TaskInfo[], cwd: string): { options: OptionInput[]; byTitle: Map<string, TaskInfo> } {
+  const seen = new Map<string, number>();
+  const byTitle = new Map<string, TaskInfo>();
+  const options: OptionInput[] = [];
+  for (const t of tasks) {
+    let title = resumeOptionTitle(t);
+    const count = seen.get(title) ?? 0;
+    seen.set(title, count + 1);
+    if (count > 0 || byTitle.has(title)) title = `${title} [${taskShortId(t.dir)}]`;
+    while (byTitle.has(title)) title = `${title} ·`;
+    byTitle.set(title, t);
+    options.push({ title, description: resumeOptionDescription(t, cwd) });
+  }
+  return { options, byTitle };
+}
+
+async function showResumeMenu(
+  orchestrator: Orchestrator,
+  ctx: any,
+  type: TaskType | undefined,
+  emptyMessage: string,
+): Promise<typeof BACK | "started"> {
+  while (true) {
+    const tasks = listTasks(orchestrator.cwd, type);
+    if (tasks.length === 0) {
+      ctx.ui.notify(emptyMessage, "info");
+      return BACK;
+    }
+
+    const { options, byTitle } = buildResumeOptions(tasks, orchestrator.cwd);
+    options.push({ title: "Back", description: "Return to the previous menu" });
+
+    const choice = await selectOption(ctx, "Resume", options);
+    if (!choice || choice === "Back") return BACK;
+
+    const task = byTitle.get(choice);
+    if (!task) continue;
+    const result = await resumeTask(orchestrator, ctx, task);
+    if (result.ok) return "started";
+  }
+}
+
+function fromOptionTitle(t: TaskInfo): string {
+  return taskName(t.dir);
+}
+
+function fromOptionDescription(t: TaskInfo, cwd: string): string {
+  const age = taskAge(t.state);
+  const rel = relative(join(cwd, ".pp", "state"), t.dir);
+  return `${t.type}, ${age} — ${rel}`;
+}
+
+async function showFromMenu(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK | "started"> {
+  while (true) {
+    const tasks = listCompletedFromTasks(orchestrator.cwd);
+    if (tasks.length === 0) {
+      ctx.ui.notify("No completed brainstorm/debug/review tasks with artifacts found.", "info");
+      return BACK;
+    }
+
+    const options: OptionInput[] = tasks.map((t) => ({
+      title: fromOptionTitle(t),
+      description: fromOptionDescription(t, orchestrator.cwd),
+    }));
+    options.push({ title: "Back", description: "Return to the previous menu" });
+
+    const choice = await selectOption(ctx, "From", options);
+    if (!choice || choice === "Back") return BACK;
+
+    const selected = tasks.find((t) => fromOptionTitle(t) === choice);
+    if (!selected) continue;
+
+    const modeSelection = await pickModeForTaskStart(orchestrator, ctx, "implement");
+    if (!modeSelection) continue;
+    await orchestrator.startTask(ctx, "implement", "implement", selected.dir, true, modeSelection.mode);
+    if (orchestrator.active) {
+      orchestrator.active.state.autonomousConfig = modeSelection.autonomousConfig;
+      saveTask(orchestrator.active.dir, orchestrator.active.state);
+    }
+    return "started";
+  }
+}
+
+async function showImplementMenu(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK | "started"> {
+  while (true) {
+    const choice = await selectOption(ctx, "Implement", [
+      { title: "New", description: "Start a new implementation from scratch" },
+      { title: "From", description: "Continue from a completed brainstorm or debug task" },
+      { title: "Resume", description: "Resume a paused implementation" },
+      { title: "Back", description: "Return to the previous menu" },
+    ]);
+    if (!choice || choice === "Back") return BACK;
+
+    if (choice === "New") {
+      const modeSelection = await pickModeForTaskStart(orchestrator, ctx, "implement");
+      if (!modeSelection) continue;
+      await orchestrator.startTask(ctx, "implement", "implement", undefined, undefined, modeSelection.mode);
+      if (orchestrator.active) {
+        orchestrator.active.state.autonomousConfig = modeSelection.autonomousConfig;
+        saveTask(orchestrator.active.dir, orchestrator.active.state);
+      }
+      return "started";
+    }
+
+    if (choice === "From") {
+      const result = await showFromMenu(orchestrator, ctx);
+      if (result === "started") return result;
+      continue;
+    }
+
+    const result = await showResumeMenu(orchestrator, ctx, "implement", "No paused implement tasks found.");
+    if (result === "started") return result;
+  }
+}
+
+function buildPrContext(parsed: any): { prUrl: string | null; prContext: string | null } {
+  const title = typeof parsed?.title === "string" ? parsed.title.trim() : "";
   const body = typeof parsed?.body === "string" ? parsed.body.trim() : "";
   const commentsRaw = Array.isArray(parsed?.comments)
     ? parsed.comments
@@ -895,47 +3029,56 @@ function buildPrContext(parsed: any): { prUrl: string | null; prContext: string
   return { prUrl, prContext: parts.length > 0 ? parts.join("\n\n") : null };
 }
 
-async function detectCurrentPrContext(orchestrator: Orchestrator): Promise<{ prUrl: string | null; prContext: string | null }> {
-  try {
-    const prResult = await orchestrator.pi.exec("gh", ["pr", "view", "--json", "url,title,body,comments"], {
-      cwd: orchestrator.cwd,
-      timeout: 10000,
-    });
-    if (prResult.code !== 0) return { prUrl: null, prContext: null };
-    const parsed = JSON.parse(prResult.stdout);
-    return buildPrContext(parsed);
-  } catch {
-    return { prUrl: null, prContext: null };
+async function detectCurrentPrContext(orchestrator: Orchestrator, repos: RepoInfo[]): Promise<RepoPrContext[]> {
+  const results: RepoPrContext[] = [];
+  for (const repo of repos) {
+    try {
+      const prResult = await orchestrator.pi.exec("gh", ["pr", "view", "--json", "url,title,body,comments"], {
+        cwd: repo.path,
+        timeout: 10000,
+      });
+      if (prResult.code !== 0) continue;
+      const parsed = JSON.parse(prResult.stdout);
+      const pr = buildPrContext(parsed);
+      if (pr.prUrl || pr.prContext) {
+        results.push({ repoPath: repo.path, prUrl: pr.prUrl, prContext: pr.prContext });
+      }
+    } catch {}
   }
+  return results;
 }
 
-async function openCodeReviewInPlannotator(orchestrator: Orchestrator, diffType?: string, defaultBranch?: string): Promise<string> {
-  const payload: Record<string, unknown> = { cwd: orchestrator.cwd };
-  if (diffType) payload.diffType = diffType;
-  if (defaultBranch) payload.defaultBranch = defaultBranch;
+async function openCodeReviewInPlannotator(
+  orchestrator: Orchestrator,
+  payload: { cwd: string; diffType?: string; defaultBranch?: string },
+): Promise<{ status: "approved" | "needs_changes" | "error"; feedback?: string; error?: string }> {
+  const requestPayload: Record<string, unknown> = { cwd: payload.cwd };
+  if (payload.diffType) requestPayload.diffType = payload.diffType;
+  if (payload.defaultBranch) requestPayload.defaultBranch = payload.defaultBranch;
 
   return await new Promise((resolve) => {
     let handled = false;
+    const timer = setTimeout(() => {
+      if (!handled) resolve({ status: "error", error: "Plannotator is not available." });
+    }, 30000);
     orchestrator.pi.events.emit("plannotator:request", {
       requestId: crypto.randomUUID(),
       action: "code-review",
-      payload,
+      payload: requestPayload,
       respond: (response: any) => {
         handled = true;
+        clearTimeout(timer);
         if (response?.status !== "handled") {
-          resolve(`Plannotator is not available${response?.error ? `: ${response.error}` : "."}`);
+          resolve({ status: "error", error: response?.error || "Plannotator is not available." });
           return;
         }
         const approved = !!response?.result?.approved;
         const feedback = typeof response?.result?.feedback === "string" && response.result.feedback.trim().length > 0
-          ? `\n\nFeedback:\n${response.result.feedback}`
-          : "";
-        resolve(approved ? "Plannotator approved the review." : `Plannotator requested changes.${feedback}`);
+          ? response.result.feedback
+          : undefined;
+        resolve({ status: approved ? "approved" : "needs_changes", feedback });
       },
     });
-    setTimeout(() => {
-      if (!handled) resolve("Plannotator is not available.");
-    }, 30000);
   });
 }
 
@@ -945,10 +3088,16 @@ async function startReviewTask(
   userRequestContent: string,
   researchContent: string | null,
   description: string,
+  mode?: TaskMode,
+  autonomousConfig?: AutonomousConfig,
 ): Promise<"started" | typeof BACK> {
-  await orchestrator.startTask(ctx, "review", description);
+  await orchestrator.startTask(ctx, "review", description, undefined, undefined, mode);
   if (!orchestrator.active || orchestrator.active.type !== "review") return BACK;
-  writeFileSync(join(orchestrator.active.dir, "USER_REQUEST.md"), userRequestContent, "utf-8");
+  orchestrator.active.state.autonomousConfig = autonomousConfig;
+  saveTask(orchestrator.active.dir, orchestrator.active.state);
+  const repos = getRegisteredRepos(orchestrator);
+  const userRequestWithRepos = appendRepoContext(userRequestContent, repos);
+  writeFileSync(join(orchestrator.active.dir, "USER_REQUEST.md"), userRequestWithRepos, "utf-8");
   if (researchContent) {
     writeFileSync(join(orchestrator.active.dir, "RESEARCH.md"), researchContent, "utf-8");
   }
@@ -957,13 +3106,16 @@ async function startReviewTask(
 
 async function showReviewMenu(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK | "started"> {
   while (true) {
-    const choice = await selectOption(ctx, "Review", [
+    const options: OptionInput[] = [
       { title: "Current branch", description: "Review changes on current branch vs base" },
+      { title: "Last commit", description: "Review changes in the most recent commit" },
+      { title: "Since commit", description: "Review all changes since a specific commit" },
       { title: "Uncommitted changes", description: "Review working directory changes" },
       { title: "Describe", description: "Describe what to review and let the agent figure it out" },
       { title: "Resume", description: "Resume a previously unfinished review" },
       { title: "Back", description: "Return to the previous menu" },
-    ]);
+    ];
+    const choice = await selectOption(ctx, "Review", options);
     if (!choice || choice === "Back") return BACK;
 
     if (choice === "Resume") {
@@ -973,38 +3125,132 @@ async function showReviewMenu(orchestrator: Orchestrator, ctx: any): Promise<typ
     }
 
     if (choice === "Current branch") {
-      const base = await detectDefaultBranch(orchestrator.pi, orchestrator.cwd, orchestrator.config);
-      const pr = await detectCurrentPrContext(orchestrator);
-
-      const urLines = [`# User Request\nReview current branch changes (${base}..HEAD)`];
-      if (pr.prUrl) urLines.push(`PR: ${pr.prUrl}`);
+      const repos = getRegisteredRepos(orchestrator);
+      const repoRanges = await Promise.all(
+        repos.map(async (repo) => `- ${formatRepoLabel(repo)}: ${await detectDefaultBranch(orchestrator, repos, repo.path)}..HEAD`),
+      );
+      const prContexts = await detectCurrentPrContext(orchestrator, repos);
+
+      const urLines = [
+        "# User Request",
+        "Review current branch changes across registered repositories.",
+        "",
+        "Diff ranges:",
+        ...repoRanges,
+      ];
+      const prUrls = prContexts
+        .filter((pr) => pr.prUrl)
+        .map((pr) => `- ${pr.repoPath}: ${pr.prUrl}`);
+      if (prUrls.length > 0) {
+        urLines.push("", "Open PRs:", ...prUrls);
+      }
       urLines.push("", "## Problem", "Review and identify issues in the code changes.", "", "## Constraints", "Focus on correctness, edge cases, style, missing tests, potential bugs.");
       const urContent = urLines.join("\n") + "\n";
 
-      let resContent: string | null = null;
-      if (pr.prContext) {
-        resContent = ["## PR Context", pr.prContext, "", "## Affected Code", "(to be filled during review)", "", "## Architecture Context", "(to be filled during review)"].join("\n") + "\n";
+      let resContent = [
+        "## Affected Code",
+        "(to be filled during review)",
+        "",
+        "## Architecture Context",
+        "(to be filled during review)",
+        "",
+        "## Constraints & Edge Cases",
+        "- MUST: Review all changed code across the registered repositories",
+        "- RISK: Issues can span repository boundaries",
+      ].join("\n") + "\n";
+      if (prContexts.length > 0) {
+        const prContextBlocks = prContexts
+          .map((pr) => {
+            const lines = [`${pr.repoPath}`];
+            if (pr.prUrl) lines.push(`URL: ${pr.prUrl}`);
+            if (pr.prContext) lines.push(pr.prContext);
+            return lines.join("\n");
+          })
+          .join("\n\n");
+        resContent = appendResearchOpenQuestions(resContent, `PR context:\n${prContextBlocks}`);
       }
 
-      const description = await promptDescription(ctx, "Describe the review (optional)", "review");
-      if (!description) continue;
-      return startReviewTask(orchestrator, ctx, urContent, resContent, description);
+      const modeSelection = await pickModeForTaskStart(orchestrator, ctx, "review");
+      if (!modeSelection) continue;
+      const description = "review-current-branch";
+      return startReviewTask(orchestrator, ctx, urContent, resContent, description, modeSelection.mode, modeSelection.autonomousConfig);
+    }
+
+    if (choice === "Last commit") {
+      const repos = getRegisteredRepos(orchestrator);
+      const urContent = [
+        "# User Request",
+        "Review last commit changes across registered repositories",
+        "",
+        "## Problem",
+        "Review and identify issues in the most recent commit.",
+        "",
+        "## Constraints",
+        "Focus on correctness, edge cases, style, missing tests, potential bugs.",
+        "",
+      ].join("\n");
+      const modeSelection = await pickModeForTaskStart(orchestrator, ctx, "review");
+      if (!modeSelection) continue;
+      return startReviewTask(orchestrator, ctx, urContent, null, "review-last-commit", modeSelection.mode, modeSelection.autonomousConfig);
+    }
+
+    if (choice === "Since commit") {
+      const repos = getRegisteredRepos(orchestrator);
+      const repoOptions: OptionInput[] = repos.map((repo) => ({
+        title: formatRepoLabel(repo),
+        description: "Choose repository for commit range",
+      }));
+      repoOptions.push({ title: "Back", description: "Return to the previous menu" });
+      const repoChoice = await selectOption(ctx, "Select repository", repoOptions);
+      if (!repoChoice || repoChoice === "Back") continue;
+      const selectedRepo = repos.find((repo) => formatRepoLabel(repo) === repoChoice);
+      if (!selectedRepo) continue;
+      const pickedHash = await pickCommitForRepo(orchestrator, ctx, selectedRepo);
+      if (!pickedHash) continue;
+
+      const urContent = [
+        "# User Request",
+        `Review changes in ${selectedRepo.path} since commit ${pickedHash}`,
+        "",
+        "## Problem",
+        `Review and identify issues in all changes in ${selectedRepo.path} since ${pickedHash}.`,
+        "",
+        "## Constraints",
+        "Focus on correctness, edge cases, style, missing tests, potential bugs.",
+        "",
+      ].join("\n");
+      const modeSelection = await pickModeForTaskStart(orchestrator, ctx, "review");
+      if (!modeSelection) continue;
+      return startReviewTask(orchestrator, ctx, urContent, null, "review-since-commit", modeSelection.mode, modeSelection.autonomousConfig);
     }
 
     if (choice === "Uncommitted changes") {
-      const urContent = "# User Request\nReview uncommitted changes\n\n## Problem\nReview and identify issues in uncommitted working directory changes.\n\n## Constraints\nFocus on correctness, edge cases, style, missing tests, potential bugs.\n";
-      const description = await promptDescription(ctx, "Describe the review (optional)", "review");
-      if (!description) continue;
-      return startReviewTask(orchestrator, ctx, urContent, null, description);
+      const repos = getRegisteredRepos(orchestrator);
+      const urContent = [
+        "# User Request",
+        "Review uncommitted changes across registered repositories",
+        "",
+        "## Problem",
+        "Review and identify issues in uncommitted working directory changes.",
+        "",
+        "## Constraints",
+        "Focus on correctness, edge cases, style, missing tests, potential bugs.",
+        "",
+      ].join("\n");
+      const modeSelection = await pickModeForTaskStart(orchestrator, ctx, "review");
+      if (!modeSelection) continue;
+      return startReviewTask(orchestrator, ctx, urContent, null, "review-uncommitted", modeSelection.mode, modeSelection.autonomousConfig);
     }
 
     const input = await ctx.ui.input("Describe what to review");
     if (input === undefined || input === null) continue;
     const trimmed = String(input).trim();
-    if (!trimmed) continue;
+    const description = trimmed || "review";
 
-    const urContent = `# User Request\n${trimmed}\n\n## Problem\n${trimmed}\n\n## Constraints\nFocus on correctness, edge cases, style, missing tests, potential bugs.\n`;
-    return startReviewTask(orchestrator, ctx, urContent, null, trimmed);
+    const urContent = `# User Request\n${description}\n\n## Problem\n${description}\n\n## Constraints\nFocus on correctness, edge cases, style, missing tests, potential bugs.\n`;
+    const modeSelection = await pickModeForTaskStart(orchestrator, ctx, "review");
+    if (!modeSelection) continue;
+    return startReviewTask(orchestrator, ctx, urContent, null, description, modeSelection.mode, modeSelection.autonomousConfig);
   }
 }
 
@@ -1012,7 +3258,6 @@ async function showTaskTypeMenu(
   orchestrator: Orchestrator,
   ctx: any,
   type: TaskType,
-  inputPrompt: string,
 ): Promise<typeof BACK | "started"> {
   while (true) {
     const choice = await selectOption(ctx, type.charAt(0).toUpperCase() + type.slice(1), [
@@ -1023,9 +3268,19 @@ async function showTaskTypeMenu(
     if (!choice || choice === "Back") return BACK;
 
     if (choice === "New") {
-      const description = await promptDescription(ctx, inputPrompt, type);
-      if (!description) continue;
-      await orchestrator.startTask(ctx, type, description);
+      let mode: TaskMode | undefined;
+      let autonomousConfig: AutonomousConfig | undefined;
+      if (type === "debug") {
+        const modeSelection = await pickModeForTaskStart(orchestrator, ctx, type);
+        if (!modeSelection) continue;
+        mode = modeSelection.mode;
+        autonomousConfig = modeSelection.autonomousConfig;
+      }
+      await orchestrator.startTask(ctx, type, type, undefined, undefined, mode);
+      if (orchestrator.active) {
+        orchestrator.active.state.autonomousConfig = autonomousConfig;
+        saveTask(orchestrator.active.dir, orchestrator.active.state);
+      }
       return "started";
     }
 
@@ -1037,23 +3292,24 @@ async function showTaskTypeMenu(
 async function showTaskMenu(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK | "started"> {
   while (true) {
     const choice = await selectOption(ctx, "Task", [
-      { title: "Debug", description: "Diagnose an issue. Then (optionally) fix it" },
-      { title: "Brainstorm", description: "Explore and brainstorm. Then (optionally) plan and implement" },
-      { title: "Implement", description: "Brainstorm, plan and implement" },
-      { title: "Review", description: "Review code changes, diffs, or pull requests" },
+      { title: "Implement", description: "Want to make some changes? Research any topic or a codebase, brainstorm solutions and implement the chosen one" },
+      { title: "Debug", description: "Something is broken? Investigate it. If there is an issue — brainstorm solutions and fix it" },
+      { title: "Brainstorm", description: "No idea where to start? Research any topic or a codebase. If there is a problem to solve — brainstorm solutions and solve it" },
+      { title: "Review", description: "Want to ensure that some commits or a GitHub PR are good to go? Review it. Even fix it yourself, if you want" },
+      { title: "Quick", description: "Quick freeform task — no phases, no reviews, just work" },
       { title: "Resume", description: "Resume a previously unfinished task" },
       { title: "Back", description: "Return to the previous menu" },
     ]);
     if (!choice || choice === "Back") return BACK;
 
     if (choice === "Debug") {
-      const result = await showTaskTypeMenu(orchestrator, ctx, "debug", "Describe the task");
+      const result = await showTaskTypeMenu(orchestrator, ctx, "debug");
       if (result === "started") return "started";
       continue;
     }
 
     if (choice === "Brainstorm") {
-      const result = await showTaskTypeMenu(orchestrator, ctx, "brainstorm", "Describe the task");
+      const result = await showTaskTypeMenu(orchestrator, ctx, "brainstorm");
       if (result === "started") return "started";
       continue;
     }
@@ -1070,6 +3326,11 @@ async function showTaskMenu(orchestrator: Orchestrator, ctx: any): Promise<typeo
       continue;
     }
 
+    if (choice === "Quick") {
+      await orchestrator.startTask(ctx, "quick", "quick");
+      return "started";
+    }
+
     if (choice === "Resume") {
       const result = await showResumeMenu(orchestrator, ctx, undefined, "No paused tasks found.");
       if (result === "started") return "started";
@@ -1082,7 +3343,7 @@ async function showNoActiveMenu(orchestrator: Orchestrator, ctx: any): Promise<s
   while (true) {
     const choice = await selectOption(ctx, "/pp", [
       { title: "Task", description: "Start a new task or resume a paused one" },
-      { title: "Info", description: "Subagents, LSP, usage, and task status" },
+      { title: "Info", description: "Subagents, usage, and task status" },
       { title: "Settings", description: "Flant AI and other configuration" },
       { title: "Back", description: "Close this menu" },
     ]);
@@ -1103,25 +3364,20 @@ async function showNoActiveMenu(orchestrator: Orchestrator, ctx: any): Promise<s
   }
 }
 
-function getReviewLabels(orchestrator: Orchestrator): { autoLabel: string; deepLabel: string } {
-  const byKind = orchestrator.active?.state.reviewPassByKind ?? {};
-  const autoCount = byKind["auto"] ?? 0;
-  const deepCount = byKind["auto-deep"] ?? 0;
+function getReviewLabels(orchestrator: Orchestrator): { autoLabel: string } {
+  const phase = orchestrator.active?.state.phase;
+  const byPhase = (phase && orchestrator.active?.state.reviewPassByKind?.[phase]) ?? {};
+  const autoCount = byPhase["auto"] ?? 0;
   const autoLabel = autoCount > 0 ? `Auto review (pass ${autoCount + 1})` : "Auto review";
-  const deepLabel = deepCount > 0 ? `Auto deep review (pass ${deepCount + 1})` : "Auto deep review";
-  return { autoLabel, deepLabel };
+  return { autoLabel };
 }
 
-function hasEnabledReviewers(orchestrator: Orchestrator, kind: "auto" | "auto-deep"): boolean {
+function hasEnabledReviewers(orchestrator: Orchestrator, presetName?: string): boolean {
   if (!orchestrator.active) return false;
   const phase = orchestrator.active.state.phase;
-  const config = kind === "auto-deep" ? deepReviewConfig(orchestrator.config) : orchestrator.config;
-  const reviewers = phase === "brainstorm"
-    ? config.brainstormReviewers
-    : phase === "plan"
-    ? config.planReviewers
-    : config.codeReviewers;
-  return Object.values(reviewers).some((v) => v.enabled);
+  const group = getReviewPresetGroup(phase);
+  const reviewers = resolvePreset(orchestrator.config, group, presetName);
+  return Object.values(reviewers).some((v) => isEnabled(v));
 }
 
 function handleReviewResult(ctx: any, text: string): { continueLoop: boolean; text?: string } {
@@ -1132,6 +3388,47 @@ function handleReviewResult(ctx: any, text: string): { continueLoop: boolean; te
   return { continueLoop: false, text };
 }
 
+async function showQuickTaskMenu(
+  orchestrator: Orchestrator,
+  ctx: any,
+  summary: string,
+  mode: MenuMode,
+): Promise<string> {
+  while (true) {
+    if (!orchestrator.active) return "No active task.";
+    const task = orchestrator.active;
+    const headerLines = [`/pp\n\nTask: ${task.type}\nPhase: ${task.state.phase}`];
+    if (summary !== "/pp") headerLines.push(`\n\n${summary}`);
+    const menuTitle = headerLines.join("");
+
+    const { choice, cancelReason } = await selectOptionCancelable(ctx, menuTitle, [
+      opt("Complete", "Mark task as done and clean up"),
+      opt("Pause", "Suspend task to resume later"),
+      opt("Info", "Subagents, usage, and task status"),
+      opt("Settings", "Flant AI and other configuration"),
+      opt("Back", "Return to the prompt and keep working"),
+    ]);
+    // A deliberate ESC in tool mode must stop the turn cleanly (mirror the
+    // guided/autonomous branches); in command mode ESC just closes the menu.
+    if (cancelReason === "user" && mode === "tool") return USER_CANCELLED;
+    if (!choice || choice === "Back") return "";
+    if (choice === "Info") {
+      await showInfoMenu(orchestrator, ctx);
+      continue;
+    }
+    if (choice === "Settings") {
+      await showSettingsMenu(orchestrator, ctx);
+      continue;
+    }
+    if (choice === "Pause") {
+      const text = await pauseTask(orchestrator, ctx);
+      return mode === "tool" ? text : "";
+    }
+    const text = await finishTask(orchestrator, ctx);
+    return mode === "tool" ? text : "";
+  }
+}
+
 export async function showActiveTaskMenu(
   orchestrator: Orchestrator,
   ctx: any,
@@ -1144,29 +3441,66 @@ export async function showActiveTaskMenu(
     if (!orchestrator.active) return "No active task.";
 
     const task = orchestrator.active;
+    if (task.type === "quick") {
+      return showQuickTaskMenu(orchestrator, ctx, summary, mode);
+    }
     const phase = task.state.phase;
     const step = task.state.step;
+    const effectiveMode = getEffectivePhaseMode(task.state);
 
-    const waiting = step === "await_planners" || step === "await_reviewers";
-    const { autoLabel, deepLabel } = getReviewLabels(orchestrator);
+    // Suppress phase-advancing/review actions while a transition is in flight
+    // (controller pending/compacting/resuming) OR while awaiting subagents. The
+    // controller's isRunning() predicate already folds in the await_* steps.
+    const waiting = !orchestrator.transitionController.isRunning();
+    const { autoLabel } = getReviewLabels(orchestrator);
     const isReviewPhase = phase === "review";
     const hasPlannotator = phase === "plan" || phase === "implement" || isReviewPhase;
 
     const opt = (title: string, description: string): OptionInput => ({ title, description });
 
+    if (effectiveMode === "autonomous") {
+      const { choice: autoChoice, cancelReason } = await selectOptionCancelable(ctx, `/pp\n\nTask: ${task.type}\nPhase: ${phase}${summary !== "/pp" ? `\n\n${summary}` : ""}`, [
+        opt("Complete task", "Mark task as done and clean up"),
+        opt("Pause task", "Suspend task to resume later"),
+        opt("Info", "Subagents, usage, and task status"),
+        opt("Settings", "Flant AI and other configuration"),
+        opt("Back", "Return to the prompt and keep working"),
+      ]);
+      // A deliberate ESC only needs distinct handling in tool mode (so
+      // pp_phase_complete can stop the turn); in command mode ESC just closes
+      // the menu like "Back".
+      if (cancelReason === "user" && mode === "tool") return USER_CANCELLED;
+      if (!autoChoice || autoChoice === "Back") return "";
+      if (autoChoice === "Info") {
+        await showInfoMenu(orchestrator, ctx);
+        continue;
+      }
+      if (autoChoice === "Settings") {
+        await showSettingsMenu(orchestrator, ctx);
+        continue;
+      }
+      if (autoChoice === "Complete task") {
+        const text = await finishTask(orchestrator, ctx);
+        return mode === "tool" ? text : "";
+      }
+      const text = await pauseTask(orchestrator, ctx);
+      return mode === "tool" ? text : "";
+    }
+
     const options: OptionInput[] = [];
     options.push(opt("Next", "Complete, pause, or continue to next phase"));
     if (!waiting) {
       options.push(opt("Review", "Auto review, Plannotator, or manual review"));
     }
-    options.push(opt("Info", "Subagents, LSP, usage, and task status"));
+    options.push(opt("Info", "Subagents, usage, and task status"));
     options.push(opt("Settings", "Flant AI and other configuration"));
     options.push(opt("Back", "Return to the prompt and keep working"));
 
     const headerLines = [`/pp\n\nTask: ${task.type}\nPhase: ${phase}`];
-    if (summary !== "/pp") headerLines.push(`\n${summary}`);
+    if (summary !== "/pp") headerLines.push(`\n\n${summary}`);
     const menuTitle = headerLines.join("");
-    const choice = await selectOption(ctx, menuTitle, options);
+    const { choice, cancelReason } = await selectOptionCancelable(ctx, menuTitle, options);
+    if (cancelReason === "user" && mode === "tool") return USER_CANCELLED;
     if (!choice || choice === "Back") {
       return "";
     }
@@ -1179,7 +3513,6 @@ export async function showActiveTaskMenu(
       await showSettingsMenu(orchestrator, ctx);
       continue;
     }
-
     if (mode === "command") {
       await abortCurrentWork(orchestrator, ctx);
     }
@@ -1205,19 +3538,39 @@ export async function showActiveTaskMenu(
         const text = await finishTask(orchestrator, ctx);
         return mode === "tool" ? text : "";
       }
+      const next = nextPhase(task.type, phase);
+
+      if (
+        next === "plan" &&
+        task.type === "brainstorm"
+      ) {
+        const modeSelection = await pickModeForTaskStart(orchestrator, ctx, "implement");
+        if (!modeSelection) continue;
+        task.state.mode = modeSelection.mode;
+        task.state.effectiveMode = undefined;
+        task.state.autonomousConfig = modeSelection.autonomousConfig;
+        saveTask(task.dir, task.state);
+      }
+
+      let plannerPreset: string | undefined;
+      if (next === "plan") {
+        if (getEffectiveMode(task.state) !== "autonomous") {
+          const pickedPlannerPreset = await pickPreset(ctx, orchestrator, "planners", "Planner preset");
+          if (!pickedPlannerPreset) continue;
+          plannerPreset = pickedPlannerPreset;
+        }
+      }
       finalizeReviewCycle(task);
-      const result = await orchestrator.transitionToNextPhase(ctx);
+      const result = await orchestrator.transitionToNextPhase(ctx, plannerPreset);
       if (!result.ok) return `Transition blocked: ${result.error}`;
-      if (orchestrator.phaseCompactionPending || orchestrator.taskDoneCompactionPending) return "";
-      const curStep = orchestrator.active?.state.step;
-      if (curStep === "await_planners" || curStep === "await_reviewers") return "";
+      // Transition is now owned by the controller (state ≠ running) or we're
+      // awaiting subagents; either way the menu returns empty.
       return "";
     }
 
     if (choice === "Review") {
       const reviewOptions: OptionInput[] = [
         opt(autoLabel, "Run automated review with configured reviewers"),
-        opt(deepLabel, "Run automated review with higher thinking level"),
       ];
       if (hasPlannotator) {
         reviewOptions.push(opt("Review in Plannotator", phase === "plan" ? "Open plan review in browser" : "Open code diff review in browser"));
@@ -1238,56 +3591,70 @@ export async function showActiveTaskMenu(
           if (handled.continueLoop) continue;
           return handled.text ?? text;
         }
-        const diffChoice = await selectOption(ctx, "Review in Plannotator", [
-          opt("All branch changes", "Committed changes vs base branch"),
-          opt("Last commit", "Changes in the most recent commit"),
-          opt("Recent commits", "Choose how many recent commits to review"),
-          opt("Uncommitted changes", "Working directory changes"),
-          opt("Back", "Return to the previous menu"),
-        ]);
-        if (!diffChoice || diffChoice === "Back") continue;
-
-        let diffType: string | undefined;
-        let defaultBranch: string | undefined;
-        if (diffChoice === "All branch changes") {
-          diffType = "branch";
-        } else if (diffChoice === "Last commit") {
-          diffType = "last-commit";
-        } else if (diffChoice === "Recent commits") {
-          let commits: Array<{ hash: string; message: string; age: string }> = [];
-          try {
-            const logResult = await orchestrator.pi.exec(
-              "git", ["log", "--oneline", "--format=%h\t%s\t%cr", "-15"],
-              { cwd: orchestrator.cwd, timeout: 5000 },
-            );
-            if (logResult.code === 0 && logResult.stdout.trim()) {
-              commits = logResult.stdout.trim().split("\n").map((line) => {
-                const [hash, message, age] = line.split("\t");
-                return { hash: hash || "", message: message || "", age: age || "" };
-              }).filter((c) => c.hash);
+        const repos = getRegisteredRepos(orchestrator);
+        const summaries: string[] = [];
+        let stopReviewing = false;
+
+        for (const repo of repos) {
+          if (stopReviewing) break;
+
+          while (true) {
+            const diffChoice = await selectOption(ctx, `Review: ${formatRepoLabel(repo)}`, [
+              opt("All branch changes", "Committed changes vs base branch"),
+              opt("Last commit", "Changes in the most recent commit"),
+              opt("Since commit", "Review all changes since a specific commit"),
+              opt("Uncommitted changes", "Working directory changes"),
+              opt("Skip this repo", "Move to the next repository"),
+              opt("Done (stop reviewing)", "Stop iterating repositories"),
+            ]);
+
+            if (!diffChoice || diffChoice === "Done (stop reviewing)") {
+              stopReviewing = true;
+              break;
             }
-          } catch {}
-          if (commits.length === 0) {
-            ctx.ui.notify("No commits found.", "info");
-            continue;
+            if (diffChoice === "Skip this repo") {
+              summaries.push(`${formatRepoLabel(repo)}: SKIPPED`);
+              break;
+            }
+
+            let diffType: string | undefined;
+            let defaultBranch: string | undefined;
+
+            if (diffChoice === "All branch changes") {
+              diffType = "branch";
+              defaultBranch = await detectDefaultBranch(orchestrator, repos, repo.path);
+            } else if (diffChoice === "Last commit") {
+              diffType = "last-commit";
+            } else if (diffChoice === "Since commit") {
+              const pickedHash = await pickCommitForRepo(orchestrator, ctx, repo);
+              if (!pickedHash) continue;
+              diffType = "branch";
+              defaultBranch = pickedHash;
+            } else {
+              diffType = "uncommitted";
+            }
+
+            const result = await openCodeReviewInPlannotator(orchestrator, {
+              cwd: repo.path,
+              diffType,
+              defaultBranch,
+            });
+            if (result.status === "error") {
+              summaries.push(`${formatRepoLabel(repo)}: ERROR${result.error ? ` — ${result.error}` : ""}`);
+            } else if (result.status === "approved") {
+              summaries.push(`${formatRepoLabel(repo)}: APPROVED`);
+            } else {
+              summaries.push(`${formatRepoLabel(repo)}: NEEDS_CHANGES${result.feedback ? `\nFeedback: ${result.feedback}` : ""}`);
+            }
+            break;
           }
-          const commitOptions: OptionInput[] = commits.map((c) => ({
-            title: `${c.hash} ${c.message}`,
-            description: c.age,
-          }));
-          commitOptions.push(opt("Back", "Return to the previous menu"));
-          const picked = await selectOption(ctx, "Review changes since:", commitOptions);
-          if (!picked || picked === "Back") continue;
-          const pickedHash = picked.split(" ")[0];
-          if (!pickedHash) continue;
-          diffType = "branch";
-          defaultBranch = pickedHash;
-        } else {
-          diffType = "uncommitted";
         }
 
-        const text = await openCodeReviewInPlannotator(orchestrator, diffType, defaultBranch);
-        ctx.ui.notify(text, "info");
+        if (summaries.length > 0) {
+          ctx.ui.notify(`Plannotator review summary:\n\n${summaries.join("\n\n")}`, "info");
+        } else {
+          ctx.ui.notify("No repositories were reviewed in Plannotator.", "info");
+        }
         continue;
       }
 
@@ -1300,14 +3667,15 @@ export async function showActiveTaskMenu(
         return continueMessage;
       }
 
+      const reviewPreset = await pickPreset(ctx, orchestrator, getReviewPresetGroup(phase), "Review preset");
+      if (!reviewPreset) continue;
       finalizeReviewCycle(task);
-      const kind = reviewChoice === autoLabel ? "auto" as const : "auto-deep" as const;
-      if (!hasEnabledReviewers(orchestrator, kind)) {
+      if (!hasEnabledReviewers(orchestrator, reviewPreset)) {
         const label = phase === "brainstorm" ? "brainstorm" : phase === "plan" ? "plan" : "code";
         ctx.ui.notify(`No ${label} reviewers enabled.`, "info");
         continue;
       }
-      const text = await enterReviewCycle(orchestrator, ctx, kind);
+      const text = await enterReviewCycle(orchestrator, ctx, reviewPreset);
       const curStep = orchestrator.active?.state.step;
       if (curStep === "await_reviewers") return "";
       const handled = handleReviewResult(ctx, text);