@ilya-lesikov/pi-pi 0.4.0 → 0.6.0

package/extensions/orchestrator/orchestrator.ts

@@ -1,18 +1,20 @@
 import { existsSync, copyFileSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync } from "fs";
 import { join, basename, relative } from "path";
 import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { loadConfig, type PiPiConfig, type VariantConfig } from "./config.js";
+import { loadConfig, resolvePreset, type NormalizedPiPiConfig } from "./config.js";
 import {
   createTask,
   loadTask,
   saveTask,
   lockTask,
+  getEffectivePhaseMode,
   type TaskType,
+  type TaskMode,
   type TaskState,
   type Phase,
 } from "./state.js";
 import { phasePipeline } from "./phases/machine.js";
-import { loadContextFiles, getPhaseArtifacts, getLatestSynthesizedPlan } from "./context.js";
+import { getContextDirs, loadAllContextFiles, getPhaseArtifacts, getLatestSynthesizedPlan } from "./context.js";
 import { brainstormSystemPrompt } from "./phases/brainstorm.js";
 import { planningSystemPrompt, spawnPlanners } from "./phases/planning.js";
 import { implementationSystemPrompt } from "./phases/implementation.js";
@@ -22,6 +24,15 @@ import { registerAgentDefinitions, unregisterAgentDefinitions } from "./agents/r
 import { createExploreAgent } from "./agents/explore.js";
 import { createLibrarianAgent } from "./agents/librarian.js";
 import { createTaskAgent } from "./agents/task.js";
