@ilya-lesikov/pi-pi 0.4.0 → 0.6.0

package/extensions/orchestrator/model-registry.ts

@@ -0,0 +1,282 @@
+import { compareModelVersion } from "./model-version.js";
+
+export type Vendor = "anthropic" | "openai" | "google" | "deepseek" | "xai" | "qwen" | "unknown";
+export type Family = "opus" | "sonnet" | "haiku" | "gpt" | "gpt-mini" | "gemini-pro" | "gemini-flash" | "deepseek" | "grok" | "qwen" | "unknown";
+export type Tier = "stupid" | "regular" | "smart" | "xsmart" | "unknown";
+
+export interface ModelInfo {
+  vendor: Vendor;
+  family: Family;
+  tier: Tier;
+  displayName: string;
+}
+
+type ProviderPrefix = "anthropic" | "openai" | "google" | "deepseek" | "x-ai" | "qwen" | "pp-flant-anthropic" | "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";
+
+export interface ModelFamilyDefinition {
+  vendor: KnownVendor;
+  family: KnownFamily;
+  tier: KnownTier;
+  displayName: string;
+  patterns: RegExp[];
+  aliasTemplate: string;
+  providers: ProviderPrefix[];
+}
+
+export interface ModelFamilyInfo {
+  vendor: KnownVendor;
+  family: KnownFamily;
+  tier: KnownTier;
+  displayName: string;
+  aliasTemplate: string;
+  aliases: string[];
+}
+
+export const MODEL_FAMILIES: ModelFamilyDefinition[] = [
+  {
+    vendor: "anthropic",
+    family: "opus",
+    tier: "smart",
+    displayName: "Claude Opus",
+    patterns: [/^(anthropic|pp-flant-anthropic)\/claude-opus-[a-z0-9.-]+$/],
+    aliasTemplate: "claude-opus-latest",
+    providers: ["anthropic", "pp-flant-anthropic"],
+  },
+  {
+    vendor: "anthropic",
+    family: "sonnet",
+    tier: "regular",
+    displayName: "Claude Sonnet",
+    patterns: [/^(anthropic|pp-flant-anthropic)\/claude-sonnet-[a-z0-9.-]+$/],
+    aliasTemplate: "claude-sonnet-latest",
+    providers: ["anthropic", "pp-flant-anthropic"],
+  },
+  {
+    vendor: "anthropic",
+    family: "haiku",
+    tier: "stupid",
+    displayName: "Claude Haiku",
+    patterns: [/^(anthropic|pp-flant-anthropic)\/claude-haiku-[a-z0-9.-]+$/],
+    aliasTemplate: "claude-haiku-latest",
+    providers: ["anthropic", "pp-flant-anthropic"],
+  },
+  {
+    vendor: "openai",
+    family: "gpt",
+    tier: "regular",
+    displayName: "GPT",
+    patterns: [/^(openai|pp-flant-openai)\/gpt-(?!mini-)(?!.*-mini(?:$|[-.]))[a-z0-9.-]+$/],
+    aliasTemplate: "gpt-latest",
+    providers: ["openai", "pp-flant-openai"],
+  },
+  {
+    vendor: "openai",
+    family: "gpt-mini",
+    tier: "stupid",
+    displayName: "GPT Mini",
+    patterns: [
+      /^(openai|pp-flant-openai)\/gpt-mini-[a-z0-9.-]+$/,
+      /^(openai|pp-flant-openai)\/gpt-[a-z0-9.]+-mini(?:-[a-z0-9.-]+)?$/,
+    ],
+    aliasTemplate: "gpt-mini-latest",
+    providers: ["openai", "pp-flant-openai"],
+  },
+  {
+    vendor: "google",
+    family: "gemini-pro",
+    tier: "regular",
+    displayName: "Gemini Pro",
+    patterns: [
+      /^(google|pp-flant-openai)\/gemini-pro-[a-z0-9.-]+$/,
+      /^(google|pp-flant-openai)\/gemini-[a-z0-9.-]+-pro(?:-[a-z0-9.-]+)?$/,
+    ],
+    aliasTemplate: "gemini-pro-latest",
+    providers: ["google", "pp-flant-openai"],
+  },
+  {
+    vendor: "google",
+    family: "gemini-flash",
+    tier: "stupid",
+    displayName: "Gemini Flash",
+    patterns: [
+      /^(google|pp-flant-openai)\/gemini-flash-[a-z0-9.-]+$/,
+      /^(google|pp-flant-openai)\/gemini-[a-z0-9.-]+-flash(?:-[a-z0-9.-]+)?$/,
+    ],
+    aliasTemplate: "gemini-flash-latest",
+    providers: ["google", "pp-flant-openai"],
+  },
+  {
+    vendor: "deepseek",
+    family: "deepseek",
+    tier: "regular",
+    displayName: "DeepSeek",
+    patterns: [/^(deepseek|pp-flant-openai)\/deepseek-/],
+    aliasTemplate: "deepseek-latest",
+    providers: ["deepseek", "pp-flant-openai"],
+  },
+  {
+    vendor: "xai",
+    family: "grok",
+    tier: "regular",
+    displayName: "Grok",
+    patterns: [/^(x-ai|pp-flant-openai)\/grok-/],
+    aliasTemplate: "grok-latest",
+    providers: ["x-ai", "pp-flant-openai"],
+  },
+  {
+    vendor: "qwen",
+    family: "qwen",
+    tier: "regular",
+    displayName: "Qwen",
+    patterns: [/^(qwen|pp-flant-openai)\/qwen-/],
+    aliasTemplate: "qwen-latest",
+    providers: ["qwen", "pp-flant-openai"],
+  },
+];
+
+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",
+};
+
+let aliasMap: Record<string, string> = { ...DEFAULT_ALIAS_MAP };
+
+function pickLatest(models: string[]): string | null {
+  if (models.length === 0) return null;
+  return models
+    .slice()
+    .sort((a, b) => compareModelVersion(b, a))[0] ?? null;
+}
+
+function toAlias(provider: ProviderPrefix, aliasTemplate: string): string {
+  return `${provider}/${aliasTemplate}`;
+}
+
+function normalizeAvailableModelIds(modelId: string): string[] {
+  const value = modelId.trim();
+  if (!value) return [];
+  if (value.includes("/")) return [value];
+  if (value.startsWith("claude-")) return [`pp-flant-anthropic/${value}`];
+  if (
+    value.startsWith("gpt-") ||
+    value.startsWith("gemini-") ||
+    value.startsWith("deepseek-") ||
+    value.startsWith("grok-") ||
+    value.startsWith("qwen")
+  ) {
+    return [`pp-flant-openai/${value}`];
+  }
+  return [];
+}
+
+function collectNormalizedModels(availableModels: string[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const modelId of availableModels) {
+    for (const normalized of normalizeAvailableModelIds(modelId)) {
+      if (seen.has(normalized)) continue;
+      seen.add(normalized);
+      out.push(normalized);
+    }
+  }
+  return out;
+}
+
+function findFamily(modelId: string): ModelFamilyDefinition | null {
+  for (const family of MODEL_FAMILIES) {
+    for (const pattern of family.patterns) {
+      if (pattern.test(modelId)) return family;
+    }
+  }
+  return null;
+}
+
+import { getLogger } from "./log.js";
+
+export function resolveModel(aliasOrId: string): string {
+  const resolved = aliasMap[aliasOrId] ?? aliasOrId;
+  if (resolved !== aliasOrId) {
+    getLogger().debug({ s: "model", alias: aliasOrId, resolved }, "resolved model alias");
+  }
+  return resolved;
+}
+
+export function getModelInfo(modelId: string): ModelInfo {
+  const resolved = resolveModel(modelId);
+  const family = findFamily(resolved) ?? findFamily(modelId);
+  if (!family) {
+    return {
+      vendor: "unknown",
+      family: "unknown",
+      tier: "unknown",
+      displayName: modelId,
+    };
+  }
+  return {
+    vendor: family.vendor,
+    family: family.family,
+    tier: family.tier,
+    displayName: family.displayName,
+  };
+}
+
+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 };
+
+  let updatedCount = 0;
+  for (const family of MODEL_FAMILIES) {
+    for (const provider of family.providers) {
+      const alias = toAlias(provider, family.aliasTemplate);
+      const candidates = normalizedModels.filter((modelId) => {
+        if (!modelId.startsWith(`${provider}/`)) return false;
+        return family.patterns.some((pattern) => pattern.test(modelId));
+      });
+      const latest = pickLatest(candidates);
+      if (latest) {
+        nextAliasMap[alias] = latest;
+        if (latest !== DEFAULT_ALIAS_MAP[alias]) updatedCount++;
+      }
+    }
+  }
+
+  aliasMap = nextAliasMap;
+  log.debug({ s: "model", availableCount: availableModels.length, normalizedCount: normalizedModels.length, updatedAliases: updatedCount }, "registry updated from available models");
+}
+
+export function getAllAliases(): Record<string, string> {
+  return { ...aliasMap };
+}
+
+export function getModelFamilies(): ModelFamilyInfo[] {
+  return MODEL_FAMILIES.map((family) => ({
+    vendor: family.vendor,
+    family: family.family,
+    tier: family.tier,
+    displayName: family.displayName,
+    aliasTemplate: family.aliasTemplate,
+    aliases: family.providers.map((provider) => toAlias(provider, family.aliasTemplate)),
+  }));
+}

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

