@ilya-lesikov/pi-pi 0.6.0 → 0.7.0

package/extensions/orchestrator/integration.test.ts

@@ -63,6 +63,7 @@ vi.mock("./config.js", async (importOriginal) => {
         debug: { model: "test/model", thinking: "high" },
         brainstorm: { model: "test/model", thinking: "high" },
         review: { model: "test/model", thinking: "high" },
+        quick: { model: "test/model", thinking: "high" },
       },
       subagents: {
         simple: {
@@ -215,6 +216,7 @@ function makeConfig() {
         debug: { model: "test/model", thinking: "high" },
         brainstorm: { model: "test/model", thinking: "high" },
         review: { model: "test/model", thinking: "high" },
+        quick: { model: "test/model", thinking: "high" },
       },
       subagents: {
         simple: {
@@ -1565,7 +1567,7 @@ describe("task modes and quick task", () => {
     expect(orchestrator.active!.state.autonomousConfig).toBeDefined();
   });
 
-  it("autonomous pp_phase_complete auto-advances without opening menu", async () => {
+  it("autonomous pp_phase_complete auto-advances (plan→implement) without opening menu", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
     const ctx = makeCtx();
@@ -1581,16 +1583,115 @@ describe("task modes and quick task", () => {
     };
     writeFileSync(join(taskDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
     writeFileSync(join(taskDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    // Move to an autonomous-capable phase (plan). brainstorm is always guided
+    // even for an autonomous task, so auto-advance only applies from plan onward.
+    orchestrator.active!.state.phase = "plan";
+    orchestrator.active!.state.step = "llm_work";
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(
+      join(plansDir, `${Math.floor(Date.now() / 1000)}_synthesized.md`),
+      makeValidPlan([
+        "- [ ] P1. Implement X — Done when: implementation for X is complete",
+      ]),
+      "utf-8",
+    );
 
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
     const result = await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     expect(result.content[0].text).toBe("");
-    expect(orchestrator.active!.state.phase).toBe("plan");
+    expect(orchestrator.active!.state.phase).toBe("implement");
     expect(menu.transcript.filter((entry) => entry.question.startsWith("/pp"))).toHaveLength(0);
   });
 
+  it("autonomous task in brainstorm stays guided (pp_phase_complete opens the menu, does NOT auto-advance)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "implement", undefined, undefined, "autonomous");
+    const taskDir = orchestrator.active!.dir;
+    orchestrator.active!.state.autonomousConfig = {
+      phases: {
+        brainstorm: { reviewPreset: "regular", maxReviewPasses: 0 },
+        plan: { plannerPreset: "regular", reviewPreset: "regular", maxReviewPasses: 0 },
+        implement: { reviewPreset: "regular", maxReviewPasses: 0 },
+      },
+    };
+    writeFileSync(join(taskDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
+    writeFileSync(join(taskDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    expect(orchestrator.active!.state.phase).toBe("brainstorm");
+
+    // brainstorm is user-driven: pp_phase_complete must fall through to the
+    // guided menu rather than the autonomous auto-advance branch. (Autonomous
+    // tasks skip the planner preset picker on transition, so only the guided
+    // Next→Continue step is expected here.)
+    expectActiveTaskNext(menu, "Continue to plan & implement");
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
+    await new Promise((r) => setTimeout(r, 10));
+
+    // The guided menu was shown (auto-advance did NOT bypass it).
+    expect(menu.transcript.filter((entry) => entry.question.startsWith("/pp"))).not.toHaveLength(0);
+  });
+
+  it("ESC on pp_phase_complete stops the turn cleanly (aborts, no reminder text)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "esc dismiss");
+    // Guided task in brainstorm; transition controller is running so the
+    // non-ESC dismiss path would normally return the reminder text.
+    expect(orchestrator.transitionController.isRunning()).toBe(true);
+
+    // Simulate a deliberate user ESC on the top-level menu.
+    menu.expect({ question: m.anyTaskMenu, cancel: "user" });
+
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    const result = await ppPhaseComplete.execute("esc-1", { summary: "done" }, undefined, undefined, ctx);
+
+    expect(ctx.abort).toHaveBeenCalled();
+    expect(result.content[0].text).toBe("");
+  });
+
+  it("Back on pp_phase_complete keeps the artifact-update reminder (does NOT abort)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "back dismiss");
+    expect(orchestrator.transitionController.isRunning()).toBe(true);
+
+    // Explicit "Back" navigation (not an ESC): the reminder must be preserved.
+    menu.expect({ question: m.anyTaskMenu, options: { include: ["Back"] }, choose: "Back" });
+
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    const result = await ppPhaseComplete.execute("back-1", { summary: "done" }, undefined, undefined, ctx);
+
+    expect(ctx.abort).not.toHaveBeenCalled();
+    expect(result.content[0].text).toContain("update USER_REQUEST.md and RESEARCH.md");
+  });
+
+  it("ESC on pp_phase_complete for a quick task also stops the turn cleanly", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "quick", "quick esc");
+    expect(orchestrator.active!.type).toBe("quick");
+
+    menu.expect({ question: m.anyTaskMenu, cancel: "user" });
+
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    const result = await ppPhaseComplete.execute("quick-esc-1", { summary: "done" }, undefined, undefined, ctx);
+
+    expect(ctx.abort).toHaveBeenCalled();
+    expect(result.content[0].text).toBe("");
+  });
+
   it("autonomous review loop re-runs until cap then advances", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -1694,6 +1795,52 @@ describe("task modes and quick task", () => {
     expect(finalState.reviewPassByKind?.implement?.auto).toBe(1);
   });
 
+  it("autonomous PLAN review cycle: apply feedback (clean approve) advances to implement", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "plan review advance", undefined, undefined, "autonomous");
+    const taskDir = orchestrator.active!.dir;
+    orchestrator.active!.state.phase = "plan";
+    orchestrator.active!.state.step = "synthesize";
+    orchestrator.active!.state.reviewPass = 0;
+    orchestrator.active!.state.reviewPassByKind = {};
+    orchestrator.active!.state.autonomousConfig = {
+      phases: { plan: { plannerPreset: "regular", reviewPreset: "regular", maxReviewPasses: 3 } },
+    };
+    writeFileSync(join(taskDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
+    writeFileSync(join(taskDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(
+      join(plansDir, "1_synthesized.md"),
+      makeValidPlan(["- [x] P1. Plan ready — Done when: synthesized plan exists"]),
+      "utf-8",
+    );
+
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    // First call: plan phase is autonomous, no clean approval yet → starts a review cycle.
+    const first = await ppPhaseComplete.execute("plan-rev-1", { summary: "plan done" }, undefined, undefined, ctx);
+    expect(first.content[0].text).toMatch(/Reviews are running|Started review cycle pass/);
+
+    // Plan reviewers write to plan-reviews/ (not code-reviews/).
+    const planReviewsDir = join(taskDir, "plan-reviews");
+    mkdirSync(planReviewsDir, { recursive: true });
+    const round = orchestrator.active!.state.reviewCycle!.pass;
+    for (const v of ["opus", "gpt", "gemini"]) {
+      writeFileSync(join(planReviewsDir, `1_${v}_round-${round}.md`), "VERDICT: APPROVE\n- CRITICAL: none", "utf-8");
+    }
+    emitSubagentCreated(pi, "plan-reviewer-1", "Plan reviewer (test)");
+    emitSubagentCompleted(pi, "plan-reviewer-1", "Plan reviewer (test)");
+
+    // Second call: finalize the clean-approved pass and advance to implement (single transition).
+    const second = await ppPhaseComplete.execute("plan-rev-2", { summary: "feedback applied" }, undefined, undefined, ctx);
+    expect(second.content[0].text).toBe("");
+    expect(orchestrator.active!.state.phase).toBe("implement");
+    expect(menu.transcript.filter((entry) => entry.question.startsWith("/pp"))).toHaveLength(0);
+  });
+
   it("clean-approved review is not re-run on a later checklist-repair re-entry", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -2041,10 +2188,11 @@ describe("task modes and quick task", () => {
 
     const title = "implement";
     const pp = getCommand(pi, "pp");
+    const titleMatch = (t: string) => t.includes(title);
     menu
       .expect({ question: "/pp", options: { include: ["Task"] }, choose: "Task" })
       .expect({ question: "Task", options: { include: ["Resume"] }, choose: "Resume" })
-      .expect({ question: "Resume", options: { include: [title] }, choose: title });
+      .expect({ question: "Resume", options: { include: [titleMatch] }, choose: titleMatch });
     await pp(undefined, ctx);
 
     expect(orchestrator.active).not.toBeNull();
@@ -2069,10 +2217,11 @@ describe("task modes and quick task", () => {
     await orchestrator.cleanupActive();
 
     const pp = getCommand(pi, "pp");
+    const configTitleMatch = (t: string) => t.includes("resume autonomous config");
     menu
       .expect({ question: "/pp", options: { include: ["Task"] }, choose: "Task" })
       .expect({ question: "Task", options: { include: ["Resume"] }, choose: "Resume" })
-      .expect({ question: "Resume", options: { include: ["resume autonomous config"] }, choose: "resume autonomous config" });
+      .expect({ question: "Resume", options: { include: [configTitleMatch] }, choose: configTitleMatch });
     await pp(undefined, ctx);
 
     expect(orchestrator.active).not.toBeNull();
@@ -2102,6 +2251,10 @@ describe("task modes and quick task", () => {
     writeFileSync(join(taskDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
     writeFileSync(join(taskDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
 
+    // brainstorm is user-driven even for an autonomous task, so the transition
+    // to plan goes through the guided menu (which auto-skips the planner preset
+    // picker because the task is autonomous).
+    expectActiveTaskNext(menu, "Continue to plan & implement");
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
     await ppPhaseComplete.execute("call-autonomous-skip-planner", { summary: "done" }, undefined, undefined, ctx);
     await new Promise((r) => setTimeout(r, 10));
@@ -2596,7 +2749,7 @@ describe("resume and recovery", () => {
     menu
       .expect({ question: "/pp", options: { include: ["Task"] }, choose: "Task" })
       .expect({ question: "Task", options: { include: ["Resume"] }, choose: "Resume" })
-      .expect({ question: "Resume", options: { include: ["resume phase state"] }, choose: "resume phase state" });
+      .expect({ question: "Resume", options: { include: [(t: string) => t.includes("resume phase state")] }, choose: (t: string) => t.includes("resume phase state") });
     await pp(undefined, ctx);
 
     expect(orchestrator.active).not.toBeNull();
@@ -2625,7 +2778,7 @@ describe("resume and recovery", () => {
     menu
       .expect({ question: "/pp", options: { include: ["Task"] }, choose: "Task" })
       .expect({ question: "Task", options: { include: ["Resume"] }, choose: "Resume" })
-      .expect({ question: "Resume", options: { include: ["resume stale repos"] }, choose: "resume stale repos" });
+      .expect({ question: "Resume", options: { include: [(t: string) => t.includes("resume stale repos")] }, choose: (t: string) => t.includes("resume stale repos") });
     await pp(undefined, ctx);
 
     expect(orchestrator.active!.state.repos).toEqual([{ path: cwd, isRoot: true }]);
@@ -2852,6 +3005,49 @@ describe("brainstorm and plan review cycles", () => {
     expect(readyMessages[readyMessages.length - 1]).toContain("artifacts/");
   });
 
+  const runPlanReviewReady = async (mode?: "autonomous") => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx({ cwd });
+
+    await orchestrator.startTask(ctx as any, "implement", "plan review message", undefined, undefined, mode);
+    const taskDir = orchestrator.active!.dir;
+    writeFileSync(join(taskDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
+    writeFileSync(join(taskDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    mkdirSync(join(taskDir, "plan-reviews"), { recursive: true });
+    writeFileSync(
+      join(taskDir, "plan-reviews", `${Math.floor(Date.now() / 1000)}_test_round-1.md`),
+      "Plan review feedback",
+      "utf-8",
+    );
+    orchestrator.active!.state.phase = "plan";
+    orchestrator.active!.state.step = "synthesize";
+    saveTask(taskDir, orchestrator.active!.state);
+
+    await enterReviewCycle(orchestrator, ctx, "regular");
+    await new Promise((r) => setTimeout(r, 10));
+
+    return (pi.sendUserMessage as any).mock.calls
+      .map((c: any[]) => c[0] as string)
+      .filter((text: string) => text.includes("ready for apply_feedback"));
+  };
+
+  it("autonomous plan review-ready message mandates re-calling pp_phase_complete", async () => {
+    const readyMessages = await runPlanReviewReady("autonomous");
+    expect(readyMessages.length).toBeGreaterThan(0);
+    const last = readyMessages[readyMessages.length - 1];
+    expect(last).toContain("pp_phase_complete");
+    expect(last).toContain("Do NOT stop or wait for the user");
+  });
+
+  it("guided plan review-ready message does NOT tell the agent to re-call pp_phase_complete or auto-advance", async () => {
+    const readyMessages = await runPlanReviewReady();
+    expect(readyMessages.length).toBeGreaterThan(0);
+    const last = readyMessages[readyMessages.length - 1];
+    expect(last).not.toContain("pp_phase_complete");
+    expect(last).not.toContain("Do NOT stop or wait for the user");
+  });
+
   it("plan review cycle reaches apply_feedback and finalizeReviewCycle returns to user_gate", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -3917,6 +4113,9 @@ describe("full user flows", () => {
     writeFileSync(join(taskDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
     writeFileSync(join(taskDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
 
+    // brainstorm is user-driven: the brainstorm→plan transition uses the guided
+    // menu. plan→implement and implement→review below are autonomous auto-advance.
+    expectActiveTaskNext(menu, "Continue to plan & implement");
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
     await ppPhaseComplete.execute("flow-auto-1", { summary: "brainstorm done" }, undefined, undefined, ctx);
     await new Promise((r) => setTimeout(r, 10));

package/extensions/orchestrator/model-registry.test.ts

@@ -7,6 +7,7 @@ vi.mock("./log.js", () => ({
 }));
 
 import {
+  findLatestFamilyMatch,
   getAllAliases,
   getModelFamilies,
   getModelInfo,
@@ -19,20 +20,43 @@ describe("model-registry", () => {
     updateRegistryFromAvailableModels([]);
   });
 
-  it("resolveModel resolves known aliases", () => {
-    expect(resolveModel("anthropic/claude-sonnet-latest")).toBe("anthropic/claude-sonnet-4-6");
-    expect(resolveModel("openai/gpt-mini-latest")).toBe("openai/gpt-5.4-mini");
+  it("resolveModel passes through native-latest aliases", () => {
+    expect(resolveModel("anthropic/claude-sonnet-latest")).toBe("anthropic/claude-sonnet-latest");
+    expect(resolveModel("anthropic/claude-opus-latest")).toBe("anthropic/claude-opus-latest");
+    expect(resolveModel("anthropic/claude-haiku-latest")).toBe("anthropic/claude-haiku-latest");
+  });
+
+  it("resolveModel returns input unchanged for non-native aliases without available models", () => {
+    expect(resolveModel("openai/gpt-mini-latest")).toBe("openai/gpt-mini-latest");
+    expect(resolveModel("pp-flant-anthropic/claude-opus-latest")).toBe("pp-flant-anthropic/claude-opus-latest");
   });
 
   it("resolveModel passes through unknown aliases", () => {
     expect(resolveModel("custom/provider-model")).toBe("custom/provider-model");
   });
 
-  it("resolveModel resolves flant aliases", () => {
+  it("resolveModel resolves flant aliases after updateRegistry", () => {
+    updateRegistryFromAvailableModels(["claude-opus-4-6", "gemini-3.1-pro"]);
     expect(resolveModel("pp-flant-anthropic/claude-opus-latest")).toBe("pp-flant-anthropic/claude-opus-4-6");
     expect(resolveModel("pp-flant-openai/gemini-pro-latest")).toBe("pp-flant-openai/gemini-3.1-pro");
   });
 
+  it("getModelInfo detects personal-subscription Claude models", () => {
+    expect(getModelInfo("pp-flant-anthropic-sub/sub/claude-opus-4-8")).toMatchObject({ vendor: "anthropic", family: "opus", tier: "smart" });
+    expect(getModelInfo("pp-flant-anthropic-sub/sub/claude-sonnet-4-6")).toMatchObject({ vendor: "anthropic", family: "sonnet", tier: "regular" });
+    expect(getModelInfo("pp-flant-anthropic-sub/sub/claude-haiku-4-5")).toMatchObject({ vendor: "anthropic", family: "haiku", tier: "stupid" });
+  });
+
+  it("resolveModel resolves subscription aliases to sub/ specs after updateRegistry", () => {
+    updateRegistryFromAvailableModels([
+      "pp-flant-anthropic-sub/sub/claude-opus-4-7",
+      "pp-flant-anthropic-sub/sub/claude-opus-4-8",
+      "pp-flant-anthropic-sub/sub/claude-haiku-4-5",
+    ]);
+    expect(resolveModel("pp-flant-anthropic-sub/claude-opus-latest")).toBe("pp-flant-anthropic-sub/sub/claude-opus-4-8");
+    expect(resolveModel("pp-flant-anthropic-sub/claude-haiku-latest")).toBe("pp-flant-anthropic-sub/sub/claude-haiku-4-5");
+  });
+
   it("getModelInfo detects all configured families", () => {
     expect(getModelInfo("anthropic/claude-opus-4-6")).toMatchObject({ vendor: "anthropic", family: "opus", tier: "smart" });
     expect(getModelInfo("anthropic/claude-sonnet-4-6")).toMatchObject({ vendor: "anthropic", family: "sonnet", tier: "regular" });
@@ -153,11 +177,11 @@ describe("model-registry", () => {
     expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-5.6");
   });
 
-  it("updateRegistryFromAvailableModels keeps defaults for missing families", () => {
+  it("updateRegistryFromAvailableModels keeps native-latest for missing families", () => {
     updateRegistryFromAvailableModels(["openai/gpt-9.1"]);
 
     expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-9.1");
-    expect(resolveModel("anthropic/claude-opus-latest")).toBe("anthropic/claude-opus-4-6");
+    expect(resolveModel("anthropic/claude-opus-latest")).toBe("anthropic/claude-opus-latest");
   });
 
   it("updateRegistryFromAvailableModels ignores aliases ending with -latest", () => {
@@ -168,7 +192,7 @@ describe("model-registry", () => {
     ]);
 
     expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-5.4");
-    expect(resolveModel("pp-flant-anthropic/claude-opus-latest")).toBe("pp-flant-anthropic/claude-opus-4-6");
+    expect(resolveModel("pp-flant-anthropic/claude-opus-latest")).toBe("pp-flant-anthropic/claude-opus-latest");
   });
 
   it("updateRegistryFromAvailableModels handles empty input", () => {
@@ -176,14 +200,14 @@ describe("model-registry", () => {
     expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-9.9");
 
     updateRegistryFromAvailableModels([]);
-    expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-5.4");
+    expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-latest");
   });
 
   it("updateRegistryFromAvailableModels ignores unknown bare ids", () => {
     updateRegistryFromAvailableModels(["custom-model-1", "another-custom-model"]);
 
-    expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-5.4");
-    expect(resolveModel("anthropic/claude-opus-latest")).toBe("anthropic/claude-opus-4-6");
+    expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-latest");
+    expect(resolveModel("anthropic/claude-opus-latest")).toBe("anthropic/claude-opus-latest");
   });
 
   it("updateRegistryFromAvailableModels chooses highest among flant openai versions", () => {
@@ -197,16 +221,25 @@ describe("model-registry", () => {
   });
 
   it("getAllAliases returns a copy", () => {
+    updateRegistryFromAvailableModels(["openai/gpt-5.4"]);
     const aliases = getAllAliases();
     aliases["openai/gpt-latest"] = "openai/gpt-0.0";
 
     expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-5.4");
   });
 
-  it("getAllAliases contains known defaults", () => {
+  it("getAllAliases contains native-latest identity mappings", () => {
+    const aliases = getAllAliases();
+
+    expect(aliases["anthropic/claude-opus-latest"]).toBe("anthropic/claude-opus-latest");
+    expect(aliases["anthropic/claude-sonnet-latest"]).toBe("anthropic/claude-sonnet-latest");
+    expect(aliases["anthropic/claude-haiku-latest"]).toBe("anthropic/claude-haiku-latest");
+  });
+
+  it("getAllAliases contains resolved aliases after updateRegistry", () => {
+    updateRegistryFromAvailableModels(["grok-4"]);
     const aliases = getAllAliases();
 
-    expect(aliases["anthropic/claude-opus-latest"]).toBe("anthropic/claude-opus-4-6");
     expect(aliases["pp-flant-openai/grok-latest"]).toBe("pp-flant-openai/grok-4");
   });
 
@@ -235,4 +268,35 @@ describe("model-registry", () => {
     expect(families.find((f) => f.family === "haiku")).toMatchObject({ vendor: "anthropic", tier: "stupid" });
     expect(families.find((f) => f.family === "gemini-pro")).toMatchObject({ vendor: "google", tier: "regular" });
   });
+
+  describe("findLatestFamilyMatch", () => {
+    it("returns latest versioned model for a native-latest alias", () => {
+      const available = [
+        "anthropic/claude-opus-4-0-20250514",
+        "anthropic/claude-opus-4-6",
+        "anthropic/claude-sonnet-4-6",
+      ];
+      expect(findLatestFamilyMatch("anthropic/claude-opus-latest", available)).toBe("anthropic/claude-opus-4-6");
+    });
+
+    it("returns null for unknown model spec", () => {
+      expect(findLatestFamilyMatch("custom/unknown-model", ["anthropic/claude-opus-4-6"])).toBeNull();
+    });
+
+    it("returns null when no candidates match the provider", () => {
+      expect(findLatestFamilyMatch("anthropic/claude-opus-latest", ["openai/gpt-5.4"])).toBeNull();
+    });
+
+    it("returns null for spec without provider", () => {
+      expect(findLatestFamilyMatch("claude-opus-latest", ["anthropic/claude-opus-4-6"])).toBeNull();
+    });
+
+    it("returns the only candidate when there is one", () => {
+      expect(findLatestFamilyMatch("openai/gpt-latest", ["openai/gpt-5.4"])).toBe("openai/gpt-5.4");
+    });
+
+    it("returns null for empty available list", () => {
+      expect(findLatestFamilyMatch("anthropic/claude-opus-latest", [])).toBeNull();
+    });
+  });
 });

package/extensions/orchestrator/model-registry.ts

@@ -11,7 +11,7 @@ export interface ModelInfo {
   displayName: string;
 }
 
-type ProviderPrefix = "anthropic" | "openai" | "google" | "deepseek" | "x-ai" | "qwen" | "pp-flant-anthropic" | "pp-flant-openai";
+type ProviderPrefix = "anthropic" | "openai" | "google" | "deepseek" | "x-ai" | "qwen" | "pp-flant-anthropic" | "pp-flant-anthropic-sub" | "pp-flant-openai";
 type KnownVendor = "anthropic" | "openai" | "google" | "deepseek" | "xai" | "qwen";
 type KnownFamily = "opus" | "sonnet" | "haiku" | "gpt" | "gpt-mini" | "gemini-pro" | "gemini-flash" | "deepseek" | "grok" | "qwen";
 type KnownTier = "stupid" | "regular" | "smart" | "xsmart";
@@ -24,6 +24,7 @@ export interface ModelFamilyDefinition {
   patterns: RegExp[];
   aliasTemplate: string;
   providers: ProviderPrefix[];
+  nativeLatestProviders?: ProviderPrefix[];
 }
 
 export interface ModelFamilyInfo {
@@ -41,27 +42,30 @@ export const MODEL_FAMILIES: ModelFamilyDefinition[] = [
     family: "opus",
     tier: "smart",
     displayName: "Claude Opus",
-    patterns: [/^(anthropic|pp-flant-anthropic)\/claude-opus-[a-z0-9.-]+$/],
+    patterns: [/^(anthropic|pp-flant-anthropic)\/claude-opus-[a-z0-9.-]+$/, /^pp-flant-anthropic-sub\/sub\/claude-opus-[a-z0-9.-]+$/],
     aliasTemplate: "claude-opus-latest",
-    providers: ["anthropic", "pp-flant-anthropic"],
+    providers: ["anthropic", "pp-flant-anthropic", "pp-flant-anthropic-sub"],
+    nativeLatestProviders: ["anthropic"],
   },
   {
     vendor: "anthropic",
     family: "sonnet",
     tier: "regular",
     displayName: "Claude Sonnet",
-    patterns: [/^(anthropic|pp-flant-anthropic)\/claude-sonnet-[a-z0-9.-]+$/],
+    patterns: [/^(anthropic|pp-flant-anthropic)\/claude-sonnet-[a-z0-9.-]+$/, /^pp-flant-anthropic-sub\/sub\/claude-sonnet-[a-z0-9.-]+$/],
     aliasTemplate: "claude-sonnet-latest",
-    providers: ["anthropic", "pp-flant-anthropic"],
+    providers: ["anthropic", "pp-flant-anthropic", "pp-flant-anthropic-sub"],
+    nativeLatestProviders: ["anthropic"],
   },
   {
     vendor: "anthropic",
     family: "haiku",
     tier: "stupid",
     displayName: "Claude Haiku",
-    patterns: [/^(anthropic|pp-flant-anthropic)\/claude-haiku-[a-z0-9.-]+$/],
+    patterns: [/^(anthropic|pp-flant-anthropic)\/claude-haiku-[a-z0-9.-]+$/, /^pp-flant-anthropic-sub\/sub\/claude-haiku-[a-z0-9.-]+$/],
     aliasTemplate: "claude-haiku-latest",
-    providers: ["anthropic", "pp-flant-anthropic"],
+    providers: ["anthropic", "pp-flant-anthropic", "pp-flant-anthropic-sub"],
+    nativeLatestProviders: ["anthropic"],
   },
   {
     vendor: "openai",
@@ -137,30 +141,20 @@ export const MODEL_FAMILIES: ModelFamilyDefinition[] = [
   },
 ];
 
-const DEFAULT_ALIAS_MAP: Record<string, string> = {
-  "anthropic/claude-opus-latest": "anthropic/claude-opus-4-6",
-  "anthropic/claude-sonnet-latest": "anthropic/claude-sonnet-4-6",
-  "anthropic/claude-haiku-latest": "anthropic/claude-haiku-3-5",
-  "openai/gpt-latest": "openai/gpt-5.4",
-  "openai/gpt-mini-latest": "openai/gpt-5.4-mini",
-  "google/gemini-pro-latest": "google/gemini-3.1-pro",
-  "google/gemini-flash-latest": "google/gemini-3.1-flash",
-  "deepseek/deepseek-latest": "deepseek/deepseek-v3",
-  "x-ai/grok-latest": "x-ai/grok-4",
-  "qwen/qwen-latest": "qwen/qwen3-coder",
-  "pp-flant-anthropic/claude-opus-latest": "pp-flant-anthropic/claude-opus-4-6",
-  "pp-flant-anthropic/claude-sonnet-latest": "pp-flant-anthropic/claude-sonnet-4-6",
-  "pp-flant-anthropic/claude-haiku-latest": "pp-flant-anthropic/claude-haiku-3-5",
-  "pp-flant-openai/gpt-latest": "pp-flant-openai/gpt-5.4",
-  "pp-flant-openai/gpt-mini-latest": "pp-flant-openai/gpt-5.4-mini",
-  "pp-flant-openai/gemini-pro-latest": "pp-flant-openai/gemini-3.1-pro",
-  "pp-flant-openai/gemini-flash-latest": "pp-flant-openai/gemini-3.1-flash",
-  "pp-flant-openai/deepseek-latest": "pp-flant-openai/deepseek-v3",
-  "pp-flant-openai/grok-latest": "pp-flant-openai/grok-4",
-  "pp-flant-openai/qwen-latest": "pp-flant-openai/qwen3-coder",
-};
+function buildNativeLatestAliases(): Record<string, string> {
+  const map: Record<string, string> = {};
+  for (const family of MODEL_FAMILIES) {
+    const nativeSet = new Set(family.nativeLatestProviders ?? []);
+    for (const provider of family.providers) {
+      if (!nativeSet.has(provider)) continue;
+      const alias = toAlias(provider, family.aliasTemplate);
+      map[alias] = alias;
+    }
+  }
+  return map;
+}
 
-let aliasMap: Record<string, string> = { ...DEFAULT_ALIAS_MAP };
+let aliasMap: Record<string, string> = buildNativeLatestAliases();
 
 function pickLatest(models: string[]): string | null {
   if (models.length === 0) return null;
@@ -244,11 +238,13 @@ export function getModelInfo(modelId: string): ModelInfo {
 export function updateRegistryFromAvailableModels(availableModels: string[]): void {
   const log = getLogger();
   const normalizedModels = collectNormalizedModels(availableModels).filter((modelId) => !modelId.endsWith("-latest"));
-  const nextAliasMap: Record<string, string> = { ...DEFAULT_ALIAS_MAP };
+  const nextAliasMap: Record<string, string> = buildNativeLatestAliases();
 
   let updatedCount = 0;
   for (const family of MODEL_FAMILIES) {
+    const nativeSet = new Set(family.nativeLatestProviders ?? []);
     for (const provider of family.providers) {
+      if (nativeSet.has(provider)) continue;
       const alias = toAlias(provider, family.aliasTemplate);
       const candidates = normalizedModels.filter((modelId) => {
         if (!modelId.startsWith(`${provider}/`)) return false;
@@ -257,7 +253,7 @@ export function updateRegistryFromAvailableModels(availableModels: string[]): vo
       const latest = pickLatest(candidates);
       if (latest) {
         nextAliasMap[alias] = latest;
-        if (latest !== DEFAULT_ALIAS_MAP[alias]) updatedCount++;
+        updatedCount++;
       }
     }
   }
@@ -270,6 +266,26 @@ export function getAllAliases(): Record<string, string> {
   return { ...aliasMap };
 }
 
+export function findLatestFamilyMatch(
+  modelSpec: string,
+  availableSpecs: string[],
+): string | null {
+  const family = findFamily(modelSpec);
+  if (!family) return null;
+
+  const slashIdx = modelSpec.indexOf("/");
+  if (slashIdx === -1) return null;
+  const requestedProvider = modelSpec.substring(0, slashIdx).trim().toLowerCase();
+
+  const candidates = availableSpecs.filter((spec) => {
+    const specLower = spec.toLowerCase();
+    if (!specLower.startsWith(`${requestedProvider}/`)) return false;
+    return family.patterns.some((p) => p.test(specLower));
+  });
+
+  return pickLatest(candidates);
+}
+
 export function getModelFamilies(): ModelFamilyInfo[] {
   return MODEL_FAMILIES.map((family) => ({
     vendor: family.vendor,

package/extensions/orchestrator/orchestrator.ts

@@ -24,7 +24,7 @@ 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 { resolveModel, getModelInfo, findLatestFamilyMatch } 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";
@@ -175,6 +175,16 @@ export class Orchestrator {
           (m) => m.provider.toLowerCase() === provider && m.id.toLowerCase() === modelId,
         );
       }
+      if (!resolved) {
+        const allSpecs = allModels.map((m) => `${m.provider}/${m.id}`);
+        const familyMatch = findLatestFamilyMatch(spec, allSpecs);
+        if (familyMatch) {
+          const fmLower = familyMatch.toLowerCase();
+          resolved = allModels.find(
+            (m) => `${m.provider.toLowerCase()}/${m.id.toLowerCase()}` === fmLower,
+          );
+        }
+      }
       if (!resolved) {
         const pattern = spec.toLowerCase();
         const matches = allModels.filter(
@@ -301,7 +311,7 @@ export class Orchestrator {
 
     if (this.active.state.reviewCycle?.step === "apply_feedback") {
       const pass = this.active.state.reviewCycle.pass;
-      return reviewCycleSystemPrompt(this.active.dir, pass, this.active.state.phase);
+      return reviewCycleSystemPrompt(this.active.dir, pass, this.active.state.phase, mode);
     }
 
     switch (this.active.state.phase) {
@@ -445,6 +455,7 @@ export class Orchestrator {
       type === "debug" ? "debug"
       : type === "brainstorm" ? "brainstorm"
       : type === "review" ? "review"
+      : type === "quick" ? "quick"
       : "implement"
     ];
     const modelOk = await this.switchModel(ctx, modelConfig.model, modelConfig.thinking);