+import { resolveModel, getModelInfo } from "./model-registry.js";
+import { buildRepoContext } from "./agents/repo-context.js";
+import { getLogger, addTaskDestination, removeTaskDestination, setLogLevel } from "./log.js";
+import { handleSpawnResult } from "./spawn-cleanup.js";
+import { TransitionController, type TransitionHost } from "./transition-controller.js";
+
+function isEnabled(value: { enabled?: boolean } | undefined): boolean {
+  return value?.enabled !== false;
+}
 
 const BUNDLED_TOOLS = new Set([
   "Agent", "get_subagent_result", "steer_subagent",
@@ -42,7 +53,7 @@ export interface ActiveTask {
 
 export class Orchestrator {
   active: ActiveTask | null = null;
-  config!: PiPiConfig;
+  config!: NormalizedPiPiConfig;
   cwd = "";
   spawnedAgentIds = new Set<string>();
   agentDescriptions = new Map<string, string>();
@@ -59,22 +70,18 @@ export class Orchestrator {
     step?: string;
   }>();
   staleAgentTimer: ReturnType<typeof setInterval> | null = null;
-  phaseCompactionPending = false;
-  phaseCompactionResolve: (() => void) | null = null;
-  taskDoneCompactionPending = false;
-  taskDoneCompactionSummary = "";
-  nudgeTimestamps: number[] = [];
-  cooldownHits: number[] = [];
+  // Single consecutive-nudge guard (replaces the old multi-tier throttle). Reset
+  // to 0 on any productive turn; once it reaches the cap the nudges halt with one
+  // user notification.
+  consecutiveNudges = 0;
   nudgeHalted = false;
   pendingSubagentSpawns = 0;
   errorRetryCount = 0;
   commitReminderSent = false;
   phaseStartTime = 0;
-  awaitPollTimer: ReturnType<typeof setInterval> | null = null;
   pendingRetryTimer: ReturnType<typeof setTimeout> | null = null;
   activeTaskToken = 0;
   userGatePending = false;
-  reviewTransitionToken = -1;
   lastCtx: any = null;
   failedPlannerVariants: string[] = [];
   failedReviewerVariants: string[] = [];
@@ -82,9 +89,65 @@ export class Orchestrator {
   reviewerFailureDialogPending = false;
   plannotatorReject: ((reason: Error) => void) | null = null;
   plannotatorUnsub: (() => void) | null = null;
-  transitionToNextPhase: (ctx: any) => Promise<{ ok: boolean; error?: string }> = async () => ({ ok: false, error: "not initialized" });
+  plannotatorTimer: ReturnType<typeof setTimeout> | null = null;
+  transitionToNextPhase: (ctx: any, plannerPreset?: string) => Promise<{ ok: boolean; error?: string }> = async () => ({ ok: false, error: "not initialized" });
+  // Assigned by registerEventHandlers. Wired into planner spawn onSettled as the
+  // safety net the deleted 5s poller used to provide: when a spawn settles having
+  // produced ZERO agents (zero enabled planners, or all spawns failed before any
+  // subagents:completed/failed event), nothing else would advance await_planners.
+  // For spawned>0 the lifecycle events drive completion, so onSettled passes the
+  // spawned count and this only force-checks the zero case.
+  checkPlannerCompletion: () => void = () => {};
+  readonly transitionController: TransitionController;
+
+  constructor(readonly pi: ExtensionAPI) {
+    // The controller calls pi (the main session) directly for sends, and uses the
+    // host only for live-ctx-dependent bits (compact/isIdle/currentStep).
+    this.transitionController = new TransitionController(this.makeTransitionHost(), this.pi);
+  }
+
+  // Live-session host the TransitionController uses for compaction/idle/step.
+  private makeTransitionHost(): TransitionHost {
+    return {
+      compact: (options) => {
+        const compact = this.lastCtx?.compact;
+        if (!compact) return false;
+        compact(options);
+        return true;
+      },
+      isIdle: () => {
+        const idle = this.lastCtx?.isIdle;
+        return typeof idle === "function" ? !!idle.call(this.lastCtx) : false;
+      },
+      currentStep: () => this.active?.state.step ?? null,
+    };
+  }
 
-  constructor(readonly pi: ExtensionAPI) {}
+  safeSendUserMessage(text: string): void {
+    const log = getLogger();
+    const attempt = (retries: number) => {
+      try {
+        // Route through the controller's single send path. "instruction" maps to
+        // followUp: queues the message and triggers a turn once the current one
+        // settles (or runs immediately when idle), so it never throws "Agent is
+        // already processing" when called mid-tool (e.g. during a transition).
+        this.transitionController.send(text, "instruction");
+        log.debug({ s: "orchestrator", retries, text: text.slice(0, 200) }, "safeSend sent");
+      } catch (err: any) {
+        if (retries < 30) {
+          log.debug({ s: "orchestrator", retries, err: err?.message }, "safeSend retry");
+          setTimeout(() => attempt(retries + 1), 1000);
+        } else {
+          log.error({ s: "orchestrator", retries, err: err?.message ?? String(err), text: text.slice(0, 200) }, "safeSend failed after max retries");
+          this.lastCtx?.ui?.notify?.(
+            "pi-pi could not deliver a message to the agent; the task may be stalled. See logs.",
+            "error",
+          );
+        }
+      }
+    };
+    attempt(0);
+  }
 
   truncateResult(result: string): string {
     const trimmed = result.trim();
@@ -96,34 +159,53 @@ export class Orchestrator {
   }
 
   async switchModel(ctx: ExtensionContext, modelSpec: string, thinking: string): Promise<boolean> {
+    const log = getLogger();
     const registry = ctx.modelRegistry;
     const allModels = registry.getAvailable();
 
-    const slashIdx = modelSpec.indexOf("/");
+    const requestedSpecs = [resolveModel(modelSpec), modelSpec].filter((value, index, arr) => arr.indexOf(value) === index);
+    log.debug({ s: "model", requestedSpecs, thinking, availableCount: allModels.length }, "switchModel");
     let resolved;
-    if (slashIdx !== -1) {
-      const provider = modelSpec.substring(0, slashIdx).trim().toLowerCase();
-      const modelId = modelSpec.substring(slashIdx + 1).trim().toLowerCase();
-      resolved = allModels.find(
-        (m) => m.provider.toLowerCase() === provider && m.id.toLowerCase() === modelId,
-      );
+    for (const spec of requestedSpecs) {
+      const slashIdx = spec.indexOf("/");
+      if (slashIdx !== -1) {
+        const provider = spec.substring(0, slashIdx).trim().toLowerCase();
+        const modelId = spec.substring(slashIdx + 1).trim().toLowerCase();
+        resolved = allModels.find(
+          (m) => m.provider.toLowerCase() === provider && m.id.toLowerCase() === modelId,
+        );
+      }
+      if (!resolved) {
+        const pattern = spec.toLowerCase();
+        const matches = allModels.filter(
+          (m) => m.id.toLowerCase() === pattern || m.id.toLowerCase().includes(pattern),
+        );
+        if (matches.length === 1) resolved = matches[0];
+      }
+      if (resolved) break;
     }
+
     if (!resolved) {
-      const pattern = modelSpec.toLowerCase();
-      const matches = allModels.filter(
-        (m) => m.id.toLowerCase() === pattern || m.id.toLowerCase().includes(pattern),
-      );
-      if (matches.length === 1) resolved = matches[0];
+      log.warn({ s: "model", requestedSpecs }, "model not found");
+      return false;
     }
 
-    if (!resolved) return false;
-
     const ok = await this.pi.setModel(resolved);
-    if (!ok) return false;
+    if (!ok) {
+      log.warn({ s: "model", resolved: `${resolved.provider}/${resolved.id}` }, "setModel returned false");
+      return false;
+    }
 
-    const VALID_THINKING = new Set(["off", "low", "medium", "high"]);
-    const thinkingLevel = (VALID_THINKING.has(thinking) ? thinking : "high") as "off" | "low" | "medium" | "high";
+    const VALID_THINKING = new Set(["off", "minimal", "low", "medium", "high", "xhigh"]);
+    const thinkingLevel = (VALID_THINKING.has(thinking) ? thinking : "high") as
+      | "off"
+      | "minimal"
+      | "low"
+      | "medium"
+      | "high"
+      | "xhigh";
     this.pi.setThinkingLevel(thinkingLevel);
+    log.debug({ s: "model", model: `${resolved.provider}/${resolved.id}`, thinking: thinkingLevel }, "model switched");
     return true;
   }
 
@@ -137,11 +219,13 @@ export class Orchestrator {
     const phase = this.active.state.phase;
     const step = this.active.state.step;
     const reviewCycle = this.active.state.reviewCycle;
+    const effectiveMode = this.active.state.effectiveMode ?? this.active.state.mode;
+    const modeLabel = effectiveMode === "autonomous" ? " [autonomous]" : "";
 
-    if (type === "debug" || type === "brainstorm") {
+    if (type === "debug" || type === "brainstorm" || type === "quick") {
       const elapsed = this.phaseStartTime > 0 ? this.formatElapsed(this.phaseStartTime) : "";
       const suffix = elapsed ? ` (${elapsed})` : "";
-      ctx.ui.setStatus("pp-phase", `pp: ${type}${suffix}`);
+      ctx.ui.setStatus("pp-phase", `pp: ${type}${modeLabel}${suffix}`);
       return;
     }
 
@@ -162,7 +246,7 @@ export class Orchestrator {
         else if (step === "user_gate") detail = "review";
 
         if (reviewCycle) {
-          const kind = reviewCycle.kind === "plannotator" ? "plannotator" : reviewCycle.kind === "auto-deep" ? "deep review" : "review";
+          const kind = reviewCycle.kind === "plannotator" ? "plannotator" : "review";
           detail = `${kind} #${reviewCycle.pass}`;
         }
 
@@ -174,7 +258,7 @@ export class Orchestrator {
       }
     }
 
-    ctx.ui.setStatus("pp-phase", `pp: ${parts.join(" → ")}`);
+    ctx.ui.setStatus("pp-phase", `pp: ${parts.join(" → ")}${modeLabel}`);
   }
 
   private formatElapsed(startTime: number): string {
@@ -188,14 +272,22 @@ export class Orchestrator {
     return remMin > 0 ? `${hr}h ${remMin}m` : `${hr}h`;
   }
 
-  getPlanStartState(taskDir: string): { step: string; shouldSpawnPlanners: boolean } {
+  getPlanStartState(taskDir: string, plannerPresetName?: string): { step: string; shouldSpawnPlanners: boolean } {
     const plansDir = join(taskDir, "plans");
-    const enabledPlannerCount = Object.values(this.config.planners).filter((v) => v.enabled).length;
+    const presetName = plannerPresetName ?? this.config.agents.subagents.presetGroups.planners.default;
+    const plannerVariants = resolvePreset(this.config, "planners", presetName);
+    const enabledPlannerVariants = Object.entries(plannerVariants)
+      .filter(([, v]) => isEnabled(v))
+      .map(([name]) => name);
     const plannerOutputs = existsSync(plansDir)
       ? readdirSync(plansDir).filter((f) => f.endsWith(".md") && !f.includes("synthesized") && !f.includes("review_"))
       : [];
+    const completedVariants = new Set(
+      plannerOutputs.map((f) => f.replace(/^\d+_/, "").replace(/\.md$/, "")),
+    );
+    const hasAllEnabledVariants = enabledPlannerVariants.every((name) => completedVariants.has(name));
 
-    if (enabledPlannerCount === 0 || plannerOutputs.length >= enabledPlannerCount || getLatestSynthesizedPlan(taskDir)) {
+    if (enabledPlannerVariants.length === 0 || hasAllEnabledVariants || getLatestSynthesizedPlan(taskDir)) {
       return { step: "synthesize", shouldSpawnPlanners: false };
     }
 
@@ -205,23 +297,26 @@ export class Orchestrator {
   getPhasePrompt(_ctx: ExtensionContext): string {
     if (!this.active) return "";
 
+    const mode: TaskMode = getEffectivePhaseMode(this.active.state);
+
     if (this.active.state.reviewCycle?.step === "apply_feedback") {
       const pass = this.active.state.reviewCycle.pass;
-      const manualReview = this.active.state.reviewCycle.kind === "manual";
-      return reviewCycleSystemPrompt(this.active.dir, pass, manualReview, this.active.state.phase);
+      return reviewCycleSystemPrompt(this.active.dir, pass, this.active.state.phase);
     }
 
     switch (this.active.state.phase) {
       case "brainstorm":
-        return brainstormSystemPrompt(this.active.type, this.active.description, this.active.dir);
+        return brainstormSystemPrompt(this.active.type, this.active.description, this.active.dir, this.cwd);
       case "debug":
-        return brainstormSystemPrompt(this.active.type, this.active.description, this.active.dir);
+        return brainstormSystemPrompt(this.active.type, this.active.description, this.active.dir, this.cwd);
       case "plan":
-        return planningSystemPrompt(this.active.dir);
+        return planningSystemPrompt(this.active.dir, mode);
       case "implement":
-        return implementationSystemPrompt(this.active.dir);
+        return implementationSystemPrompt(this.active.dir, this.cwd);
       case "review":
-        return reviewTaskSystemPrompt(this.active.dir);
+        return reviewTaskSystemPrompt(this.active.dir, this.cwd);
+      case "quick":
+        return "Work on the user's request directly. There are no phases, planning, or reviews.";
       default:
         return "";
     }
@@ -244,19 +339,31 @@ export class Orchestrator {
     description: string,
     fromTaskDir?: string,
     skipBrainstorm?: boolean,
+    mode?: TaskMode,
   ): Promise<void> {
+    const log = getLogger();
+    log.info({ s: "task", type, description, fromTaskDir: fromTaskDir ?? null, skipBrainstorm: skipBrainstorm ?? false, mode: mode ?? null }, "startTask");
+    const hadActive = !!this.active;
     if (this.active) {
       ctx.ui.notify(
-        `Finishing previous task "${this.active.description}" (phase: ${this.active.state.phase})…`,
+        `Pausing previous task "${this.active.description}" (phase: ${this.active.state.phase})…`,
         "info",
       );
       this.abortAllSubagents();
-      this.active.state.phase = "done";
       saveTask(this.active.dir, this.active.state);
       unregisterAgentDefinitions(this.pi);
       await this.cleanupActive();
     }
 
+    if (hadActive) {
+      // Route new-task compaction through the controller as a "done" target.
+      this.lastCtx = ctx;
+      await this.transitionController.requestTransition({
+        kind: "done",
+        summary: `Starting new ${type} task. Previous conversation discarded.`,
+      });
+    }
+
     try {
       this.config = loadConfig(this.cwd);
     } catch (err: any) {
@@ -264,16 +371,28 @@ export class Orchestrator {
       return;
     }
 
+    setLogLevel(this.config.general.logLevel);
     ensureGitignore(this.cwd);
 
-    const dir = createTask(this.cwd, type, description);
+    const dir = createTask(this.cwd, type, description, mode);
     const state = loadTask(dir);
 
     if (fromTaskDir) {
       const srcUr = join(fromTaskDir, "USER_REQUEST.md");
       const srcRes = join(fromTaskDir, "RESEARCH.md");
       const srcArtifacts = join(fromTaskDir, "artifacts");
-      if (existsSync(srcUr)) copyFileSync(srcUr, join(dir, "USER_REQUEST.md"));
+      if (existsSync(srcUr)) {
+        const originalUr = readFileSync(srcUr, "utf-8");
+        const implNote =
+          "# IMPLEMENTATION TASK\n\n" +
+          "This is now an **implement** task — the previous brainstorm/debug/review task is over.\n" +
+          "The user request, research, and artifacts below are carried over as context for implementation.\n" +
+          "Your job is to plan and implement actual code changes based on this research.\n" +
+          "Any prior instructions in the text below saying \"brainstorm only\", \"review only\",\n" +
+          "\"do not implement\", \"no code changes\", or similar DO NOT APPLY — they were for the previous task.\n\n" +
+          "---\n\n";
+        writeFileSync(join(dir, "USER_REQUEST.md"), implNote + originalUr, "utf-8");
+      }
       if (existsSync(srcRes)) copyFileSync(srcRes, join(dir, "RESEARCH.md"));
       if (existsSync(srcArtifacts)) {
         const destArtifacts = join(dir, "artifacts");
@@ -285,19 +404,21 @@ export class Orchestrator {
       state.from = relative(join(this.cwd, ".pp", "state"), fromTaskDir);
       if (skipBrainstorm && type === "implement") {
         state.phase = "plan";
-        state.step = this.getPlanStartState(dir).step;
+        state.initialPhase = "plan";
+        state.activePlannerPreset = this.config.agents.subagents.presetGroups.planners.default;
+        state.step = this.getPlanStartState(dir, state.activePlannerPreset).step;
       }
       saveTask(dir, state);
     }
 
     let release: (() => Promise<void>) | null = null;
     try {
-      release = await lockTask(dir, this.config.timeouts);
+      release = await lockTask(dir, this.config.performance.internals);
     } catch (err: any) {
       try {
         rmSync(dir, { recursive: true, force: true });
       } catch {
-        console.error(`[pi-pi] Failed to clean up orphaned task dir: ${dir}`);
+        log.warn({ s: "task", dir }, "failed to clean up orphaned task dir");
       }
       ctx.ui.notify(`Failed to lock task: ${err.message}`, "error");
       return;
@@ -317,7 +438,10 @@ export class Orchestrator {
       description: state.description,
     };
 
-    const modelConfig = this.config.mainModel[
+    addTaskDestination(dir);
+    log.info({ s: "task", dir, taskId: this.active.taskId, phase: state.phase, step: state.step }, "task activated");
+
+    const modelConfig = this.config.agents.orchestrators[
       type === "debug" ? "debug"
       : type === "brainstorm" ? "brainstorm"
       : type === "review" ? "review"
@@ -337,30 +461,52 @@ export class Orchestrator {
 
     this.phaseStartTime = Date.now();
     const isGenericDescription = ["implement", "debug", "brainstorm", "review"].includes(this.active.description);
+    const isGenericQuickDescription = this.active.description === "quick";
     const hasInheritedTaskContext = Boolean(fromTaskDir && type === "implement");
     const isWaitingForPlanners = this.active.state.phase === "plan" && this.active.state.step === "await_planners";
-    if (isGenericDescription && !hasInheritedTaskContext) {
+    if ((isGenericDescription || isGenericQuickDescription) && !hasInheritedTaskContext) {
       ctx.ui.notify("Task created. Describe what you'd like to do.", "info");
     } else if (isWaitingForPlanners) {
       ctx.ui.notify("Entered plan phase. Waiting for planners to complete before synthesis.", "info");
     } else {
-      this.pi.sendUserMessage(`[PI-PI] Entered ${this.active.state.phase} phase. Begin working.`, { deliverAs: "followUp" });
+      const desc = this.active.description;
+      const descSuffix = !isGenericDescription ? `\n\nTask: ${desc}` : "";
+      this.safeSendUserMessage(`[PI-PI] Entered ${this.active.state.phase} phase. Begin working.${descSuffix}`);
     }
 
     if (this.active.state.phase === "plan" && this.active.state.step === "await_planners") {
-      this.pendingSubagentSpawns = Object.values(this.config.planners).filter((v) => v.enabled).length;
+      const requestedPlannerPresetName = this.active.state.activePlannerPreset ?? this.config.agents.subagents.presetGroups.planners.default;
+      const plannerPresetExists = Object.prototype.hasOwnProperty.call(this.config.agents.subagents.presetGroups.planners.presets ?? {}, requestedPlannerPresetName);
+      const plannerPresetName = plannerPresetExists
+        ? requestedPlannerPresetName
+        : (Object.keys(this.config.agents.subagents.presetGroups.planners.presets ?? {})[0] ?? requestedPlannerPresetName);
+      if (this.active.state.activePlannerPreset !== plannerPresetName) {
+        this.active.state.activePlannerPreset = plannerPresetName;
+        saveTask(this.active.dir, this.active.state);
+      }
+      if (!plannerPresetExists && plannerPresetName !== requestedPlannerPresetName) {
+        ctx.ui.notify(
+          `Planner preset "${requestedPlannerPresetName}" not found. Falling back to "${plannerPresetName}".`,
+          "warning",
+        );
+      }
+      const plannerVariants = resolvePreset(this.config, "planners", plannerPresetName);
+      this.pendingSubagentSpawns = Object.values(plannerVariants).filter((v) => isEnabled(v)).length;
       this.failedPlannerVariants = [];
-      spawnPlanners(this.pi, this.cwd, this.active.dir, this.active.taskId, this.config).then((result) => {
-        this.failedPlannerVariants = result.failedVariants;
-        if (result.spawned === 0) this.pendingSubagentSpawns = 0;
-        for (const id of result.agentIds ?? []) {
-          this.spawnedAgentIds.delete(id);
-        }
-        this.pendingSubagentSpawns = 0;
-      }).catch((err) => {
-        this.pendingSubagentSpawns = 0;
-        console.error(`[pi-pi] spawnPlanners failed: ${err.message}`);
-      });
+      handleSpawnResult(
+        this,
+        spawnPlanners(
+          this.pi,
+          this.cwd,
+          this.active.dir,
+          this.active.taskId,
+          this.config,
+          this.transitionController.phaseSend,
+          plannerVariants,
+          this.active?.state.repos ?? [],
+        ),
+        { kind: "planner", logScope: "planner", logMessage: "spawnPlanners failed", onSettled: (result) => { if (!result?.spawned) this.checkPlannerCompletion(); } },
+      );
     }
   }
 
@@ -383,22 +529,14 @@ export class Orchestrator {
     this.pendingSubagentSpawns = 0;
     this.errorRetryCount = 0;
     this.commitReminderSent = false;
-    this.nudgeTimestamps = [];
-    this.cooldownHits = [];
+    this.consecutiveNudges = 0;
     this.nudgeHalted = false;
-    this.phaseCompactionPending = false;
-    this.phaseCompactionResolve = null;
     this.phaseStartTime = 0;
     this.userGatePending = false;
-    this.reviewTransitionToken = -1;
     this.failedPlannerVariants = [];
     this.failedReviewerVariants = [];
     this.plannerFailureDialogPending = false;
     this.reviewerFailureDialogPending = false;
-    if (this.awaitPollTimer) {
-      clearInterval(this.awaitPollTimer);
-      this.awaitPollTimer = null;
-    }
     if (this.pendingRetryTimer) {
       clearTimeout(this.pendingRetryTimer);
       this.pendingRetryTimer = null;
@@ -411,101 +549,127 @@ export class Orchestrator {
 
   async cleanupActive(): Promise<void> {
     if (!this.active) return;
+    const dir = this.active.dir;
+    getLogger().info({ s: "task", dir }, "cleaning up active task");
+    removeTaskDestination();
     this.resetTaskScopedState();
     if (this.active.release) {
       try {
         await this.active.release();
       } catch (err: any) {
-        console.error(`[pi-pi] Failed to release lock for ${this.active.dir}: ${err.message}`);
+        getLogger().error({ s: "task", dir, err: err.message }, "failed to release lock");
       }
     }
     this.active = null;
   }
 
   registerAgents(): void {
+    const log = getLogger();
     const explore = createExploreAgent(this.config);
     const librarian = createLibrarianAgent(this.config);
     const taskAgent = createTaskAgent(this.config, "{{subtask}}", { userRequest: "", synthesizedPlan: "" });
-
-    const appendContext = (agentType: string, prompt: string): string => {
-      const contextFiles = loadContextFiles(this.cwd, agentType as any, "system");
-      if (contextFiles.length === 0) return prompt;
+    const phase = this.active?.state.phase;
+    const repos = this.active?.state.repos ?? [];
+    log.debug({ s: "agents", phase, repoCount: repos.length }, "registering agent definitions");
+    const contextDirs = getContextDirs(this.cwd, repos, this.config.general.loadExtraRepoConfigs);
+    const repoContext = buildRepoContext(repos);
+
+    const appendContext = (agentType: string, prompt: string, modelInfo: { vendor: string; family: string; tier: string }): string => {
+      const contextFiles = loadAllContextFiles(contextDirs, agentType as any, "system", phase, modelInfo);
+      if (contextFiles.length === 0 && !repoContext) return prompt;
+      const parts = [prompt];
+      if (repoContext) parts.push(repoContext.trimEnd());
+      if (contextFiles.length === 0) return parts.join("\n\n");
       const contextBlock = contextFiles.map((f) => f.content).join("\n\n");
-      return prompt + "\n\n# Project Context\n\n" + contextBlock;
+      parts.push("# Project Context\n\n" + contextBlock);
+      return parts.join("\n\n");
     };
 
     registerAgentDefinitions(this.pi, [
-      { type: "explore", variant: null, ...explore, prompt: appendContext("explore", explore.prompt) },
-      { type: "librarian", variant: null, ...librarian, prompt: appendContext("librarian", librarian.prompt) },
-      { type: "task", variant: null, ...taskAgent, prompt: appendContext("task", taskAgent.prompt) },
+      {
+        type: "explore",
+        variant: null,
+        ...explore,
+        prompt: appendContext("explore", explore.prompt, getModelInfo(resolveModel(this.config.agents.subagents.simple.explore.model))),
+      },
+      {
+        type: "librarian",
+        variant: null,
+        ...librarian,
+        prompt: appendContext("librarian", librarian.prompt, getModelInfo(resolveModel(this.config.agents.subagents.simple.librarian.model))),
+      },
+      {
+        type: "task",
+        variant: null,
+        ...taskAgent,
+        prompt: appendContext("task", taskAgent.prompt, getModelInfo(resolveModel(this.config.agents.subagents.simple.task.model))),
+      },
     ]);
   }
 
   injectContextAndArtifacts(taskDir: string, phase: Phase): void {
-    const contextFiles = loadContextFiles(this.cwd, "main", "context");
+    const log = getLogger();
+    log.debug({ s: "context", taskDir, phase }, "injecting context and artifacts");
+    const modelSpec =
+      phase === "debug" && this.active?.type === "debug"
+        ? this.config.agents.orchestrators.debug.model
+      : phase === "brainstorm" && this.active?.type === "brainstorm"
+        ? this.config.agents.orchestrators.brainstorm.model
+      : phase === "review" && this.active?.type === "review"
+        ? this.config.agents.orchestrators.review.model
+      : phase === "plan"
+        ? this.config.agents.orchestrators.plan.model
+      : this.config.agents.orchestrators.implement.model;
+    const activeModelSpec = this.lastCtx?.model
+      ? `${this.lastCtx.model.provider}/${this.lastCtx.model.id}`
+      : modelSpec;
+    const repos = this.active?.state.repos ?? [];
+    const contextDirs = getContextDirs(this.cwd, repos, this.config.general.loadExtraRepoConfigs);
+    const contextFiles = loadAllContextFiles(
+      contextDirs,
+      "main",
+      "context",
+      phase,
+      getModelInfo(activeModelSpec),
+    );
     for (const cf of contextFiles) {
-      this.pi.sendMessage(
+      this.transitionController.sendCustom(
         { customType: "pp-context", content: cf.content, display: false },
-        { deliverAs: "steer" },
+        "context",
       );
     }
     const artifacts = getPhaseArtifacts(taskDir, phase);
     for (const artifact of artifacts) {
-      this.pi.sendMessage(
+      this.transitionController.sendCustom(
         { customType: "pp-artifact", content: `=== ${artifact.name} ===\n${artifact.content}`, display: false },
-        { deliverAs: "steer" },
+        "context",
       );
     }
   }
 
-  waitForCompaction(): Promise<void> {
-    if (!this.phaseCompactionPending && !this.taskDoneCompactionPending) return Promise.resolve();
-    return new Promise((resolve) => {
-      this.phaseCompactionResolve = resolve;
-    });
-  }
-
-  compactAndTransition(ctx: ExtensionContext, taskDir: string, phase: Phase): void {
-    this.phaseCompactionPending = true;
-    ctx.compact({
-      customInstructions: "Phase transition — discard all prior conversation. Produce a one-line summary: 'Previous phase completed.'",
-      onComplete: () => {
-        this.phaseCompactionPending = false;
-        if (this.phaseCompactionResolve) {
-          this.phaseCompactionResolve();
-          this.phaseCompactionResolve = null;
-        }
-        this.phaseStartTime = Date.now();
-        if (this.active && (phase === "plan" || phase === "implement")) {
-          const modelConfig = this.config.mainModel.implement;
-          this.switchModel(ctx, modelConfig.model, modelConfig.thinking).catch(() => {});
-        }
-        this.injectContextAndArtifacts(taskDir, phase);
-        if (this.active?.state.phase === "plan" && this.active.state.step === "await_planners") {
-          ctx.ui.notify("Entered plan phase. Waiting for planners to complete before synthesis.", "info");
-        } else {
-          this.pi.sendUserMessage(`[PI-PI] Entered ${phase} phase. Begin working.`, { deliverAs: "followUp" });
-        }
-      },
-      onError: (err) => {
-        console.error(`[pi-pi] Phase compaction failed: ${err.message}`);
-        this.phaseCompactionPending = false;
-        if (this.phaseCompactionResolve) {
-          this.phaseCompactionResolve();
-          this.phaseCompactionResolve = null;
-        }
+  compactAndTransition(ctx: ExtensionContext, taskDir: string, phase: Phase, onReady?: () => void, summary?: string): void {
+    getLogger().info({ s: "phase", taskDir, phase }, "compact and transition");
+    // Ensure the controller's host can reach this live ctx for compact/isIdle.
+    this.lastCtx = ctx;
+    // Notify-only case: entering plan and immediately awaiting planners. No
+    // "Begin working" instruction is sent — the agent waits for onSubagentsDone.
+    const notifyOnly = this.active?.state.phase === "plan" && this.active.state.step === "await_planners";
+    void this.transitionController.requestTransition({
+      kind: "phase",
+      summary: summary || "Phase transition — previous phase completed.",
+      onResume: async () => {
         this.phaseStartTime = Date.now();
         if (this.active && (phase === "plan" || phase === "implement")) {
-          const modelConfig = this.config.mainModel.implement;
-          this.switchModel(ctx, modelConfig.model, modelConfig.thinking).catch(() => {});
+          const modelConfig = phase === "plan" ? this.config.agents.orchestrators.plan : this.config.agents.orchestrators.implement;
+          await this.switchModel(ctx, modelConfig.model, modelConfig.thinking);
         }
         this.injectContextAndArtifacts(taskDir, phase);
-        if (this.active?.state.phase === "plan" && this.active.state.step === "await_planners") {
+        onReady?.();
+        if (notifyOnly) {
           ctx.ui.notify("Entered plan phase. Waiting for planners to complete before synthesis.", "info");
-        } else {
-          this.pi.sendUserMessage(`[PI-PI] Entered ${phase} phase. Begin working.`, { deliverAs: "followUp" });
         }
       },
+      instruction: notifyOnly ? undefined : `[PI-PI] Entered ${phase} phase. Begin working.`,
     });
   }
 
@@ -521,23 +685,6 @@ export class Orchestrator {
   }
 }
 
-export function deepReviewConfig(config: PiPiConfig): PiPiConfig {
-  const THINKING_UPGRADE: Record<string, string> = { low: "medium", medium: "high", high: "xhigh" };
-  const upgrade = (reviewers: Record<string, VariantConfig>) => {
-    const upgraded: Record<string, VariantConfig> = {};
-    for (const [name, variant] of Object.entries(reviewers)) {
-      upgraded[name] = { ...variant, thinking: THINKING_UPGRADE[variant.thinking] ?? "high" };
-    }
-    return upgraded;
-  };
-  return {
-    ...config,
-    codeReviewers: upgrade(config.codeReviewers),
-    planReviewers: upgrade(config.planReviewers),
-    brainstormReviewers: upgrade(config.brainstormReviewers),
-  };
-}
-
 export function ensureGitignore(cwd: string): void {
   const ppDir = join(cwd, ".pp");
   if (!existsSync(ppDir)) {
@@ -545,7 +692,7 @@ export function ensureGitignore(cwd: string): void {
   }
 
   const gitignorePath = join(ppDir, ".gitignore");
-  const requiredEntries = ["state/", "config.json"];
+  const requiredEntries = ["state/", "config.json", "logs/"];
 
   if (!existsSync(gitignorePath)) {
     writeFileSync(gitignorePath, requiredEntries.join("\n") + "\n", "utf-8");