@@ -0,0 +1,27 @@
+import { describe, it, expect } from "vitest";
+import { compareModelVersion } from "./model-version.js";
+
+function latest(models: string[]): string {
+  return models.slice().sort((a, b) => compareModelVersion(b, a))[0];
+}
+
+describe("compareModelVersion", () => {
+  it("ranks a higher semantic minor above a dated snapshot in the same family", () => {
+    expect(compareModelVersion("claude-opus-4-6", "claude-opus-4-20250101")).toBeGreaterThan(0);
+    expect(latest(["claude-opus-4-6", "claude-opus-4-20250101", "claude-opus-4-5"])).toBe("claude-opus-4-6");
+  });
+
+  it("orders ordinary numeric versions normally", () => {
+    expect(compareModelVersion("gpt-4-2", "gpt-4-10")).toBeLessThan(0);
+    expect(latest(["gpt-4-2", "gpt-4-10", "gpt-4-1"])).toBe("gpt-4-10");
+  });
+
+  it("orders two dated snapshots by date", () => {
+    expect(compareModelVersion("claude-opus-4-20250201", "claude-opus-4-20250101")).toBeGreaterThan(0);
+    expect(latest(["claude-opus-4-20250101", "claude-opus-4-20250201"])).toBe("claude-opus-4-20250201");
+  });
+
+  it("falls back to lexical comparison when numeric parts are equal", () => {
+    expect(compareModelVersion("model-a", "model-b")).toBeLessThan(0);
+  });
+});

