@ilya-lesikov/pi-pi 0.6.0 → 0.8.0

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

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 vi.mock("./log.js", () => ({
   getLogger: () => ({
@@ -7,10 +7,14 @@ vi.mock("./log.js", () => ({
 }));
 
 import {
+  findLatestFamilyMatch,
   getAllAliases,
   getModelFamilies,
   getModelInfo,
+  isSubscriptionFallbackActive,
   resolveModel,
+  setSubscriptionFallbackActive,
+  toNonSubSpec,
   updateRegistryFromAvailableModels,
 } from "./model-registry.js";
 
@@ -19,20 +23,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 +180,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 +195,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 +203,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 +224,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 +271,79 @@ 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();
+    });
+  });
+
+  describe("subscription fallback rewrite", () => {
+    beforeEach(() => setSubscriptionFallbackActive(false));
+    afterEach(() => setSubscriptionFallbackActive(false));
+
+    it("toNonSubSpec rewrites provider-prefixed sub specs", () => {
+      expect(toNonSubSpec("pp-flant-anthropic-sub/sub/claude-opus-4-8")).toBe("pp-flant-anthropic/claude-opus-4-8");
+    });
+
+    it("toNonSubSpec rewrites bare sub/ ids", () => {
+      expect(toNonSubSpec("sub/claude-haiku-4-5")).toBe("pp-flant-anthropic/claude-haiku-4-5");
+    });
+
+    it("toNonSubSpec leaves non-subscription specs unchanged", () => {
+      expect(toNonSubSpec("pp-flant-anthropic/claude-opus-4-8")).toBe("pp-flant-anthropic/claude-opus-4-8");
+      expect(toNonSubSpec("openai/gpt-5.4")).toBe("openai/gpt-5.4");
+    });
+
+    it("resolveModel leaves sub specs unchanged while fallback inactive", () => {
+      expect(isSubscriptionFallbackActive()).toBe(false);
+      expect(resolveModel("pp-flant-anthropic-sub/sub/claude-opus-4-8")).toBe("pp-flant-anthropic-sub/sub/claude-opus-4-8");
+    });
+
+    it("resolveModel rewrites sub specs to non-sub while fallback active", () => {
+      setSubscriptionFallbackActive(true);
+      expect(isSubscriptionFallbackActive()).toBe(true);
+      expect(resolveModel("pp-flant-anthropic-sub/sub/claude-opus-4-8")).toBe("pp-flant-anthropic/claude-opus-4-8");
+      expect(resolveModel("sub/claude-haiku-4-5")).toBe("pp-flant-anthropic/claude-haiku-4-5");
+    });
+
+    it("resolveModel does not touch non-sub specs while fallback active", () => {
+      setSubscriptionFallbackActive(true);
+      expect(resolveModel("pp-flant-openai/gpt-5-4")).toBe("pp-flant-openai/gpt-5-4");
+    });
+
+    it("resolveModel rewrites a subscription alias after registry update while fallback active", () => {
+      updateRegistryFromAvailableModels([
+        "pp-flant-anthropic-sub/sub/claude-opus-4-7",
+        "pp-flant-anthropic-sub/sub/claude-opus-4-8",
+      ]);
+      setSubscriptionFallbackActive(true);
+      expect(resolveModel("pp-flant-anthropic-sub/claude-opus-latest")).toBe("pp-flant-anthropic/claude-opus-4-8");
+    });
+  });
 });

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;
@@ -213,12 +207,54 @@ function findFamily(modelId: string): ModelFamilyDefinition | null {
 }
 
 import { getLogger } from "./log.js";
+import { SUB_MODEL_PREFIX, SUB_PROVIDER } from "./flant-infra.js";
+
+// Session-scoped subscription fallback. When active (set after the user accepts
+// a sub-429 fallback), every model spec resolved through resolveModel that is
+// subscription-routed (`pp-flant-anthropic-sub/sub/<m>` or a bare `sub/<m>`) is
+// rewritten to the regular per-token form `pp-flant-anthropic/<m>`. This is the
+// single lever every resolution site funnels through (main phase switchModel,
+// subagent tool_call input.model, planner/reviewer specs, registerAgents), so a
+// one-shot switch cannot be undone by a later phase/subagent re-resolving a
+// `sub/` spec. Cleared when the user switches back or the task ends.
+let subscriptionFallbackActive = false;
+
+export function setSubscriptionFallbackActive(active: boolean): void {
+  subscriptionFallbackActive = active;
+}
+
+export function isSubscriptionFallbackActive(): boolean {
+  return subscriptionFallbackActive;
+}
+
+// Rewrite a subscription-routed spec to its regular per-token equivalent.
+// Handles both `pp-flant-anthropic-sub/sub/<m>` and a bare `sub/<m>` id.
+// Non-subscription specs pass through unchanged.
+export function toNonSubSpec(spec: string): string {
+  if (spec.startsWith(`${SUB_PROVIDER}/${SUB_MODEL_PREFIX}`)) {
+    return `pp-flant-anthropic/${spec.slice(`${SUB_PROVIDER}/${SUB_MODEL_PREFIX}`.length)}`;
+  }
+  if (spec.startsWith(`${SUB_PROVIDER}/`)) {
+    return `pp-flant-anthropic/${spec.slice(`${SUB_PROVIDER}/`.length)}`;
+  }
+  if (spec.startsWith(SUB_MODEL_PREFIX)) {
+    return `pp-flant-anthropic/${spec.slice(SUB_MODEL_PREFIX.length)}`;
+  }
+  return spec;
+}
 
 export function resolveModel(aliasOrId: string): string {
-  const resolved = aliasMap[aliasOrId] ?? aliasOrId;
+  let resolved = aliasMap[aliasOrId] ?? aliasOrId;
   if (resolved !== aliasOrId) {
     getLogger().debug({ s: "model", alias: aliasOrId, resolved }, "resolved model alias");
   }
+  if (subscriptionFallbackActive) {
+    const rewritten = toNonSubSpec(resolved);
+    if (rewritten !== resolved) {
+      getLogger().debug({ s: "model", from: resolved, to: rewritten }, "subscription fallback rewrite");
+      resolved = rewritten;
+    }
+  }
   return resolved;
 }
 