package/extensions/orchestrator/model-version.ts

@@ -0,0 +1,19 @@
+function isDateSegment(n: number): boolean {
+  return n >= 19700101 && n <= 99991231 && String(n).length === 8;
+}
+
+export function compareModelVersion(a: string, b: string): number {
+  const aParts = (a.match(/\d+/g) ?? []).map(Number);
+  const bParts = (b.match(/\d+/g) ?? []).map(Number);
+  const len = Math.max(aParts.length, bParts.length);
+  for (let i = 0; i < len; i++) {
+    const ai = aParts[i] ?? 0;
+    const bi = bParts[i] ?? 0;
+    if (ai === bi) continue;
+    const aDate = isDateSegment(ai);
+    const bDate = isDateSegment(bi);
+    if (aDate !== bDate) return aDate ? -1 : 1;
+    return ai - bi;
+  }
+  return a.localeCompare(b);
+}

package/extensions/orchestrator/orchestrator.test.ts

@@ -2,7 +2,8 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync
 import { tmpdir } from "os";
 import { join } from "path";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { Orchestrator, deepReviewConfig, ensureGitignore, type ActiveTask } from "./orchestrator.js";
+import { Orchestrator, ensureGitignore, type ActiveTask } from "./orchestrator.js";
+import { getDefaultConfig, resolvePreset } from "./config.js";
 
 const tempDirs: string[] = [];
 
@@ -84,6 +85,76 @@ describe("Orchestrator.truncateResult", () => {
   });
 });
 
+describe("Orchestrator.safeSendUserMessage", () => {
+  it("notifies the user once after exhausting retries, not during them", async () => {
+    vi.useFakeTimers();
+    const notify = vi.fn();
+    const pi = makePi({
+      sendUserMessage: vi.fn(() => {
+        throw new Error("not ready");
+      }),
+    });
+    const orchestrator = new Orchestrator(pi);
+    orchestrator.lastCtx = { ui: { notify } };
+
+    orchestrator.safeSendUserMessage("[PI-PI] Entered plan phase. Begin working.");
+    await vi.advanceTimersByTimeAsync(5000);
+    expect(notify).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(30000);
+    expect(notify).toHaveBeenCalledTimes(1);
+    expect(notify.mock.calls[0][1]).toBe("error");
+    vi.useRealTimers();
+  });
+
+  it("queues as a follow-up so it never throws 'Agent is already processing'", () => {
+    // Regression: during an autonomous phase transition pp_phase_complete is
+    // still in-flight when the post-compaction 'Begin working' message is sent.
+    // Without deliverAs the runtime throws and the implement phase never starts.
+    const sendUserMessage = vi.fn();
+    const orchestrator = new Orchestrator(makePi({ sendUserMessage }));
+
+    orchestrator.safeSendUserMessage("[PI-PI] Entered implement phase. Begin working.");
+
+    expect(sendUserMessage).toHaveBeenCalledWith(
+      "[PI-PI] Entered implement phase. Begin working.",
+      { deliverAs: "followUp" },
+    );
+  });
+});
+
+describe("Orchestrator.switchModel thinking level", () => {
+  function makeCtx() {
+    return {
+      modelRegistry: {
+        getAvailable: () => [{ provider: "anthropic", id: "claude-test-model" }],
+      },
+    } as any;
+  }
+
+  it("honors xhigh on the main agent (no downgrade)", async () => {
+    const pi = makePi({ setModel: vi.fn().mockResolvedValue(true) });
+    const orchestrator = new Orchestrator(pi);
+    const ok = await orchestrator.switchModel(makeCtx(), "anthropic/claude-test-model", "xhigh");
+    expect(ok).toBe(true);
+    expect(pi.setThinkingLevel).toHaveBeenCalledWith("xhigh");
+  });
+
+  it("honors minimal on the main agent", async () => {
+    const pi = makePi({ setModel: vi.fn().mockResolvedValue(true) });
+    const orchestrator = new Orchestrator(pi);
+    await orchestrator.switchModel(makeCtx(), "anthropic/claude-test-model", "minimal");
+    expect(pi.setThinkingLevel).toHaveBeenCalledWith("minimal");
+  });
+
+  it("falls back to high for an invalid thinking level", async () => {
+    const pi = makePi({ setModel: vi.fn().mockResolvedValue(true) });
+    const orchestrator = new Orchestrator(pi);
+    await orchestrator.switchModel(makeCtx(), "anthropic/claude-test-model", "bogus");
+    expect(pi.setThinkingLevel).toHaveBeenCalledWith("high");
+  });
+});
+
 describe("Orchestrator.taskIdFromDir", () => {
   it("extracts numeric prefix from directory basename", () => {
     const orchestrator = new Orchestrator(makePi());
@@ -91,65 +162,75 @@ describe("Orchestrator.taskIdFromDir", () => {
   });
 });
 
-describe("deepReviewConfig", () => {
-  it("upgrades reviewer thinking levels", () => {
-    const config = {
-      mainModel: {
-        implement: { model: "a/impl", thinking: "high" },
-        debug: { model: "a/debug", thinking: "high" },
-        brainstorm: { model: "a/brain", thinking: "high" },
-        review: { model: "a/review", thinking: "high" },
+describe("resolvePreset", () => {
+  it("resolves deep reviewer preset", () => {
+    const config = getDefaultConfig();
+    config.agents.subagents.presetGroups.planReviewers = {
+      default: "regular",
+      presets: {
+        regular: {
+          enabled: true,
+          agents: {
+            low: { enabled: true, model: "x/p1", thinking: "low" },
+          },
+        },
+        deep: {
+          enabled: true,
+          agents: {
+            low: { enabled: true, model: "x/p1", thinking: "xhigh" },
+          },
+        },
       },
-      planners: {},
-      planReviewers: {
-        low: { enabled: true, model: "x/p1", thinking: "low" },
-        medium: { enabled: true, model: "x/p2", thinking: "medium" },
-        high: { enabled: true, model: "x/p3", thinking: "high" },
-        other: { enabled: true, model: "x/p4", thinking: "off" },
-      },
-      brainstormReviewers: {
-        low: { enabled: true, model: "x/b1", thinking: "low" },
-        medium: { enabled: true, model: "x/b2", thinking: "medium" },
-        high: { enabled: true, model: "x/b3", thinking: "high" },
-        other: { enabled: true, model: "x/b4", thinking: "off" },
-      },
-      codeReviewers: {
-        low: { enabled: true, model: "x/1", thinking: "low" },
-        medium: { enabled: true, model: "x/2", thinking: "medium" },
-        high: { enabled: true, model: "x/3", thinking: "high" },
-        other: { enabled: true, model: "x/4", thinking: "off" },
-      },
-      agents: {
-        explore: { model: "x/e", thinking: "low" },
-        librarian: { model: "x/l", thinking: "medium" },
-        task: { model: "x/t", thinking: "medium" },
+    };
+    config.agents.subagents.presetGroups.brainstormReviewers = {
+      default: "regular",
+      presets: {
+        regular: {
+          enabled: true,
+          agents: {
+            low: { enabled: true, model: "x/b1", thinking: "low" },
+          },
+        },
+        deep: {
+          enabled: true,
+          agents: {
+            low: { enabled: true, model: "x/b1", thinking: "xhigh" },
+          },
+        },
       },
-      commands: { afterEdit: [], afterImplement: [] },
-      timeouts: {
-        afterEdit: 1,
-        afterImplement: 1,
-        agentSpawn: 1,
-        agentReadyPing: 1,
-        lockStale: 1,
-        lockUpdate: 1,
+    };
+    config.agents.subagents.presetGroups.codeReviewers = {
+      default: "regular",
+      presets: {
+        regular: {
+          enabled: true,
+          agents: {
+            low: { enabled: true, model: "x/1", thinking: "low" },
+            medium: { enabled: true, model: "x/2", thinking: "medium" },
+            high: { enabled: true, model: "x/3", thinking: "high" },
+            other: { enabled: true, model: "x/4", thinking: "off" },
+          },
+        },
+        deep: {
+          enabled: true,
+          agents: {
+            low: { enabled: true, model: "x/1", thinking: "xhigh" },
+            medium: { enabled: true, model: "x/2", thinking: "xhigh" },
+            high: { enabled: true, model: "x/3", thinking: "xhigh" },
+            other: { enabled: true, model: "x/4", thinking: "xhigh" },
+          },
+        },
       },
-      autoCommit: true,
     };
+    config.commands.afterEdit = {};
+    config.commands.afterImplement = {};
+
+    const upgraded = resolvePreset(config as any, "codeReviewers", "deep");
 
-    const upgraded = deepReviewConfig(config as any);
-
-    expect(upgraded.codeReviewers.low.thinking).toBe("medium");
-    expect(upgraded.codeReviewers.medium.thinking).toBe("high");
-    expect(upgraded.codeReviewers.high.thinking).toBe("xhigh");
-    expect(upgraded.codeReviewers.other.thinking).toBe("high");
-    expect(upgraded.brainstormReviewers.low.thinking).toBe("medium");
-    expect(upgraded.brainstormReviewers.medium.thinking).toBe("high");
-    expect(upgraded.brainstormReviewers.high.thinking).toBe("xhigh");
-    expect(upgraded.brainstormReviewers.other.thinking).toBe("high");
-    expect(upgraded.planReviewers.low.thinking).toBe("medium");
-    expect(upgraded.planReviewers.medium.thinking).toBe("high");
-    expect(upgraded.planReviewers.high.thinking).toBe("xhigh");
-    expect(upgraded.planReviewers.other.thinking).toBe("high");
+    expect(upgraded.low.thinking).toBe("xhigh");
+    expect(upgraded.medium.thinking).toBe("xhigh");
+    expect(upgraded.high.thinking).toBe("xhigh");
+    expect(upgraded.other.thinking).toBe("xhigh");
   });
 });
 
@@ -161,7 +242,7 @@ describe("ensureGitignore", () => {
 
     const gitignorePath = join(cwd, ".pp", ".gitignore");
     expect(existsSync(gitignorePath)).toBe(true);
-    expect(readFileSync(gitignorePath, "utf-8")).toBe("state/\nconfig.json\n");
+    expect(readFileSync(gitignorePath, "utf-8")).toBe("state/\nconfig.json\nlogs/\n");
   });
 
   it("adds missing entries and does not duplicate existing ones", () => {
@@ -251,3 +332,72 @@ describe("Orchestrator.cleanupActive", () => {
     expect(orchestrator.active).toBeNull();
   });
 });
+
+describe("Orchestrator.getPlanStartState", () => {
+  function makePlannerConfig() {
+    const config = getDefaultConfig();
+    config.general.autoCommit = false;
+    config.general.loadExtraRepoConfigs = true;
+    config.general.logLevel = "info";
+    config.agents.subagents.presetGroups.planners = {
+      default: "regular",
+      presets: {
+        regular: {
+          enabled: true,
+          agents: {
+            alpha: { enabled: true, model: "x/a", thinking: "low" },
+            beta: { enabled: true, model: "x/b", thinking: "low" },
+          },
+        },
+      },
+    };
+    config.commands.afterEdit = {};
+    config.commands.afterImplement = {};
+    config.performance.commands.afterEdit = 1;
+    config.performance.commands.afterImplement = 1;
+    config.performance.internals.subagentStale = 1;
+    config.performance.internals.taskLockStale = 1;
+    config.performance.internals.taskLockRefresh = 1;
+    return config as any;
+  }
+
+  it("returns synthesize when all enabled planner variants have outputs", () => {
+    const orchestrator = new Orchestrator(makePi());
+    orchestrator.config = makePlannerConfig();
+    const taskDir = makeTempDir();
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(join(plansDir, `${Math.floor(Date.now() / 1000)}_alpha.md`), "# Plan\n", "utf-8");
+    writeFileSync(join(plansDir, `${Math.floor(Date.now() / 1000) + 1}_beta.md`), "# Plan\n", "utf-8");
+
+    const state = orchestrator.getPlanStartState(taskDir, "regular");
+
+    expect(state).toEqual({ step: "synthesize", shouldSpawnPlanners: false });
+  });
+
+  it("returns await_planners when required planner outputs are missing", () => {
+    const orchestrator = new Orchestrator(makePi());
+    orchestrator.config = makePlannerConfig();
+    const taskDir = makeTempDir();
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(join(plansDir, `${Math.floor(Date.now() / 1000)}_alpha.md`), "# Plan\n", "utf-8");
+
+    const state = orchestrator.getPlanStartState(taskDir, "regular");
+
+    expect(state).toEqual({ step: "await_planners", shouldSpawnPlanners: true });
+  });
+
+  it("returns synthesize when synthesized plan already exists", () => {
+    const orchestrator = new Orchestrator(makePi());
+    orchestrator.config = makePlannerConfig();
+    const taskDir = makeTempDir();
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(join(plansDir, `${Math.floor(Date.now() / 1000)}_synthesized.md`), "# Plan\n", "utf-8");
+
+    const state = orchestrator.getPlanStartState(taskDir, "regular");
+
+    expect(state).toEqual({ step: "synthesize", shouldSpawnPlanners: false });
+  });
+});