@@ -244,11 +280,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 +295,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 +308,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.test.ts

@@ -123,6 +123,119 @@ describe("Orchestrator.safeSendUserMessage", () => {
   });
 });
 
+describe("Orchestrator.cancelPendingRetry", () => {
+  it("clears the pending timer, disarms the ESC interrupt, and resets the counter", () => {
+    vi.useFakeTimers();
+    const send = vi.fn();
+    const orchestrator = new Orchestrator(makePi({ sendUserMessage: send }));
+    const unsub = vi.fn();
+    orchestrator.errorRetryCount = 3;
+    orchestrator.pendingRetryEscUnsub = unsub;
+    orchestrator.pendingRetryTimer = setTimeout(() => send("fired"), 1000) as any;
+
+    orchestrator.cancelPendingRetry();
+
+    expect(orchestrator.pendingRetryTimer).toBeNull();
+    expect(orchestrator.pendingRetryEscUnsub).toBeNull();
+    expect(orchestrator.errorRetryCount).toBe(0);
+    expect(unsub).toHaveBeenCalledTimes(1);
+    vi.advanceTimersByTime(2000);
+    expect(send).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+});
+
+describe("Orchestrator.armRetryEscInterrupt", () => {
+  function makeCtxWithTerminal() {
+    let handler: ((data: string) => any) | null = null;
+    const notify = vi.fn();
+    const ctx = {
+      ui: {
+        notify,
+        onTerminalInput: (h: (data: string) => any) => {
+          handler = h;
+          return () => { handler = null; };
+        },
+      },
+    };
+    return { ctx, notify, feed: (data: string) => handler?.(data) };
+  }
+
+  it("cancels the pending retry on a bare ESC only", () => {
+    vi.useFakeTimers();
+    const orchestrator = new Orchestrator(makePi());
+    const { ctx, notify, feed } = makeCtxWithTerminal();
+    orchestrator.pendingRetryTimer = setTimeout(() => {}, 10000) as any;
+    orchestrator.armRetryEscInterrupt(ctx as any);
+
+    // Arrow key (ESC-prefixed sequence) must NOT cancel and must NOT be consumed.
+    const arrow = feed("\x1b[A");
+    expect(arrow).toBeUndefined();
+    expect(orchestrator.pendingRetryTimer).not.toBeNull();
+
+    // Bare ESC cancels and consumes.
+    const esc = feed("\x1b");
+    expect(esc).toEqual({ consume: true });
+    expect(orchestrator.pendingRetryTimer).toBeNull();
+    expect(notify).toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+
+  it("is a no-op when no retry timer is armed", () => {
+    const orchestrator = new Orchestrator(makePi());
+    const { ctx, feed } = makeCtxWithTerminal();
+    orchestrator.armRetryEscInterrupt(ctx as any);
+    expect(feed("\x1b")).toBeUndefined();
+  });
+});
+
+describe("Orchestrator.sendUserMessageWhenIdle", () => {
+  it("sends immediately when idle", () => {
+    const send = vi.fn();
+    const orchestrator = new Orchestrator(makePi({ sendUserMessage: send }));
+    orchestrator.active = makeActiveTask(null);
+    orchestrator.activeTaskToken = 7;
+    orchestrator.lastCtx = { isIdle: () => true };
+
+    orchestrator.sendUserMessageWhenIdle("[PI-PI] go", 7);
+    expect(send).toHaveBeenCalledWith("[PI-PI] go", { deliverAs: "followUp" });
+  });
+
+  it("defers while busy, then sends once idle", async () => {
+    vi.useFakeTimers();
+    const send = vi.fn();
+    const orchestrator = new Orchestrator(makePi({ sendUserMessage: send }));
+    orchestrator.active = makeActiveTask(null);
+    orchestrator.activeTaskToken = 1;
+    let idle = false;
+    orchestrator.lastCtx = { isIdle: () => idle };
+
+    orchestrator.sendUserMessageWhenIdle("[PI-PI] go", 1);
+    expect(send).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(3000);
+    expect(send).not.toHaveBeenCalled();
+    idle = true;
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(send).toHaveBeenCalledWith("[PI-PI] go", { deliverAs: "followUp" });
+    vi.useRealTimers();
+  });
+
+  it("drops (does not send) when the task token changes", async () => {
+    vi.useFakeTimers();
+    const send = vi.fn();
+    const orchestrator = new Orchestrator(makePi({ sendUserMessage: send }));
+    orchestrator.active = makeActiveTask(null);
+    orchestrator.activeTaskToken = 1;
+    orchestrator.lastCtx = { isIdle: () => false };
+
+    orchestrator.sendUserMessageWhenIdle("[PI-PI] go", 1);
+    orchestrator.activeTaskToken = 2; // task switched
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(send).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+});
+
 describe("Orchestrator.switchModel thinking level", () => {
   function makeCtx() {
     return {